guardcoreapi 0.1.0__py3-none-any.whl

guardcoreapi/__init__.py

@@ -0,0 +1,3 @@
+from .manager import GuardCoreApi
+
+__all__ = ["GuardCoreApi"]

guardcoreapi/core/__init__.py

@@ -0,0 +1,17 @@
+from .request import RequestCore
+from .exceptions import (
+    GuardCoreApiException,
+    RequestAuthenticationError,
+    RequestConnectionError,
+    RequestResponseError,
+    RequestTimeoutError,
+)
+
+__all__ = [
+    "RequestCore",
+    "GuardCoreApiException",
+    "RequestAuthenticationError",
+    "RequestConnectionError",
+    "RequestResponseError",
+    "RequestTimeoutError",
+]

guardcoreapi/core/exceptions.py

@@ -0,0 +1,28 @@
+class GuardCoreApiException(Exception):
+    """Base class for request errors."""
+
+    pass
+
+
+class RequestTimeoutError(GuardCoreApiException):
+    """Exception raised for request timeouts."""
+
+    pass
+
+
+class RequestConnectionError(GuardCoreApiException):
+    """Exception raised for connection errors."""
+
+    pass
+
+
+class RequestResponseError(GuardCoreApiException):
+    """Exception raised for invalid responses."""
+
+    pass
+
+
+class RequestAuthenticationError(GuardCoreApiException):
+    """Exception raised for authentication failures."""
+
+    pass

guardcoreapi/core/request.py

@@ -0,0 +1,140 @@
+import asyncio
+from typing import Optional
+
+import aiohttp
+from pydantic import BaseModel
+from .exceptions import (
+    RequestAuthenticationError,
+    RequestConnectionError,
+    RequestResponseError,
+    RequestTimeoutError,
+)
+
+
+class RequestCore:
+    _BASE_URL = "https://core.erfjab.com"
+
+    @staticmethod
+    def generate_headers(access_token: Optional[str] = None) -> dict:
+        headers = {
+            "Accept": "application/json",
+            "Content-Type": "application/json",
+        }
+        if access_token:
+            headers["Authorization"] = f"Bearer {access_token}"
+        return headers
+
+    @staticmethod
+    async def fetch(
+        endpoint: str,
+        method: str = "GET",
+        headers: Optional[dict] = None,
+        params: Optional[dict] = None,
+        data: Optional[dict] = None,
+        json: Optional[dict] = None,
+        response_model: Optional[BaseModel] = None,
+        use_list: bool = False,
+        timeout: float = 10.0,
+    ) -> dict:
+        try:
+            async with aiohttp.ClientSession(
+                timeout=aiohttp.ClientTimeout(total=timeout)
+            ) as session:
+                async with session.request(
+                    method=method,
+                    url=RequestCore._BASE_URL + endpoint,
+                    headers=headers,
+                    params=params,
+                    data=data,
+                    json=json,
+                ) as response:
+                    response.raise_for_status()
+                    resp_json = await response.json()
+                    if response_model:
+                        if use_list:
+                            return [response_model(**item) for item in resp_json]
+                        return response_model(**resp_json)
+                    return resp_json
+        except aiohttp.ClientResponseError as e:
+            if e.status == 401:
+                raise RequestAuthenticationError("Authentication failed") from e
+            else:
+                raise RequestResponseError(f"Invalid response: {e.status}") from e
+        except aiohttp.ClientConnectionError as e:
+            raise RequestConnectionError("Connection error occurred") from e
+        except asyncio.TimeoutError as e:
+            raise RequestTimeoutError("Request timed out") from e
+
+    @staticmethod
+    async def get(
+        endpoint: str,
+        headers: Optional[dict] = None,
+        params: Optional[dict] = None,
+        response_model: Optional[BaseModel] = None,
+        use_list: bool = False,
+        timeout: float = 10.0,
+    ) -> dict:
+        return await RequestCore.fetch(
+            endpoint=endpoint,
+            method="GET",
+            headers=headers,
+            params=params,
+            timeout=timeout,
+            use_list=use_list,
+            response_model=response_model,
+        )
+
+    @staticmethod
+    async def post(
+        endpoint: str,
+        headers: Optional[dict] = None,
+        data: Optional[dict] = None,
+        json: Optional[dict] = None,
+        timeout: float = 10.0,
+        response_model: Optional[BaseModel] = None,
+        use_list: bool = False,
+    ) -> dict:
+        return await RequestCore.fetch(
+            endpoint=endpoint,
+            method="POST",
+            headers=headers,
+            data=data,
+            json=json,
+            timeout=timeout,
+            response_model=response_model,
+            use_list=use_list,
+        )
+
+    @staticmethod
+    async def put(
+        endpoint: str,
+        headers: Optional[dict] = None,
+        data: Optional[dict] = None,
+        json: Optional[dict] = None,
+        timeout: float = 10.0,
+        response_model: Optional[BaseModel] = None,
+        use_list: bool = False,
+    ) -> dict:
+        return await RequestCore.fetch(
+            endpoint=endpoint,
+            method="PUT",
+            headers=headers,
+            data=data,
+            json=json,
+            timeout=timeout,
+            response_model=response_model,
+            use_list=use_list,
+        )
+
+    @staticmethod
+    async def delete(
+        endpoint: str,
+        headers: Optional[dict] = None,
+        timeout: float = 10.0,
+    ) -> dict:
+        return await RequestCore.fetch(
+            endpoint=endpoint,
+            method="DELETE",
+            headers=headers,
+            timeout=timeout,
+        )

guardcoreapi/manager.py

@@ -0,0 +1,374 @@
+from .core import RequestCore
+from .types import (
+    AdminToken,
+    AdminResponse,
+    AdminCreate,
+    AdminCurrentUpdate,
+    AdminUsageLogsResponse,
+    AdminUpdate,
+    SubscriptionResponse,
+    SubscriptionCreate,
+    SubscriptionStatsResponse,
+    SubscriptionUpdate,
+    SubscriptionUsageLogsResponse,
+    NodeResponse,
+    NodeCreate,
+    NodeUpdate,
+    NodeStatsResponse,
+    ServiceCreate,
+    ServiceResponse,
+    ServiceUpdate,
+)
+
+
+class GuardCoreApi:
+    @staticmethod
+    async def get_all_admin(access: str) -> list[AdminResponse]:
+        return await RequestCore.get(
+            "/api/admins",
+            headers=RequestCore.generate_headers(access),
+            response_model=AdminResponse,
+            use_list=True,
+        )
+
+    @staticmethod
+    async def create_admin(data: AdminCreate, access: str) -> AdminResponse:
+        return await RequestCore.post(
+            "/api/admins",
+            headers=RequestCore.generate_headers(access),
+            json=data.dict(),
+            response_model=AdminResponse,
+        )
+
+    @staticmethod
+    async def generate_admin_token(username: str, password: str) -> AdminToken:
+        return await RequestCore.post(
+            "/api/admins/token",
+            data={
+                "username": username,
+                "password": password,
+            },
+            response_model=AdminToken,
+        )
+
+    @staticmethod
+    async def get_current_admin(access: str) -> AdminResponse:
+        return await RequestCore.get(
+            "/api/admins/current",
+            headers=RequestCore.generate_headers(access),
+            response_model=AdminResponse,
+        )
+
+    @staticmethod
+    async def update_current_admin(
+        data: AdminCurrentUpdate, access: str
+    ) -> AdminResponse:
+        return await RequestCore.put(
+            "/api/admins/current",
+            headers=RequestCore.generate_headers(access),
+            json=data.dict(),
+            response_model=AdminResponse,
+        )
+
+    @staticmethod
+    async def get_current_admin_usages(access: str) -> dict:
+        return await RequestCore.get(
+            "/api/admins/current/usages",
+            headers=RequestCore.generate_headers(access),
+            response_model=AdminUsageLogsResponse,
+        )
+
+    @staticmethod
+    async def get_admin(username: str, access: str) -> AdminResponse:
+        return await RequestCore.get(
+            f"/api/admins/{username}",
+            headers=RequestCore.generate_headers(access),
+            response_model=AdminResponse,
+        )
+
+    @staticmethod
+    async def update_admin(
+        username: str, data: AdminUpdate, access: str
+    ) -> AdminResponse:
+        return await RequestCore.put(
+            f"/api/admins/{username}",
+            headers=RequestCore.generate_headers(access),
+            json=data.dict(),
+            response_model=AdminResponse,
+        )
+
+    @staticmethod
+    async def delete_admin(username: str, access: str) -> dict:
+        return await RequestCore.post(
+            f"/api/admins/{username}/delete",
+            headers=RequestCore.generate_headers(access),
+        )
+
+    @staticmethod
+    async def get_admin_usages(username: str, access: str) -> dict:
+        return await RequestCore.get(
+            f"/api/admins/{username}/usages",
+            headers=RequestCore.generate_headers(access),
+            response_model=AdminUsageLogsResponse,
+        )
+
+    @staticmethod
+    async def enable_admin(username: str, access: str) -> AdminResponse:
+        return await RequestCore.post(
+            f"/api/admins/{username}/enable",
+            headers=RequestCore.generate_headers(access),
+            response_model=AdminResponse,
+        )
+
+    @staticmethod
+    async def disable_admin(username: str, access: str) -> AdminResponse:
+        return await RequestCore.post(
+            f"/api/admins/{username}/disable",
+            headers=RequestCore.generate_headers(access),
+            response_model=AdminResponse,
+        )
+
+    @staticmethod
+    async def get_admin_subscriptions(
+        username: str, access: str
+    ) -> list[SubscriptionResponse]:
+        return await RequestCore.get(
+            f"/api/admins/{username}/subscriptions",
+            headers=RequestCore.generate_headers(access),
+            response_model=SubscriptionResponse,
+            use_list=True,
+        )
+
+    @staticmethod
+    async def delete_admin_subscriptions(username: str, access: str) -> dict:
+        return await RequestCore.delete(
+            f"/api/admins/{username}/subscriptions",
+            headers=RequestCore.generate_headers(access),
+        )
+
+    @staticmethod
+    async def activate_admin_subscriptions(username: str, access: str) -> dict:
+        return await RequestCore.post(
+            f"/api/admins/{username}/subscriptions/activate",
+            headers=RequestCore.generate_headers(access),
+        )
+
+    @staticmethod
+    async def deactivate_admin_subscriptions(username: str, access: str) -> dict:
+        return await RequestCore.post(
+            f"/api/admins/{username}/subscriptions/deactivate",
+            headers=RequestCore.generate_headers(access),
+        )
+
+    @staticmethod
+    async def get_all_subscriptions(access: str) -> list[SubscriptionResponse]:
+        return await RequestCore.get(
+            "/api/subscriptions",
+            headers=RequestCore.generate_headers(access),
+            response_model=SubscriptionResponse,
+            use_list=True,
+        )
+
+    @staticmethod
+    async def create_subscription(
+        data: list[SubscriptionCreate], access: str
+    ) -> SubscriptionResponse:
+        return await RequestCore.post(
+            "/api/subscriptions",
+            headers=RequestCore.generate_headers(access),
+            json=[item.dict() for item in data],
+            response_model=SubscriptionResponse,
+            use_list=True,
+        )
+
+    @staticmethod
+    async def get_subscription_stats(access: str) -> SubscriptionStatsResponse:
+        return await RequestCore.get(
+            "/api/subscriptions/stats",
+            headers=RequestCore.generate_headers(access),
+            response_model=SubscriptionStatsResponse,
+        )
+
+    @staticmethod
+    async def get_subscription(username: str, access: str) -> SubscriptionResponse:
+        return await RequestCore.get(
+            f"/api/subscriptions/{username}",
+            headers=RequestCore.generate_headers(access),
+            response_model=SubscriptionResponse,
+        )
+
+    @staticmethod
+    async def update_subscription(
+        username: str, data: SubscriptionUpdate, access: str
+    ) -> SubscriptionResponse:
+        return await RequestCore.put(
+            f"/api/subscriptions/{username}",
+            headers=RequestCore.generate_headers(access),
+            json=data.dict(),
+            response_model=SubscriptionResponse,
+        )
+
+    @staticmethod
+    async def delete_subscription(username: str, access: str) -> dict:
+        return await RequestCore.delete(
+            f"/api/subscriptions/{username}",
+            headers=RequestCore.generate_headers(access),
+        )
+
+    @staticmethod
+    async def get_subscription_usages(
+        username: str, access: str
+    ) -> SubscriptionUsageLogsResponse:
+        return await RequestCore.get(
+            f"/api/subscriptions/{username}/usages",
+            headers=RequestCore.generate_headers(access),
+            response_model=SubscriptionUsageLogsResponse,
+        )
+
+    @staticmethod
+    async def enable_subscription(username: str, access: str) -> SubscriptionResponse:
+        return await RequestCore.post(
+            f"/api/subscriptions/{username}/enable",
+            headers=RequestCore.generate_headers(access),
+            response_model=SubscriptionResponse,
+        )
+
+    @staticmethod
+    async def disable_subscription(username: str, access: str) -> SubscriptionResponse:
+        return await RequestCore.post(
+            f"/api/subscriptions/{username}/disable",
+            headers=RequestCore.generate_headers(access),
+            response_model=SubscriptionResponse,
+        )
+
+    @staticmethod
+    async def revoke_subscription(username: str, access: str) -> SubscriptionResponse:
+        return await RequestCore.post(
+            f"/api/subscriptions/{username}/revoke",
+            headers=RequestCore.generate_headers(access),
+            response_model=SubscriptionResponse,
+        )
+
+    @staticmethod
+    async def reset_subscription(username: str, access: str) -> SubscriptionResponse:
+        return await RequestCore.post(
+            f"/api/subscriptions/{username}/reset",
+            headers=RequestCore.generate_headers(access),
+            response_model=SubscriptionResponse,
+        )
+
+    @staticmethod
+    async def get_nodes(access: str) -> list[NodeResponse]:
+        return await RequestCore.get(
+            "/api/nodes",
+            headers=RequestCore.generate_headers(access),
+            response_model=NodeResponse,
+            use_list=True,
+        )
+
+    @staticmethod
+    async def create_node(data: NodeCreate, access: str) -> NodeResponse:
+        return await RequestCore.post(
+            "/api/nodes",
+            headers=RequestCore.generate_headers(access),
+            json=data.dict(),
+            response_model=NodeResponse,
+        )
+
+    @staticmethod
+    async def get_node_stats(access: str) -> NodeStatsResponse:
+        return await RequestCore.get(
+            "/api/nodes/stats",
+            headers=RequestCore.generate_headers(access),
+            response_model=NodeStatsResponse,
+        )
+
+    @staticmethod
+    async def get_node(node_id: int, access: str) -> NodeResponse:
+        return await RequestCore.get(
+            f"/api/nodes/{node_id}",
+            headers=RequestCore.generate_headers(access),
+            response_model=NodeResponse,
+        )
+
+    @staticmethod
+    async def update_node(node_id: int, data: NodeUpdate, access: str) -> NodeResponse:
+        return await RequestCore.put(
+            f"/api/nodes/{node_id}",
+            headers=RequestCore.generate_headers(access),
+            json=data.dict(),
+            response_model=NodeResponse,
+        )
+
+    @staticmethod
+    async def delete_node(node_id: int, access: str) -> dict:
+        return await RequestCore.delete(
+            f"/api/nodes/{node_id}",
+            headers=RequestCore.generate_headers(access),
+        )
+
+    @staticmethod
+    async def enable_node(node_id: int, access: str) -> NodeResponse:
+        return await RequestCore.post(
+            f"/api/nodes/{node_id}/enable",
+            headers=RequestCore.generate_headers(access),
+            response_model=NodeResponse,
+        )
+
+    @staticmethod
+    async def disable_node(node_id: int, access: str) -> NodeResponse:
+        return await RequestCore.post(
+            f"/api/nodes/{node_id}/disable",
+            headers=RequestCore.generate_headers(access),
+            response_model=NodeResponse,
+        )
+
+    @staticmethod
+    async def get_services(access: str) -> list[ServiceResponse]:
+        return await RequestCore.get(
+            "/api/services",
+            headers=RequestCore.generate_headers(access),
+            response_model=ServiceResponse,
+            use_list=True,
+        )
+
+    @staticmethod
+    async def create_service(data: ServiceCreate, access: str) -> ServiceResponse:
+        return await RequestCore.post(
+            "/api/services",
+            headers=RequestCore.generate_headers(access),
+            json=data.dict(),
+            response_model=ServiceResponse,
+        )
+
+    @staticmethod
+    async def get_service(service_id: int, access: str) -> ServiceResponse:
+        return await RequestCore.get(
+            f"/api/services/{service_id}",
+            headers=RequestCore.generate_headers(access),
+            response_model=ServiceResponse,
+        )
+
+    @staticmethod
+    async def update_service(
+        service_id: int, data: ServiceUpdate, access: str
+    ) -> ServiceResponse:
+        return await RequestCore.put(
+            f"/api/services/{service_id}",
+            headers=RequestCore.generate_headers(access),
+            json=data.dict(),
+            response_model=ServiceResponse,
+        )
+
+    @staticmethod
+    async def delete_service(service_id: int, access: str) -> dict:
+        return await RequestCore.delete(
+            f"/api/services/{service_id}",
+            headers=RequestCore.generate_headers(access),
+        )
+
+    @staticmethod
+    async def get_guard(secret: str) -> list[str]:
+        return await RequestCore.get(
+            f"/api/guards/{secret}",
+        )

guardcoreapi/types/__init__.py

@@ -0,0 +1,58 @@
+from .admins import (
+    AdminPlaceHolderCategory,
+    AdminPlaceHolder,
+    AdminRole,
+    AdminToken,
+    AdminResponse,
+    ADMIN_PLACEHOLDER_REMARK_FORMATS,
+    AdminCreate,
+    AdminCurrentUpdate,
+    AdminUpdate,
+    AdminUsageLog,
+    AdminUsageLogsResponse,
+)
+from .subscriptions import (
+    SubscriptionCreate,
+    SubscriptionResponse,
+    SubscriptionUpdate,
+    SubscriptionUsageLog,
+    SubscriptionUsageLogsResponse,
+    SubscriptionStatsResponse,
+)
+from .nodes import (
+    NodeCategory,
+    NodeResponse,
+    NodeCreate,
+    NodeUpdate,
+    NodeStatsResponse,
+)
+from .services import ServiceResponse, ServiceCreate, ServiceUpdate
+
+
+__all__ = [
+    "AdminPlaceHolderCategory",
+    "AdminPlaceHolder",
+    "AdminRole",
+    "AdminToken",
+    "AdminResponse",
+    "ADMIN_PLACEHOLDER_REMARK_FORMATS",
+    "AdminCreate",
+    "AdminCurrentUpdate",
+    "AdminUpdate",
+    "AdminUsageLog",
+    "AdminUsageLogsResponse",
+    "SubscriptionCreate",
+    "SubscriptionResponse",
+    "SubscriptionUpdate",
+    "SubscriptionUsageLog",
+    "SubscriptionUsageLogsResponse",
+    "SubscriptionStatsResponse",
+    "NodeCategory",
+    "NodeResponse",
+    "NodeCreate",
+    "NodeUpdate",
+    "NodeStatsResponse",
+    "ServiceResponse",
+    "ServiceCreate",
+    "ServiceUpdate",
+]

guardcoreapi/types/admins.py

@@ -0,0 +1,117 @@
+from enum import StrEnum
+from typing import Optional
+from datetime import datetime
+from pydantic import BaseModel
+
+
+class AdminPlaceHolderCategory(StrEnum):
+    INFO = "info"
+    LIMITED = "limited"
+    EXPIRED = "expired"
+    DISABLED = "disabled"
+
+
+ADMIN_PLACEHOLDER_REMARK_FORMATS = [
+    "id",
+    "username",
+    "owner_username",
+    "enabled",
+    "activated",
+    "limited",
+    "expired",
+    "is_active",
+    "limit_usage",
+    "current_usage",
+    "left_usage",
+    "expire_date",
+    "expire_in",
+    "expire_in_days",
+]
+
+
+class AdminPlaceHolder(BaseModel):
+    remark: str
+    categories: list[AdminPlaceHolderCategory]
+
+
+class AdminRole(StrEnum):
+    OWNER = "owner"
+    RESELLER = "reseller"
+
+
+class AdminToken(BaseModel):
+    access_token: str
+    token_type: str = "bearer"
+
+
+class AdminResponse(BaseModel):
+    id: int
+    enabled: bool
+    removed: bool
+    username: str
+    role: AdminRole
+    service_ids: list[int]
+    create_access: Optional[bool]
+    update_access: Optional[bool]
+    remove_access: Optional[bool]
+    count_limit: Optional[int]
+    current_count: Optional[int]
+    left_count: Optional[int]
+    reached_count_limit: Optional[bool]
+    usage_limit: Optional[int]
+    current_usage: Optional[int]
+    left_usage: Optional[int]
+    reached_usage_limit: Optional[bool]
+    placeholders: Optional[list[AdminPlaceHolder]]
+    max_links: Optional[int]
+    last_login_at: Optional[datetime]
+    last_online_at: Optional[datetime]
+    created_at: datetime
+    updated_at: datetime
+
+    class Config:
+        from_attributes = True
+
+
+class AdminCreate(BaseModel):
+    username: str
+    password: str
+    role: AdminRole
+    service_ids: Optional[list[int]]
+    create_access: Optional[bool] = False
+    update_access: Optional[bool] = False
+    remove_access: Optional[bool] = False
+    count_limit: Optional[int] = None
+    usage_limit: Optional[int] = None
+    access_prefix: Optional[str] = None
+
+
+class AdminUpdate(BaseModel):
+    password: Optional[str] = None
+    create_access: Optional[bool] = None
+    update_access: Optional[bool] = None
+    remove_access: Optional[bool] = None
+    count_limit: Optional[int] = None
+    usage_limit: Optional[int] = None
+    service_ids: Optional[list[int]] = None
+    placeholders: Optional[list[AdminPlaceHolder]] = None
+    max_links: Optional[int] = None
+    shuffle_links: Optional[bool] = None
+    access_prefix: Optional[str] = None
+
+
+class AdminCurrentUpdate(BaseModel):
+    password: Optional[str] = None
+    placeholders: Optional[list[AdminPlaceHolder]] = None
+    max_links: Optional[int] = None
+    shuffle_links: Optional[bool] = None
+
+
+class AdminUsageLog(BaseModel):
+    usage: int
+    created_at: datetime
+
+
+class AdminUsageLogsResponse(BaseModel):
+    admin: AdminResponse
+    usages: list[AdminUsageLog]

guardcoreapi/types/nodes.py

@@ -0,0 +1,49 @@
+from enum import StrEnum
+from datetime import datetime
+from pydantic import BaseModel
+
+
+class NodeCategory(StrEnum):
+    marzban = "marzban"
+    marzneshin = "marzneshin"
+
+
+class NodeResponse(BaseModel):
+    id: int
+    enabled: bool
+    remark: str
+    category: NodeCategory
+    username: str
+    password: str
+    host: str
+    created_at: datetime
+    updated_at: datetime
+
+    class Config:
+        from_attributes = True
+
+
+class NodeCreate(BaseModel):
+    remark: str
+    category: NodeCategory
+    username: str
+    password: str
+    host: str
+    offset_link: int = 0
+
+
+class NodeUpdate(BaseModel):
+    remark: str | None = None
+    username: str | None = None
+    password: str | None = None
+    host: str | None = None
+    offset_link: int | None = None
+
+
+class NodeStatsResponse(BaseModel):
+    total_nodes: int
+    active_nodes: int
+    inactive_nodes: int
+
+    class Config:
+        from_attributes = True

guardcoreapi/types/services.py

@@ -0,0 +1,21 @@
+from typing import List
+from pydantic import BaseModel
+
+
+class ServiceResponse(BaseModel):
+    id: int
+    remark: str
+    node_ids: List[int]
+
+    class Config:
+        from_attributes = True
+
+
+class ServiceCreate(BaseModel):
+    remark: str
+    node_ids: List[int]
+
+
+class ServiceUpdate(BaseModel):
+    remark: str | None = None
+    node_ids: List[int] | None = None

guardcoreapi/types/subscriptions.py

@@ -0,0 +1,68 @@
+from typing import Optional
+from datetime import datetime
+from pydantic import BaseModel
+
+
+class SubscriptionResponse(BaseModel):
+    id: int
+    username: str
+    owner_username: str
+    access_key: str
+
+    enabled: bool
+    activated: bool
+    limited: bool
+    expired: bool
+    is_active: bool
+
+    link: str
+
+    limit_usage: int
+    reset_usage: int
+    total_usage: int
+    current_usage: int
+    limit_expire: int
+
+    last_reset_at: Optional[datetime]
+    last_revoke_at: Optional[datetime]
+    last_request_at: Optional[datetime]
+    last_client_agent: Optional[str]
+    created_at: datetime
+    updated_at: datetime
+
+    class Config:
+        from_attributes = True
+
+
+class SubscriptionCreate(BaseModel):
+    username: str
+    limit_usage: int
+    limit_expire: int
+
+
+class SubscriptionUpdate(BaseModel):
+    limit_usage: Optional[int] = None
+    limit_expire: Optional[int] = None
+
+
+class SubscriptionUsageLog(BaseModel):
+    usage: int
+    created_at: datetime
+
+
+class SubscriptionUsageLogsResponse(BaseModel):
+    subscription: SubscriptionResponse
+    usages: list[SubscriptionUsageLog]
+
+
+class SubscriptionStatsResponse(BaseModel):
+    total: int
+    active: int
+    inactive: int
+    disabled: int
+    expired: int
+    limited: int
+    has_revoked: int
+    has_reseted: int
+    total_removed: int
+    total_usage: int

guardcoreapi-0.1.0.dist-info/METADATA

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: guardcoreapi
+Version: 0.1.0
+Summary: Guard Management Core Api Python lib
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: aiohttp>=3.13.1
+Requires-Dist: pydantic>=2.12.3
+Dynamic: license-file

guardcoreapi-0.1.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+guardcoreapi/__init__.py,sha256=GohrmPFFH_Bfa5Ex3n0u-c4RjU47KbmoBYi38k8S_NI,62
+guardcoreapi/manager.py,sha256=D0wKFdCb7kFCa9ZbUX-pDxJ8XffSxIiXUjx6tgtvx7M,12570
+guardcoreapi/core/__init__.py,sha256=QJhZCPZui7zDpnQJbmWZsEijiAAP3rglUZb_w6E61_M,381
+guardcoreapi/core/exceptions.py,sha256=KbmdV8p31gSlKXjmJoW3lR9wGOQSvaaZKl9oGb7qlFI,555
+guardcoreapi/core/request.py,sha256=HMPHwReoxCPIop2rnQxPN5A1icU0JBI11HuG2kO_-XM,4327
+guardcoreapi/types/__init__.py,sha256=AtHWIIQoso_L5jb6nozhNBs6_0Tm2Zvvj8VvaH5eKwg,1275
+guardcoreapi/types/admins.py,sha256=sOF8dODF9cNABCOVJJd3Cqc9juggIYq0sAyphJT5PFk,2800
+guardcoreapi/types/nodes.py,sha256=m89zmH_f9iNGkU8wC7HHPlDAxQZy6reptEk_X84H8CA,919
+guardcoreapi/types/services.py,sha256=3lpP76Q9iij2zSEXutDg1IatIslLokQ-DNPvSdckRCQ,369
+guardcoreapi/types/subscriptions.py,sha256=3AwwNmyXVYq7KLaiGdCuECRMsqWCNdrZbRpC2LkhGjQ,1336
+guardcoreapi-0.1.0.dist-info/licenses/LICENSE,sha256=BPTJfvegcaek6E2PQ2rViLbxbfB1AbjIauxVQWo5Od4,1062
+guardcoreapi-0.1.0.dist-info/METADATA,sha256=JGV4PVDmJYhxQ65AbzCa-OFJqBgDj0TXqnuWSw0Wv5U,273
+guardcoreapi-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+guardcoreapi-0.1.0.dist-info/top_level.txt,sha256=ArZR_iOVG8XvUCTMHioVgKI8CkJOX_yH8t7898OXBF8,13
+guardcoreapi-0.1.0.dist-info/RECORD,,

guardcoreapi-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

guardcoreapi-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Erfan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

guardcoreapi-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+guardcoreapi