proxyhat 0.2.0__py3-none-any.whl

proxyhat/resources/payments.py

@@ -0,0 +1,107 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+import httpx
+
+from proxyhat.types.payments import Cryptocurrency, Payment, PaymentCreateResponse, PaymentDetails
+
+if TYPE_CHECKING:
+    from proxyhat.async_client import AsyncProxyHat
+    from proxyhat.client import ProxyHat
+
+
+class PaymentsResource:
+    def __init__(self, client: ProxyHat) -> None:
+        self._client = client
+
+    def list(self) -> list[Payment]:
+        data = self._client.request("GET", "/payments")
+        if isinstance(data, list):
+            return [Payment.from_dict(item) for item in data]
+        return []
+
+    def create(
+        self,
+        *,
+        type: str,
+        plan_id: str,
+        gate: str = "crypto",
+        cryptocurrency_code: str,
+        coupon_code: str | None = None,
+    ) -> PaymentCreateResponse:
+        body: dict[str, Any] = {
+            "type": type,
+            "plan_id": plan_id,
+            "gate": gate,
+            "cryptocurrency_code": cryptocurrency_code,
+        }
+        if coupon_code is not None:
+            body["coupon_code"] = coupon_code
+        data = self._client.request("POST", "/payments", json=body)
+        return PaymentCreateResponse.from_dict(data)
+
+    def get(self, id: str) -> PaymentDetails:
+        data = self._client.request("GET", f"/payments/{id}")
+        return PaymentDetails.from_dict(data)
+
+    def check(self, id: str) -> PaymentDetails:
+        data = self._client.request("GET", f"/payments/{id}/check")
+        return PaymentDetails.from_dict(data)
+
+    def invoice(self, id: str, *, format: str = "pdf") -> httpx.Response:
+        return self._client.request_raw("GET", f"/payments/{id}/invoice", params={"format": format})
+
+    def cryptocurrencies(self) -> list[Cryptocurrency]:
+        data = self._client.request("GET", "/payments/cryptocurrencies")
+        if isinstance(data, list):
+            return [Cryptocurrency.from_dict(item) for item in data]
+        return []
+
+
+class AsyncPaymentsResource:
+    def __init__(self, client: AsyncProxyHat) -> None:
+        self._client = client
+
+    async def list(self) -> list[Payment]:
+        data = await self._client.request("GET", "/payments")
+        if isinstance(data, list):
+            return [Payment.from_dict(item) for item in data]
+        return []
+
+    async def create(
+        self,
+        *,
+        type: str,
+        plan_id: str,
+        gate: str = "crypto",
+        cryptocurrency_code: str,
+        coupon_code: str | None = None,
+    ) -> PaymentCreateResponse:
+        body: dict[str, Any] = {
+            "type": type,
+            "plan_id": plan_id,
+            "gate": gate,
+            "cryptocurrency_code": cryptocurrency_code,
+        }
+        if coupon_code is not None:
+            body["coupon_code"] = coupon_code
+        data = await self._client.request("POST", "/payments", json=body)
+        return PaymentCreateResponse.from_dict(data)
+
+    async def get(self, id: str) -> PaymentDetails:
+        data = await self._client.request("GET", f"/payments/{id}")
+        return PaymentDetails.from_dict(data)
+
+    async def check(self, id: str) -> PaymentDetails:
+        data = await self._client.request("GET", f"/payments/{id}/check")
+        return PaymentDetails.from_dict(data)
+
+    async def invoice(self, id: str, *, format: str = "pdf") -> httpx.Response:
+        return await self._client.request_raw("GET", f"/payments/{id}/invoice", params={"format": format})
+
+    async def cryptocurrencies(self) -> list[Cryptocurrency]:
+        data = await self._client.request("GET", "/payments/cryptocurrencies")
+        if isinstance(data, list):
+            return [Cryptocurrency.from_dict(item) for item in data]
+        return []

proxyhat/resources/plans.py

@@ -0,0 +1,83 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from proxyhat.types.plans import RegularPlan, SubscriptionPlan
+
+if TYPE_CHECKING:
+    from proxyhat.async_client import AsyncProxyHat
+    from proxyhat.client import ProxyHat
+
+
+class PlansResource:
+    def __init__(self, client: ProxyHat) -> None:
+        self._client = client
+
+    def list_regular(self) -> list[RegularPlan]:
+        data = self._client.request("GET", "/regular-options")
+        if isinstance(data, list):
+            return [RegularPlan.from_dict(item) for item in data]
+        return []
+
+    def list_subscriptions(self) -> list[SubscriptionPlan]:
+        data = self._client.request("GET", "/subscription-plans")
+        if isinstance(data, list):
+            return [SubscriptionPlan.from_dict(item) for item in data]
+        return []
+
+    def get_regular(self, name: str) -> RegularPlan:
+        data = self._client.request("GET", f"/plans/regular/{name}")
+        return RegularPlan.from_dict(data)
+
+    def get_subscription(self, name: str) -> SubscriptionPlan:
+        data = self._client.request("GET", f"/plans/subscription/{name}")
+        return SubscriptionPlan.from_dict(data)
+
+    def pricing_regular(self) -> list[Any]:
+        data = self._client.request("GET", "/pricing/regular")
+        if isinstance(data, list):
+            return data
+        return []
+
+    def pricing_subscriptions(self) -> list[Any]:
+        data = self._client.request("GET", "/pricing/subscriptions")
+        if isinstance(data, list):
+            return data
+        return []
+
+
+class AsyncPlansResource:
+    def __init__(self, client: AsyncProxyHat) -> None:
+        self._client = client
+
+    async def list_regular(self) -> list[RegularPlan]:
+        data = await self._client.request("GET", "/regular-options")
+        if isinstance(data, list):
+            return [RegularPlan.from_dict(item) for item in data]
+        return []
+
+    async def list_subscriptions(self) -> list[SubscriptionPlan]:
+        data = await self._client.request("GET", "/subscription-plans")
+        if isinstance(data, list):
+            return [SubscriptionPlan.from_dict(item) for item in data]
+        return []
+
+    async def get_regular(self, name: str) -> RegularPlan:
+        data = await self._client.request("GET", f"/plans/regular/{name}")
+        return RegularPlan.from_dict(data)
+
+    async def get_subscription(self, name: str) -> SubscriptionPlan:
+        data = await self._client.request("GET", f"/plans/subscription/{name}")
+        return SubscriptionPlan.from_dict(data)
+
+    async def pricing_regular(self) -> list[Any]:
+        data = await self._client.request("GET", "/pricing/regular")
+        if isinstance(data, list):
+            return data
+        return []
+
+    async def pricing_subscriptions(self) -> list[Any]:
+        data = await self._client.request("GET", "/pricing/subscriptions")
+        if isinstance(data, list):
+            return data
+        return []

proxyhat/resources/profile.py

@@ -0,0 +1,75 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from proxyhat.types.profile import APIKey, Preferences
+
+if TYPE_CHECKING:
+    from proxyhat.async_client import AsyncProxyHat
+    from proxyhat.client import ProxyHat
+
+
+class ProfileResource:
+    def __init__(self, client: ProxyHat) -> None:
+        self._client = client
+
+    def get_preferences(self) -> Preferences:
+        data = self._client.request("GET", "/profile/preferences")
+        return Preferences.from_dict(data)
+
+    def update_preferences(self, **preferences: Any) -> Preferences:
+        data = self._client.request("PUT", "/profile/preferences", json=preferences)
+        return Preferences.from_dict(data)
+
+    def list_api_keys(self) -> list[APIKey]:
+        data = self._client.request("GET", "/profile/api-keys")
+        if isinstance(data, list):
+            return [APIKey.from_dict(item) for item in data]
+        return []
+
+    def create_api_key(self, *, name: str | None = None) -> APIKey:
+        body: dict[str, Any] = {}
+        if name is not None:
+            body["name"] = name
+        data = self._client.request("POST", "/profile/api-keys", json=body)
+        return APIKey.from_dict(data)
+
+    def delete_api_key(self, id: str) -> None:
+        self._client.request("DELETE", f"/profile/api-keys/{id}")
+
+    def regenerate_api_key(self, id: str) -> APIKey:
+        data = self._client.request("POST", f"/profile/api-keys/{id}/regenerate")
+        return APIKey.from_dict(data)
+
+
+class AsyncProfileResource:
+    def __init__(self, client: AsyncProxyHat) -> None:
+        self._client = client
+
+    async def get_preferences(self) -> Preferences:
+        data = await self._client.request("GET", "/profile/preferences")
+        return Preferences.from_dict(data)
+
+    async def update_preferences(self, **preferences: Any) -> Preferences:
+        data = await self._client.request("PUT", "/profile/preferences", json=preferences)
+        return Preferences.from_dict(data)
+
+    async def list_api_keys(self) -> list[APIKey]:
+        data = await self._client.request("GET", "/profile/api-keys")
+        if isinstance(data, list):
+            return [APIKey.from_dict(item) for item in data]
+        return []
+
+    async def create_api_key(self, *, name: str | None = None) -> APIKey:
+        body: dict[str, Any] = {}
+        if name is not None:
+            body["name"] = name
+        data = await self._client.request("POST", "/profile/api-keys", json=body)
+        return APIKey.from_dict(data)
+
+    async def delete_api_key(self, id: str) -> None:
+        await self._client.request("DELETE", f"/profile/api-keys/{id}")
+
+    async def regenerate_api_key(self, id: str) -> APIKey:
+        data = await self._client.request("POST", f"/profile/api-keys/{id}/regenerate")
+        return APIKey.from_dict(data)

proxyhat/resources/proxy_descriptors.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from proxyhat.types.proxy_descriptor import ProxyDescriptor
+
+if TYPE_CHECKING:
+    from proxyhat.async_client import AsyncProxyHat
+    from proxyhat.client import ProxyHat
+
+
+def _body(
+    sub_user_uuid: str,
+    protocol: str,
+    location: dict[str, Any] | None,
+    session: dict[str, Any] | None,
+    filter: str | None,
+) -> dict[str, Any]:
+    body: dict[str, Any] = {"sub_user_uuid": sub_user_uuid, "protocol": protocol}
+    if location is not None:
+        body["location"] = location
+    if session is not None:
+        body["session"] = session
+    if filter is not None:
+        body["filter"] = filter
+    return body
+
+
+class ProxyDescriptorsResource:
+    def __init__(self, client: ProxyHat) -> None:
+        self._client = client
+
+    def create(
+        self,
+        *,
+        sub_user_uuid: str,
+        protocol: str = "http",
+        location: dict[str, Any] | None = None,
+        session: dict[str, Any] | None = None,
+        filter: str | None = None,
+    ) -> ProxyDescriptor:
+        data = self._client.request(
+            "POST", "/proxy-descriptors", json=_body(sub_user_uuid, protocol, location, session, filter)
+        )
+        return ProxyDescriptor.from_dict(data)
+
+
+class AsyncProxyDescriptorsResource:
+    def __init__(self, client: AsyncProxyHat) -> None:
+        self._client = client
+
+    async def create(
+        self,
+        *,
+        sub_user_uuid: str,
+        protocol: str = "http",
+        location: dict[str, Any] | None = None,
+        session: dict[str, Any] | None = None,
+        filter: str | None = None,
+    ) -> ProxyDescriptor:
+        data = await self._client.request(
+            "POST", "/proxy-descriptors", json=_body(sub_user_uuid, protocol, location, session, filter)
+        )
+        return ProxyDescriptor.from_dict(data)

proxyhat/resources/proxy_presets.py

@@ -0,0 +1,71 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from proxyhat.types.proxy_presets import ProxyPreset
+
+if TYPE_CHECKING:
+    from proxyhat.async_client import AsyncProxyHat
+    from proxyhat.client import ProxyHat
+
+
+class ProxyPresetsResource:
+    def __init__(self, client: ProxyHat) -> None:
+        self._client = client
+
+    def list(self) -> list[ProxyPreset]:
+        data = self._client.request("GET", "/proxy-presets")
+        if isinstance(data, list):
+            return [ProxyPreset.from_dict(item) for item in data]
+        return []
+
+    def create(self, *, name: str, data: dict[str, Any]) -> ProxyPreset:
+        result = self._client.request("POST", "/proxy-presets", json={"name": name, "data": data})
+        return ProxyPreset.from_dict(result)
+
+    def get(self, id: str) -> ProxyPreset:
+        data = self._client.request("GET", f"/proxy-presets/{id}")
+        return ProxyPreset.from_dict(data)
+
+    def update(self, id: str, *, name: str | None = None, data: dict[str, Any] | None = None) -> ProxyPreset:
+        body: dict[str, Any] = {}
+        if name is not None:
+            body["name"] = name
+        if data is not None:
+            body["data"] = data
+        result = self._client.request("PUT", f"/proxy-presets/{id}", json=body)
+        return ProxyPreset.from_dict(result)
+
+    def delete(self, id: str) -> None:
+        self._client.request("DELETE", f"/proxy-presets/{id}")
+
+
+class AsyncProxyPresetsResource:
+    def __init__(self, client: AsyncProxyHat) -> None:
+        self._client = client
+
+    async def list(self) -> list[ProxyPreset]:
+        data = await self._client.request("GET", "/proxy-presets")
+        if isinstance(data, list):
+            return [ProxyPreset.from_dict(item) for item in data]
+        return []
+
+    async def create(self, *, name: str, data: dict[str, Any]) -> ProxyPreset:
+        result = await self._client.request("POST", "/proxy-presets", json={"name": name, "data": data})
+        return ProxyPreset.from_dict(result)
+
+    async def get(self, id: str) -> ProxyPreset:
+        data = await self._client.request("GET", f"/proxy-presets/{id}")
+        return ProxyPreset.from_dict(data)
+
+    async def update(self, id: str, *, name: str | None = None, data: dict[str, Any] | None = None) -> ProxyPreset:
+        body: dict[str, Any] = {}
+        if name is not None:
+            body["name"] = name
+        if data is not None:
+            body["data"] = data
+        result = await self._client.request("PUT", f"/proxy-presets/{id}", json=body)
+        return ProxyPreset.from_dict(result)
+
+    async def delete(self, id: str) -> None:
+        await self._client.request("DELETE", f"/proxy-presets/{id}")

proxyhat/resources/sub_user_groups.py

@@ -0,0 +1,77 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from proxyhat.types.sub_user_groups import SubUserGroup
+
+if TYPE_CHECKING:
+    from proxyhat.async_client import AsyncProxyHat
+    from proxyhat.client import ProxyHat
+
+
+class SubUserGroupsResource:
+    def __init__(self, client: ProxyHat) -> None:
+        self._client = client
+
+    def list(self) -> list[SubUserGroup]:
+        data = self._client.request("GET", "/sub-user-groups")
+        if isinstance(data, list):
+            return [SubUserGroup.from_dict(item) for item in data]
+        return []
+
+    def create(self, *, name: str, description: str | None = None) -> SubUserGroup:
+        body: dict[str, Any] = {"name": name}
+        if description is not None:
+            body["description"] = description
+        data = self._client.request("POST", "/sub-user-groups", json=body)
+        return SubUserGroup.from_dict(data)
+
+    def get(self, id: str) -> SubUserGroup:
+        data = self._client.request("GET", f"/sub-user-groups/{id}")
+        return SubUserGroup.from_dict(data)
+
+    def update(self, id: str, *, name: str | None = None, description: str | None = None) -> SubUserGroup:
+        body: dict[str, Any] = {}
+        if name is not None:
+            body["name"] = name
+        if description is not None:
+            body["description"] = description
+        data = self._client.request("PUT", f"/sub-user-groups/{id}", json=body)
+        return SubUserGroup.from_dict(data)
+
+    def delete(self, id: str) -> None:
+        self._client.request("DELETE", f"/sub-user-groups/{id}")
+
+
+class AsyncSubUserGroupsResource:
+    def __init__(self, client: AsyncProxyHat) -> None:
+        self._client = client
+
+    async def list(self) -> list[SubUserGroup]:
+        data = await self._client.request("GET", "/sub-user-groups")
+        if isinstance(data, list):
+            return [SubUserGroup.from_dict(item) for item in data]
+        return []
+
+    async def create(self, *, name: str, description: str | None = None) -> SubUserGroup:
+        body: dict[str, Any] = {"name": name}
+        if description is not None:
+            body["description"] = description
+        data = await self._client.request("POST", "/sub-user-groups", json=body)
+        return SubUserGroup.from_dict(data)
+
+    async def get(self, id: str) -> SubUserGroup:
+        data = await self._client.request("GET", f"/sub-user-groups/{id}")
+        return SubUserGroup.from_dict(data)
+
+    async def update(self, id: str, *, name: str | None = None, description: str | None = None) -> SubUserGroup:
+        body: dict[str, Any] = {}
+        if name is not None:
+            body["name"] = name
+        if description is not None:
+            body["description"] = description
+        data = await self._client.request("PUT", f"/sub-user-groups/{id}", json=body)
+        return SubUserGroup.from_dict(data)
+
+    async def delete(self, id: str) -> None:
+        await self._client.request("DELETE", f"/sub-user-groups/{id}")

proxyhat/resources/sub_users.py

@@ -0,0 +1,171 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from proxyhat.types.sub_user import BulkDeleteResponse, ResetUsageResponse, SubUser
+
+if TYPE_CHECKING:
+    from proxyhat.async_client import AsyncProxyHat
+    from proxyhat.client import ProxyHat
+
+
+class SubUsersResource:
+    def __init__(self, client: ProxyHat) -> None:
+        self._client = client
+
+    def list(self) -> list[SubUser]:
+        data = self._client.request("GET", "/sub-users")
+        if isinstance(data, list):
+            return [SubUser.from_dict(item) for item in data]
+        return []
+
+    def create(
+        self,
+        *,
+        proxy_password: str,
+        is_traffic_limited: bool = False,
+        traffic_limit: str | None = None,
+        name: str | None = None,
+        notes: str | None = None,
+        sub_user_group_id: str | None = None,
+    ) -> SubUser:
+        body: dict[str, Any] = {
+            "proxy_password": proxy_password,
+            "is_traffic_limited": is_traffic_limited,
+        }
+        if traffic_limit is not None:
+            body["traffic_limit"] = traffic_limit
+        if name is not None:
+            body["name"] = name
+        if notes is not None:
+            body["notes"] = notes
+        if sub_user_group_id is not None:
+            body["sub_user_group_id"] = sub_user_group_id
+
+        data = self._client.request("POST", "/sub-users", json=body)
+        return SubUser.from_dict(data)
+
+    def get(self, id: str) -> SubUser:
+        data = self._client.request("GET", f"/sub-users/{id}")
+        return SubUser.from_dict(data)
+
+    def update(
+        self,
+        id: str,
+        *,
+        proxy_password: str | None = None,
+        is_traffic_limited: bool | None = None,
+        traffic_limit: str | None = None,
+        name: str | None = None,
+        notes: str | None = None,
+    ) -> SubUser:
+        body: dict[str, Any] = {}
+        if proxy_password is not None:
+            body["proxy_password"] = proxy_password
+        if is_traffic_limited is not None:
+            body["is_traffic_limited"] = is_traffic_limited
+        if traffic_limit is not None:
+            body["traffic_limit"] = traffic_limit
+        if name is not None:
+            body["name"] = name
+        if notes is not None:
+            body["notes"] = notes
+
+        data = self._client.request("PUT", f"/sub-users/{id}", json=body)
+        return SubUser.from_dict(data)
+
+    def delete(self, id: str) -> None:
+        self._client.request("DELETE", f"/sub-users/{id}")
+
+    def reset_usage(self, ids: list[str]) -> ResetUsageResponse:
+        data = self._client.request("POST", "/sub-users/reset/usage", json={"ids": ids})
+        return ResetUsageResponse.from_dict(data)
+
+    def bulk_delete(self, ids: list[str]) -> BulkDeleteResponse:
+        data = self._client.request("POST", "/sub-users/bulk-delete", json={"ids": ids})
+        return BulkDeleteResponse.from_dict(data)
+
+    def bulk_move_to_group(self, ids: list[str], group_id: str | None = None) -> Any:
+        return self._client.request("POST", "/sub-users/bulk-move-to-group", json={"ids": ids, "group_id": group_id})
+
+
+class AsyncSubUsersResource:
+    def __init__(self, client: AsyncProxyHat) -> None:
+        self._client = client
+
+    async def list(self) -> list[SubUser]:
+        data = await self._client.request("GET", "/sub-users")
+        if isinstance(data, list):
+            return [SubUser.from_dict(item) for item in data]
+        return []
+
+    async def create(
+        self,
+        *,
+        proxy_password: str,
+        is_traffic_limited: bool = False,
+        traffic_limit: str | None = None,
+        name: str | None = None,
+        notes: str | None = None,
+        sub_user_group_id: str | None = None,
+    ) -> SubUser:
+        body: dict[str, Any] = {
+            "proxy_password": proxy_password,
+            "is_traffic_limited": is_traffic_limited,
+        }
+        if traffic_limit is not None:
+            body["traffic_limit"] = traffic_limit
+        if name is not None:
+            body["name"] = name
+        if notes is not None:
+            body["notes"] = notes
+        if sub_user_group_id is not None:
+            body["sub_user_group_id"] = sub_user_group_id
+
+        data = await self._client.request("POST", "/sub-users", json=body)
+        return SubUser.from_dict(data)
+
+    async def get(self, id: str) -> SubUser:
+        data = await self._client.request("GET", f"/sub-users/{id}")
+        return SubUser.from_dict(data)
+
+    async def update(
+        self,
+        id: str,
+        *,
+        proxy_password: str | None = None,
+        is_traffic_limited: bool | None = None,
+        traffic_limit: str | None = None,
+        name: str | None = None,
+        notes: str | None = None,
+    ) -> SubUser:
+        body: dict[str, Any] = {}
+        if proxy_password is not None:
+            body["proxy_password"] = proxy_password
+        if is_traffic_limited is not None:
+            body["is_traffic_limited"] = is_traffic_limited
+        if traffic_limit is not None:
+            body["traffic_limit"] = traffic_limit
+        if name is not None:
+            body["name"] = name
+        if notes is not None:
+            body["notes"] = notes
+
+        data = await self._client.request("PUT", f"/sub-users/{id}", json=body)
+        return SubUser.from_dict(data)
+
+    async def delete(self, id: str) -> None:
+        await self._client.request("DELETE", f"/sub-users/{id}")
+
+    async def reset_usage(self, ids: list[str]) -> ResetUsageResponse:
+        data = await self._client.request("POST", "/sub-users/reset/usage", json={"ids": ids})
+        return ResetUsageResponse.from_dict(data)
+
+    async def bulk_delete(self, ids: list[str]) -> BulkDeleteResponse:
+        data = await self._client.request("POST", "/sub-users/bulk-delete", json={"ids": ids})
+        return BulkDeleteResponse.from_dict(data)
+
+    async def bulk_move_to_group(self, ids: list[str], group_id: str | None = None) -> Any:
+        return await self._client.request(
+            "POST", "/sub-users/bulk-move-to-group", json={"ids": ids, "group_id": group_id}
+        )