thrustlab 0.1.0__py3-none-any.whl

thrustlab/_models/user_patch.py

@@ -0,0 +1,73 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from thrustlab._models.types import UNSET, Unset
+
+T = TypeVar("T", bound="UserPatch")
+
+
+@_attrs_define
+class UserPatch:
+    """
+    Attributes:
+        email (None | str | Unset):
+    """
+
+    email: None | str | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        email: None | str | Unset
+        if isinstance(self.email, Unset):
+            email = UNSET
+        else:
+            email = self.email
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if email is not UNSET:
+            field_dict["email"] = email
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+
+        def _parse_email(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        email = _parse_email(d.pop("email", UNSET))
+
+        user_patch = cls(
+            email=email,
+        )
+
+        user_patch.additional_properties = d
+        return user_patch
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

thrustlab/_models/user_resource.py

@@ -0,0 +1,170 @@
+from __future__ import annotations
+
+import datetime
+from collections.abc import Mapping
+from typing import Any, TypeVar, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+from dateutil.parser import isoparse
+
+from thrustlab._models.types import UNSET, Unset
+
+T = TypeVar("T", bound="UserResource")
+
+
+@_attrs_define
+class UserResource:
+    """
+    Attributes:
+        created_at (datetime.datetime):
+        email (str):
+        email_verified (bool):
+        id (str):
+        tier (str):
+        trial_days_remaining (int | None):
+        trial_end (datetime.datetime | None):
+        trial_start (datetime.datetime | None):
+        object_ (str | Unset):  Default: 'user'.
+    """
+
+    created_at: datetime.datetime
+    email: str
+    email_verified: bool
+    id: str
+    tier: str
+    trial_days_remaining: int | None
+    trial_end: datetime.datetime | None
+    trial_start: datetime.datetime | None
+    object_: str | Unset = "user"
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        created_at = self.created_at.isoformat()
+
+        email = self.email
+
+        email_verified = self.email_verified
+
+        id = self.id
+
+        tier = self.tier
+
+        trial_days_remaining: int | None
+        trial_days_remaining = self.trial_days_remaining
+
+        trial_end: None | str
+        if isinstance(self.trial_end, datetime.datetime):
+            trial_end = self.trial_end.isoformat()
+        else:
+            trial_end = self.trial_end
+
+        trial_start: None | str
+        if isinstance(self.trial_start, datetime.datetime):
+            trial_start = self.trial_start.isoformat()
+        else:
+            trial_start = self.trial_start
+
+        object_ = self.object_
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "created_at": created_at,
+                "email": email,
+                "email_verified": email_verified,
+                "id": id,
+                "tier": tier,
+                "trial_days_remaining": trial_days_remaining,
+                "trial_end": trial_end,
+                "trial_start": trial_start,
+            }
+        )
+        if object_ is not UNSET:
+            field_dict["object"] = object_
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        created_at = isoparse(d.pop("created_at"))
+
+        email = d.pop("email")
+
+        email_verified = d.pop("email_verified")
+
+        id = d.pop("id")
+
+        tier = d.pop("tier")
+
+        def _parse_trial_days_remaining(data: object) -> int | None:
+            if data is None:
+                return data
+            return cast(int | None, data)
+
+        trial_days_remaining = _parse_trial_days_remaining(d.pop("trial_days_remaining"))
+
+        def _parse_trial_end(data: object) -> datetime.datetime | None:
+            if data is None:
+                return data
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                trial_end_type_0 = isoparse(data)
+
+                return trial_end_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(datetime.datetime | None, data)
+
+        trial_end = _parse_trial_end(d.pop("trial_end"))
+
+        def _parse_trial_start(data: object) -> datetime.datetime | None:
+            if data is None:
+                return data
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                trial_start_type_0 = isoparse(data)
+
+                return trial_start_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(datetime.datetime | None, data)
+
+        trial_start = _parse_trial_start(d.pop("trial_start"))
+
+        object_ = d.pop("object", UNSET)
+
+        user_resource = cls(
+            created_at=created_at,
+            email=email,
+            email_verified=email_verified,
+            id=id,
+            tier=tier,
+            trial_days_remaining=trial_days_remaining,
+            trial_end=trial_end,
+            trial_start=trial_start,
+            object_=object_,
+        )
+
+        user_resource.additional_properties = d
+        return user_resource
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

thrustlab/_models/v1_health_v1_health_get_response_v1_health_v1_health_get.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="V1HealthV1HealthGetResponseV1HealthV1HealthGet")
+
+
+@_attrs_define
+class V1HealthV1HealthGetResponseV1HealthV1HealthGet:
+    """ """
+
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        v1_health_v1_health_get_response_v1_health_v1_health_get = cls()
+
+        v1_health_v1_health_get_response_v1_health_v1_health_get.additional_properties = d
+        return v1_health_v1_health_get_response_v1_health_v1_health_get
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

thrustlab/_models/validation_error.py

@@ -0,0 +1,90 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="ValidationError")
+
+
+@_attrs_define
+class ValidationError:
+    """
+    Attributes:
+        loc (list[int | str]):
+        msg (str):
+        type_ (str):
+    """
+
+    loc: list[int | str]
+    msg: str
+    type_: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        loc = []
+        for loc_item_data in self.loc:
+            loc_item: int | str
+            loc_item = loc_item_data
+            loc.append(loc_item)
+
+        msg = self.msg
+
+        type_ = self.type_
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "loc": loc,
+                "msg": msg,
+                "type": type_,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        loc = []
+        _loc = d.pop("loc")
+        for loc_item_data in _loc:
+
+            def _parse_loc_item(data: object) -> int | str:
+                return cast(int | str, data)
+
+            loc_item = _parse_loc_item(loc_item_data)
+
+            loc.append(loc_item)
+
+        msg = d.pop("msg")
+
+        type_ = d.pop("type")
+
+        validation_error = cls(
+            loc=loc,
+            msg=msg,
+            type_=type_,
+        )
+
+        validation_error.additional_properties = d
+        return validation_error
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

thrustlab/_models/webhook_endpoint_create.py

@@ -0,0 +1,91 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from thrustlab._models.types import UNSET, Unset
+
+T = TypeVar("T", bound="WebhookEndpointCreate")
+
+
+@_attrs_define
+class WebhookEndpointCreate:
+    """
+    Attributes:
+        events (list[str]):
+        url (str):
+        description (None | str | Unset):
+    """
+
+    events: list[str]
+    url: str
+    description: None | str | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        events = self.events
+
+        url = self.url
+
+        description: None | str | Unset
+        if isinstance(self.description, Unset):
+            description = UNSET
+        else:
+            description = self.description
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "events": events,
+                "url": url,
+            }
+        )
+        if description is not UNSET:
+            field_dict["description"] = description
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        events = cast(list[str], d.pop("events"))
+
+        url = d.pop("url")
+
+        def _parse_description(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        description = _parse_description(d.pop("description", UNSET))
+
+        webhook_endpoint_create = cls(
+            events=events,
+            url=url,
+            description=description,
+        )
+
+        webhook_endpoint_create.additional_properties = d
+        return webhook_endpoint_create
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

thrustlab/_models/webhook_endpoint_patch.py

@@ -0,0 +1,144 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from thrustlab._models.types import UNSET, Unset
+
+T = TypeVar("T", bound="WebhookEndpointPatch")
+
+
+@_attrs_define
+class WebhookEndpointPatch:
+    """
+    Attributes:
+        description (None | str | Unset):
+        enabled (bool | None | Unset):
+        events (list[str] | None | Unset):
+        url (None | str | Unset):
+    """
+
+    description: None | str | Unset = UNSET
+    enabled: bool | None | Unset = UNSET
+    events: list[str] | None | Unset = UNSET
+    url: None | str | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        description: None | str | Unset
+        if isinstance(self.description, Unset):
+            description = UNSET
+        else:
+            description = self.description
+
+        enabled: bool | None | Unset
+        if isinstance(self.enabled, Unset):
+            enabled = UNSET
+        else:
+            enabled = self.enabled
+
+        events: list[str] | None | Unset
+        if isinstance(self.events, Unset):
+            events = UNSET
+        elif isinstance(self.events, list):
+            events = self.events
+
+        else:
+            events = self.events
+
+        url: None | str | Unset
+        if isinstance(self.url, Unset):
+            url = UNSET
+        else:
+            url = self.url
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if description is not UNSET:
+            field_dict["description"] = description
+        if enabled is not UNSET:
+            field_dict["enabled"] = enabled
+        if events is not UNSET:
+            field_dict["events"] = events
+        if url is not UNSET:
+            field_dict["url"] = url
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+
+        def _parse_description(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        description = _parse_description(d.pop("description", UNSET))
+
+        def _parse_enabled(data: object) -> bool | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(bool | None | Unset, data)
+
+        enabled = _parse_enabled(d.pop("enabled", UNSET))
+
+        def _parse_events(data: object) -> list[str] | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, list):
+                    raise TypeError()
+                events_type_0 = cast(list[str], data)
+
+                return events_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(list[str] | None | Unset, data)
+
+        events = _parse_events(d.pop("events", UNSET))
+
+        def _parse_url(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        url = _parse_url(d.pop("url", UNSET))
+
+        webhook_endpoint_patch = cls(
+            description=description,
+            enabled=enabled,
+            events=events,
+            url=url,
+        )
+
+        webhook_endpoint_patch.additional_properties = d
+        return webhook_endpoint_patch
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties