proxyrequest-sdk 1.0.0__py3-none-any.whl

proxyrequest_sdk/_generated/models/region.py

@@ -0,0 +1,145 @@
+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
+
+if TYPE_CHECKING:
+    from ..models.location_code_name import LocationCodeName
+    from ..models.location_country_summary import LocationCountrySummary
+
+
+T = TypeVar("T", bound="Region")
+
+
+@_attrs_define
+class Region:
+    code: str
+    """ Raw region code as it appears in the source data. Used together with country to form a unique identifier.
+    california ile_de_france """
+    name: str
+    """ English display name of the region used across the admin and API responses. """
+    country: LocationCountrySummary
+    isps: list[LocationCodeName]
+    asns: list[LocationCodeName]
+    id: str | Unset = UNSET
+    iso31662: str | Unset = UNSET
+    """ ISO 3166-2 subdivision code for this region. US-CA FR-IDF """
+    original_name: str | Unset = UNSET
+    """ Native-language name of the region as it appears in the source data. """
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.location_code_name import LocationCodeName
+        from ..models.location_country_summary import LocationCountrySummary
+
+        code = self.code
+
+        name = self.name
+
+        country = self.country.to_dict()
+
+        isps = []
+        for isps_item_data in self.isps:
+            isps_item = isps_item_data.to_dict()
+            isps.append(isps_item)
+
+        asns = []
+        for asns_item_data in self.asns:
+            asns_item = asns_item_data.to_dict()
+            asns.append(asns_item)
+
+        id = self.id
+
+        iso31662 = self.iso31662
+
+        original_name = self.original_name
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "code": code,
+                "name": name,
+                "country": country,
+                "isps": isps,
+                "asns": asns,
+            }
+        )
+        if id is not UNSET:
+            field_dict["id"] = id
+        if iso31662 is not UNSET:
+            field_dict["iso31662"] = iso31662
+        if original_name is not UNSET:
+            field_dict["original_name"] = original_name
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.location_code_name import LocationCodeName
+        from ..models.location_country_summary import LocationCountrySummary
+
+        d = dict(src_dict)
+        code = d.pop("code")
+
+        name = d.pop("name")
+
+        country = LocationCountrySummary.from_dict(d.pop("country"))
+
+        isps = []
+        _isps = d.pop("isps")
+        for isps_item_data in _isps:
+            isps_item = LocationCodeName.from_dict(isps_item_data)
+
+            isps.append(isps_item)
+
+        asns = []
+        _asns = d.pop("asns")
+        for asns_item_data in _asns:
+            asns_item = LocationCodeName.from_dict(asns_item_data)
+
+            asns.append(asns_item)
+
+        id = d.pop("id", UNSET)
+
+        iso31662 = d.pop("iso31662", UNSET)
+
+        original_name = d.pop("original_name", UNSET)
+
+        region = cls(
+            code=code,
+            name=name,
+            country=country,
+            isps=isps,
+            asns=asns,
+            id=id,
+            iso31662=iso31662,
+            original_name=original_name,
+        )
+
+        region.additional_properties = d
+        return region
+
+    @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/reset_password_create_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="ResetPasswordCreateResponse400")
+
+
+@_attrs_define
+class ResetPasswordCreateResponse400:
+    """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))
+
+        reset_password_create_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
+
+        reset_password_create_response_400.additional_properties = additional_properties
+        return reset_password_create_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/reset_password_create_response_404.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="ResetPasswordCreateResponse404")
+
+
+@_attrs_define
+class ResetPasswordCreateResponse404:
+    """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))
+
+        reset_password_create_response_404 = 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
+
+        reset_password_create_response_404.additional_properties = additional_properties
+        return reset_password_create_response_404
+
+    @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/reset_password_request.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 uuid import UUID
+
+
+T = TypeVar("T", bound="ResetPasswordRequest")
+
+
+@_attrs_define
+class ResetPasswordRequest:
+    order_id: UUID
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        order_id = str(self.order_id)
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "order_id": order_id,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        order_id = UUID(d.pop("order_id"))
+
+        reset_password_request = cls(
+            order_id=order_id,
+        )
+
+        reset_password_request.additional_properties = d
+        return reset_password_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/reward.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 ..models.level_enum import LevelEnum
+from ..models.reward_status_enum import RewardStatusEnum
+from ..types import UNSET, Unset
+from typing import cast
+import datetime
+
+
+T = TypeVar("T", bound="Reward")
+
+
+@_attrs_define
+class Reward:
+    email: str
+    created: datetime.datetime
+    id: str | Unset = UNSET
+    balance: int | Unset = UNSET
+    data: int | Unset = UNSET
+    """ The amount of data in bytes. """
+    status: RewardStatusEnum | Unset = UNSET
+    """ * `pending` - Pending * `paid` - Paid * `review` - Review * `cancelled` - Cancelled """
+    description: str | Unset = UNSET
+    """ Description of the reward, used to include payout details. """
+    level: LevelEnum | Unset = UNSET
+    """ * `standard` - Standard * `silver` - Silver * `gold` - Gold * `diamond` - Diamond """
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        email = self.email
+
+        created = self.created.isoformat()
+
+        id = self.id
+
+        balance = self.balance
+
+        data = self.data
+
+        status: str | Unset = UNSET
+        if not isinstance(self.status, Unset):
+            status = self.status.value
+
+        description = self.description
+
+        level: str | Unset = UNSET
+        if not isinstance(self.level, Unset):
+            level = self.level.value
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "email": email,
+                "created": created,
+            }
+        )
+        if id is not UNSET:
+            field_dict["id"] = id
+        if balance is not UNSET:
+            field_dict["balance"] = balance
+        if data is not UNSET:
+            field_dict["data"] = data
+        if status is not UNSET:
+            field_dict["status"] = status
+        if description is not UNSET:
+            field_dict["description"] = description
+        if level is not UNSET:
+            field_dict["level"] = level
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        email = d.pop("email")
+
+        created = datetime.datetime.fromisoformat(d.pop("created"))
+
+        id = d.pop("id", UNSET)
+
+        balance = d.pop("balance", UNSET)
+
+        data = d.pop("data", UNSET)
+
+        _status = d.pop("status", UNSET)
+        status: RewardStatusEnum | Unset
+        if isinstance(_status, Unset):
+            status = UNSET
+        else:
+            status = RewardStatusEnum(_status)
+
+        description = d.pop("description", UNSET)
+
+        _level = d.pop("level", UNSET)
+        level: LevelEnum | Unset
+        if isinstance(_level, Unset):
+            level = UNSET
+        else:
+            level = LevelEnum(_level)
+
+        reward = cls(
+            email=email,
+            created=created,
+            id=id,
+            balance=balance,
+            data=data,
+            status=status,
+            description=description,
+            level=level,
+        )
+
+        reward.additional_properties = d
+        return reward
+
+    @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/reward_claim_request.py

@@ -0,0 +1,71 @@
+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
+
+
+T = TypeVar("T", bound="RewardClaimRequest")
+
+
+@_attrs_define
+class RewardClaimRequest:
+    type_: str
+    """ Reward balance to claim, for example balance or data. """
+    description: str | Unset = UNSET
+    """ Optional note stored with the claim. """
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        type_ = self.type_
+
+        description = self.description
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "type": type_,
+            }
+        )
+        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)
+        type_ = d.pop("type")
+
+        description = d.pop("description", UNSET)
+
+        reward_claim_request = cls(
+            type_=type_,
+            description=description,
+        )
+
+        reward_claim_request.additional_properties = d
+        return reward_claim_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/reward_status_enum.py

@@ -0,0 +1,20 @@
+from enum import Enum
+
+
+class RewardStatusEnum(str, Enum):
+    @classmethod
+    def _missing_(cls, value: object):
+        if not isinstance(value, str):
+            return None
+        member = str.__new__(cls, value)
+        member._name_ = f"UNKNOWN_{value}"
+        member._value_ = value
+        return member
+
+    CANCELLED = "cancelled"
+    PAID = "paid"
+    PENDING = "pending"
+    REVIEW = "review"
+
+    def __str__(self) -> str:
+        return str(self.value)