proxyhat 0.2.0__py3-none-any.whl

proxyhat/resources/two_factor.py

@@ -0,0 +1,107 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from proxyhat.types.two_factor import RecoveryCodes, TwoFactorEnableResponse, TwoFactorStatus
+
+if TYPE_CHECKING:
+    from proxyhat.async_client import AsyncProxyHat
+    from proxyhat.client import ProxyHat
+
+
+class TwoFactorResource:
+    def __init__(self, client: ProxyHat) -> None:
+        self._client = client
+
+    def status(self) -> TwoFactorStatus:
+        data = self._client.request("GET", "/profile/2fa/status")
+        return TwoFactorStatus.from_dict(data)
+
+    def enable(self) -> TwoFactorEnableResponse:
+        data = self._client.request("POST", "/profile/2fa/enable")
+        return TwoFactorEnableResponse.from_dict(data)
+
+    def confirm(self, *, code: str) -> Any:
+        return self._client.request("POST", "/profile/2fa/confirm", json={"code": code})
+
+    def disable(self, *, twofa_code: str) -> Any:
+        return self._client.request("POST", "/profile/2fa/disable", json={"twofa_code": twofa_code})
+
+    def qr_code(self) -> TwoFactorEnableResponse:
+        data = self._client.request("GET", "/profile/2fa/qr-code")
+        return TwoFactorEnableResponse.from_dict(data)
+
+    def recovery_codes(self) -> RecoveryCodes:
+        data = self._client.request("GET", "/profile/2fa/recovery-codes")
+        return RecoveryCodes.from_dict(data)
+
+    def disable_by_recovery(self, *, recovery_code: str) -> Any:
+        return self._client.request(
+            "POST", "/profile/2fa/disable-by-recovery-code", json={"recovery_code": recovery_code}
+        )
+
+    def change_password(
+        self,
+        *,
+        current_password: str,
+        password: str,
+        password_confirmation: str,
+        twofa_code: str | None = None,
+    ) -> Any:
+        body: dict[str, Any] = {
+            "current_password": current_password,
+            "password": password,
+            "password_confirmation": password_confirmation,
+        }
+        if twofa_code is not None:
+            body["twofa_code"] = twofa_code
+        return self._client.request("POST", "/profile/password", json=body)
+
+
+class AsyncTwoFactorResource:
+    def __init__(self, client: AsyncProxyHat) -> None:
+        self._client = client
+
+    async def status(self) -> TwoFactorStatus:
+        data = await self._client.request("GET", "/profile/2fa/status")
+        return TwoFactorStatus.from_dict(data)
+
+    async def enable(self) -> TwoFactorEnableResponse:
+        data = await self._client.request("POST", "/profile/2fa/enable")
+        return TwoFactorEnableResponse.from_dict(data)
+
+    async def confirm(self, *, code: str) -> Any:
+        return await self._client.request("POST", "/profile/2fa/confirm", json={"code": code})
+
+    async def disable(self, *, twofa_code: str) -> Any:
+        return await self._client.request("POST", "/profile/2fa/disable", json={"twofa_code": twofa_code})
+
+    async def qr_code(self) -> TwoFactorEnableResponse:
+        data = await self._client.request("GET", "/profile/2fa/qr-code")
+        return TwoFactorEnableResponse.from_dict(data)
+
+    async def recovery_codes(self) -> RecoveryCodes:
+        data = await self._client.request("GET", "/profile/2fa/recovery-codes")
+        return RecoveryCodes.from_dict(data)
+
+    async def disable_by_recovery(self, *, recovery_code: str) -> Any:
+        return await self._client.request(
+            "POST", "/profile/2fa/disable-by-recovery-code", json={"recovery_code": recovery_code}
+        )
+
+    async def change_password(
+        self,
+        *,
+        current_password: str,
+        password: str,
+        password_confirmation: str,
+        twofa_code: str | None = None,
+    ) -> Any:
+        body: dict[str, Any] = {
+            "current_password": current_password,
+            "password": password,
+            "password_confirmation": password_confirmation,
+        }
+        if twofa_code is not None:
+            body["twofa_code"] = twofa_code
+        return await self._client.request("POST", "/profile/password", json=body)

proxyhat/types/__init__.py

@@ -0,0 +1,49 @@
+from proxyhat.types.analytics import DomainBreakdownItem, DomainBreakdownResponse, TimeSeriesResponse, TotalResponse
+from proxyhat.types.auth import LoginResponse, RegisterResponse, SocialAccount, SupportedProvider, TrafficInfo, User
+from proxyhat.types.coupons import Coupon, CouponResponse
+from proxyhat.types.email import EmailChangeResponse
+from proxyhat.types.locations import ISP, City, Country, Region, Zipcode
+from proxyhat.types.payments import Cryptocurrency, Payment, PaymentCreateResponse, PaymentDetails
+from proxyhat.types.plans import RegularPlan, SubscriptionPlan
+from proxyhat.types.profile import APIKey, Preferences
+from proxyhat.types.proxy_presets import ProxyPreset
+from proxyhat.types.sub_user import BulkDeleteResponse, ResetUsageResponse, SubUser
+from proxyhat.types.sub_user_groups import SubUserGroup
+from proxyhat.types.two_factor import RecoveryCodes, TwoFactorEnableResponse, TwoFactorStatus
+
+__all__ = [
+    "APIKey",
+    "BulkDeleteResponse",
+    "City",
+    "Country",
+    "Coupon",
+    "CouponResponse",
+    "Cryptocurrency",
+    "DomainBreakdownItem",
+    "DomainBreakdownResponse",
+    "EmailChangeResponse",
+    "ISP",
+    "LoginResponse",
+    "Payment",
+    "PaymentCreateResponse",
+    "PaymentDetails",
+    "Preferences",
+    "ProxyPreset",
+    "RecoveryCodes",
+    "Region",
+    "RegularPlan",
+    "RegisterResponse",
+    "ResetUsageResponse",
+    "SocialAccount",
+    "SubUser",
+    "SubUserGroup",
+    "SubscriptionPlan",
+    "SupportedProvider",
+    "TimeSeriesResponse",
+    "TotalResponse",
+    "TrafficInfo",
+    "TwoFactorEnableResponse",
+    "TwoFactorStatus",
+    "User",
+    "Zipcode",
+]

proxyhat/types/analytics.py

@@ -0,0 +1,52 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass
+class TimeSeriesResponse:
+    labels: list[str] = field(default_factory=list)
+    data: list[int] = field(default_factory=list)
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> TimeSeriesResponse:
+        return cls(
+            labels=data.get("labels", []),
+            data=data.get("data", []),
+        )
+
+
+@dataclass
+class TotalResponse:
+    total: int = 0
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> TotalResponse:
+        return cls(total=data.get("total", 0))
+
+
+@dataclass
+class DomainBreakdownItem:
+    domain: str
+    bandwidth: int
+    requests: int
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> DomainBreakdownItem:
+        return cls(
+            domain=data.get("domain", ""),
+            bandwidth=data.get("bandwidth", 0),
+            requests=data.get("requests", 0),
+        )
+
+
+@dataclass
+class DomainBreakdownResponse:
+    items: list[DomainBreakdownItem] = field(default_factory=list)
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> DomainBreakdownResponse:
+        return cls(
+            items=[DomainBreakdownItem.from_dict(item) for item in data.get("items", [])],
+        )

proxyhat/types/auth.py

@@ -0,0 +1,106 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass
+class RegisterResponse:
+    message: str
+    access_token: str
+    token_type: str
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> RegisterResponse:
+        return cls(
+            message=data.get("message", ""),
+            access_token=data.get("accessToken", ""),
+            token_type=data.get("tokenType", ""),
+        )
+
+
+@dataclass
+class LoginResponse:
+    access_token: str
+    token_type: str
+    requires_2fa: bool = False
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> LoginResponse:
+        return cls(
+            access_token=data.get("accessToken", ""),
+            token_type=data.get("tokenType", ""),
+            requires_2fa=data.get("requires_2fa", False),
+        )
+
+
+@dataclass
+class TrafficInfo:
+    subscription: str | None
+    subscription_starts_at: str | None
+    subscription_expires_at: str | None
+    regular_bytes: int
+    regular_human: str
+    subscription_bytes: int
+    subscription_human: str
+    total_bytes: int
+    total_human: str
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> TrafficInfo:
+        return cls(
+            subscription=data.get("subscription"),
+            subscription_starts_at=data.get("subscription_starts_at"),
+            subscription_expires_at=data.get("subscription_expires_at"),
+            regular_bytes=data.get("regular_bytes", 0),
+            regular_human=data.get("regular_human", ""),
+            subscription_bytes=data.get("subscription_bytes", 0),
+            subscription_human=data.get("subscription_human", ""),
+            total_bytes=data.get("total_bytes", 0),
+            total_human=data.get("total_human", ""),
+        )
+
+
+@dataclass
+class User:
+    uuid: str
+    name: str
+    email: str
+    traffic: TrafficInfo
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> User:
+        return cls(
+            uuid=data.get("uuid", ""),
+            name=data.get("name", ""),
+            email=data.get("email", ""),
+            traffic=TrafficInfo.from_dict(data.get("traffic", {})),
+        )
+
+
+@dataclass
+class SupportedProvider:
+    name: str
+    slug: str
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> SupportedProvider:
+        return cls(
+            name=data.get("name", ""),
+            slug=data.get("slug", ""),
+        )
+
+
+@dataclass
+class SocialAccount:
+    provider: str
+    email: str | None
+    connected_at: str | None
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> SocialAccount:
+        return cls(
+            provider=data.get("provider", ""),
+            email=data.get("email"),
+            connected_at=data.get("connected_at"),
+        )

proxyhat/types/coupons.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass
+class Coupon:
+    id: str
+    code: str
+    type: str
+    data: Any
+    discount: float | None = None
+    final_amount: float | None = None
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> Coupon:
+        return cls(
+            id=data.get("id", ""),
+            code=data.get("code", ""),
+            type=data.get("type", ""),
+            data=data.get("data"),
+            discount=data.get("discount"),
+            final_amount=data.get("final_amount"),
+        )
+
+
+@dataclass
+class CouponResponse:
+    success: bool
+    coupon: Coupon | None = None
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> CouponResponse:
+        coupon_data = data.get("coupon")
+        return cls(
+            success=data.get("success", False),
+            coupon=Coupon.from_dict(coupon_data) if coupon_data else None,
+        )

proxyhat/types/email.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass
+class EmailChangeResponse:
+    message: str
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> EmailChangeResponse:
+        return cls(message=data.get("message", ""))

proxyhat/types/locations.py

@@ -0,0 +1,101 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass
+class Country:
+    code: str
+    name: str
+    availability: str
+    connection_type: str
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> Country:
+        return cls(
+            code=data.get("code", ""),
+            name=data.get("name", ""),
+            availability=data.get("availability", ""),
+            connection_type=data.get("connection_type", ""),
+        )
+
+
+@dataclass
+class Region:
+    code: str
+    name: str
+    country_code: str
+    availability: str | None = None
+    connection_type: str | None = None
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> Region:
+        return cls(
+            code=data.get("code", ""),
+            name=data.get("name", ""),
+            country_code=data.get("country_code", ""),
+            availability=data.get("availability"),
+            connection_type=data.get("connection_type"),
+        )
+
+
+@dataclass
+class City:
+    code: str
+    name: str
+    country_code: str
+    region_code: str | None = None
+    availability: str | None = None
+    connection_type: str | None = None
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> City:
+        return cls(
+            code=data.get("code", ""),
+            name=data.get("name", ""),
+            country_code=data.get("country_code", ""),
+            region_code=data.get("region_code"),
+            availability=data.get("availability"),
+            connection_type=data.get("connection_type"),
+        )
+
+
+@dataclass
+class ISP:
+    code: str
+    name: str
+    country_code: str
+    availability: str | None = None
+    connection_type: str | None = None
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> ISP:
+        return cls(
+            code=data.get("code", ""),
+            name=data.get("name", ""),
+            country_code=data.get("country_code", ""),
+            availability=data.get("availability"),
+            connection_type=data.get("connection_type"),
+        )
+
+
+@dataclass
+class Zipcode:
+    code: str
+    name: str
+    country_code: str
+    city_code: str | None = None
+    availability: str | None = None
+    connection_type: str | None = None
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> Zipcode:
+        return cls(
+            code=data.get("code", ""),
+            name=data.get("name", ""),
+            country_code=data.get("country_code", ""),
+            city_code=data.get("city_code"),
+            availability=data.get("availability"),
+            connection_type=data.get("connection_type"),
+        )

proxyhat/types/payments.py

@@ -0,0 +1,101 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass
+class PaymentCreateResponse:
+    success: bool
+    payment_id: str
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> PaymentCreateResponse:
+        return cls(
+            success=data.get("success", False),
+            payment_id=data.get("payment_id", ""),
+        )
+
+
+@dataclass
+class CryptoInfo:
+    code: str
+    currency: str
+    network: str
+    icon: str | None = None
+    label: str | None = None
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> CryptoInfo:
+        return cls(
+            code=data.get("code", ""),
+            currency=data.get("currency", ""),
+            network=data.get("network", ""),
+            icon=data.get("icon"),
+            label=data.get("label"),
+        )
+
+
+@dataclass
+class PaymentDetails:
+    pay_address: str
+    crypto_amount: float
+    amount_usd: float
+    crypto: CryptoInfo
+    status: str
+    tx_hash: str | None = None
+    expires_at: str | None = None
+    completed_at: str | None = None
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> PaymentDetails:
+        return cls(
+            pay_address=data.get("pay_address", ""),
+            crypto_amount=data.get("crypto_amount", 0.0),
+            amount_usd=data.get("amount_usd", 0.0),
+            crypto=CryptoInfo.from_dict(data.get("crypto", {})),
+            status=data.get("status", ""),
+            tx_hash=data.get("tx_hash"),
+            expires_at=data.get("expires_at"),
+            completed_at=data.get("completed_at"),
+        )
+
+
+@dataclass
+class Payment:
+    id: str
+    type: str
+    status: str
+    amount: float | None = None
+    currency: str | None = None
+    created_at: str | None = None
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> Payment:
+        return cls(
+            id=data.get("id", ""),
+            type=data.get("type", ""),
+            status=data.get("status", ""),
+            amount=data.get("amount"),
+            currency=data.get("currency"),
+            created_at=data.get("created_at"),
+        )
+
+
+@dataclass
+class Cryptocurrency:
+    code: str
+    currency: str
+    network: str
+    icon: str | None = None
+    label: str | None = None
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> Cryptocurrency:
+        return cls(
+            code=data.get("code", ""),
+            currency=data.get("currency", ""),
+            network=data.get("network", ""),
+            icon=data.get("icon"),
+            label=data.get("label"),
+        )

proxyhat/types/plans.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass
+class RegularPlan:
+    id: str
+    name: str
+    gb: int
+    price_per_gb: float
+    price_total: float
+    currency: str
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> RegularPlan:
+        return cls(
+            id=data.get("id", ""),
+            name=data.get("name", ""),
+            gb=data.get("gb", 0),
+            price_per_gb=data.get("price_per_gb", 0.0),
+            price_total=data.get("price_total", 0.0),
+            currency=data.get("currency", "USD"),
+        )
+
+
+@dataclass
+class SubscriptionPlan:
+    id: str
+    name: str
+    gb: int
+    price_per_gb: float
+    price_total: float
+    period: str
+    rollover_enabled: bool = False
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> SubscriptionPlan:
+        return cls(
+            id=data.get("id", ""),
+            name=data.get("name", ""),
+            gb=data.get("gb", 0),
+            price_per_gb=data.get("price_per_gb", 0.0),
+            price_total=data.get("price_total", 0.0),
+            period=data.get("period", ""),
+            rollover_enabled=data.get("rollover_enabled", False),
+        )
+
+
+@dataclass
+class PublicPricing:
+    plans: list[Any]
+
+    @classmethod
+    def from_dict(cls, data: Any) -> PublicPricing:
+        if isinstance(data, list):
+            return cls(plans=data)
+        return cls(plans=data.get("plans", []))

proxyhat/types/profile.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass
+class Preferences:
+    data: dict[str, Any]
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> Preferences:
+        return cls(data=data)
+
+
+@dataclass
+class APIKey:
+    id: str
+    name: str | None
+    plain_text_token: str | None = None
+    created_at: str | None = None
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> APIKey:
+        return cls(
+            id=data.get("id", ""),
+            name=data.get("name"),
+            plain_text_token=data.get("plain_text_token"),
+            created_at=data.get("created_at"),
+        )

proxyhat/types/proxy_descriptor.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass
+class ProxyDescriptor:
+    """Server-built connection descriptor (POST /v1/proxy-descriptors)."""
+
+    provider_id: str
+    sub_user_uuid: str
+    protocol: str
+    filter: str
+    host: str
+    port: int
+    username: str
+    password: str
+    url: str
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> ProxyDescriptor:
+        return cls(
+            provider_id=data.get("provider_id", ""),
+            sub_user_uuid=data.get("sub_user_uuid", ""),
+            protocol=data.get("protocol", ""),
+            filter=data.get("filter", ""),
+            host=data.get("host", ""),
+            port=data.get("port", 0),
+            username=data.get("username", ""),
+            password=data.get("password", ""),
+            url=data.get("url", ""),
+        )