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. For a sweep, pass this same value as the
23                `requestId` path parameter to `executeSweep` — same identifier, different name at that call site. Example:
24                13RBLGQlPnfDjO6wyKSX8i.
25    """
26
27    job_id: str
28    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
29
30    def to_dict(self) -> dict[str, Any]:
31        job_id = self.job_id
32
33        field_dict: dict[str, Any] = {}
34        field_dict.update(self.additional_properties)
35        field_dict.update(
36            {
37                "jobId": job_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        job_id = d.pop("jobId")
47
48        accepted_job = cls(
49            job_id=job_id,
50        )
51
52        accepted_job.additional_properties = d
53        return accepted_job
54
55    @property
56    def additional_keys(self) -> list[str]:
57        return list(self.additional_properties.keys())
58
59    def __getitem__(self, key: str) -> Any:
60        return self.additional_properties[key]
61
62    def __setitem__(self, key: str, value: Any) -> None:
63        self.additional_properties[key] = value
64
65    def __delitem__(self, key: str) -> None:
66        del self.additional_properties[key]
67
68    def __contains__(self, key: str) -> bool:
69        return key in self.additional_properties

 17@_attrs_define
 18class Account:
 19    """Your identity and tier limits. No database call behind this one — safe to fetch on every
 20    page load. Live usage against these limits is a separate resource, `GET /account/usage`,
 21    deliberately: usage changes on every upload/execution and costs a query to compute, this
 22    one doesn't.
 23
 24        Attributes:
 25            user_id (str): Your account id — the JWT `sub` claim. Example: 00000000-0000-0000-0000-000000000000.
 26            tier (str): Your current subscription tier. Example: free.
 27            max_execute (int): Maximum number of strategy executions (and sweeps) you can have running at the same time
 28                through the API. Starting one past this number is answered with `429`, whose message
 29                carries the same number. The value already includes any API allowance your plan has.
 30                 Example: 10.
 31            max_range_days (int): Maximum length, in days, of the time range of a backtest on one of your own datasets.
 32                Example: 7.
 33            max_sweep_cartesian (int): Largest full grid, in parameter combinations, a sweep may run with the `grid`
 34                sampler.
 35                A grid with more combinations is refused with `400`; the `random` and `lhs` samplers run
 36                only their `samples` and are not held to it.
 37                 Example: 100.
 38            max_import_range_hours (int): Maximum length, in hours, of the time range of one dataset import from an
 39                exchange. Example: 6.
 40            max_datasets (int): Maximum number of active datasets your tier allows. Example: 3.
 41            max_dataset_bytes (int): Maximum size, in bytes, of a single dataset version as stored, that is the `bytes` of
 42                its ready version. For a CSV upload that is the converted file, not the file you upload, so estimate from the
 43                number of rows. The Datasets guide has the details. Example: 52428800.
 44            max_total_storage_bytes (int): Maximum combined storage, in bytes, across every dataset, strategy-execution
 45                signal,
 46                and registered strategy on your account — one shared pool, not a separate cap per
 47                resource type, since they all compete for the same underlying storage. See `GET
 48                /account/usage`'s `storageBytesUsed` for your current usage against this number.
 49                 Example: 104857600.
 50            field_links (AccountLinks): HAL `_links` for `GET /account`
 51    """
 52
 53    user_id: str
 54    tier: str
 55    max_execute: int
 56    max_range_days: int
 57    max_sweep_cartesian: int
 58    max_import_range_hours: int
 59    max_datasets: int
 60    max_dataset_bytes: int
 61    max_total_storage_bytes: int
 62    field_links: AccountLinks
 63    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 64
 65    def to_dict(self) -> dict[str, Any]:
 66        user_id = self.user_id
 67
 68        tier = self.tier
 69
 70        max_execute = self.max_execute
 71
 72        max_range_days = self.max_range_days
 73
 74        max_sweep_cartesian = self.max_sweep_cartesian
 75
 76        max_import_range_hours = self.max_import_range_hours
 77
 78        max_datasets = self.max_datasets
 79
 80        max_dataset_bytes = self.max_dataset_bytes
 81
 82        max_total_storage_bytes = self.max_total_storage_bytes
 83
 84        field_links = self.field_links.to_dict()
 85
 86        field_dict: dict[str, Any] = {}
 87        field_dict.update(self.additional_properties)
 88        field_dict.update(
 89            {
 90                "userId": user_id,
 91                "tier": tier,
 92                "maxExecute": max_execute,
 93                "maxRangeDays": max_range_days,
 94                "maxSweepCartesian": max_sweep_cartesian,
 95                "maxImportRangeHours": max_import_range_hours,
 96                "maxDatasets": max_datasets,
 97                "maxDatasetBytes": max_dataset_bytes,
 98                "maxTotalStorageBytes": max_total_storage_bytes,
 99                "_links": field_links,
100            }
101        )
102
103        return field_dict
104
105    @classmethod
106    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
107        from ..models.account_links import AccountLinks
108
109        d = dict(src_dict)
110        user_id = d.pop("userId")
111
112        tier = d.pop("tier")
113
114        max_execute = d.pop("maxExecute")
115
116        max_range_days = d.pop("maxRangeDays")
117
118        max_sweep_cartesian = d.pop("maxSweepCartesian")
119
120        max_import_range_hours = d.pop("maxImportRangeHours")
121
122        max_datasets = d.pop("maxDatasets")
123
124        max_dataset_bytes = d.pop("maxDatasetBytes")
125
126        max_total_storage_bytes = d.pop("maxTotalStorageBytes")
127
128        field_links = AccountLinks.from_dict(d.pop("_links"))
129
130        account = cls(
131            user_id=user_id,
132            tier=tier,
133            max_execute=max_execute,
134            max_range_days=max_range_days,
135            max_sweep_cartesian=max_sweep_cartesian,
136            max_import_range_hours=max_import_range_hours,
137            max_datasets=max_datasets,
138            max_dataset_bytes=max_dataset_bytes,
139            max_total_storage_bytes=max_total_storage_bytes,
140            field_links=field_links,
141        )
142
143        account.additional_properties = d
144        return account
145
146    @property
147    def additional_keys(self) -> list[str]:
148        return list(self.additional_properties.keys())
149
150    def __getitem__(self, key: str) -> Any:
151        return self.additional_properties[key]
152
153    def __setitem__(self, key: str, value: Any) -> None:
154        self.additional_properties[key] = value
155
156    def __delitem__(self, key: str) -> None:
157        del self.additional_properties[key]
158
159    def __contains__(self, key: str) -> bool:
160        return key in self.additional_properties

17@_attrs_define
18class AccountLinks:
19    """HAL `_links` for `GET /account`
20
21    Attributes:
22        self_ (HalLink): A HAL link object (Hypertext Application Language)
23        usage (HalLink): A HAL link object (Hypertext Application Language)
24    """
25
26    self_: HalLink
27    usage: HalLink
28    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
29
30    def to_dict(self) -> dict[str, Any]:
31        self_ = self.self_.to_dict()
32
33        usage = self.usage.to_dict()
34
35        field_dict: dict[str, Any] = {}
36        field_dict.update(self.additional_properties)
37        field_dict.update(
38            {
39                "self": self_,
40                "usage": usage,
41            }
42        )
43
44        return field_dict
45
46    @classmethod
47    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
48        from ..models.hal_link import HalLink
49
50        d = dict(src_dict)
51        self_ = HalLink.from_dict(d.pop("self"))
52
53        usage = HalLink.from_dict(d.pop("usage"))
54
55        account_links = cls(
56            self_=self_,
57            usage=usage,
58        )
59
60        account_links.additional_properties = d
61        return account_links
62
63    @property
64    def additional_keys(self) -> list[str]:
65        return list(self.additional_properties.keys())
66
67    def __getitem__(self, key: str) -> Any:
68        return self.additional_properties[key]
69
70    def __setitem__(self, key: str, value: Any) -> None:
71        self.additional_properties[key] = value
72
73    def __delitem__(self, key: str) -> None:
74        del self.additional_properties[key]
75
76    def __contains__(self, key: str) -> bool:
77        return key in self.additional_properties

 17@_attrs_define
 18class AccountUsage:
 19    """Your live usage of the shared storage pool `GET /account`'s `maxTotalStorageBytes` caps.
 20    Not guaranteed real-time — a just-completed upload or strategy execution may take a short
 21    moment to be reflected here.
 22
 23        Attributes:
 24            datasets_used (int): Active datasets counted — the same set `GET /account`'s `maxDatasets` limits. Example: 2.
 25            dataset_bytes_used (int): Combined bytes of every active dataset's current version. Example: 15728640.
 26            signals_used (int): Recorded strategy-execution signal uploads. Example: 1.
 27            signal_bytes_used (int): Combined bytes of every recorded signal upload. Example: 524288.
 28            strategies_used (int): Registered strategies (see `GET /strategies`). Example: 4.
 29            strategy_bytes_used (int): Combined bytes of each registered strategy's source plus its latest compiled
 30                bytecode. Superseded (non-latest) compilations aren't counted.
 31                 Example: 40960.
 32            storage_bytes_used (int): `datasetBytesUsed + signalBytesUsed + strategyBytesUsed` — the number checked
 33                against `GET /account`'s `maxTotalStorageBytes`.
 34                 Example: 16293888.
 35            field_links (AccountUsageLinks): HAL `_links` for `GET /account/usage`
 36    """
 37
 38    datasets_used: int
 39    dataset_bytes_used: int
 40    signals_used: int
 41    signal_bytes_used: int
 42    strategies_used: int
 43    strategy_bytes_used: int
 44    storage_bytes_used: int
 45    field_links: AccountUsageLinks
 46    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 47
 48    def to_dict(self) -> dict[str, Any]:
 49        datasets_used = self.datasets_used
 50
 51        dataset_bytes_used = self.dataset_bytes_used
 52
 53        signals_used = self.signals_used
 54
 55        signal_bytes_used = self.signal_bytes_used
 56
 57        strategies_used = self.strategies_used
 58
 59        strategy_bytes_used = self.strategy_bytes_used
 60
 61        storage_bytes_used = self.storage_bytes_used
 62
 63        field_links = self.field_links.to_dict()
 64
 65        field_dict: dict[str, Any] = {}
 66        field_dict.update(self.additional_properties)
 67        field_dict.update(
 68            {
 69                "datasetsUsed": datasets_used,
 70                "datasetBytesUsed": dataset_bytes_used,
 71                "signalsUsed": signals_used,
 72                "signalBytesUsed": signal_bytes_used,
 73                "strategiesUsed": strategies_used,
 74                "strategyBytesUsed": strategy_bytes_used,
 75                "storageBytesUsed": storage_bytes_used,
 76                "_links": field_links,
 77            }
 78        )
 79
 80        return field_dict
 81
 82    @classmethod
 83    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
 84        from ..models.account_usage_links import AccountUsageLinks
 85
 86        d = dict(src_dict)
 87        datasets_used = d.pop("datasetsUsed")
 88
 89        dataset_bytes_used = d.pop("datasetBytesUsed")
 90
 91        signals_used = d.pop("signalsUsed")
 92
 93        signal_bytes_used = d.pop("signalBytesUsed")
 94
 95        strategies_used = d.pop("strategiesUsed")
 96
 97        strategy_bytes_used = d.pop("strategyBytesUsed")
 98
 99        storage_bytes_used = d.pop("storageBytesUsed")
100
101        field_links = AccountUsageLinks.from_dict(d.pop("_links"))
102
103        account_usage = cls(
104            datasets_used=datasets_used,
105            dataset_bytes_used=dataset_bytes_used,
106            signals_used=signals_used,
107            signal_bytes_used=signal_bytes_used,
108            strategies_used=strategies_used,
109            strategy_bytes_used=strategy_bytes_used,
110            storage_bytes_used=storage_bytes_used,
111            field_links=field_links,
112        )
113
114        account_usage.additional_properties = d
115        return account_usage
116
117    @property
118    def additional_keys(self) -> list[str]:
119        return list(self.additional_properties.keys())
120
121    def __getitem__(self, key: str) -> Any:
122        return self.additional_properties[key]
123
124    def __setitem__(self, key: str, value: Any) -> None:
125        self.additional_properties[key] = value
126
127    def __delitem__(self, key: str) -> None:
128        del self.additional_properties[key]
129
130    def __contains__(self, key: str) -> bool:
131        return key in self.additional_properties

17@_attrs_define
18class AccountUsageLinks:
19    """HAL `_links` for `GET /account/usage`
20
21    Attributes:
22        self_ (HalLink): A HAL link object (Hypertext Application Language)
23        account (HalLink): A HAL link object (Hypertext Application Language)
24    """
25
26    self_: HalLink
27    account: HalLink
28    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
29
30    def to_dict(self) -> dict[str, Any]:
31        self_ = self.self_.to_dict()
32
33        account = self.account.to_dict()
34
35        field_dict: dict[str, Any] = {}
36        field_dict.update(self.additional_properties)
37        field_dict.update(
38            {
39                "self": self_,
40                "account": account,
41            }
42        )
43
44        return field_dict
45
46    @classmethod
47    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
48        from ..models.hal_link import HalLink
49
50        d = dict(src_dict)
51        self_ = HalLink.from_dict(d.pop("self"))
52
53        account = HalLink.from_dict(d.pop("account"))
54
55        account_usage_links = cls(
56            self_=self_,
57            account=account,
58        )
59
60        account_usage_links.additional_properties = d
61        return account_usage_links
62
63    @property
64    def additional_keys(self) -> list[str]:
65        return list(self.additional_properties.keys())
66
67    def __getitem__(self, key: str) -> Any:
68        return self.additional_properties[key]
69
70    def __setitem__(self, key: str, value: Any) -> None:
71        self.additional_properties[key] = value
72
73    def __delitem__(self, key: str) -> None:
74        del self.additional_properties[key]
75
76    def __contains__(self, key: str) -> bool:
77        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