qtsurfer.api.client.models

13@_attrs_define
14class AcceptedJob:
15    """Response returned by async endpoints (`202 Accepted`). The `jobId` is deterministic for the
16    same input parameters — repeated calls with identical params return the same id.
17
18        Example:
19            {'jobId': '13RBLGQlPnfDjO6wyKSX8i'}
20
21        Attributes:
22            job_id (str): Unique job identifier; use this to poll for completion. Example: 13RBLGQlPnfDjO6wyKSX8i.
23    """
24
25    job_id: str
26    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
27
28    def to_dict(self) -> dict[str, Any]:
29        job_id = self.job_id
30
31        field_dict: dict[str, Any] = {}
32        field_dict.update(self.additional_properties)
33        field_dict.update(
34            {
35                "jobId": job_id,
36            }
37        )
38
39        return field_dict
40
41    @classmethod
42    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
43        d = dict(src_dict)
44        job_id = d.pop("jobId")
45
46        accepted_job = cls(
47            job_id=job_id,
48        )
49
50        accepted_job.additional_properties = d
51        return accepted_job
52
53    @property
54    def additional_keys(self) -> list[str]:
55        return list(self.additional_properties.keys())
56
57    def __getitem__(self, key: str) -> Any:
58        return self.additional_properties[key]
59
60    def __setitem__(self, key: str, value: Any) -> None:
61        self.additional_properties[key] = value
62
63    def __delitem__(self, key: str) -> None:
64        del self.additional_properties[key]
65
66    def __contains__(self, key: str) -> bool:
67        return key in self.additional_properties

15@_attrs_define
16class AuthTokenError:
17    """Error envelope returned by `POST /auth/token` when the API key is rejected.
18
19    Attributes:
20        code (AuthTokenErrorCode): Machine-readable error reason.
21        message (str): Human-readable description of the failure.
22    """
23
24    code: AuthTokenErrorCode
25    message: str
26    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
27
28    def to_dict(self) -> dict[str, Any]:
29        code = self.code.value
30
31        message = self.message
32
33        field_dict: dict[str, Any] = {}
34        field_dict.update(self.additional_properties)
35        field_dict.update(
36            {
37                "code": code,
38                "message": message,
39            }
40        )
41
42        return field_dict
43
44    @classmethod
45    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
46        d = dict(src_dict)
47        code = AuthTokenErrorCode(d.pop("code"))
48
49        message = d.pop("message")
50
51        auth_token_error = cls(
52            code=code,
53            message=message,
54        )
55
56        auth_token_error.additional_properties = d
57        return auth_token_error
58
59    @property
60    def additional_keys(self) -> list[str]:
61        return list(self.additional_properties.keys())
62
63    def __getitem__(self, key: str) -> Any:
64        return self.additional_properties[key]
65
66    def __setitem__(self, key: str, value: Any) -> None:
67        self.additional_properties[key] = value
68
69    def __delitem__(self, key: str) -> None:
70        del self.additional_properties[key]
71
72    def __contains__(self, key: str) -> bool:
73        return key in self.additional_properties

 5class AuthTokenErrorCode(str, Enum):
 6    APIKEY_EXPIRED = "apikey_expired"
 7    APIKEY_REVOKED = "apikey_revoked"
 8    INVALID_APIKEY = "invalid_apikey"
 9
10    def __str__(self) -> str:
11        return str(self.value)

 17@_attrs_define
 18class AuthTokenResponse:
 19    """
 20    Attributes:
 21        access_token (str): Short-lived HS256 JWT. Send as `Authorization: Bearer <token>` on all other endpoints.
 22        token_type (AuthTokenResponseTokenType): Always `Bearer`.
 23        expires_in (int): Seconds until the JWT expires (typically 3600). Example: 3600.
 24        tier (AuthTokenResponseTier): Subscription tier this token was issued for. Drives rate limits and feature flags
 25            on downstream endpoints. Example: free.
 26        scopes (list[str] | Unset): Scopes granted to this token. Reserved for future use; currently always empty.
 27    """
 28
 29    access_token: str
 30    token_type: AuthTokenResponseTokenType
 31    expires_in: int
 32    tier: AuthTokenResponseTier
 33    scopes: list[str] | Unset = UNSET
 34    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 35
 36    def to_dict(self) -> dict[str, Any]:
 37        access_token = self.access_token
 38
 39        token_type = self.token_type.value
 40
 41        expires_in = self.expires_in
 42
 43        tier = self.tier.value
 44
 45        scopes: list[str] | Unset = UNSET
 46        if not isinstance(self.scopes, Unset):
 47            scopes = self.scopes
 48
 49        field_dict: dict[str, Any] = {}
 50        field_dict.update(self.additional_properties)
 51        field_dict.update(
 52            {
 53                "access_token": access_token,
 54                "token_type": token_type,
 55                "expires_in": expires_in,
 56                "tier": tier,
 57            }
 58        )
 59        if scopes is not UNSET:
 60            field_dict["scopes"] = scopes
 61
 62        return field_dict
 63
 64    @classmethod
 65    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
 66        d = dict(src_dict)
 67        access_token = d.pop("access_token")
 68
 69        token_type = AuthTokenResponseTokenType(d.pop("token_type"))
 70
 71        expires_in = d.pop("expires_in")
 72
 73        tier = AuthTokenResponseTier(d.pop("tier"))
 74
 75        scopes = cast(list[str], d.pop("scopes", UNSET))
 76
 77        auth_token_response = cls(
 78            access_token=access_token,
 79            token_type=token_type,
 80            expires_in=expires_in,
 81            tier=tier,
 82            scopes=scopes,
 83        )
 84
 85        auth_token_response.additional_properties = d
 86        return auth_token_response
 87
 88    @property
 89    def additional_keys(self) -> list[str]:
 90        return list(self.additional_properties.keys())
 91
 92    def __getitem__(self, key: str) -> Any:
 93        return self.additional_properties[key]
 94
 95    def __setitem__(self, key: str, value: Any) -> None:
 96        self.additional_properties[key] = value
 97
 98    def __delitem__(self, key: str) -> None:
 99        del self.additional_properties[key]
100
101    def __contains__(self, key: str) -> bool:
102        return key in self.additional_properties

 5class AuthTokenResponseTier(str, Enum):
 6    BASIC = "basic"
 7    ELITE = "elite"
 8    FREE = "free"
 9    PRO = "pro"
10
11    def __str__(self) -> str:
12        return str(self.value)

5class AuthTokenResponseTokenType(str, Enum):
6    BEARER = "Bearer"
7
8    def __str__(self) -> str:
9        return str(self.value)

18@_attrs_define
19class BacktestJobResult:
20    """Backtest job result.
21
22    Attributes:
23        results (ResultMap): Execution result map. Always includes core fields (hostName, iops, strategyId, instrument).
24            Yield metrics (pnlTotal, pnlTotalPercent, totalTrades, winRate, equityCurve, etc.) are present when the strategy
25            emitted at least one trade. When signal storage is enabled, includes signal fields described below. `notices`
26            carries what the run had to say about itself, and is absent when it had nothing.
27        state (JobState): Information about a single job
28    """
29
30    results: ResultMap
31    state: JobState
32    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
33
34    def to_dict(self) -> dict[str, Any]:
35        results = self.results.to_dict()
36
37        state = self.state.to_dict()
38
39        field_dict: dict[str, Any] = {}
40        field_dict.update(self.additional_properties)
41        field_dict.update(
42            {
43                "results": results,
44                "state": state,
45            }
46        )
47
48        return field_dict
49
50    @classmethod
51    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
52        from ..models.job_state import JobState
53        from ..models.result_map import ResultMap
54
55        d = dict(src_dict)
56        results = ResultMap.from_dict(d.pop("results"))
57
58        state = JobState.from_dict(d.pop("state"))
59
60        backtest_job_result = cls(
61            results=results,
62            state=state,
63        )
64
65        backtest_job_result.additional_properties = d
66        return backtest_job_result
67
68    @property
69    def additional_keys(self) -> list[str]:
70        return list(self.additional_properties.keys())
71
72    def __getitem__(self, key: str) -> Any:
73        return self.additional_properties[key]
74
75    def __setitem__(self, key: str, value: Any) -> None:
76        self.additional_properties[key] = value
77
78    def __delitem__(self, key: str) -> None:
79        del self.additional_properties[key]
80
81    def __contains__(self, key: str) -> bool:
82        return key in self.additional_properties

16@_attrs_define
17class CancelBacktestResponse200:
18    """
19    Attributes:
20        status (CancelBacktestResponse200Status | Unset):  Example: cancelling.
21        job_id (str | Unset):  Example: 13RBLGQlPnfDjO6wyKSX8i.
22    """
23
24    status: CancelBacktestResponse200Status | Unset = UNSET
25    job_id: str | Unset = UNSET
26    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
27
28    def to_dict(self) -> dict[str, Any]:
29        status: str | Unset = UNSET
30        if not isinstance(self.status, Unset):
31            status = self.status.value
32
33        job_id = self.job_id
34
35        field_dict: dict[str, Any] = {}
36        field_dict.update(self.additional_properties)
37        field_dict.update({})
38        if status is not UNSET:
39            field_dict["status"] = status
40        if job_id is not UNSET:
41            field_dict["jobId"] = job_id
42
43        return field_dict
44
45    @classmethod
46    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
47        d = dict(src_dict)
48        _status = d.pop("status", UNSET)
49        status: CancelBacktestResponse200Status | Unset
50        if isinstance(_status, Unset):
51            status = UNSET
52        else:
53            status = CancelBacktestResponse200Status(_status)
54
55        job_id = d.pop("jobId", UNSET)
56
57        cancel_backtest_response_200 = cls(
58            status=status,
59            job_id=job_id,
60        )
61
62        cancel_backtest_response_200.additional_properties = d
63        return cancel_backtest_response_200
64
65    @property
66    def additional_keys(self) -> list[str]:
67        return list(self.additional_properties.keys())
68
69    def __getitem__(self, key: str) -> Any:
70        return self.additional_properties[key]
71
72    def __setitem__(self, key: str, value: Any) -> None:
73        self.additional_properties[key] = value
74
75    def __delitem__(self, key: str) -> None:
76        del self.additional_properties[key]
77
78    def __contains__(self, key: str) -> bool:
79        return key in self.additional_properties

5class CancelBacktestResponse200Status(str, Enum):
6    CANCELLING = "cancelling"
7
8    def __str__(self) -> str:
9        return str(self.value)

15@_attrs_define
16class CancelSweepResponse200:
17    """
18    Attributes:
19        status (CancelSweepResponse200Status):
20        sweep_id (str):
21    """
22
23    status: CancelSweepResponse200Status
24    sweep_id: str
25    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
26
27    def to_dict(self) -> dict[str, Any]:
28        status = self.status.value
29
30        sweep_id = self.sweep_id
31
32        field_dict: dict[str, Any] = {}
33        field_dict.update(self.additional_properties)
34        field_dict.update(
35            {
36                "status": status,
37                "sweepId": sweep_id,
38            }
39        )
40
41        return field_dict
42
43    @classmethod
44    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
45        d = dict(src_dict)
46        status = CancelSweepResponse200Status(d.pop("status"))
47
48        sweep_id = d.pop("sweepId")
49
50        cancel_sweep_response_200 = cls(
51            status=status,
52            sweep_id=sweep_id,
53        )
54
55        cancel_sweep_response_200.additional_properties = d
56        return cancel_sweep_response_200
57
58    @property
59    def additional_keys(self) -> list[str]:
60        return list(self.additional_properties.keys())
61
62    def __getitem__(self, key: str) -> Any:
63        return self.additional_properties[key]
64
65    def __setitem__(self, key: str, value: Any) -> None:
66        self.additional_properties[key] = value
67
68    def __delitem__(self, key: str) -> None:
69        del self.additional_properties[key]
70
71    def __contains__(self, key: str) -> bool:
72        return key in self.additional_properties

5class CancelSweepResponse200Status(str, Enum):
6    CANCELLING = "cancelling"
7
8    def __str__(self) -> str:
9        return str(self.value)

19@_attrs_define
20class CompileStrategyResponse200:
21    """
22    Attributes:
23        strategy_id (str): Unique identifier for a compiled strategy, derived from the source itself: the same code
24            always yields the same id, for every caller, whatever its formatting. See
25            `POST /strategy` for exactly which rewrites preserve it and which do not.
26             Example: 6bsh31ikwkuivhtgcoa6s4.
27        declared_properties (list[DeclaredProperty] | Unset): What could be established about this strategy's sweep-key
28            vocabulary without
29            constructing it. See `DeclaredProperty` — best-effort, not exhaustive.
30    """
31
32    strategy_id: str
33    declared_properties: list[DeclaredProperty] | Unset = UNSET
34    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
35
36    def to_dict(self) -> dict[str, Any]:
37        strategy_id = self.strategy_id
38
39        declared_properties: list[dict[str, Any]] | Unset = UNSET
40        if not isinstance(self.declared_properties, Unset):
41            declared_properties = []
42            for declared_properties_item_data in self.declared_properties:
43                declared_properties_item = declared_properties_item_data.to_dict()
44                declared_properties.append(declared_properties_item)
45
46        field_dict: dict[str, Any] = {}
47        field_dict.update(self.additional_properties)
48        field_dict.update(
49            {
50                "strategyId": strategy_id,
51            }
52        )
53        if declared_properties is not UNSET:
54            field_dict["declaredProperties"] = declared_properties
55
56        return field_dict
57
58    @classmethod
59    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
60        from ..models.declared_property import DeclaredProperty
61
62        d = dict(src_dict)
63        strategy_id = d.pop("strategyId")
64
65        _declared_properties = d.pop("declaredProperties", UNSET)
66        declared_properties: list[DeclaredProperty] | Unset = UNSET
67        if _declared_properties is not UNSET:
68            declared_properties = []
69            for declared_properties_item_data in _declared_properties:
70                declared_properties_item = DeclaredProperty.from_dict(declared_properties_item_data)
71
72                declared_properties.append(declared_properties_item)
73
74        compile_strategy_response_200 = cls(
75            strategy_id=strategy_id,
76            declared_properties=declared_properties,
77        )
78
79        compile_strategy_response_200.additional_properties = d
80        return compile_strategy_response_200
81
82    @property
83    def additional_keys(self) -> list[str]:
84        return list(self.additional_properties.keys())
85
86    def __getitem__(self, key: str) -> Any:
87        return self.additional_properties[key]
88
89    def __setitem__(self, key: str, value: Any) -> None:
90        self.additional_properties[key] = value
91
92    def __delitem__(self, key: str) -> None:
93        del self.additional_properties[key]
94
95    def __contains__(self, key: str) -> bool:
96        return key in self.additional_properties

 17@_attrs_define
 18class CoverageWindow:
 19    """The time range of available data for a single data type
 20
 21    Attributes:
 22        from_ (datetime.datetime | Unset): Earliest timestamp with data available Example: 2026-04-10T21:00:00Z.
 23        to (datetime.datetime | Unset): Latest timestamp with data available Example: 2026-07-09T20:31:08Z.
 24        inactive_since (datetime.datetime | Unset): If the instrument stopped producing this data type
 25            (delisted/inactive), the timestamp it went inactive. Optional — omitted while the instrument is active. Example:
 26            2026-06-30T12:00:00Z.
 27    """
 28
 29    from_: datetime.datetime | Unset = UNSET
 30    to: datetime.datetime | Unset = UNSET
 31    inactive_since: datetime.datetime | Unset = UNSET
 32    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 33
 34    def to_dict(self) -> dict[str, Any]:
 35        from_: str | Unset = UNSET
 36        if not isinstance(self.from_, Unset):
 37            from_ = self.from_.isoformat()
 38
 39        to: str | Unset = UNSET
 40        if not isinstance(self.to, Unset):
 41            to = self.to.isoformat()
 42
 43        inactive_since: str | Unset = UNSET
 44        if not isinstance(self.inactive_since, Unset):
 45            inactive_since = self.inactive_since.isoformat()
 46
 47        field_dict: dict[str, Any] = {}
 48        field_dict.update(self.additional_properties)
 49        field_dict.update({})
 50        if from_ is not UNSET:
 51            field_dict["from"] = from_
 52        if to is not UNSET:
 53            field_dict["to"] = to
 54        if inactive_since is not UNSET:
 55            field_dict["inactiveSince"] = inactive_since
 56
 57        return field_dict
 58
 59    @classmethod
 60    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
 61        d = dict(src_dict)
 62        _from_ = d.pop("from", UNSET)
 63        from_: datetime.datetime | Unset
 64        if isinstance(_from_, Unset):
 65            from_ = UNSET
 66        else:
 67            from_ = isoparse(_from_)
 68
 69        _to = d.pop("to", UNSET)
 70        to: datetime.datetime | Unset
 71        if isinstance(_to, Unset):
 72            to = UNSET
 73        else:
 74            to = isoparse(_to)
 75
 76        _inactive_since = d.pop("inactiveSince", UNSET)
 77        inactive_since: datetime.datetime | Unset
 78        if isinstance(_inactive_since, Unset):
 79            inactive_since = UNSET
 80        else:
 81            inactive_since = isoparse(_inactive_since)
 82
 83        coverage_window = cls(
 84            from_=from_,
 85            to=to,
 86            inactive_since=inactive_since,
 87        )
 88
 89        coverage_window.additional_properties = d
 90        return coverage_window
 91
 92    @property
 93    def additional_keys(self) -> list[str]:
 94        return list(self.additional_properties.keys())
 95
 96    def __getitem__(self, key: str) -> Any:
 97        return self.additional_properties[key]
 98
 99    def __setitem__(self, key: str, value: Any) -> None:
100        self.additional_properties[key] = value
101
102    def __delitem__(self, key: str) -> None:
103        del self.additional_properties[key]
104
105    def __contains__(self, key: str) -> bool:
106        return key in self.additional_properties