proxyrequest-sdk 1.0.0__py3-none-any.whl

proxyrequest_sdk/_generated/models/telegram_session_response_user.py

@@ -0,0 +1,48 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar, BinaryIO, TextIO, TYPE_CHECKING, Generator
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+
+T = TypeVar("T", bound="TelegramSessionResponseUser")
+
+
+@_attrs_define
+class TelegramSessionResponseUser:
+    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)
+        telegram_session_response_user = cls()
+
+        telegram_session_response_user.additional_properties = d
+        return telegram_session_response_user
+
+    @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

proxyrequest_sdk/_generated/models/token_pair_response.py

@@ -0,0 +1,68 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar, BinaryIO, TextIO, TYPE_CHECKING, Generator
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+
+T = TypeVar("T", bound="TokenPairResponse")
+
+
+@_attrs_define
+class TokenPairResponse:
+    token: str
+    """ Short-lived access token used in the Authorization header. """
+    refresh: str
+    """ Long-lived token used to request a new access token. """
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        token = self.token
+
+        refresh = self.refresh
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "token": token,
+                "refresh": refresh,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        token = d.pop("token")
+
+        refresh = d.pop("refresh")
+
+        token_pair_response = cls(
+            token=token,
+            refresh=refresh,
+        )
+
+        token_pair_response.additional_properties = d
+        return token_pair_response
+
+    @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

proxyrequest_sdk/_generated/models/token_refresh_request.py

@@ -0,0 +1,60 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar, BinaryIO, TextIO, TYPE_CHECKING, Generator
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+
+T = TypeVar("T", bound="TokenRefreshRequest")
+
+
+@_attrs_define
+class TokenRefreshRequest:
+    refresh: str
+    """ A valid refresh token. """
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        refresh = self.refresh
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "refresh": refresh,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        refresh = d.pop("refresh")
+
+        token_refresh_request = cls(
+            refresh=refresh,
+        )
+
+        token_refresh_request.additional_properties = d
+        return token_refresh_request
+
+    @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

proxyrequest_sdk/_generated/models/token_refresh_response.py

@@ -0,0 +1,60 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar, BinaryIO, TextIO, TYPE_CHECKING, Generator
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+
+T = TypeVar("T", bound="TokenRefreshResponse")
+
+
+@_attrs_define
+class TokenRefreshResponse:
+    access: str
+    """ New access token for the same account session. """
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        access = self.access
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "access": access,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        access = d.pop("access")
+
+        token_refresh_response = cls(
+            access=access,
+        )
+
+        token_refresh_response.additional_properties = d
+        return token_refresh_response
+
+    @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

proxyrequest_sdk/_generated/models/transaction_record.py

@@ -0,0 +1,170 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar, BinaryIO, TextIO, TYPE_CHECKING, Generator
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+from typing import cast
+import datetime
+
+
+T = TypeVar("T", bound="TransactionRecord")
+
+
+@_attrs_define
+class TransactionRecord:
+    sender_uuid: None | str
+    recipient_uuid: None | str
+    type_: int
+    amount: int
+    package_uuid: None | str
+    details: None | str
+    date: datetime.datetime | None
+    timestamp: datetime.datetime | None
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        sender_uuid: None | str
+        sender_uuid = self.sender_uuid
+
+        recipient_uuid: None | str
+        recipient_uuid = self.recipient_uuid
+
+        type_ = self.type_
+
+        amount = self.amount
+
+        package_uuid: None | str
+        package_uuid = self.package_uuid
+
+        details: None | str
+        details = self.details
+
+        date: None | str
+        if isinstance(self.date, datetime.datetime):
+            date = self.date.isoformat()
+        else:
+            date = self.date
+
+        timestamp: None | str
+        if isinstance(self.timestamp, datetime.datetime):
+            timestamp = self.timestamp.isoformat()
+        else:
+            timestamp = self.timestamp
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "sender_uuid": sender_uuid,
+                "recipient_uuid": recipient_uuid,
+                "type": type_,
+                "amount": amount,
+                "package_uuid": package_uuid,
+                "details": details,
+                "date": date,
+                "timestamp": timestamp,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+
+        def _parse_sender_uuid(data: object) -> None | str:
+            if data is None:
+                return data
+            return cast(None | str, data)
+
+        sender_uuid = _parse_sender_uuid(d.pop("sender_uuid"))
+
+        def _parse_recipient_uuid(data: object) -> None | str:
+            if data is None:
+                return data
+            return cast(None | str, data)
+
+        recipient_uuid = _parse_recipient_uuid(d.pop("recipient_uuid"))
+
+        type_ = d.pop("type")
+
+        amount = d.pop("amount")
+
+        def _parse_package_uuid(data: object) -> None | str:
+            if data is None:
+                return data
+            return cast(None | str, data)
+
+        package_uuid = _parse_package_uuid(d.pop("package_uuid"))
+
+        def _parse_details(data: object) -> None | str:
+            if data is None:
+                return data
+            return cast(None | str, data)
+
+        details = _parse_details(d.pop("details"))
+
+        def _parse_date(data: object) -> datetime.datetime | None:
+            if data is None:
+                return data
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                date_type_0 = datetime.datetime.fromisoformat(data)
+
+                return date_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(datetime.datetime | None, data)
+
+        date = _parse_date(d.pop("date"))
+
+        def _parse_timestamp(data: object) -> datetime.datetime | None:
+            if data is None:
+                return data
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                timestamp_type_0 = datetime.datetime.fromisoformat(data)
+
+                return timestamp_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(datetime.datetime | None, data)
+
+        timestamp = _parse_timestamp(d.pop("timestamp"))
+
+        transaction_record = cls(
+            sender_uuid=sender_uuid,
+            recipient_uuid=recipient_uuid,
+            type_=type_,
+            amount=amount,
+            package_uuid=package_uuid,
+            details=details,
+            date=date,
+            timestamp=timestamp,
+        )
+
+        transaction_record.additional_properties = d
+        return transaction_record
+
+    @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

proxyrequest_sdk/_generated/models/transactions_response.py

@@ -0,0 +1,131 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar, BinaryIO, TextIO, TYPE_CHECKING, Generator
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+from typing import cast
+import datetime
+
+if TYPE_CHECKING:
+    from ..models.transaction_record import TransactionRecord
+
+
+T = TypeVar("T", bound="TransactionsResponse")
+
+
+@_attrs_define
+class TransactionsResponse:
+    count: int
+    next_: None | str
+    previous: None | str
+    timezone: str
+    start: datetime.datetime
+    end: datetime.datetime
+    results: list[TransactionRecord]
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.transaction_record import TransactionRecord
+
+        count = self.count
+
+        next_: None | str
+        next_ = self.next_
+
+        previous: None | str
+        previous = self.previous
+
+        timezone = self.timezone
+
+        start = self.start.isoformat()
+
+        end = self.end.isoformat()
+
+        results = []
+        for results_item_data in self.results:
+            results_item = results_item_data.to_dict()
+            results.append(results_item)
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "count": count,
+                "next": next_,
+                "previous": previous,
+                "timezone": timezone,
+                "start": start,
+                "end": end,
+                "results": results,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.transaction_record import TransactionRecord
+
+        d = dict(src_dict)
+        count = d.pop("count")
+
+        def _parse_next_(data: object) -> None | str:
+            if data is None:
+                return data
+            return cast(None | str, data)
+
+        next_ = _parse_next_(d.pop("next"))
+
+        def _parse_previous(data: object) -> None | str:
+            if data is None:
+                return data
+            return cast(None | str, data)
+
+        previous = _parse_previous(d.pop("previous"))
+
+        timezone = d.pop("timezone")
+
+        start = datetime.datetime.fromisoformat(d.pop("start"))
+
+        end = datetime.datetime.fromisoformat(d.pop("end"))
+
+        results = []
+        _results = d.pop("results")
+        for results_item_data in _results:
+            results_item = TransactionRecord.from_dict(results_item_data)
+
+            results.append(results_item)
+
+        transactions_response = cls(
+            count=count,
+            next_=next_,
+            previous=previous,
+            timezone=timezone,
+            start=start,
+            end=end,
+            results=results,
+        )
+
+        transactions_response.additional_properties = d
+        return transactions_response
+
+    @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

proxyrequest_sdk/_generated/models/two_factor_confirm_request.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar, BinaryIO, TextIO, TYPE_CHECKING, Generator
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+
+T = TypeVar("T", bound="TwoFactorConfirmRequest")
+
+
+@_attrs_define
+class TwoFactorConfirmRequest:
+    code: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        code = self.code
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "code": code,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        code = d.pop("code")
+
+        two_factor_confirm_request = cls(
+            code=code,
+        )
+
+        two_factor_confirm_request.additional_properties = d
+        return two_factor_confirm_request
+
+    @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

proxyrequest_sdk/_generated/models/two_factor_disable_request.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar, BinaryIO, TextIO, TYPE_CHECKING, Generator
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+
+T = TypeVar("T", bound="TwoFactorDisableRequest")
+
+
+@_attrs_define
+class TwoFactorDisableRequest:
+    code: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        code = self.code
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "code": code,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        code = d.pop("code")
+
+        two_factor_disable_request = cls(
+            code=code,
+        )
+
+        two_factor_disable_request.additional_properties = d
+        return two_factor_disable_request
+
+    @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