proxyrequest-sdk 1.0.0__py3-none-any.whl

proxyrequest_sdk/_generated/models/targeting_options.py

@@ -0,0 +1,227 @@
+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="TargetingOptions")
+
+
+@_attrs_define
+class TargetingOptions:
+    package: str
+    split_char: str
+    value_char: str
+    continent: str
+    country: str
+    region: str
+    city: str
+    asn: str
+    isp: str
+    username: str
+    pool: str
+    location: str
+    location_format: str
+    session: str
+    session_mode_tag: str
+    session_ttl: str
+    session_ttl_format: int
+    os: str
+    os_combined: bool
+    os_split_char: str
+    os_linux: str
+    os_windows: str
+    os_ios: str
+    os_macos: str
+    os_android: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        package = self.package
+
+        split_char = self.split_char
+
+        value_char = self.value_char
+
+        continent = self.continent
+
+        country = self.country
+
+        region = self.region
+
+        city = self.city
+
+        asn = self.asn
+
+        isp = self.isp
+
+        username = self.username
+
+        pool = self.pool
+
+        location = self.location
+
+        location_format = self.location_format
+
+        session = self.session
+
+        session_mode_tag = self.session_mode_tag
+
+        session_ttl = self.session_ttl
+
+        session_ttl_format = self.session_ttl_format
+
+        os = self.os
+
+        os_combined = self.os_combined
+
+        os_split_char = self.os_split_char
+
+        os_linux = self.os_linux
+
+        os_windows = self.os_windows
+
+        os_ios = self.os_ios
+
+        os_macos = self.os_macos
+
+        os_android = self.os_android
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "package": package,
+                "split_char": split_char,
+                "value_char": value_char,
+                "continent": continent,
+                "country": country,
+                "region": region,
+                "city": city,
+                "asn": asn,
+                "isp": isp,
+                "username": username,
+                "pool": pool,
+                "location": location,
+                "location_format": location_format,
+                "session": session,
+                "session_mode_tag": session_mode_tag,
+                "session_ttl": session_ttl,
+                "session_ttl_format": session_ttl_format,
+                "os": os,
+                "os_combined": os_combined,
+                "os_split_char": os_split_char,
+                "os_linux": os_linux,
+                "os_windows": os_windows,
+                "os_ios": os_ios,
+                "os_macos": os_macos,
+                "os_android": os_android,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        package = d.pop("package")
+
+        split_char = d.pop("split_char")
+
+        value_char = d.pop("value_char")
+
+        continent = d.pop("continent")
+
+        country = d.pop("country")
+
+        region = d.pop("region")
+
+        city = d.pop("city")
+
+        asn = d.pop("asn")
+
+        isp = d.pop("isp")
+
+        username = d.pop("username")
+
+        pool = d.pop("pool")
+
+        location = d.pop("location")
+
+        location_format = d.pop("location_format")
+
+        session = d.pop("session")
+
+        session_mode_tag = d.pop("session_mode_tag")
+
+        session_ttl = d.pop("session_ttl")
+
+        session_ttl_format = d.pop("session_ttl_format")
+
+        os = d.pop("os")
+
+        os_combined = d.pop("os_combined")
+
+        os_split_char = d.pop("os_split_char")
+
+        os_linux = d.pop("os_linux")
+
+        os_windows = d.pop("os_windows")
+
+        os_ios = d.pop("os_ios")
+
+        os_macos = d.pop("os_macos")
+
+        os_android = d.pop("os_android")
+
+        targeting_options = cls(
+            package=package,
+            split_char=split_char,
+            value_char=value_char,
+            continent=continent,
+            country=country,
+            region=region,
+            city=city,
+            asn=asn,
+            isp=isp,
+            username=username,
+            pool=pool,
+            location=location,
+            location_format=location_format,
+            session=session,
+            session_mode_tag=session_mode_tag,
+            session_ttl=session_ttl,
+            session_ttl_format=session_ttl_format,
+            os=os,
+            os_combined=os_combined,
+            os_split_char=os_split_char,
+            os_linux=os_linux,
+            os_windows=os_windows,
+            os_ios=os_ios,
+            os_macos=os_macos,
+            os_android=os_android,
+        )
+
+        targeting_options.additional_properties = d
+        return targeting_options
+
+    @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/telegram_connection_response.py

@@ -0,0 +1,157 @@
+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
+import datetime
+
+
+T = TypeVar("T", bound="TelegramConnectionResponse")
+
+
+@_attrs_define
+class TelegramConnectionResponse:
+    available: bool
+    status: str
+    bot_username: str
+    locale: str
+    timezone: str
+    telegram_username: str | Unset = UNSET
+    linked_at: datetime.datetime | None | Unset = UNSET
+    pending_expires_at: datetime.datetime | None | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        available = self.available
+
+        status = self.status
+
+        bot_username = self.bot_username
+
+        locale = self.locale
+
+        timezone = self.timezone
+
+        telegram_username = self.telegram_username
+
+        linked_at: None | str | Unset
+        if isinstance(self.linked_at, Unset):
+            linked_at = UNSET
+        elif isinstance(self.linked_at, datetime.datetime):
+            linked_at = self.linked_at.isoformat()
+        else:
+            linked_at = self.linked_at
+
+        pending_expires_at: None | str | Unset
+        if isinstance(self.pending_expires_at, Unset):
+            pending_expires_at = UNSET
+        elif isinstance(self.pending_expires_at, datetime.datetime):
+            pending_expires_at = self.pending_expires_at.isoformat()
+        else:
+            pending_expires_at = self.pending_expires_at
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "available": available,
+                "status": status,
+                "bot_username": bot_username,
+                "locale": locale,
+                "timezone": timezone,
+            }
+        )
+        if telegram_username is not UNSET:
+            field_dict["telegram_username"] = telegram_username
+        if linked_at is not UNSET:
+            field_dict["linked_at"] = linked_at
+        if pending_expires_at is not UNSET:
+            field_dict["pending_expires_at"] = pending_expires_at
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        available = d.pop("available")
+
+        status = d.pop("status")
+
+        bot_username = d.pop("bot_username")
+
+        locale = d.pop("locale")
+
+        timezone = d.pop("timezone")
+
+        telegram_username = d.pop("telegram_username", UNSET)
+
+        def _parse_linked_at(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()
+                linked_at_type_0 = datetime.datetime.fromisoformat(data)
+
+                return linked_at_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(datetime.datetime | None | Unset, data)
+
+        linked_at = _parse_linked_at(d.pop("linked_at", UNSET))
+
+        def _parse_pending_expires_at(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()
+                pending_expires_at_type_0 = datetime.datetime.fromisoformat(data)
+
+                return pending_expires_at_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(datetime.datetime | None | Unset, data)
+
+        pending_expires_at = _parse_pending_expires_at(d.pop("pending_expires_at", UNSET))
+
+        telegram_connection_response = cls(
+            available=available,
+            status=status,
+            bot_username=bot_username,
+            locale=locale,
+            timezone=timezone,
+            telegram_username=telegram_username,
+            linked_at=linked_at,
+            pending_expires_at=pending_expires_at,
+        )
+
+        telegram_connection_response.additional_properties = d
+        return telegram_connection_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/telegram_link_consume_request.py

@@ -0,0 +1,91 @@
+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="TelegramLinkConsumeRequest")
+
+
+@_attrs_define
+class TelegramLinkConsumeRequest:
+    token: str
+    telegram_user_id: int
+    chat_id: int
+    username: str | Unset = UNSET
+    language_code: str | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        token = self.token
+
+        telegram_user_id = self.telegram_user_id
+
+        chat_id = self.chat_id
+
+        username = self.username
+
+        language_code = self.language_code
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "token": token,
+                "telegram_user_id": telegram_user_id,
+                "chat_id": chat_id,
+            }
+        )
+        if username is not UNSET:
+            field_dict["username"] = username
+        if language_code is not UNSET:
+            field_dict["language_code"] = language_code
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        token = d.pop("token")
+
+        telegram_user_id = d.pop("telegram_user_id")
+
+        chat_id = d.pop("chat_id")
+
+        username = d.pop("username", UNSET)
+
+        language_code = d.pop("language_code", UNSET)
+
+        telegram_link_consume_request = cls(
+            token=token,
+            telegram_user_id=telegram_user_id,
+            chat_id=chat_id,
+            username=username,
+            language_code=language_code,
+        )
+
+        telegram_link_consume_request.additional_properties = d
+        return telegram_link_consume_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/telegram_link_response.py

@@ -0,0 +1,76 @@
+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="TelegramLinkResponse")
+
+
+@_attrs_define
+class TelegramLinkResponse:
+    status: str
+    bot_url: str
+    expires_at: datetime.datetime
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        status = self.status
+
+        bot_url = self.bot_url
+
+        expires_at = self.expires_at.isoformat()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "status": status,
+                "bot_url": bot_url,
+                "expires_at": expires_at,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        status = d.pop("status")
+
+        bot_url = d.pop("bot_url")
+
+        expires_at = datetime.datetime.fromisoformat(d.pop("expires_at"))
+
+        telegram_link_response = cls(
+            status=status,
+            bot_url=bot_url,
+            expires_at=expires_at,
+        )
+
+        telegram_link_response.additional_properties = d
+        return telegram_link_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/telegram_session_request.py

@@ -0,0 +1,66 @@
+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="TelegramSessionRequest")
+
+
+@_attrs_define
+class TelegramSessionRequest:
+    telegram_user_id: int
+    chat_id: int
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        telegram_user_id = self.telegram_user_id
+
+        chat_id = self.chat_id
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "telegram_user_id": telegram_user_id,
+                "chat_id": chat_id,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        telegram_user_id = d.pop("telegram_user_id")
+
+        chat_id = d.pop("chat_id")
+
+        telegram_session_request = cls(
+            telegram_user_id=telegram_user_id,
+            chat_id=chat_id,
+        )
+
+        telegram_session_request.additional_properties = d
+        return telegram_session_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/telegram_session_response.py

@@ -0,0 +1,96 @@
+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.telegram_session_response_user import TelegramSessionResponseUser
+
+
+T = TypeVar("T", bound="TelegramSessionResponse")
+
+
+@_attrs_define
+class TelegramSessionResponse:
+    access: str
+    expires_in: int
+    locale: str
+    timezone: str
+    user: TelegramSessionResponseUser
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.telegram_session_response_user import TelegramSessionResponseUser
+
+        access = self.access
+
+        expires_in = self.expires_in
+
+        locale = self.locale
+
+        timezone = self.timezone
+
+        user = self.user.to_dict()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "access": access,
+                "expires_in": expires_in,
+                "locale": locale,
+                "timezone": timezone,
+                "user": user,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.telegram_session_response_user import TelegramSessionResponseUser
+
+        d = dict(src_dict)
+        access = d.pop("access")
+
+        expires_in = d.pop("expires_in")
+
+        locale = d.pop("locale")
+
+        timezone = d.pop("timezone")
+
+        user = TelegramSessionResponseUser.from_dict(d.pop("user"))
+
+        telegram_session_response = cls(
+            access=access,
+            expires_in=expires_in,
+            locale=locale,
+            timezone=timezone,
+            user=user,
+        )
+
+        telegram_session_response.additional_properties = d
+        return telegram_session_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