proxyhat 0.2.0__py3-none-any.whl

proxyhat/resources/analytics.py

@@ -0,0 +1,140 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from proxyhat.types.analytics import DomainBreakdownResponse, TimeSeriesResponse, TotalResponse
+
+if TYPE_CHECKING:
+    from proxyhat.async_client import AsyncProxyHat
+    from proxyhat.client import ProxyHat
+
+
+def _analytics_body(
+    period: str = "24h",
+    start_date: str | None = None,
+    end_date: str | None = None,
+) -> dict[str, Any]:
+    body: dict[str, Any] = {"period": period}
+    body["start_date"] = start_date
+    body["end_date"] = end_date
+    return body
+
+
+class AnalyticsResource:
+    def __init__(self, client: ProxyHat) -> None:
+        self._client = client
+
+    def traffic(
+        self,
+        *,
+        period: str = "24h",
+        start_date: str | None = None,
+        end_date: str | None = None,
+    ) -> TimeSeriesResponse:
+        body = _analytics_body(period, start_date, end_date)
+        data = self._client.request("POST", "/traffic", json=body)
+        return TimeSeriesResponse.from_dict(data)
+
+    def traffic_total(
+        self,
+        *,
+        period: str = "24h",
+        start_date: str | None = None,
+        end_date: str | None = None,
+    ) -> TotalResponse:
+        body = _analytics_body(period, start_date, end_date)
+        data = self._client.request("POST", "/traffic/period-total", json=body)
+        return TotalResponse.from_dict(data)
+
+    def requests(
+        self,
+        *,
+        period: str = "24h",
+        start_date: str | None = None,
+        end_date: str | None = None,
+    ) -> TimeSeriesResponse:
+        body = _analytics_body(period, start_date, end_date)
+        data = self._client.request("POST", "/requests", json=body)
+        return TimeSeriesResponse.from_dict(data)
+
+    def requests_total(
+        self,
+        *,
+        period: str = "24h",
+        start_date: str | None = None,
+        end_date: str | None = None,
+    ) -> TotalResponse:
+        body = _analytics_body(period, start_date, end_date)
+        data = self._client.request("POST", "/requests/period-total", json=body)
+        return TotalResponse.from_dict(data)
+
+    def domain_breakdown(
+        self,
+        *,
+        period: str = "24h",
+        start_date: str | None = None,
+        end_date: str | None = None,
+    ) -> DomainBreakdownResponse:
+        body = _analytics_body(period, start_date, end_date)
+        data = self._client.request("POST", "/domain-breakdown", json=body)
+        return DomainBreakdownResponse.from_dict(data)
+
+
+class AsyncAnalyticsResource:
+    def __init__(self, client: AsyncProxyHat) -> None:
+        self._client = client
+
+    async def traffic(
+        self,
+        *,
+        period: str = "24h",
+        start_date: str | None = None,
+        end_date: str | None = None,
+    ) -> TimeSeriesResponse:
+        body = _analytics_body(period, start_date, end_date)
+        data = await self._client.request("POST", "/traffic", json=body)
+        return TimeSeriesResponse.from_dict(data)
+
+    async def traffic_total(
+        self,
+        *,
+        period: str = "24h",
+        start_date: str | None = None,
+        end_date: str | None = None,
+    ) -> TotalResponse:
+        body = _analytics_body(period, start_date, end_date)
+        data = await self._client.request("POST", "/traffic/period-total", json=body)
+        return TotalResponse.from_dict(data)
+
+    async def requests(
+        self,
+        *,
+        period: str = "24h",
+        start_date: str | None = None,
+        end_date: str | None = None,
+    ) -> TimeSeriesResponse:
+        body = _analytics_body(period, start_date, end_date)
+        data = await self._client.request("POST", "/requests", json=body)
+        return TimeSeriesResponse.from_dict(data)
+
+    async def requests_total(
+        self,
+        *,
+        period: str = "24h",
+        start_date: str | None = None,
+        end_date: str | None = None,
+    ) -> TotalResponse:
+        body = _analytics_body(period, start_date, end_date)
+        data = await self._client.request("POST", "/requests/period-total", json=body)
+        return TotalResponse.from_dict(data)
+
+    async def domain_breakdown(
+        self,
+        *,
+        period: str = "24h",
+        start_date: str | None = None,
+        end_date: str | None = None,
+    ) -> DomainBreakdownResponse:
+        body = _analytics_body(period, start_date, end_date)
+        data = await self._client.request("POST", "/domain-breakdown", json=body)
+        return DomainBreakdownResponse.from_dict(data)

proxyhat/resources/auth.py

@@ -0,0 +1,155 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from proxyhat.types.auth import LoginResponse, RegisterResponse, SocialAccount, SupportedProvider, User
+
+if TYPE_CHECKING:
+    from proxyhat.async_client import AsyncProxyHat
+    from proxyhat.client import ProxyHat
+
+
+class AuthResource:
+    def __init__(self, client: ProxyHat) -> None:
+        self._client = client
+
+    def register(
+        self,
+        *,
+        name: str,
+        email: str,
+        password: str,
+        password_confirmation: str,
+        referral_code: str | None = None,
+        utm_source: str | None = None,
+        utm_medium: str | None = None,
+        utm_campaign: str | None = None,
+    ) -> RegisterResponse:
+        body: dict[str, Any] = {
+            "name": name,
+            "email": email,
+            "password": password,
+            "password_confirmation": password_confirmation,
+        }
+        if referral_code is not None:
+            body["referral_code"] = referral_code
+        if utm_source is not None:
+            body["utm_source"] = utm_source
+        if utm_medium is not None:
+            body["utm_medium"] = utm_medium
+        if utm_campaign is not None:
+            body["utm_campaign"] = utm_campaign
+
+        data = self._client.request("POST", "/auth/register", json=body)
+        return RegisterResponse.from_dict(data)
+
+    def login(
+        self,
+        *,
+        email: str,
+        password: str,
+        twofa_code: str | None = None,
+    ) -> LoginResponse:
+        body: dict[str, Any] = {"email": email, "password": password}
+        if twofa_code is not None:
+            body["twofa_code"] = twofa_code
+        data = self._client.request("POST", "/auth/login", json=body)
+        return LoginResponse.from_dict(data)
+
+    def user(self) -> User:
+        data = self._client.request("GET", "/auth/user")
+        return User.from_dict(data)
+
+    def logout(self) -> None:
+        self._client.request("POST", "/auth/logout")
+
+    def supported_providers(self) -> list[SupportedProvider]:
+        data = self._client.request("GET", "/auth/supported-providers")
+        if isinstance(data, list):
+            return [SupportedProvider.from_dict(item) for item in data]
+        return []
+
+    def social_accounts(self) -> list[SocialAccount]:
+        data = self._client.request("GET", "/auth/social-accounts")
+        if isinstance(data, list):
+            return [SocialAccount.from_dict(item) for item in data]
+        return []
+
+    def disconnect_social(self, provider: str) -> None:
+        self._client.request("DELETE", f"/auth/social-accounts/{provider}")
+
+    def oauth_redirect(self, provider: str) -> Any:
+        return self._client.request("GET", f"/auth/{provider}/redirect")
+
+
+class AsyncAuthResource:
+    def __init__(self, client: AsyncProxyHat) -> None:
+        self._client = client
+
+    async def register(
+        self,
+        *,
+        name: str,
+        email: str,
+        password: str,
+        password_confirmation: str,
+        referral_code: str | None = None,
+        utm_source: str | None = None,
+        utm_medium: str | None = None,
+        utm_campaign: str | None = None,
+    ) -> RegisterResponse:
+        body: dict[str, Any] = {
+            "name": name,
+            "email": email,
+            "password": password,
+            "password_confirmation": password_confirmation,
+        }
+        if referral_code is not None:
+            body["referral_code"] = referral_code
+        if utm_source is not None:
+            body["utm_source"] = utm_source
+        if utm_medium is not None:
+            body["utm_medium"] = utm_medium
+        if utm_campaign is not None:
+            body["utm_campaign"] = utm_campaign
+
+        data = await self._client.request("POST", "/auth/register", json=body)
+        return RegisterResponse.from_dict(data)
+
+    async def login(
+        self,
+        *,
+        email: str,
+        password: str,
+        twofa_code: str | None = None,
+    ) -> LoginResponse:
+        body: dict[str, Any] = {"email": email, "password": password}
+        if twofa_code is not None:
+            body["twofa_code"] = twofa_code
+        data = await self._client.request("POST", "/auth/login", json=body)
+        return LoginResponse.from_dict(data)
+
+    async def user(self) -> User:
+        data = await self._client.request("GET", "/auth/user")
+        return User.from_dict(data)
+
+    async def logout(self) -> None:
+        await self._client.request("POST", "/auth/logout")
+
+    async def supported_providers(self) -> list[SupportedProvider]:
+        data = await self._client.request("GET", "/auth/supported-providers")
+        if isinstance(data, list):
+            return [SupportedProvider.from_dict(item) for item in data]
+        return []
+
+    async def social_accounts(self) -> list[SocialAccount]:
+        data = await self._client.request("GET", "/auth/social-accounts")
+        if isinstance(data, list):
+            return [SocialAccount.from_dict(item) for item in data]
+        return []
+
+    async def disconnect_social(self, provider: str) -> None:
+        await self._client.request("DELETE", f"/auth/social-accounts/{provider}")
+
+    async def oauth_redirect(self, provider: str) -> Any:
+        return await self._client.request("GET", f"/auth/{provider}/redirect")

proxyhat/resources/coupons.py

@@ -0,0 +1,99 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from proxyhat.types.coupons import CouponResponse
+
+if TYPE_CHECKING:
+    from proxyhat.async_client import AsyncProxyHat
+    from proxyhat.client import ProxyHat
+
+
+class CouponsResource:
+    def __init__(self, client: ProxyHat) -> None:
+        self._client = client
+
+    def validate(
+        self,
+        *,
+        code: str,
+        plan_id: str | None = None,
+        order_sum: float | None = None,
+        currency: str | None = None,
+    ) -> CouponResponse:
+        body: dict[str, Any] = {"code": code}
+        if plan_id is not None:
+            body["plan_id"] = plan_id
+        if order_sum is not None:
+            body["order_sum"] = order_sum
+        if currency is not None:
+            body["currency"] = currency
+        data = self._client.request("POST", "/coupon/validate", json=body)
+        return CouponResponse.from_dict(data)
+
+    def apply(
+        self,
+        *,
+        code: str,
+        plan_id: str | None = None,
+        order_sum: float | None = None,
+        currency: str | None = None,
+    ) -> CouponResponse:
+        body: dict[str, Any] = {"code": code}
+        if plan_id is not None:
+            body["plan_id"] = plan_id
+        if order_sum is not None:
+            body["order_sum"] = order_sum
+        if currency is not None:
+            body["currency"] = currency
+        data = self._client.request("POST", "/coupon/apply", json=body)
+        return CouponResponse.from_dict(data)
+
+    def redeem(self, *, code: str) -> CouponResponse:
+        data = self._client.request("POST", "/coupon/redeem", json={"code": code})
+        return CouponResponse.from_dict(data)
+
+
+class AsyncCouponsResource:
+    def __init__(self, client: AsyncProxyHat) -> None:
+        self._client = client
+
+    async def validate(
+        self,
+        *,
+        code: str,
+        plan_id: str | None = None,
+        order_sum: float | None = None,
+        currency: str | None = None,
+    ) -> CouponResponse:
+        body: dict[str, Any] = {"code": code}
+        if plan_id is not None:
+            body["plan_id"] = plan_id
+        if order_sum is not None:
+            body["order_sum"] = order_sum
+        if currency is not None:
+            body["currency"] = currency
+        data = await self._client.request("POST", "/coupon/validate", json=body)
+        return CouponResponse.from_dict(data)
+
+    async def apply(
+        self,
+        *,
+        code: str,
+        plan_id: str | None = None,
+        order_sum: float | None = None,
+        currency: str | None = None,
+    ) -> CouponResponse:
+        body: dict[str, Any] = {"code": code}
+        if plan_id is not None:
+            body["plan_id"] = plan_id
+        if order_sum is not None:
+            body["order_sum"] = order_sum
+        if currency is not None:
+            body["currency"] = currency
+        data = await self._client.request("POST", "/coupon/apply", json=body)
+        return CouponResponse.from_dict(data)
+
+    async def redeem(self, *, code: str) -> CouponResponse:
+        data = await self._client.request("POST", "/coupon/redeem", json={"code": code})
+        return CouponResponse.from_dict(data)

proxyhat/resources/email.py

@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from proxyhat.types.email import EmailChangeResponse
+
+if TYPE_CHECKING:
+    from proxyhat.async_client import AsyncProxyHat
+    from proxyhat.client import ProxyHat
+
+
+class EmailResource:
+    def __init__(self, client: ProxyHat) -> None:
+        self._client = client
+
+    def request_change(self, *, email: str, twofa_code: str | None = None) -> EmailChangeResponse:
+        body: dict[str, Any] = {"email": email}
+        if twofa_code is not None:
+            body["twofa_code"] = twofa_code
+        data = self._client.request("POST", "/profile/email/request-change", json=body)
+        return EmailChangeResponse.from_dict(data)
+
+    def confirm_change(self, *, token: str) -> EmailChangeResponse:
+        data = self._client.request("POST", "/profile/email/confirm-change", json={"token": token})
+        return EmailChangeResponse.from_dict(data)
+
+    def cancel_change(self) -> EmailChangeResponse:
+        data = self._client.request("POST", "/profile/email/cancel-change")
+        return EmailChangeResponse.from_dict(data)
+
+    def resend_verification(self) -> EmailChangeResponse:
+        data = self._client.request("POST", "/profile/email/resend-verification")
+        return EmailChangeResponse.from_dict(data)
+
+
+class AsyncEmailResource:
+    def __init__(self, client: AsyncProxyHat) -> None:
+        self._client = client
+
+    async def request_change(self, *, email: str, twofa_code: str | None = None) -> EmailChangeResponse:
+        body: dict[str, Any] = {"email": email}
+        if twofa_code is not None:
+            body["twofa_code"] = twofa_code
+        data = await self._client.request("POST", "/profile/email/request-change", json=body)
+        return EmailChangeResponse.from_dict(data)
+
+    async def confirm_change(self, *, token: str) -> EmailChangeResponse:
+        data = await self._client.request("POST", "/profile/email/confirm-change", json={"token": token})
+        return EmailChangeResponse.from_dict(data)
+
+    async def cancel_change(self) -> EmailChangeResponse:
+        data = await self._client.request("POST", "/profile/email/cancel-change")
+        return EmailChangeResponse.from_dict(data)
+
+    async def resend_verification(self) -> EmailChangeResponse:
+        data = await self._client.request("POST", "/profile/email/resend-verification")
+        return EmailChangeResponse.from_dict(data)

proxyhat/resources/locations.py

@@ -0,0 +1,227 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from proxyhat.types.locations import ISP, City, Country, Region, Zipcode
+
+if TYPE_CHECKING:
+    from proxyhat.async_client import AsyncProxyHat
+    from proxyhat.client import ProxyHat
+
+
+def _location_params(
+    limit: int | None = None,
+    offset: int | None = None,
+    name: str | None = None,
+    connection_type: str | None = None,
+    **kwargs: Any,
+) -> dict[str, Any]:
+    params: dict[str, Any] = {}
+    if limit is not None:
+        params["limit"] = limit
+    if offset is not None:
+        params["offset"] = offset
+    if name is not None:
+        params["name"] = name
+    if connection_type is not None:
+        params["connection_type"] = connection_type
+    params.update({k: v for k, v in kwargs.items() if v is not None})
+    return params
+
+
+class LocationsResource:
+    def __init__(self, client: ProxyHat) -> None:
+        self._client = client
+
+    def countries(
+        self,
+        *,
+        limit: int | None = None,
+        offset: int | None = None,
+        name: str | None = None,
+        connection_type: str | None = None,
+    ) -> list[Country]:
+        params = _location_params(limit=limit, offset=offset, name=name, connection_type=connection_type)
+        data = self._client.request("GET", "/locations/countries", params=params)
+        if isinstance(data, list):
+            return [Country.from_dict(item) for item in data]
+        return []
+
+    def regions(
+        self,
+        *,
+        limit: int | None = None,
+        offset: int | None = None,
+        name: str | None = None,
+        connection_type: str | None = None,
+        country__code: str | None = None,
+    ) -> list[Region]:
+        params = _location_params(
+            limit=limit, offset=offset, name=name, connection_type=connection_type, country__code=country__code
+        )
+        data = self._client.request("GET", "/locations/regions", params=params)
+        if isinstance(data, list):
+            return [Region.from_dict(item) for item in data]
+        return []
+
+    def cities(
+        self,
+        *,
+        limit: int | None = None,
+        offset: int | None = None,
+        name: str | None = None,
+        connection_type: str | None = None,
+        country__code: str | None = None,
+        region__code: str | None = None,
+    ) -> list[City]:
+        params = _location_params(
+            limit=limit,
+            offset=offset,
+            name=name,
+            connection_type=connection_type,
+            country__code=country__code,
+            region__code=region__code,
+        )
+        data = self._client.request("GET", "/locations/cities", params=params)
+        if isinstance(data, list):
+            return [City.from_dict(item) for item in data]
+        return []
+
+    def isps(
+        self,
+        *,
+        limit: int | None = None,
+        offset: int | None = None,
+        name: str | None = None,
+        connection_type: str | None = None,
+        country__code: str | None = None,
+    ) -> list[ISP]:
+        params = _location_params(
+            limit=limit, offset=offset, name=name, connection_type=connection_type, country__code=country__code
+        )
+        data = self._client.request("GET", "/locations/isps", params=params)
+        if isinstance(data, list):
+            return [ISP.from_dict(item) for item in data]
+        return []
+
+    def zipcodes(
+        self,
+        *,
+        limit: int | None = None,
+        offset: int | None = None,
+        name: str | None = None,
+        connection_type: str | None = None,
+        country__code: str | None = None,
+        city__code: str | None = None,
+    ) -> list[Zipcode]:
+        params = _location_params(
+            limit=limit,
+            offset=offset,
+            name=name,
+            connection_type=connection_type,
+            country__code=country__code,
+            city__code=city__code,
+        )
+        data = self._client.request("GET", "/locations/zipcodes", params=params)
+        if isinstance(data, list):
+            return [Zipcode.from_dict(item) for item in data]
+        return []
+
+
+class AsyncLocationsResource:
+    def __init__(self, client: AsyncProxyHat) -> None:
+        self._client = client
+
+    async def countries(
+        self,
+        *,
+        limit: int | None = None,
+        offset: int | None = None,
+        name: str | None = None,
+        connection_type: str | None = None,
+    ) -> list[Country]:
+        params = _location_params(limit=limit, offset=offset, name=name, connection_type=connection_type)
+        data = await self._client.request("GET", "/locations/countries", params=params)
+        if isinstance(data, list):
+            return [Country.from_dict(item) for item in data]
+        return []
+
+    async def regions(
+        self,
+        *,
+        limit: int | None = None,
+        offset: int | None = None,
+        name: str | None = None,
+        connection_type: str | None = None,
+        country__code: str | None = None,
+    ) -> list[Region]:
+        params = _location_params(
+            limit=limit, offset=offset, name=name, connection_type=connection_type, country__code=country__code
+        )
+        data = await self._client.request("GET", "/locations/regions", params=params)
+        if isinstance(data, list):
+            return [Region.from_dict(item) for item in data]
+        return []
+
+    async def cities(
+        self,
+        *,
+        limit: int | None = None,
+        offset: int | None = None,
+        name: str | None = None,
+        connection_type: str | None = None,
+        country__code: str | None = None,
+        region__code: str | None = None,
+    ) -> list[City]:
+        params = _location_params(
+            limit=limit,
+            offset=offset,
+            name=name,
+            connection_type=connection_type,
+            country__code=country__code,
+            region__code=region__code,
+        )
+        data = await self._client.request("GET", "/locations/cities", params=params)
+        if isinstance(data, list):
+            return [City.from_dict(item) for item in data]
+        return []
+
+    async def isps(
+        self,
+        *,
+        limit: int | None = None,
+        offset: int | None = None,
+        name: str | None = None,
+        connection_type: str | None = None,
+        country__code: str | None = None,
+    ) -> list[ISP]:
+        params = _location_params(
+            limit=limit, offset=offset, name=name, connection_type=connection_type, country__code=country__code
+        )
+        data = await self._client.request("GET", "/locations/isps", params=params)
+        if isinstance(data, list):
+            return [ISP.from_dict(item) for item in data]
+        return []
+
+    async def zipcodes(
+        self,
+        *,
+        limit: int | None = None,
+        offset: int | None = None,
+        name: str | None = None,
+        connection_type: str | None = None,
+        country__code: str | None = None,
+        city__code: str | None = None,
+    ) -> list[Zipcode]:
+        params = _location_params(
+            limit=limit,
+            offset=offset,
+            name=name,
+            connection_type=connection_type,
+            country__code=country__code,
+            city__code=city__code,
+        )
+        data = await self._client.request("GET", "/locations/zipcodes", params=params)
+        if isinstance(data, list):
+            return [Zipcode.from_dict(item) for item in data]
+        return []