rebecca-api 0.1.3__py3-none-any.whl

rebecca/__init__.py

@@ -0,0 +1,98 @@
+from .api import RebeccaAPI
+from .models import (
+    Admin,
+    AdminCreate,
+    AdminModify,
+    BulkGroup,
+    BulkUser,
+    BulkUsersProxy,
+    CoreCreate,
+    CoreResponse,
+    CoreResponseList,
+    CoreStats,
+    CreateUserFromTemplate,
+    GroupCreate,
+    GroupModify,
+    GroupResponse,
+    GroupsResponse,
+    HostBase,
+    HostResponse,
+    HTTPValidationError,
+    ModifyUserByTemplate,
+    NextPlanModel,
+    NodeCreate,
+    NodeModify,
+    NodeResponse,
+    NodesUsageResponse,
+    NodeUsageResponse,
+    ProxyHost,
+    ProxyInbound,
+    ProxySettings,
+    SubscriptionUserResponse,
+    SystemStats,
+    Token,
+    UserCreate,
+    UserModify,
+    UserResponse,
+    UsersResponse,
+    UserStatus,
+    UserTemplateCreate,
+    UserTemplateModify,
+    UserTemplateResponse,
+    UserUsageResponse,
+    UserUsagesResponse,
+    ValidationError,
+)
+from .utils import RebeccaTokenCache
+from .enums import RoleEnum
+__all__ = (
+    "__version__",
+    "RebeccaAPI",
+    "RebeccaTokenCache",
+    "Admin",
+    "AdminCreate",
+    "AdminModify",
+    "UserCreate",
+    "UserModify",
+    "UserResponse",
+    "UsersResponse",
+    "UserStatus",
+    "UserTemplateCreate",
+    "UserTemplateModify",
+    "UserTemplateResponse",
+    "UserUsageResponse",
+    "UserUsagesResponse",
+    "NodeUsageResponse",
+    "NodesUsageResponse",
+    "NodeCreate",
+    "NodeModify",
+    "NodeResponse",
+    "GroupCreate",
+    "GroupModify",
+    "GroupResponse",
+    "GroupsResponse",
+    "BulkGroup",
+    "HostBase",
+    "HostResponse",
+    "CoreCreate",
+    "CoreResponse",
+    "CoreResponseList",
+    "ModifyUserByTemplate",
+    "CreateUserFromTemplate",
+    "BulkUser",
+    "BulkUsersProxy",
+    "SystemStats",
+    "CoreStats",
+    "ProxySettings",
+    "ProxyHost",
+    "ProxyInbound",
+    "Token",
+    "HTTPValidationError",
+    "ValidationError",
+    "SubscriptionUserResponse",
+    "NextPlanModel",
+    # Enum
+    "RoleEnum",
+)
+
+__version__ = "0.1.3"

rebecca/api.py

@@ -0,0 +1,606 @@
+from datetime import datetime
+from typing import Optional
+
+import httpx
+import paramiko
+from paramiko.ssh_exception import SSHException
+from sshtunnel import SSHTunnelForwarder
+
+from .models import *  # noqa: F403
+
+
+class RebeccaAPI:
+    def __init__(
+        self,
+        base_url: str,
+        *,
+        timeout: float = 10.0,
+        verify: bool = False,
+        ssh_username: Optional[str] = None,
+        ssh_host: Optional[str] = None,
+        ssh_port: Optional[int] = 22,
+        ssh_private_key_path: Optional[str] = None,
+        ssh_key_passphrase: Optional[str] = None,
+        ssh_password: Optional[str] = None,
+        local_bind_host: str = "127.0.0.1",
+        local_bind_port: int = 8000,
+        remote_bind_host: str = "127.0.0.1",
+        remote_bind_port: int = 8000,
+    ):
+        """
+        Initializes the RebeccaAPI client with optional SSH tunneling for secure remote access.
+
+        :param base_url: The base URL of the Rebecca API.
+        :param timeout: The request timeout in seconds (default: 10.0).
+        :param verify: SSL verification flag; set to False to ignore SSL verification (default: False).
+        :param ssh_username: SSH username for tunnel authentication.
+        :param ssh_host: SSH server address for setting up the tunnel. If None, no SSH tunnel is used.
+        :param ssh_port: SSH port for connecting to the server (default: 22).
+        :param ssh_private_key_path: Path to the SSH private key file for authentication.
+        :param ssh_key_passphrase: Passphrase for the SSH private key, if applicable.
+        :param ssh_password: Password for SSH authentication. Use if no private key is provided.
+        :param local_bind_host: Local IP address for binding the SSH tunnel (default: '127.0.0.1').
+        :param local_bind_port: Local port for SSH tunnel binding (default: 8000).
+        :param remote_bind_host: Remote IP address for binding on the SSH server side (default: '127.0.0.1').
+        :param remote_bind_port: Remote port for the SSH server binding (default: 8000).
+
+        :raises ValueError: If SSH tunneling is requested but neither a private key nor password is provided.
+        """
+
+        self.base_url = base_url
+        self.timeout = timeout
+        self.verify = verify
+        self.ssh_username = ssh_username
+        self.ssh_host = ssh_host
+        self.ssh_port = ssh_port
+        self.ssh_private_key_path = ssh_private_key_path
+        self.ssh_key_passphrase = ssh_key_passphrase
+        self.ssh_password = ssh_password
+        self.local_bind_host = local_bind_host
+        self.local_bind_port = local_bind_port
+        self.remote_bind_host = remote_bind_host
+        self.remote_bind_port = remote_bind_port
+        self.client = None
+        self._tunnel = None
+        self._forwarder = None
+        if ssh_host and not ssh_private_key_path and not ssh_password:
+            raise ValueError("For an SSH tunnel, you must specify either ssh_private_key_path or ssh_password")
+        if not ssh_host:
+            self.client = httpx.AsyncClient(base_url=self.base_url, verify=self.verify, timeout=self.timeout)
+
+    def _load_private_key(self, key_path, passphrase):
+        key_classes = [paramiko.RSAKey, paramiko.DSSKey, paramiko.ECDSAKey, paramiko.Ed25519Key]
+        for key_class in key_classes:
+            try:
+                if passphrase:
+                    pkey = key_class.from_private_key_file(key_path, password=passphrase)
+                else:
+                    pkey = key_class.from_private_key_file(key_path)
+                return pkey
+            except paramiko.ssh_exception.PasswordRequiredException:
+                print("Ошибка: Приватный ключ защищен паролем. Пожалуйста, укажите пароль.")
+            except SSHException:
+                continue
+        raise ValueError("Unsupported key format or incorrect passphrase.")
+
+    def _initialize(self):
+        """Initialization of the SSH tunnel and the HTTP client."""
+        if self.ssh_host:
+            if self._tunnel and self._tunnel.is_active:
+                return
+            # Uploading the key using paramiko
+            private_key = None
+            if self.ssh_private_key_path:
+                private_key = self._load_private_key(self.ssh_private_key_path, self.ssh_key_passphrase)
+            # Installing an SSH tunnel using sshtunnel
+            self._tunnel = SSHTunnelForwarder(
+                (self.ssh_host, self.ssh_port),
+                ssh_username=self.ssh_username,
+                ssh_password=self.ssh_password,
+                ssh_pkey=private_key,
+                remote_bind_address=(self.remote_bind_host, self.remote_bind_port),
+                local_bind_address=(self.local_bind_host, self.local_bind_port),
+            )
+            self._tunnel.start()
+            self.client = httpx.AsyncClient(
+                base_url=f"http://{self.local_bind_host}:{self.local_bind_port}",
+                timeout=self.timeout,
+                verify=self.verify,
+            )
+
+            # HTTP-client with local URL
+
+    def _get_headers(self, token: str) -> Dict[str, str]:
+        return {"Authorization": f"Bearer {token}"}
+
+    async def _request(
+        self,
+        method: str,
+        url: str,
+        token: Optional[str] = None,
+        data: Optional[BaseModel] = None,
+        params: Optional[Dict[str, Any]] = None,
+    ) -> httpx.Response:
+        if self.ssh_host and (not self.client or not self._tunnel.is_active):
+            # Initialize the HTTP client and SSH tunnel if they are closed
+            self._initialize()
+            return await self._request(method, url, token, data, params)
+        headers = self._get_headers(token) if token else {}
+        if data is None:
+            json_data = None
+        elif hasattr(data, "model_dump"):
+            json_data = data.model_dump(exclude_none=True)
+        else:
+            json_data = data
+        params = {k: v for k, v in (params or {}).items() if v is not None}
+        response = await self.client.request(method, url, headers=headers, json=json_data, params=params)
+        response.raise_for_status()
+        return response
+
+    async def get_token(self, username: str, password: str) -> Token:
+        url = "/api/admin/token"
+        payload = {
+            "grant_type": "password",
+            "username": username,
+            "password": password,
+            "scope": "",
+            "client_id": "",
+            "client_secret": "",
+        }
+        if self.ssh_host and (not self.client or not self._tunnel.is_active):
+            # Initialize the HTTP client and SSH tunnel if they are closed
+            self._initialize()
+            return await self.get_token(username, password)
+        response = await self.client.post(url, data=payload)
+        response.raise_for_status()
+        return Token(**response.json())
+
+    async def get_current_admin(self, token: str) -> Admin:
+        url = "/api/admin"
+        response = await self._request("GET", url, token)
+        return Admin(**response.json())
+
+    async def create_admin(self, admin: AdminCreate, token: str) -> Admin:
+        url = "/api/admin"
+        response = await self._request("POST", url, token, data=admin)
+        return Admin(**response.json())
+
+    async def modify_admin(self, username: str, admin: AdminModify, token: str) -> Admin:
+        url = f"/api/admin/{username}"
+        response = await self._request("PUT", url, token, data=admin)
+        return Admin(**response.json())
+
+    async def remove_admin(self, username: str, token: str) -> None:
+        url = f"/api/admin/{username}"
+        await self._request("DELETE", url, token)
+
+    async def get_admins(
+        self, token: str, offset: Optional[int] = None, limit: Optional[int] = None, username: Optional[str] = None
+    ) -> List[Admin]:
+        url = "/api/admins"
+        params = {"offset": offset, "limit": limit, "username": username}
+        response = await self._request("GET", url, token, params=params)
+        return [Admin(**admin) for admin in response.json()]
+
+    async def disable_all_users_admin(self, username: str, token: str) -> None:
+        url = f"/api/admin/{username}/users/disable"
+        await self._request("POST", url, token)
+
+    async def activate_all_users_admin(self, username: str, token: str) -> None:
+        url = f"/api/admin/{username}/users/activate"
+        await self._request("POST", url, token)
+
+    async def reset_admin_usage(self, username: str, token: str) -> Admin:
+        url = f"/api/admin/usage/reset/{username}"
+        response = await self._request("POST", url, token)
+        return Admin(**response.json())
+
+    async def get_admin_usage(self, username: str, token: str) -> Admin:
+        url = f"/api/admin/usage/{username}"
+        response = await self._request("GET", url, token)
+        return response.json()
+
+    async def get_system_stats(self, token: str) -> SystemStats:
+        url = "/api/system"
+        response = await self._request("GET", url, token)
+        return SystemStats(**response.json())
+
+    async def get_inbounds(self, token: str) -> Dict[str, List[ProxyInbound]]:
+        url = "/api/inbounds"
+        response = await self._request("GET", url, token)
+        return response.json()
+
+    async def get_hosts(self, token: str) -> Dict[str, List[ProxyHost]]:
+        url = "/api/hosts"
+        response = await self._request("GET", url, token)
+        return response.json()
+
+    async def modify_hosts(self, hosts: Dict[str, List[ProxyHost]], token: str) -> Dict[str, List[ProxyHost]]:
+        url = "/api/hosts"
+
+        hosts_model = HostsModel(root=hosts)
+        response = await self._request("PUT", url, token, data=hosts_model)
+        return response.json()
+
+    async def create_host(self, host: HostBase, token: str) -> HostResponse:
+        url = "/api/host"
+        response = await self._request("POST", url, token, data=host)
+        return HostResponse(**response.json())
+
+    async def get_host(self, host_id: int, token: str) -> HostResponse:
+        url = f"/api/host/{host_id}"
+        response = await self._request("GET", url, token)
+        return HostResponse(**response.json())
+
+    async def modify_host(self, host_id: int, host: HostBase, token: str) -> HostResponse:
+        url = f"/api/host/{host_id}"
+        response = await self._request("PUT", url, token, data=host)
+        return HostResponse(**response.json())
+
+    async def remove_host(self, host_id: int, token: str) -> None:
+        url = f"/api/host/{host_id}"
+        await self._request("DELETE", url, token)
+
+    async def get_core_stats(self, token: str) -> CoreStats:
+        url = "/api/core"
+        response = await self._request("GET", url, token)
+        return CoreStats(**response.json())
+
+    async def create_core_config(self, core: CoreCreate, token: str) -> CoreResponse:
+        url = "/api/core"
+        response = await self._request("POST", url, token, data=core)
+        return CoreResponse(**response.json())
+
+    async def get_core_config(self, core_id: int, token: str) -> CoreResponse:
+        url = f"/api/core/{core_id}"
+        response = await self._request("GET", url, token)
+        return CoreResponse(**response.json())
+
+    async def modify_core_config(
+        self, core_id: int, config: CoreCreate, token: str, restart_nodes: bool = False
+    ) -> CoreResponse:
+        url = f"/api/core/{core_id}"
+        params = {"restart_nodes": restart_nodes}
+        response = await self._request("PUT", url, token, data=config, params=params)
+        return CoreResponse(**response.json())
+
+    async def delete_core_config(self, core_id: int, token: str, restart_nodes: bool = False) -> None:
+        url = f"/api/core/{core_id}"
+        params = {"restart_nodes": restart_nodes}
+        await self._request("DELETE", url, token, params=params)
+
+    async def get_all_cores(
+        self, token: str, offset: Optional[int] = None, limit: Optional[int] = None
+    ) -> CoreResponseList:
+        url = "/api/cores"
+        params = {"offset": offset, "limit": limit}
+        response = await self._request("GET", url, token, params=params)
+        return CoreResponseList(**response.json())
+
+    async def restart_core(self, core_id: int, token: str) -> None:
+        url = f"/api/core/{core_id}/restart"
+        await self._request("POST", url, token)
+
+    async def add_user(self, user: UserCreate, token: str) -> UserResponse:
+        url = "/api/user"
+        response = await self._request("POST", url, token, data=user)
+        return UserResponse(**response.json())
+
+    async def create_user_from_template(self, template_user: CreateUserFromTemplate, token: str) -> UserResponse:
+        url = "/api/user/from_template"
+        response = await self._request("POST", url, token, data=template_user)
+        return UserResponse(**response.json())
+
+    async def get_user(self, username: str, token: str) -> UserResponse:
+        url = f"/api/user/{username}"
+        response = await self._request("GET", url, token)
+        return UserResponse(**response.json())
+
+    async def modify_user(self, username: str, user: UserModify, token: str) -> UserResponse:
+        url = f"/api/user/{username}"
+        response = await self._request("PUT", url, token, data=user)
+        return UserResponse(**response.json())
+
+    async def modify_user_with_template(
+        self, username: str, template_user: ModifyUserByTemplate, token: str
+    ) -> UserResponse:
+        url = f"/api/user/from_template/{username}"
+        response = await self._request("PUT", url, token, data=template_user)
+        return UserResponse(**response.json())
+
+    async def activate_next_plan(self, username: str, token: str) -> UserResponse:
+        url = f"/api/user/{username}/active-next"
+        response = await self._request("POST", url, token)
+        return UserResponse(**response.json())
+
+    async def remove_user(self, username: str, token: str) -> None:
+        url = f"/api/user/{username}"
+        await self._request("DELETE", url, token)
+
+    async def bulk_modify_users_expire(self, bulk: BulkUser, token: str) -> Dict[str, Any]:
+        url = "/api/users/bulk/expire"
+        response = await self._request("POST", url, token, data=bulk)
+        return response.json()
+
+    async def bulk_modify_users_datalimit(self, bulk: BulkUser, token: str) -> Dict[str, Any]:
+        url = "/api/users/bulk/data_limit"
+        response = await self._request("POST", url, token, data=bulk)
+        return response.json()
+
+    async def bulk_modify_users_proxy_settings(self, bulk: BulkUsersProxy, token: str) -> Dict[str, Any]:
+        url = "/api/users/bulk/proxy_settings"
+        response = await self._request("POST", url, token, data=bulk)
+        return response.json()
+
+    async def reset_user_data_usage(self, username: str, token: str) -> UserResponse:
+        url = f"/api/user/{username}/reset"
+        response = await self._request("POST", url, token)
+        return UserResponse(**response.json())
+
+    async def revoke_user_subscription(self, username: str, token: str) -> UserResponse:
+        url = f"/api/user/{username}/revoke_sub"
+        response = await self._request("POST", url, token)
+        return UserResponse(**response.json())
+
+    async def get_users(
+        self,
+        token: str,
+        offset: Optional[int] = None,
+        limit: Optional[int] = None,
+        username: Optional[List[str]] = None,
+        search: Optional[str] = None,
+        status: Optional[str] = None,
+        sort: Optional[str] = None,
+    ) -> UsersResponse:
+        url = "/api/users"
+        params = {
+            "offset": offset,
+            "limit": limit,
+            "username": username,
+            "search": search,
+            "status": status,
+            "sort": sort,
+        }
+        response = await self._request("GET", url, token, params=params)
+        return UsersResponse(**response.json())
+
+    async def reset_users_data_usage(self, token: str) -> None:
+        url = "/api/users/reset"
+        await self._request("POST", url, token)
+
+    async def get_user_data_usage(
+        self, username: str, token: str, start_date: Optional[datetime] = None, end_date: Optional[datetime] = None
+    ) -> UserUsagesResponse:
+        if isinstance(start_date, str):
+            start_date = datetime.fromisoformat(start_date)
+        if isinstance(end_date, str):
+            end_date = datetime.fromisoformat(end_date)
+
+        params = {
+            "start": start_date.isoformat(timespec="seconds") if start_date else None,
+            "end": end_date.isoformat(timespec="seconds") if end_date else None,
+        }
+        params = {k: v for k, v in params.items() if v is not None}
+        url = f"/api/user/{username}/usage"
+        response = await self._request("GET", url, token, params=params)
+        return UserUsagesResponse(**response.json())
+
+    async def set_owner(self, username: str, admin_username: str, token: str) -> UserResponse:
+        url = f"/api/user/{username}/set-owner?admin_username={admin_username}"
+        response = await self._request("PUT", url, token)
+        return UserResponse(**response.json())
+
+    async def get_expired_users(
+        self, token: str, expired_before: Optional[str] = None, expired_after: Optional[str] = None
+    ) -> List[str]:
+        url = "/api/users/expired"
+        params = {"expired_before": expired_before, "expired_after": expired_after}
+        response = await self._request("GET", url, token, params=params)
+        return response.json()
+
+    async def delete_expired_users(
+        self, token: str, expired_before: Optional[str] = None, expired_after: Optional[str] = None
+    ) -> List[str]:
+        url = "/api/users/expired"
+        params = {"expired_before": expired_before, "expired_after": expired_after}
+        response = await self._request("DELETE", url, token, params=params)
+        return response.json()
+
+    async def get_user_templates(
+        self, token: str, offset: Optional[int] = None, limit: Optional[int] = None
+    ) -> List[UserTemplateResponse]:
+        url = "/api/user_template"
+        params = {"offset": offset, "limit": limit}
+        response = await self._request("GET", url, token, params=params)
+        return [UserTemplateResponse(**template) for template in response.json()]
+
+    async def add_user_template(self, template: UserTemplateCreate, token: str) -> UserTemplateResponse:
+        url = "/api/user_template"
+        response = await self._request("POST", url, token, data=template)
+        return UserTemplateResponse(**response.json())
+
+    async def get_user_template(self, template_id: int, token: str) -> UserTemplateResponse:
+        url = f"/api/user_template/{template_id}"
+        response = await self._request("GET", url, token)
+        return UserTemplateResponse(**response.json())
+
+    async def modify_user_template(
+        self, template_id: int, template: UserTemplateModify, token: str
+    ) -> UserTemplateResponse:
+        url = f"/api/user_template/{template_id}"
+        response = await self._request("PUT", url, token, data=template)
+        return UserTemplateResponse(**response.json())
+
+    async def remove_user_template(self, template_id: int, token: str) -> None:
+        url = f"/api/user_template/{template_id}"
+        await self._request("DELETE", url, token)
+
+    # Group endpoints
+    async def create_group(self, group: GroupCreate, token: str) -> GroupResponse:
+        url = "/api/group"
+        response = await self._request("POST", url, token, data=group)
+        return GroupResponse(**response.json())
+
+    async def get_group(self, group_id: int, token: str) -> GroupResponse:
+        url = f"/api/group/{group_id}"
+        response = await self._request("GET", url, token)
+        return GroupResponse(**response.json())
+
+    async def modify_group(self, group_id: int, group: GroupModify, token: str) -> GroupResponse:
+        url = f"/api/group/{group_id}"
+        response = await self._request("PUT", url, token, data=group)
+        return GroupResponse(**response.json())
+
+    async def remove_group(self, group_id: int, token: str) -> None:
+        url = f"/api/group/{group_id}"
+        await self._request("DELETE", url, token)
+
+    async def get_groups(self, token: str, offset: Optional[int] = None, limit: Optional[int] = None) -> GroupsResponse:
+        url = "/api/groups"
+        params = {"offset": offset, "limit": limit}
+        response = await self._request("GET", url, token, params=params)
+        return GroupsResponse(**response.json())
+
+    async def bulk_add_groups_to_users(self, bulk_group: BulkGroup, token: str) -> Dict[str, Any]:
+        url = "/api/groups/bulk/add"
+        response = await self._request("POST", url, token, data=bulk_group)
+        return response.json()
+
+    async def bulk_remove_users_from_groups(self, bulk_group: BulkGroup, token: str) -> Dict[str, Any]:
+        url = "/api/groups/bulk/remove"
+        response = await self._request("POST", url, token, data=bulk_group)
+        return response.json()
+
+    async def get_node_settings(self, token: str) -> Dict[str, Any]:
+        url = "/api/node/settings"
+        response = await self._request("GET", url, token)
+        return response.json()
+
+    async def add_node(self, node: NodeCreate, token: str) -> NodeResponse:
+        url = "/api/node"
+        response = await self._request("POST", url, token, data=node)
+        return NodeResponse(**response.json())
+
+    async def get_node(self, node_id: int, token: str) -> NodeResponse:
+        url = f"/api/node/{node_id}"
+        response = await self._request("GET", url, token)
+        return NodeResponse(**response.json())
+
+    async def modify_node(self, node_id: int, node: NodeModify, token: str) -> NodeResponse:
+        url = f"/api/node/{node_id}"
+        response = await self._request("PUT", url, token, data=node)
+        return NodeResponse(**response.json())
+
+    async def remove_node(self, node_id: int, token: str) -> None:
+        url = f"/api/node/{node_id}"
+        await self._request("DELETE", url, token)
+
+    async def reconnect_node(self, node_id: int, token: str) -> None:
+        url = f"/api/node/{node_id}/reconnect"
+        await self._request("POST", url, token)
+
+    async def sync_node(self, node_id: int, token: str, flush_users: bool = False) -> Any:
+        url = f"/api/node/{node_id}/sync"
+        params = {"flush_users": flush_users}
+        response = await self._request("PUT", url, token, params=params)
+        return response.json()
+
+    async def node_logs(self, node_id: int, token: str) -> str:
+        url = f"/api/node/{node_id}/logs"
+        response = await self._request("GET", url, token)
+        return response.text
+
+    async def get_node_stats_periodic(
+        self, node_id: int, token: str, start: Optional[str] = None, end: Optional[str] = None, period: str = "hour"
+    ) -> Any:
+        url = f"/api/node/{node_id}/stats"
+        params = {"start": start, "end": end, "period": period}
+        response = await self._request("GET", url, token, params=params)
+        return response.json()
+
+    async def realtime_node_stats(self, node_id: int, token: str) -> Any:
+        url = f"/api/node/{node_id}/realtime_stats"
+        response = await self._request("GET", url, token)
+        return response.json()
+
+    async def realtime_nodes_stats(self, token: str) -> Any:
+        url = "/api/nodes/realtime_stats"
+        response = await self._request("GET", url, token)
+        return response.json()
+
+    async def user_online_stats(self, node_id: int, username: str, token: str) -> Any:
+        url = f"/api/node/{node_id}/online_stats/{username}"
+        response = await self._request("GET", url, token)
+        return response.json()
+
+    async def user_online_ip_list(self, node_id: int, username: str, token: str) -> Any:
+        url = f"/api/node/{node_id}/online_stats/{username}/ip"
+        response = await self._request("GET", url, token)
+        return response.json()
+
+    async def clear_usage_data(
+        self, table: str, token: str, start: Optional[str] = None, end: Optional[str] = None
+    ) -> Any:
+        url = f"/api/nodes/clear_usage_data/{table}"
+        params = {"start": start, "end": end}
+        response = await self._request("DELETE", url, token, params=params)
+        return response.json()
+
+    async def get_nodes(self, token: str) -> List[NodeResponse]:
+        url = "/api/nodes"
+        response = await self._request("GET", url, token)
+        return [NodeResponse(**node) for node in response.json()]
+
+    async def get_usage(self, token: str, start: Optional[str] = None, end: Optional[str] = None) -> NodesUsageResponse:
+        url = "/api/nodes/usage"
+        params = {"start": start, "end": end}
+        response = await self._request("GET", url, token, params=params)
+        return NodesUsageResponse(**response.json())
+
+    async def get_user_subscription_info(self, url: str = None, token: str = None) -> SubscriptionUserResponse:
+        if url:
+            # Use the provided URL if it is given
+            final_url = url + "/info"
+        elif token:
+            # Form the URL using the token if it is provided
+            final_url = f"/sub/{token}/info"
+        else:
+            raise ValueError("Either url or token must be provided")
+
+        response = await self._request("GET", final_url)
+        return SubscriptionUserResponse(**response.json())
+
+    async def get_user_usage(
+        self, url: str = None, token: str = None, start: Optional[str] = None, end: Optional[str] = None
+    ) -> Any:
+        if url:
+            # Use the provided URL if it is given
+            final_url = url + "/usage"
+        elif token:
+            # Form the URL using the token if it is provided
+            final_url = f"/sub/{token}/usage"
+        else:
+            raise ValueError("Either url or token must be provided")
+        params = {"start": start, "end": end}
+        response = await self._request("GET", final_url, params=params)
+        return response.json()
+
+    async def get_user_subscription_with_client_type(self, client_type: str, url: str = None, token: str = None) -> Any:
+        if url:
+            # Use the provided URL if it is given
+            final_url = url + f"/{client_type}"
+        elif token:
+            # Form the URL using the token if it is provided
+            final_url = f"/sub/{token}/{client_type}"
+        else:
+            raise ValueError("Either url or token must be provided")
+
+        response = await self._request("GET", final_url)
+        return response.json()
+
+    async def close(self):
+        """Closing the HTTP client and SSH tunnel."""
+        if self.client:
+            await self.client.aclose()
+        if self._tunnel:
+            self._tunnel.stop()

rebecca/enums.py

@@ -0,0 +1,7 @@
+from enum import Enum
+
+
+class RoleEnum(str, Enum):
+    full_access = "full_access"
+    standard = "standard"
+    sudo = "sudo"

rebecca/models.py

@@ -0,0 +1,492 @@
+from typing import Any, ClassVar, Dict, List, Literal, Optional
+from pydantic import BaseModel, RootModel, field_validator, Field
+from .enums import RoleEnum
+
+
+class Token(BaseModel):
+    access_token: str
+    token_type: str = "bearer"
+
+
+class Admin(BaseModel):
+    id: Optional[int] = None
+    username: Optional[str] = None
+    role: Optional[RoleEnum] = RoleEnum.standard
+    status: Optional[str] = None
+    telegram_id: Optional[int] = None
+    users_usage: Optional[int] = None
+    data_limit: Optional[int] = None
+    users_limit: Optional[int] = None
+    active_users: Optional[int] = None
+    online_users: Optional[int] = None
+    limited_users: Optional[int] = None
+    expired_users: Optional[int] = None
+
+    class Config:
+        extra = "ignore"
+
+
+class AdminListResponse(BaseModel):
+    admins: List[Admin]
+    total: int
+
+class UsersPermissions(BaseModel):
+    create: bool = False
+    delete: bool = False
+    reset_usage: bool = False
+    revoke: bool = False
+    create_on_hold: bool = False
+    allow_unlimited_data: bool = False
+    allow_unlimited_expire: bool = False
+    allow_next_plan: bool = False
+    max_data_limit_per_user: int = 0
+
+class AdminManagementPermissions(BaseModel):
+    can_view: bool = False
+    can_edit: bool = False
+    can_manage_sudo: bool = False
+
+class SectionsPermissions(BaseModel):
+    usage: bool = False
+    admins: bool = False
+    services: bool = False
+    hosts: bool = False
+    nodes: bool = False
+    integrations: bool = False
+    xray: bool = False
+
+class Permissions(BaseModel):
+    users: Optional[UsersPermissions] = Field(default_factory=UsersPermissions)
+    admin_management: Optional[AdminManagementPermissions] = Field(default_factory=AdminManagementPermissions)
+    sections: Optional[SectionsPermissions] = Field(default_factory=SectionsPermissions)
+
+class AdminCreate(BaseModel):
+    username: str
+    password: str
+    role: Optional[RoleEnum] = RoleEnum.standard
+    permissions: Optional[Permissions] = Field(default_factory=Permissions)
+    telegram_id: Optional[int] = None
+    status: Optional[str] = "active"
+    disabled_reason: Optional[str] = ""
+    users_usage: Optional[int] = 0
+    data_limit: Optional[int] = 0
+    users_limit: Optional[int] = 0
+    active_users: Optional[int] = 0
+    online_users: Optional[int] = 0
+    limited_users: Optional[int] = 0
+    expired_users: Optional[int] = 0
+
+    class Config:
+        extra = "ignore"
+
+
+class AdminModify(BaseModel):
+    role: Optional[RoleEnum] = RoleEnum.standard
+    password: Optional[str] = None
+
+
+class HTTPValidationError(BaseModel):
+    detail: Optional[List[Dict[str, Any]]] = None
+
+
+class ProxySettings(BaseModel):
+    id: Optional[str] = None
+    flow: Optional[str] = None
+    method: Optional[str] = None
+
+
+class NextPlanModel(BaseModel):
+    add_remaining_traffic: bool = False
+    data_limit: Optional[int] = 0
+    expire: Optional[int] = 0
+    fire_on_either: bool = True
+
+    @field_validator("data_limit", mode="before")
+    def validate_data_limit(cls, value):
+        if value is not None and value < 0:
+            raise ValueError("Data limit in the next plan must be 0 or greater")
+        return value
+
+
+class UserCreate(BaseModel):
+    username: str
+    proxy_settings: Optional[Dict[str, ProxySettings]] = None
+    group_ids: Optional[List[int]] = None
+    expire: Optional[int] = None
+    data_limit: Optional[int] = 0
+    data_limit_reset_strategy: Optional[str] = "no_reset"
+    note: Optional[str] = None
+    sub_updated_at: Optional[str] = None
+    sub_last_user_agent: Optional[str] = None
+    online_at: Optional[str] = None
+    on_hold_expire_duration: Optional[int] = 0
+    on_hold_timeout: Optional[str] = None
+    status: Literal["active", "on_hold"] = "active"
+    next_plan: Optional[NextPlanModel] = None
+
+
+class UserResponse(BaseModel):
+    username: Optional[str] = None
+    proxy_settings: Optional[Dict[str, ProxySettings]] = {}
+    group_ids: Optional[List[int]] = None
+    expire: Optional[int] = None
+    data_limit: Optional[int] = None
+    data_limit_reset_strategy: Optional[str] = None
+    note: Optional[str] = None
+    sub_updated_at: Optional[str] = None
+    sub_last_user_agent: Optional[str] = None
+    online_at: Optional[str] = None
+    on_hold_expire_duration: Optional[int] = None
+    on_hold_timeout: Optional[str] = None
+    status: Literal["active", "disabled", "limited", "expired", "on_hold"] = "active"
+    used_traffic: Optional[int] = None
+    lifetime_used_traffic: Optional[int] = None
+    links: Optional[List[str]] = []
+    subscription_url: Optional[str] = None
+    subscription_token: Optional[str] = None
+    next_plan: Optional[NextPlanModel] = None
+    admin: Optional[Admin] = None
+    created_at: Optional[str] = None
+
+    def __init__(self, **data):
+        super().__init__(**data)
+        if not self.subscription_token and self.subscription_url:
+            self.subscription_token = self.subscription_url.split("/")[-1]
+
+
+class NodeCreate(BaseModel):
+    name: str
+    address: str
+    port: int = 62050
+    usage_coefficient: float = 1.0
+    connection_type: Optional[str] = None
+    server_ca: Optional[str] = None
+    keep_alive: Optional[int] = None
+    max_logs: Optional[int] = 1000
+    core_config_id: Optional[int] = None
+    api_key: Optional[str] = None
+    gather_logs: Optional[bool] = True
+    api_port: Optional[int] = None
+
+
+class NodeModify(BaseModel):
+    name: Optional[str] = None
+    address: Optional[str] = None
+    port: Optional[int] = None
+    api_port: Optional[int] = None
+    usage_coefficient: Optional[float] = None
+    status: Optional[str] = None
+    connection_type: Optional[str] = None
+    server_ca: Optional[str] = None
+    keep_alive: Optional[int] = None
+    max_logs: Optional[int] = None
+    core_config_id: Optional[int] = None
+    api_key: Optional[str] = None
+    gather_logs: Optional[bool] = None
+
+
+class NodeResponse(BaseModel):
+    name: str
+    address: str
+    port: int
+    usage_coefficient: float
+    id: int
+    api_key: Optional[str] = None
+    core_config_id: Optional[int] = None
+    xray_version: Optional[str] = None
+    node_version: Optional[str] = None
+    status: str
+    message: Optional[str] = None
+
+
+class NodeUsageResponse(BaseModel):
+    node_id: Optional[int] = None
+    node_name: Optional[str] = None
+    uplink: Optional[int] = None
+    downlink: Optional[int] = None
+
+
+class NodesUsageResponse(BaseModel):
+    usages: List[NodeUsageResponse]
+
+
+class ProxyHost(BaseModel):
+    remark: str
+    address: str
+    port: Optional[int] = None
+    sni: Optional[str] = None
+    host: Optional[str] = None
+    path: Optional[str] = None
+    security: str = "inbound_default"
+    alpn: str = ""
+    fingerprint: str = ""
+    allowinsecure: bool
+    is_disabled: bool
+
+
+class HostsModel(RootModel):
+    root: Dict[str, List[ProxyHost]]
+
+
+class ProxyInbound(BaseModel):
+    tag: str
+    protocol: str
+    network: str
+    tls: str
+    port: Any
+
+
+class CoreStats(BaseModel):
+    version: str
+    started: bool
+    logs_websocket: str
+
+
+class UserModify(BaseModel):
+    proxy_settings: Optional[Dict[str, ProxySettings]] = {}
+    group_ids: Optional[List[int]] = None
+    expire: Optional[int] = None
+    data_limit: Optional[int] = None
+    data_limit_reset_strategy: Optional[Literal["no_reset", "day", "week", "month", "year"]] = None
+    note: Optional[str] = None
+    sub_updated_at: Optional[str] = None
+    sub_last_user_agent: Optional[str] = None
+    online_at: Optional[str] = None
+    on_hold_expire_duration: Optional[int] = None
+    on_hold_timeout: Optional[str] = None
+    status: Optional[Literal["active", "disabled", "limited", "expired", "on_hold"]] = None
+    next_plan: Optional[NextPlanModel] = None
+
+
+class UserTemplateCreate(BaseModel):
+    name: Optional[str] = None
+    group_ids: Optional[List[int]] = []
+    data_limit: int = 0
+    expire_duration: int = 0
+    extra_settings: Optional[ProxySettings] = None
+    status: Literal["active", "on_hold"] = "active"
+    reset_usages: Optional[bool] = None
+
+
+class UserTemplateResponse(BaseModel):
+    id: int
+    name: Optional[str] = None
+    group_ids: Optional[List[int]] = None
+    data_limit: int
+    expire_duration: int
+    extra_settings: Optional[ProxySettings] = None
+    status: Literal["active", "on_hold"]
+    reset_usages: Optional[bool] = None
+
+
+class UserTemplateModify(BaseModel):
+    name: Optional[str] = None
+    group_ids: Optional[List[int]] = None
+    data_limit: Optional[int] = None
+    expire_duration: Optional[int] = None
+    extra_settings: Optional[ProxySettings] = None
+    status: Optional[Literal["active", "on_hold"]] = None
+    reset_usages: Optional[bool] = None
+
+
+class UserUsageResponse(BaseModel):
+    node_id: Optional[int]
+    node_name: Optional[str]
+    used_traffic: Optional[int]
+
+
+class UserUsagesResponse(BaseModel):
+    username: str
+    usages: List[UserUsageResponse]
+
+
+class UsersResponse(BaseModel):
+    users: List[UserResponse]
+    total: int
+
+
+class UserStatus(BaseModel):
+    enum: ClassVar[List[str]] = ["active", "disabled", "limited", "expired", "on_hold"]
+
+
+class ValidationError(BaseModel):
+    loc: List[Any]
+    msg: str
+    type: str
+
+
+class SubscriptionUserResponse(BaseModel):
+    proxies: Dict[str, Any]
+    expire: Optional[int] = None
+    data_limit: Optional[int] = None
+    data_limit_reset_strategy: str = "no_reset"
+    inbounds: Dict[str, List[str]] = {}
+    note: Optional[str] = None
+    sub_updated_at: Optional[str] = None
+    sub_last_user_agent: Optional[str] = None
+    online_at: Optional[str] = None
+    on_hold_expire_duration: Optional[int] = None
+    on_hold_timeout: Optional[str] = None
+    auto_delete_in_days: Optional[int] = None
+    username: str
+    status: str
+    used_traffic: int
+    lifetime_used_traffic: int = 0
+    created_at: str
+    links: List[str] = []
+    subscription_url: str = ""
+    excluded_inbounds: Dict[str, List[str]] = {}
+    admin: Optional[Admin] = None
+
+
+class SystemStats(BaseModel):
+    version: Optional[str] = None
+    cpu_cores: Optional[int] = None
+    cpu_usage: Optional[float] = None
+    total_user: Optional[int] = None
+    users_active: Optional[int] = None
+    incoming_bandwidth: Optional[int] = None
+    outgoing_bandwidth: Optional[int] = None
+    incoming_bandwidth_speed: Optional[int] = None
+    outgoing_bandwidth_speed: Optional[int] = None
+    online_users: Optional[int] = None
+    users_on_hold: Optional[int] = None
+    users_disabled: Optional[int] = None
+    users_expired: Optional[int] = None
+    users_limited: Optional[int] = None
+
+
+class Settings(BaseModel):
+    clients: Optional[List[Dict[str, Any]]] = []
+    decryption: Optional[str] = None
+    network: Optional[str] = None
+
+
+class StreamSettings(BaseModel):
+    network: Optional[str] = None
+    security: Optional[str] = None
+    tcpSettings: Optional[Dict[str, Any]] = {}
+    wsSettings: Optional[Dict[str, Any]] = {}
+    grpcSettings: Optional[Dict[str, Any]] = {}
+    tlsSettings: Optional[Dict[str, Any]] = {}
+    realitySettings: Optional[Dict[str, Any]] = {}
+
+
+class Inbound(BaseModel):
+    port: Optional[int] = None
+    protocol: Optional[str] = None
+    settings: Optional[Settings] = Settings()
+    streamSettings: Optional[StreamSettings] = StreamSettings()
+    sniffing: Optional[Dict[str, Any]] = {}
+    tag: Optional[str] = None
+
+
+class Outbound(BaseModel):
+    protocol: Optional[str] = None
+    settings: Optional[Dict[str, Any]] = {}
+    tag: Optional[str] = None
+
+
+class RoutingRule(BaseModel):
+    type: Optional[str] = None
+    ip: Optional[List[str]] = []
+    domain: Optional[List[str]] = []
+    protocol: Optional[List[str]] = []
+    outboundTag: Optional[str] = None
+
+
+class Routing(BaseModel):
+    domainStrategy: Optional[str] = None
+    rules: Optional[List[RoutingRule]] = []
+
+
+class CoreConfig(BaseModel):
+    log: Optional[Dict[str, Any]] = {}
+    inbounds: Optional[List[Inbound]] = []
+    outbounds: Optional[List[Outbound]] = []
+    routing: Optional[Routing] = Routing()
+
+
+class GroupBase(BaseModel):
+    name: str
+    inbound_tags: Optional[List[str]] = []
+    is_disabled: Optional[bool] = False
+
+
+class GroupCreate(GroupBase):
+    pass
+
+
+class GroupModify(GroupBase):
+    pass
+
+
+class GroupResponse(GroupBase):
+    id: int
+    total_users: Optional[int] = 0
+
+
+class GroupsResponse(BaseModel):
+    groups: List[GroupResponse]
+    total: int
+
+
+class BulkGroup(BaseModel):
+    group_ids: List[int]
+    admins: Optional[List[int]] = None
+    users: Optional[List[int]] = None
+
+
+class HostBase(BaseModel):
+    remark: str
+    address: str
+    port: Optional[int] = None
+    sni: Optional[str] = None
+    inbound_tag: Optional[str] = None
+    priority: Optional[int] = None
+
+
+class HostResponse(HostBase):
+    id: Optional[int] = None
+
+
+class CoreCreate(BaseModel):
+    config: Dict[str, Any]
+    name: Optional[str] = None
+    exclude_inbound_tags: Optional[str] = None
+    fallbacks_inbound_tags: Optional[str] = None
+
+
+class CoreResponse(CoreCreate):
+    id: int
+    created_at: Optional[str] = None
+
+
+class CoreResponseList(BaseModel):
+    count: int
+    cores: List[CoreResponse]
+
+
+class ModifyUserByTemplate(BaseModel):
+    user_template_id: int
+    note: Optional[str] = None
+
+
+class CreateUserFromTemplate(ModifyUserByTemplate):
+    username: str
+
+
+class BulkUser(BaseModel):
+    amount: int
+    group_ids: Optional[List[int]] = None
+    admins: Optional[List[int]] = None
+    users: Optional[List[int]] = None
+    status: Optional[List[str]] = None
+
+
+class BulkUsersProxy(BaseModel):
+    flow: Optional[str] = None
+    method: Optional[str] = None
+    group_ids: Optional[List[int]] = None
+    admins: Optional[List[int]] = None
+    users: Optional[List[int]] = None

rebecca/utils.py

@@ -0,0 +1,30 @@
+import logging
+from datetime import datetime, timedelta
+from typing import Optional
+
+from rebecca import RebeccaAPI
+
+
+class RebeccaTokenCache:
+    def __init__(self, client: RebeccaAPI, username: str, password: str, token_expire_minutes: int = 1440):
+        self._client = client
+        self._username = username
+        self._password = password
+        self._token_expire_minutes = token_expire_minutes
+        self._token: Optional[str] = None
+        self._exp_at: Optional[datetime] = None
+
+    async def get_token(self):
+        if not self._exp_at or self._exp_at < datetime.now():
+            logging.info("Get new token")
+            self._token = await self.get_new_token()
+            self._exp_at = datetime.now() + timedelta(minutes=self._token_expire_minutes - 1)
+        return self._token
+
+    async def get_new_token(self):
+        try:
+            token = await self._client.get_token(username=self._username, password=self._password)
+            return token.access_token
+        except Exception as e:
+            logging.error(f"{e}", exc_info=True)
+            raise e

rebecca_api-0.1.3.dist-info/METADATA

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: rebecca-api
+Version: 0.1.3
+Summary: Add your description here
+Requires-Python: >=3.12
+Requires-Dist: datetime>=5.5
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: paramiko>=4.0.0
+Requires-Dist: pydantic>=2.12.0
+Requires-Dist: sshtunnel>=0.4.0

rebecca_api-0.1.3.dist-info/RECORD

@@ -0,0 +1,8 @@
+rebecca/__init__.py,sha256=av5dwod0p6uiRpdZNu_UGkowAKDv6q4w9lhRf42w03E,1930
+rebecca/api.py,sha256=fUMa9EdBlMArkJ6V_G_pIzHrNsyPXSa4Kg5pZRIKnC0,26824
+rebecca/enums.py,sha256=h2d1Hq-X4GkKEVjxokCY-a5nVJim2T2RSVn8Jv5uTNI,126
+rebecca/models.py,sha256=D5zUNC0hoOUa_j9JSt1rnGTVbypcdCAWP2sDPCQ6xv0,13672
+rebecca/utils.py,sha256=5JQBa8oLVhBQxHDaccwikRymkprmAsf4rAJ1Uwi_xe0,1092
+rebecca_api-0.1.3.dist-info/METADATA,sha256=WphiAB9IUFj4X7AJjJ98p9kHkZd2dD1SJHDK5ul7fSo,267
+rebecca_api-0.1.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+rebecca_api-0.1.3.dist-info/RECORD,,

rebecca_api-0.1.3.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any