proxyrequest-sdk 1.0.0__py3-none-any.whl

proxyrequest_sdk/_generated/models/feed_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.feed_record import FeedRecord
+
+
+T = TypeVar("T", bound="FeedResponse")
+
+
+@_attrs_define
+class FeedResponse:
+    count: int
+    next_: None | str
+    previous: None | str
+    timezone: str
+    start: datetime.datetime
+    end: datetime.datetime
+    results: list[FeedRecord]
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.feed_record import FeedRecord
+
+        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.feed_record import FeedRecord
+
+        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 = FeedRecord.from_dict(results_item_data)
+
+            results.append(results_item)
+
+        feed_response = cls(
+            count=count,
+            next_=next_,
+            previous=previous,
+            timezone=timezone,
+            start=start,
+            end=end,
+            results=results,
+        )
+
+        feed_response.additional_properties = d
+        return feed_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/generate_proxy_request.py

@@ -0,0 +1,150 @@
+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
+from uuid import UUID
+
+if TYPE_CHECKING:
+    from ..models.proxy_generation_connection_request import ProxyGenerationConnectionRequest
+    from ..models.proxy_generation_session_request import ProxyGenerationSessionRequest
+    from ..models.proxy_generation_targeting_request import ProxyGenerationTargetingRequest
+
+
+T = TypeVar("T", bound="GenerateProxyRequest")
+
+
+@_attrs_define
+class GenerateProxyRequest:
+    """Validates proxy generation request data and builds generator config."""
+
+    package_id: UUID
+    """ ProxyRequest package UUID used to generate credentials. Headless integrations must resolve this from their
+    local product mapping. """
+    quantity: int
+    """ Number of proxies to generate """
+    user_id: UUID | Unset = UNSET
+    """ ProxyRequest sub-user UUID that will use the generated credentials. Headless integrations must resolve this
+    from their local customer mapping. """
+    targeting: ProxyGenerationTargetingRequest | Unset = UNSET
+    connection: ProxyGenerationConnectionRequest | Unset = UNSET
+    session: ProxyGenerationSessionRequest | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.proxy_generation_connection_request import ProxyGenerationConnectionRequest
+        from ..models.proxy_generation_session_request import ProxyGenerationSessionRequest
+        from ..models.proxy_generation_targeting_request import ProxyGenerationTargetingRequest
+
+        package_id = str(self.package_id)
+
+        quantity = self.quantity
+
+        user_id: str | Unset = UNSET
+        if not isinstance(self.user_id, Unset):
+            user_id = str(self.user_id)
+
+        targeting: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.targeting, Unset):
+            targeting = self.targeting.to_dict()
+
+        connection: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.connection, Unset):
+            connection = self.connection.to_dict()
+
+        session: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.session, Unset):
+            session = self.session.to_dict()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "package_id": package_id,
+                "quantity": quantity,
+            }
+        )
+        if user_id is not UNSET:
+            field_dict["user_id"] = user_id
+        if targeting is not UNSET:
+            field_dict["targeting"] = targeting
+        if connection is not UNSET:
+            field_dict["connection"] = connection
+        if session is not UNSET:
+            field_dict["session"] = session
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.proxy_generation_connection_request import ProxyGenerationConnectionRequest
+        from ..models.proxy_generation_session_request import ProxyGenerationSessionRequest
+        from ..models.proxy_generation_targeting_request import ProxyGenerationTargetingRequest
+
+        d = dict(src_dict)
+        package_id = UUID(d.pop("package_id"))
+
+        quantity = d.pop("quantity")
+
+        _user_id = d.pop("user_id", UNSET)
+        user_id: UUID | Unset
+        if isinstance(_user_id, Unset):
+            user_id = UNSET
+        else:
+            user_id = UUID(_user_id)
+
+        _targeting = d.pop("targeting", UNSET)
+        targeting: ProxyGenerationTargetingRequest | Unset
+        if isinstance(_targeting, Unset):
+            targeting = UNSET
+        else:
+            targeting = ProxyGenerationTargetingRequest.from_dict(_targeting)
+
+        _connection = d.pop("connection", UNSET)
+        connection: ProxyGenerationConnectionRequest | Unset
+        if isinstance(_connection, Unset):
+            connection = UNSET
+        else:
+            connection = ProxyGenerationConnectionRequest.from_dict(_connection)
+
+        _session = d.pop("session", UNSET)
+        session: ProxyGenerationSessionRequest | Unset
+        if isinstance(_session, Unset):
+            session = UNSET
+        else:
+            session = ProxyGenerationSessionRequest.from_dict(_session)
+
+        generate_proxy_request = cls(
+            package_id=package_id,
+            quantity=quantity,
+            user_id=user_id,
+            targeting=targeting,
+            connection=connection,
+            session=session,
+        )
+
+        generate_proxy_request.additional_properties = d
+        return generate_proxy_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/generate_proxy_response.py

@@ -0,0 +1,83 @@
+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.generated_proxy import GeneratedProxy
+
+
+T = TypeVar("T", bound="GenerateProxyResponse")
+
+
+@_attrs_define
+class GenerateProxyResponse:
+    count: int
+    proxies: list[GeneratedProxy]
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.generated_proxy import GeneratedProxy
+
+        count = self.count
+
+        proxies = []
+        for proxies_item_data in self.proxies:
+            proxies_item = proxies_item_data.to_dict()
+            proxies.append(proxies_item)
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "count": count,
+                "proxies": proxies,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.generated_proxy import GeneratedProxy
+
+        d = dict(src_dict)
+        count = d.pop("count")
+
+        proxies = []
+        _proxies = d.pop("proxies")
+        for proxies_item_data in _proxies:
+            proxies_item = GeneratedProxy.from_dict(proxies_item_data)
+
+            proxies.append(proxies_item)
+
+        generate_proxy_response = cls(
+            count=count,
+            proxies=proxies,
+        )
+
+        generate_proxy_response.additional_properties = d
+        return generate_proxy_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/generated_proxy.py

@@ -0,0 +1,94 @@
+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="GeneratedProxy")
+
+
+@_attrs_define
+class GeneratedProxy:
+    host: str
+    port: int
+    protocol: str
+    username: str
+    password: str
+    connection_string: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        host = self.host
+
+        port = self.port
+
+        protocol = self.protocol
+
+        username = self.username
+
+        password = self.password
+
+        connection_string = self.connection_string
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "host": host,
+                "port": port,
+                "protocol": protocol,
+                "username": username,
+                "password": password,
+                "connection_string": connection_string,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        host = d.pop("host")
+
+        port = d.pop("port")
+
+        protocol = d.pop("protocol")
+
+        username = d.pop("username")
+
+        password = d.pop("password")
+
+        connection_string = d.pop("connection_string")
+
+        generated_proxy = cls(
+            host=host,
+            port=port,
+            protocol=protocol,
+            username=username,
+            password=password,
+            connection_string=connection_string,
+        )
+
+        generated_proxy.additional_properties = d
+        return generated_proxy
+
+    @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/google_auth_request.py

@@ -0,0 +1,100 @@
+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="GoogleAuthRequest")
+
+
+@_attrs_define
+class GoogleAuthRequest:
+    """Enhanced Google OAuth authentication with comprehensive security validation and user management."""
+
+    credential: str
+    """ Google ID token credential """
+    client_id: str | Unset = UNSET
+    """ Google OAuth client ID """
+    select_by: str | Unset = UNSET
+    """ User selection method """
+    affiliate_code: str | Unset = UNSET
+    """ Optional affiliate code """
+    referral_code: str | Unset = UNSET
+    """ Optional referral code """
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        credential = self.credential
+
+        client_id = self.client_id
+
+        select_by = self.select_by
+
+        affiliate_code = self.affiliate_code
+
+        referral_code = self.referral_code
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "credential": credential,
+            }
+        )
+        if client_id is not UNSET:
+            field_dict["client_id"] = client_id
+        if select_by is not UNSET:
+            field_dict["select_by"] = select_by
+        if affiliate_code is not UNSET:
+            field_dict["affiliate_code"] = affiliate_code
+        if referral_code is not UNSET:
+            field_dict["referral_code"] = referral_code
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        credential = d.pop("credential")
+
+        client_id = d.pop("client_id", UNSET)
+
+        select_by = d.pop("select_by", UNSET)
+
+        affiliate_code = d.pop("affiliate_code", UNSET)
+
+        referral_code = d.pop("referral_code", UNSET)
+
+        google_auth_request = cls(
+            credential=credential,
+            client_id=client_id,
+            select_by=select_by,
+            affiliate_code=affiliate_code,
+            referral_code=referral_code,
+        )
+
+        google_auth_request.additional_properties = d
+        return google_auth_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/integrations_telegram_connection_destroy_response_400.py

@@ -0,0 +1,101 @@
+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="IntegrationsTelegramConnectionDestroyResponse400")
+
+
+@_attrs_define
+class IntegrationsTelegramConnectionDestroyResponse400:
+    """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))
+
+        integrations_telegram_connection_destroy_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
+
+        integrations_telegram_connection_destroy_response_400.additional_properties = (
+            additional_properties
+        )
+        return integrations_telegram_connection_destroy_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