proxyrequest-sdk 1.0.0__py3-none-any.whl

proxyrequest_sdk/_generated/models/commission_type_enum.py

@@ -0,0 +1,19 @@
+from enum import Enum
+
+
+class CommissionTypeEnum(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
+
+    FIXED = "fixed"
+    FLEXIBLE = "flexible"
+    PERCENTAGE = "percentage"
+
+    def __str__(self) -> str:
+        return str(self.value)

proxyrequest_sdk/_generated/models/connection_record.py

@@ -0,0 +1,82 @@
+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="ConnectionRecord")
+
+
+@_attrs_define
+class ConnectionRecord:
+    user_id: UUID
+    package_id: UUID
+    connections: int
+    server_ip: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        user_id = str(self.user_id)
+
+        package_id = str(self.package_id)
+
+        connections = self.connections
+
+        server_ip = self.server_ip
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "user_id": user_id,
+                "package_id": package_id,
+                "connections": connections,
+                "server_ip": server_ip,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        user_id = UUID(d.pop("user_id"))
+
+        package_id = UUID(d.pop("package_id"))
+
+        connections = d.pop("connections")
+
+        server_ip = d.pop("server_ip")
+
+        connection_record = cls(
+            user_id=user_id,
+            package_id=package_id,
+            connections=connections,
+            server_ip=server_ip,
+        )
+
+        connection_record.additional_properties = d
+        return connection_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/connections_response.py

@@ -0,0 +1,109 @@
+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.connection_record import ConnectionRecord
+
+
+T = TypeVar("T", bound="ConnectionsResponse")
+
+
+@_attrs_define
+class ConnectionsResponse:
+    count: int
+    next_: None | str
+    previous: None | str
+    results: list[ConnectionRecord]
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.connection_record import ConnectionRecord
+
+        count = self.count
+
+        next_: None | str
+        next_ = self.next_
+
+        previous: None | str
+        previous = self.previous
+
+        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,
+                "results": results,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.connection_record import ConnectionRecord
+
+        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"))
+
+        results = []
+        _results = d.pop("results")
+        for results_item_data in _results:
+            results_item = ConnectionRecord.from_dict(results_item_data)
+
+            results.append(results_item)
+
+        connections_response = cls(
+            count=count,
+            next_=next_,
+            previous=previous,
+            results=results,
+        )
+
+        connections_response.additional_properties = d
+        return connections_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/continent.py

@@ -0,0 +1,78 @@
+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="Continent")
+
+
+@_attrs_define
+class Continent:
+    code: str
+    """ Two-letter ISO 3166-1 alpha-2 country code. Must be unique. us de fr """
+    name: str
+    """ English display name of the country used across the admin and API responses. """
+    id: str | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        code = self.code
+
+        name = self.name
+
+        id = self.id
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "code": code,
+                "name": name,
+            }
+        )
+        if id is not UNSET:
+            field_dict["id"] = id
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        code = d.pop("code")
+
+        name = d.pop("name")
+
+        id = d.pop("id", UNSET)
+
+        continent = cls(
+            code=code,
+            name=name,
+            id=id,
+        )
+
+        continent.additional_properties = d
+        return continent
+
+    @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/country.py

@@ -0,0 +1,125 @@
+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
+
+
+T = TypeVar("T", bound="Country")
+
+
+@_attrs_define
+class Country:
+    code: str
+    """ Two-letter ISO 3166-1 alpha-2 country code. Must be unique. us de fr """
+    name: str
+    """ English display name of the country used across the admin and API responses. """
+    isps: list[LocationCodeName]
+    asns: list[LocationCodeName]
+    id: str | Unset = UNSET
+    original_name: str | Unset = UNSET
+    """ Native-language name of the country as it appears in the source data. Deutschland Français """
+    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
+
+        code = self.code
+
+        name = self.name
+
+        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
+
+        original_name = self.original_name
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "code": code,
+                "name": name,
+                "isps": isps,
+                "asns": asns,
+            }
+        )
+        if id is not UNSET:
+            field_dict["id"] = id
+        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
+
+        d = dict(src_dict)
+        code = d.pop("code")
+
+        name = d.pop("name")
+
+        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)
+
+        original_name = d.pop("original_name", UNSET)
+
+        country = cls(
+            code=code,
+            name=name,
+            isps=isps,
+            asns=asns,
+            id=id,
+            original_name=original_name,
+        )
+
+        country.additional_properties = d
+        return country
+
+    @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/coupon.py

@@ -0,0 +1,279 @@
+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.coupon_type_enum import CouponTypeEnum
+from ..types import UNSET, Unset
+from typing import cast
+from uuid import UUID
+import datetime
+
+if TYPE_CHECKING:
+    from ..models.coupon_stats_type_0 import CouponStatsType0
+    from ..models.package_short import PackageShort
+
+
+T = TypeVar("T", bound="Coupon")
+
+
+@_attrs_define
+class Coupon:
+    redeemed_count: int
+    is_expired: bool
+    is_redeemed: bool
+    packages: list[PackageShort]
+    stats: CouponStatsType0 | None
+    created: datetime.datetime
+    value: int
+    """ Arbitrary coupon value """
+    code: str
+    """ Leaving this field empty will generate a random code. """
+    type_: CouponTypeEnum
+    """ * `free_data` - Free Data * `monetary` - Money * `percentage` - Percentage """
+    user: None | UUID
+    """ The user who created this coupon. """
+    id: str | Unset = UNSET
+    is_multi_use: bool | Unset = UNSET
+    """ If true, coupon can be used multiple times. """
+    is_available_to_one_time: bool | Unset = UNSET
+    """ If true, coupon can not be used for one-time package tiers. """
+    limit: int | Unset = UNSET
+    """ Number of times coupon can be used """
+    valid_until: datetime.datetime | None | Unset = UNSET
+    """ Leave empty for coupons that never expire """
+    marketer: None | Unset | UUID = UNSET
+    """ The marketer who owns this coupon. Required if is_marketer is true. """
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.coupon_stats_type_0 import CouponStatsType0
+        from ..models.package_short import PackageShort
+
+        redeemed_count = self.redeemed_count
+
+        is_expired = self.is_expired
+
+        is_redeemed = self.is_redeemed
+
+        packages = []
+        for packages_item_data in self.packages:
+            packages_item = packages_item_data.to_dict()
+            packages.append(packages_item)
+
+        stats: dict[str, Any] | None
+        if isinstance(self.stats, CouponStatsType0):
+            stats = self.stats.to_dict()
+        else:
+            stats = self.stats
+
+        created = self.created.isoformat()
+
+        value = self.value
+
+        code = self.code
+
+        type_ = self.type_.value
+
+        user: None | str
+        if isinstance(self.user, UUID):
+            user = str(self.user)
+        else:
+            user = self.user
+
+        id = self.id
+
+        is_multi_use = self.is_multi_use
+
+        is_available_to_one_time = self.is_available_to_one_time
+
+        limit = self.limit
+
+        valid_until: None | str | Unset
+        if isinstance(self.valid_until, Unset):
+            valid_until = UNSET
+        elif isinstance(self.valid_until, datetime.datetime):
+            valid_until = self.valid_until.isoformat()
+        else:
+            valid_until = self.valid_until
+
+        marketer: None | str | Unset
+        if isinstance(self.marketer, Unset):
+            marketer = UNSET
+        elif isinstance(self.marketer, UUID):
+            marketer = str(self.marketer)
+        else:
+            marketer = self.marketer
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "redeemed_count": redeemed_count,
+                "is_expired": is_expired,
+                "is_redeemed": is_redeemed,
+                "packages": packages,
+                "stats": stats,
+                "created": created,
+                "value": value,
+                "code": code,
+                "type": type_,
+                "user": user,
+            }
+        )
+        if id is not UNSET:
+            field_dict["id"] = id
+        if is_multi_use is not UNSET:
+            field_dict["is_multi_use"] = is_multi_use
+        if is_available_to_one_time is not UNSET:
+            field_dict["is_available_to_one_time"] = is_available_to_one_time
+        if limit is not UNSET:
+            field_dict["limit"] = limit
+        if valid_until is not UNSET:
+            field_dict["valid_until"] = valid_until
+        if marketer is not UNSET:
+            field_dict["marketer"] = marketer
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.coupon_stats_type_0 import CouponStatsType0
+        from ..models.package_short import PackageShort
+
+        d = dict(src_dict)
+        redeemed_count = d.pop("redeemed_count")
+
+        is_expired = d.pop("is_expired")
+
+        is_redeemed = d.pop("is_redeemed")
+
+        packages = []
+        _packages = d.pop("packages")
+        for packages_item_data in _packages:
+            packages_item = PackageShort.from_dict(packages_item_data)
+
+            packages.append(packages_item)
+
+        def _parse_stats(data: object) -> CouponStatsType0 | None:
+            if data is None:
+                return data
+            try:
+                if not isinstance(data, dict):
+                    raise TypeError()
+                stats_type_0 = CouponStatsType0.from_dict(data)
+
+                return stats_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(CouponStatsType0 | None, data)
+
+        stats = _parse_stats(d.pop("stats"))
+
+        created = datetime.datetime.fromisoformat(d.pop("created"))
+
+        value = d.pop("value")
+
+        code = d.pop("code")
+
+        type_ = CouponTypeEnum(d.pop("type"))
+
+        def _parse_user(data: object) -> None | UUID:
+            if data is None:
+                return data
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                user_type_0 = UUID(data)
+
+                return user_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(None | UUID, data)
+
+        user = _parse_user(d.pop("user"))
+
+        id = d.pop("id", UNSET)
+
+        is_multi_use = d.pop("is_multi_use", UNSET)
+
+        is_available_to_one_time = d.pop("is_available_to_one_time", UNSET)
+
+        limit = d.pop("limit", UNSET)
+
+        def _parse_valid_until(data: object) -> datetime.datetime | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                valid_until_type_0 = datetime.datetime.fromisoformat(data)
+
+                return valid_until_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(datetime.datetime | None | Unset, data)
+
+        valid_until = _parse_valid_until(d.pop("valid_until", UNSET))
+
+        def _parse_marketer(data: object) -> None | Unset | UUID:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                marketer_type_0 = UUID(data)
+
+                return marketer_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(None | Unset | UUID, data)
+
+        marketer = _parse_marketer(d.pop("marketer", UNSET))
+
+        coupon = cls(
+            redeemed_count=redeemed_count,
+            is_expired=is_expired,
+            is_redeemed=is_redeemed,
+            packages=packages,
+            stats=stats,
+            created=created,
+            value=value,
+            code=code,
+            type_=type_,
+            user=user,
+            id=id,
+            is_multi_use=is_multi_use,
+            is_available_to_one_time=is_available_to_one_time,
+            limit=limit,
+            valid_until=valid_until,
+            marketer=marketer,
+        )
+
+        coupon.additional_properties = d
+        return coupon
+
+    @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