proxyrequest-sdk 1.0.0__py3-none-any.whl

proxyrequest_sdk/_generated/models/sessions_list_response_403.py

@@ -0,0 +1,99 @@
+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 ..types import UNSET, Unset
+from typing import cast
+
+
+T = TypeVar("T", bound="SessionsListResponse403")
+
+
+@_attrs_define
+class SessionsListResponse403:
+    """Validation and API error payload. Field names may be added dynamically; field errors are returned as arrays of
+    human-readable messages.
+
+    """
+
+    detail: str | Unset = UNSET
+    non_field_errors: list[str] | Unset = UNSET
+    additional_properties: dict[str, list[str] | str] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        detail = self.detail
+
+        non_field_errors: list[str] | Unset = UNSET
+        if not isinstance(self.non_field_errors, Unset):
+            non_field_errors = self.non_field_errors
+
+        field_dict: dict[str, Any] = {}
+        for prop_name, prop in self.additional_properties.items():
+            if isinstance(prop, list):
+                field_dict[prop_name] = prop
+
+            else:
+                field_dict[prop_name] = prop
+
+        field_dict.update({})
+        if detail is not UNSET:
+            field_dict["detail"] = detail
+        if non_field_errors is not UNSET:
+            field_dict["non_field_errors"] = non_field_errors
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        detail = d.pop("detail", UNSET)
+
+        non_field_errors = cast(list[str], d.pop("non_field_errors", UNSET))
+
+        sessions_list_response_403 = cls(
+            detail=detail,
+            non_field_errors=non_field_errors,
+        )
+
+        additional_properties = {}
+        for prop_name, prop_dict in d.items():
+
+            def _parse_additional_property(data: object) -> list[str] | str:
+                try:
+                    if not isinstance(data, list):
+                        raise TypeError()
+                    additional_property_type_1 = cast(list[str], data)
+
+                    return additional_property_type_1
+                except (TypeError, ValueError, AttributeError, KeyError):
+                    pass
+                return cast(list[str] | str, data)
+
+            additional_property = _parse_additional_property(prop_dict)
+
+            additional_properties[prop_name] = additional_property
+
+        sessions_list_response_403.additional_properties = additional_properties
+        return sessions_list_response_403
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> list[str] | str:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: list[str] | str) -> 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/settings_crypto.py

@@ -0,0 +1,61 @@
+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
+
+
+T = TypeVar("T", bound="SettingsCrypto")
+
+
+@_attrs_define
+class SettingsCrypto:
+    currencies: list[str]
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        currencies = self.currencies
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "currencies": currencies,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        currencies = cast(list[str], d.pop("currencies"))
+
+        settings_crypto = cls(
+            currencies=currencies,
+        )
+
+        settings_crypto.additional_properties = d
+        return settings_crypto
+
+    @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/settings_gateway.py

@@ -0,0 +1,118 @@
+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
+from uuid import UUID
+
+
+T = TypeVar("T", bound="SettingsGateway")
+
+
+@_attrs_define
+class SettingsGateway:
+    id: UUID
+    name: str
+    region: str
+    hostname: str
+    hostnames: list[str]
+    port_http: int
+    port_socks5: int
+    port_auto: int
+    port_haproxy: int
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        id = str(self.id)
+
+        name = self.name
+
+        region = self.region
+
+        hostname = self.hostname
+
+        hostnames = self.hostnames
+
+        port_http = self.port_http
+
+        port_socks5 = self.port_socks5
+
+        port_auto = self.port_auto
+
+        port_haproxy = self.port_haproxy
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "id": id,
+                "name": name,
+                "region": region,
+                "hostname": hostname,
+                "hostnames": hostnames,
+                "port_http": port_http,
+                "port_socks5": port_socks5,
+                "port_auto": port_auto,
+                "port_haproxy": port_haproxy,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        id = UUID(d.pop("id"))
+
+        name = d.pop("name")
+
+        region = d.pop("region")
+
+        hostname = d.pop("hostname")
+
+        hostnames = cast(list[str], d.pop("hostnames"))
+
+        port_http = d.pop("port_http")
+
+        port_socks5 = d.pop("port_socks5")
+
+        port_auto = d.pop("port_auto")
+
+        port_haproxy = d.pop("port_haproxy")
+
+        settings_gateway = cls(
+            id=id,
+            name=name,
+            region=region,
+            hostname=hostname,
+            hostnames=hostnames,
+            port_http=port_http,
+            port_socks5=port_socks5,
+            port_auto=port_auto,
+            port_haproxy=port_haproxy,
+        )
+
+        settings_gateway.additional_properties = d
+        return settings_gateway
+
+    @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/settings_referral.py

@@ -0,0 +1,80 @@
+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="SettingsReferral")
+
+
+@_attrs_define
+class SettingsReferral:
+    reward_balance_percentage: float
+    reward_data_percentage: float
+    reward_min_balance: float
+    reward_min_data: float
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        reward_balance_percentage = self.reward_balance_percentage
+
+        reward_data_percentage = self.reward_data_percentage
+
+        reward_min_balance = self.reward_min_balance
+
+        reward_min_data = self.reward_min_data
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "reward_balance_percentage": reward_balance_percentage,
+                "reward_data_percentage": reward_data_percentage,
+                "reward_min_balance": reward_min_balance,
+                "reward_min_data": reward_min_data,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        reward_balance_percentage = d.pop("reward_balance_percentage")
+
+        reward_data_percentage = d.pop("reward_data_percentage")
+
+        reward_min_balance = d.pop("reward_min_balance")
+
+        reward_min_data = d.pop("reward_min_data")
+
+        settings_referral = cls(
+            reward_balance_percentage=reward_balance_percentage,
+            reward_data_percentage=reward_data_percentage,
+            reward_min_balance=reward_min_balance,
+            reward_min_data=reward_min_data,
+        )
+
+        settings_referral.additional_properties = d
+        return settings_referral
+
+    @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/settings_response.py

@@ -0,0 +1,138 @@
+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
+
+if TYPE_CHECKING:
+    from ..models.settings_crypto import SettingsCrypto
+    from ..models.settings_gateway import SettingsGateway
+    from ..models.settings_referral import SettingsReferral
+
+
+T = TypeVar("T", bound="SettingsResponse")
+
+
+@_attrs_define
+class SettingsResponse:
+    gateways: list[SettingsGateway]
+    spent_total: float
+    orders_total: int
+    orders_active: int
+    data_available: int
+    data_spent: int
+    referrals: SettingsReferral
+    crypto: SettingsCrypto
+    payment_methods: list[str]
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.settings_crypto import SettingsCrypto
+        from ..models.settings_gateway import SettingsGateway
+        from ..models.settings_referral import SettingsReferral
+
+        gateways = []
+        for gateways_item_data in self.gateways:
+            gateways_item = gateways_item_data.to_dict()
+            gateways.append(gateways_item)
+
+        spent_total = self.spent_total
+
+        orders_total = self.orders_total
+
+        orders_active = self.orders_active
+
+        data_available = self.data_available
+
+        data_spent = self.data_spent
+
+        referrals = self.referrals.to_dict()
+
+        crypto = self.crypto.to_dict()
+
+        payment_methods = self.payment_methods
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "gateways": gateways,
+                "spent_total": spent_total,
+                "orders_total": orders_total,
+                "orders_active": orders_active,
+                "data_available": data_available,
+                "data_spent": data_spent,
+                "referrals": referrals,
+                "crypto": crypto,
+                "payment_methods": payment_methods,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.settings_crypto import SettingsCrypto
+        from ..models.settings_gateway import SettingsGateway
+        from ..models.settings_referral import SettingsReferral
+
+        d = dict(src_dict)
+        gateways = []
+        _gateways = d.pop("gateways")
+        for gateways_item_data in _gateways:
+            gateways_item = SettingsGateway.from_dict(gateways_item_data)
+
+            gateways.append(gateways_item)
+
+        spent_total = d.pop("spent_total")
+
+        orders_total = d.pop("orders_total")
+
+        orders_active = d.pop("orders_active")
+
+        data_available = d.pop("data_available")
+
+        data_spent = d.pop("data_spent")
+
+        referrals = SettingsReferral.from_dict(d.pop("referrals"))
+
+        crypto = SettingsCrypto.from_dict(d.pop("crypto"))
+
+        payment_methods = cast(list[str], d.pop("payment_methods"))
+
+        settings_response = cls(
+            gateways=gateways,
+            spent_total=spent_total,
+            orders_total=orders_total,
+            orders_active=orders_active,
+            data_available=data_available,
+            data_spent=data_spent,
+            referrals=referrals,
+            crypto=crypto,
+            payment_methods=payment_methods,
+        )
+
+        settings_response.additional_properties = d
+        return settings_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/settings_retrieve_response_400.py

@@ -0,0 +1,99 @@
+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 ..types import UNSET, Unset
+from typing import cast
+
+
+T = TypeVar("T", bound="SettingsRetrieveResponse400")
+
+
+@_attrs_define
+class SettingsRetrieveResponse400:
+    """Validation and API error payload. Field names may be added dynamically; field errors are returned as arrays of
+    human-readable messages.
+
+    """
+
+    detail: str | Unset = UNSET
+    non_field_errors: list[str] | Unset = UNSET
+    additional_properties: dict[str, list[str] | str] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        detail = self.detail
+
+        non_field_errors: list[str] | Unset = UNSET
+        if not isinstance(self.non_field_errors, Unset):
+            non_field_errors = self.non_field_errors
+
+        field_dict: dict[str, Any] = {}
+        for prop_name, prop in self.additional_properties.items():
+            if isinstance(prop, list):
+                field_dict[prop_name] = prop
+
+            else:
+                field_dict[prop_name] = prop
+
+        field_dict.update({})
+        if detail is not UNSET:
+            field_dict["detail"] = detail
+        if non_field_errors is not UNSET:
+            field_dict["non_field_errors"] = non_field_errors
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        detail = d.pop("detail", UNSET)
+
+        non_field_errors = cast(list[str], d.pop("non_field_errors", UNSET))
+
+        settings_retrieve_response_400 = cls(
+            detail=detail,
+            non_field_errors=non_field_errors,
+        )
+
+        additional_properties = {}
+        for prop_name, prop_dict in d.items():
+
+            def _parse_additional_property(data: object) -> list[str] | str:
+                try:
+                    if not isinstance(data, list):
+                        raise TypeError()
+                    additional_property_type_1 = cast(list[str], data)
+
+                    return additional_property_type_1
+                except (TypeError, ValueError, AttributeError, KeyError):
+                    pass
+                return cast(list[str] | str, data)
+
+            additional_property = _parse_additional_property(prop_dict)
+
+            additional_properties[prop_name] = additional_property
+
+        settings_retrieve_response_400.additional_properties = additional_properties
+        return settings_retrieve_response_400
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> list[str] | str:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: list[str] | str) -> 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/settings_retrieve_response_401.py

@@ -0,0 +1,99 @@
+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 ..types import UNSET, Unset
+from typing import cast
+
+
+T = TypeVar("T", bound="SettingsRetrieveResponse401")
+
+
+@_attrs_define
+class SettingsRetrieveResponse401:
+    """Validation and API error payload. Field names may be added dynamically; field errors are returned as arrays of
+    human-readable messages.
+
+    """
+
+    detail: str | Unset = UNSET
+    non_field_errors: list[str] | Unset = UNSET
+    additional_properties: dict[str, list[str] | str] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        detail = self.detail
+
+        non_field_errors: list[str] | Unset = UNSET
+        if not isinstance(self.non_field_errors, Unset):
+            non_field_errors = self.non_field_errors
+
+        field_dict: dict[str, Any] = {}
+        for prop_name, prop in self.additional_properties.items():
+            if isinstance(prop, list):
+                field_dict[prop_name] = prop
+
+            else:
+                field_dict[prop_name] = prop
+
+        field_dict.update({})
+        if detail is not UNSET:
+            field_dict["detail"] = detail
+        if non_field_errors is not UNSET:
+            field_dict["non_field_errors"] = non_field_errors
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        detail = d.pop("detail", UNSET)
+
+        non_field_errors = cast(list[str], d.pop("non_field_errors", UNSET))
+
+        settings_retrieve_response_401 = cls(
+            detail=detail,
+            non_field_errors=non_field_errors,
+        )
+
+        additional_properties = {}
+        for prop_name, prop_dict in d.items():
+
+            def _parse_additional_property(data: object) -> list[str] | str:
+                try:
+                    if not isinstance(data, list):
+                        raise TypeError()
+                    additional_property_type_1 = cast(list[str], data)
+
+                    return additional_property_type_1
+                except (TypeError, ValueError, AttributeError, KeyError):
+                    pass
+                return cast(list[str] | str, data)
+
+            additional_property = _parse_additional_property(prop_dict)
+
+            additional_properties[prop_name] = additional_property
+
+        settings_retrieve_response_401.additional_properties = additional_properties
+        return settings_retrieve_response_401
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> list[str] | str:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: list[str] | str) -> 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