remnawave-api 1.0.0__py3-none-any.whl

remnawave_api/__init__.py

@@ -0,0 +1,90 @@
+import logging
+from typing import Optional
+
+import httpx
+
+from remnawave_api.controllers import (
+    APITokensManagementController,
+    AuthController,
+    BandWidthStatsController,
+    HostsBulkActionsController,
+    HostsController,
+    InboundsBulkActionsController,
+    InboundsController,
+    KeygenController,
+    NodesController,
+    SubscriptionController,
+    SubscriptionsSettingsController,
+    SubscriptionsTemplateController,
+    SystemController,
+    UsersBulkActionsController,
+    UsersController,
+    UsersStatsController,
+    XrayConfigController,
+)
+
+
+class RemnawaveSDK:
+    def __init__(
+        self,
+        client: Optional[httpx.AsyncClient] = None,
+        base_url: Optional[str] = None,
+        token: Optional[str] = None,
+    ):
+        self._client = client
+        self._token = token
+        self.base_url = base_url
+
+        self._validate_params()
+
+        if self._client is None:
+            self._client = self._prepare_client()
+
+        self.api_tokens_management = APITokensManagementController(self._client)
+        self.auth = AuthController(self._client)
+        self.bandwidthstats = BandWidthStatsController(self._client)
+        self.hosts = HostsController(self._client)
+        self.hosts_bulk_actions = HostsBulkActionsController(self._client)
+        self.inbounds = InboundsController(self._client)
+        self.inbounds_bulk_actions = InboundsBulkActionsController(self._client)
+        self.keygen = KeygenController(self._client)
+        self.nodes = NodesController(self._client)
+        self.subscription = SubscriptionController(self._client)
+        self.subscriptions_settings = SubscriptionsSettingsController(self._client)
+        self.subscriptions_template = SubscriptionsTemplateController(self._client)
+        self.system = SystemController(self._client)
+        self.users = UsersController(self._client)
+        self.users_bulk_actions = UsersBulkActionsController(self._client)
+        self.users_stats = UsersStatsController(self._client)
+        self.xray_config = XrayConfigController(self._client)
+
+    def _validate_params(self) -> None:
+        if self._client is None:
+            if self.base_url is None or self._token is None:
+                raise ValueError(
+                    "base_url and token must be provided if client is not provided"
+                )
+        else:
+            if self.base_url is not None or self._token is not None:
+                logging.warning(
+                    "base_url and token will be ignored if client is provided"
+                )
+
+    def _prepare_client(self) -> httpx.AsyncClient:
+        return httpx.AsyncClient(
+            base_url=self._prepare_url(), headers=self._prepare_headers()
+        )
+
+    def _prepare_headers(self) -> dict:
+        if not self._token.startswith("Bearer "):
+            self._token = "Bearer " + self._token
+        return {"Authorization": self._token}
+
+    def _prepare_url(self) -> str:
+        if self.base_url.endswith("/"):
+            self.base_url[:-1]
+
+        if not self.base_url.endswith("/api"):
+            self.base_url += "/api"
+
+        return self.base_url

remnawave_api/controllers/__init__.py

@@ -0,0 +1,37 @@
+from .api_tokens_management import APITokensManagementController
+from .auth import AuthController
+from .bandwidthstats import BandWidthStatsController
+from .hosts import HostsController
+from .hosts_bulk_actions import HostsBulkActionsController
+from .inbounds import InboundsController
+from .inbounds_bulk_actions import InboundsBulkActionsController
+from .keygen import KeygenController
+from .nodes import NodesController
+from .subscription import SubscriptionController
+from .subscriptions_settings import SubscriptionsSettingsController
+from .subscriptions_template import SubscriptionsTemplateController
+from .system import SystemController
+from .users import UsersController
+from .users_bulk_actions import UsersBulkActionsController
+from .users_stats import UsersStatsController
+from .xray_config import XrayConfigController
+
+__all__ = [
+    "APITokensManagementController",
+    "AuthController",
+    "BandWidthStatsController",
+    "HostsController",
+    "HostsBulkActionsController",
+    "InboundsController",
+    "InboundsBulkActionsController",
+    "KeygenController",
+    "NodesController",
+    "SubscriptionController",
+    "SubscriptionsSettingsController",
+    "SubscriptionsTemplateController",
+    "SystemController",
+    "UsersController",
+    "UsersBulkActionsController",
+    "UsersStatsController",
+    "XrayConfigController",
+]

remnawave_api/controllers/api_tokens_management.py

@@ -0,0 +1,33 @@
+from typing import Annotated
+
+from httpx import Response
+from rapid_api_client import Path
+from rapid_api_client.annotations import PydanticBody
+
+from remnawave_api.models import CreateApiTokenRequestDto
+from remnawave_api.rapid import BaseController, delete, get, post
+
+
+class APITokensManagementController(BaseController):
+    @post("/tokens/create", response_class=Response)
+    async def create(
+        self,
+        body: Annotated[CreateApiTokenRequestDto, PydanticBody()],
+    ) -> Response:
+        """Create new API token"""
+        ...
+
+    @delete("/tokens/delete/{uuid}", response_class=Response)
+    async def delete(
+        self,
+        uuid: Annotated[str, Path(description="UUID of the API token")],
+    ) -> Response:
+        """Delete API token"""
+        ...
+
+    @get("/tokens", response_class=Response)
+    async def find_all(
+        self,
+    ) -> Response:
+        """Get all API tokens"""
+        ...

remnawave_api/controllers/auth.py

@@ -0,0 +1,37 @@
+from typing import Annotated
+
+from rapid_api_client.annotations import PydanticBody
+
+from remnawave_api.models import (
+    LoginRequestDto,
+    LoginResponseDto,
+    RegisterRequestDto,
+    RegisterResponseDto,
+    StatusResponseDto,
+)
+from remnawave_api.rapid import BaseController, get, post
+
+
+class AuthController(BaseController):
+    @post("/auth/login", response_class=LoginResponseDto)
+    async def login(
+        self,
+        body: Annotated[LoginRequestDto, PydanticBody()],
+    ) -> LoginResponseDto:
+        """Login"""
+        ...
+
+    @post("/auth/register", response_class=RegisterResponseDto)
+    async def register(
+        self,
+        body: Annotated[RegisterRequestDto, PydanticBody()],
+    ) -> RegisterResponseDto:
+        """Register"""
+        ...
+
+    @get("/auth/status", response_class=StatusResponseDto)
+    async def get_status(
+        self,
+    ) -> StatusResponseDto:
+        """Get status"""
+        ...

remnawave_api/controllers/bandwidthstats.py

@@ -0,0 +1,17 @@
+from typing import Annotated
+
+from rapid_api_client import Query
+
+from remnawave_api.models import NodesUsageResponseDto
+from remnawave_api.rapid import BaseController, get
+
+
+class BandWidthStatsController(BaseController):
+    @get("/nodes/usage/range", response_class=NodesUsageResponseDto)
+    async def get_nodes_usage_by_range(
+        self,
+        start: Annotated[str, Query(description="Start date in ISO format")],
+        end: Annotated[str, Query(description="End date in ISO format")],
+    ) -> NodesUsageResponseDto:
+        """Get Nodes Usage By Range"""
+        ...

remnawave_api/controllers/hosts.py

@@ -0,0 +1,64 @@
+from typing import Annotated, List
+
+from rapid_api_client import Path
+from rapid_api_client.annotations import PydanticBody
+
+from remnawave_api.models import (
+    CreateHostRequestDto,
+    DeleteHostResponseDto,
+    HostResponseDto,
+    HostsResponseDto,
+    ReorderHostRequestDto,
+    ReorderHostResponseDto,
+    UpdateHostRequestDto,
+)
+from remnawave_api.rapid import AttributeBody, BaseController, delete, get, post
+
+
+class HostsController(BaseController):
+    @post("/hosts/create", response_class=HostResponseDto)
+    async def create_host(
+        self,
+        body: Annotated[CreateHostRequestDto, PydanticBody()],
+    ) -> HostResponseDto:
+        """Create Host"""
+        ...
+
+    @post("/hosts/update", response_class=HostResponseDto)
+    async def update_host(
+        self,
+        body: Annotated[UpdateHostRequestDto, PydanticBody()],
+    ) -> HostResponseDto:
+        """Update Host"""
+        ...
+
+    @get("/hosts/all", response_class=HostsResponseDto)
+    async def get_all_hosts(
+        self,
+    ) -> HostsResponseDto:
+        """Get All Hosts"""
+        ...
+
+    @get("/hosts/get-one/{uuid}", response_class=HostResponseDto)
+    async def get_one_host(
+        self,
+        uuid: Annotated[str, Path(description="UUID of the host")],
+    ) -> HostResponseDto:
+        """Get One Host"""
+        ...
+
+    @post("/hosts/reorder", response_class=ReorderHostResponseDto)
+    async def reorder_hosts(
+        self,
+        hosts: Annotated[List[ReorderHostRequestDto], AttributeBody()],
+    ) -> ReorderHostResponseDto:
+        """Reorder Hosts"""
+        ...
+
+    @delete("/hosts/delete/{uuid}", response_class=DeleteHostResponseDto)
+    async def delete_host(
+        self,
+        uuid: Annotated[str, Path(description="UUID of the host")],
+    ) -> DeleteHostResponseDto:
+        """Delete Host"""
+        ...

remnawave_api/controllers/hosts_bulk_actions.py

@@ -0,0 +1,60 @@
+from typing import Annotated, List
+from uuid import UUID
+
+from rapid_api_client import PydanticBody
+
+from remnawave_api.models import (
+    BulkDeleteHostsResponseDto,
+    BulkDisableHostsResponseDto,
+    BulkEnableHostsResponseDto,
+    SetInboundToManyHostsRequestDto,
+    SetInboundToManyHostsResponseDto,
+    SetPortToManyHostsResponseDto,
+)
+from remnawave_api.rapid import AttributeBody, BaseController, post
+
+
+class HostsBulkActionsController(BaseController):
+    @post("/hosts/bulk/delete", response_class=BulkDeleteHostsResponseDto)
+    async def delete_hosts(
+        self,
+        uuids: Annotated[List[UUID], AttributeBody()],
+    ) -> BulkDeleteHostsResponseDto:
+        """Delete many hosts"""
+        ...
+
+    @post("/hosts/bulk/disable", response_class=BulkDisableHostsResponseDto)
+    async def disable_hosts(
+        self,
+        uuids: Annotated[List[UUID], AttributeBody()],
+    ) -> BulkDisableHostsResponseDto:
+        """Disable many hosts"""
+        ...
+
+    @post("/hosts/bulk/enable", response_class=BulkEnableHostsResponseDto)
+    async def enable_hosts(
+        self,
+        uuids: Annotated[List[UUID], AttributeBody()],
+    ) -> BulkEnableHostsResponseDto:
+        """Enable many hosts"""
+        ...
+
+    @post(
+        "/hosts/bulk/set-inbound",
+        response_class=SetInboundToManyHostsResponseDto,
+    )
+    async def set_inbound_to_hosts(
+        self,
+        body: Annotated[SetInboundToManyHostsRequestDto, PydanticBody()],
+    ) -> SetInboundToManyHostsResponseDto:
+        """Set inbound to many hosts"""
+        ...
+
+    @post("/hosts/bulk/set-port", response_class=SetPortToManyHostsResponseDto)
+    async def set_port_to_hosts(
+        self,
+        uuids: Annotated[List[UUID], AttributeBody()],
+        port: Annotated[float, AttributeBody()],
+    ) -> SetPortToManyHostsResponseDto:
+        """Set port to many hosts"""
+        ...

remnawave_api/controllers/inbounds.py

@@ -0,0 +1,18 @@
+from remnawave_api.models import FullInboundsResponseDto, InboundsResponseDto
+from remnawave_api.rapid import BaseController, get
+
+
+class InboundsController(BaseController):
+    @get("/inbounds", response_class=InboundsResponseDto)
+    async def get_inbounds(
+        self,
+    ) -> InboundsResponseDto:
+        """Get Inbounds"""
+        ...
+
+    @get("/inbounds/full", response_class=FullInboundsResponseDto)
+    async def get_full_inbounds(
+        self,
+    ) -> FullInboundsResponseDto:
+        """Get Full Inbounds"""
+        ...

remnawave_api/controllers/inbounds_bulk_actions.py

@@ -0,0 +1,50 @@
+from typing import Annotated
+from uuid import UUID
+
+from remnawave_api.models import (
+    AddInboundToNodesResponseDto,
+    AddInboundToUsersResponseDto,
+    RemoveInboundFromNodesResponseDto,
+    RemoveInboundFromUsersResponseDto,
+)
+from remnawave_api.rapid import AttributeBody, BaseController, post
+
+
+class InboundsBulkActionsController(BaseController):
+    @post("/inbounds/bulk/add-to-users", response_class=AddInboundToUsersResponseDto)
+    async def add_inbound_to_users(
+        self,
+        inbound_uuid: Annotated[UUID, AttributeBody()],
+    ) -> AddInboundToUsersResponseDto:
+        """Add Inbound To Users"""
+        ...
+
+    @post(
+        "/inbounds/bulk/remove-from-users",
+        response_class=RemoveInboundFromUsersResponseDto,
+    )
+    async def remove_inbound_from_users(
+        self,
+        inbound_uuid: Annotated[UUID, AttributeBody()],
+    ) -> RemoveInboundFromUsersResponseDto:
+        """Remove Inbound From Users"""
+        ...
+
+    @post("/inbounds/bulk/add-to-nodes", response_class=AddInboundToNodesResponseDto)
+    async def add_inbound_to_nodes(
+        self,
+        inbound_uuid: Annotated[UUID, AttributeBody()],
+    ) -> AddInboundToNodesResponseDto:
+        """Add Inbound To All Nodes"""
+        ...
+
+    @post(
+        "/inbounds/bulk/remove-from-nodes",
+        response_class=RemoveInboundFromNodesResponseDto,
+    )
+    async def remove_inbound_from_nodes(
+        self,
+        inbound_uuid: Annotated[UUID, AttributeBody()],
+    ) -> RemoveInboundFromNodesResponseDto:
+        """Remove Inbound From All Nodes"""
+        ...

remnawave_api/controllers/keygen.py

@@ -0,0 +1,11 @@
+from remnawave_api.models import PubKeyResponseDto
+from remnawave_api.rapid import BaseController, get
+
+
+class KeygenController(BaseController):
+    @get("/keygen/get", response_class=PubKeyResponseDto)
+    async def generate_key(
+        self,
+    ) -> PubKeyResponseDto:
+        """Get Public Key"""
+        ...

remnawave_api/controllers/nodes.py

@@ -0,0 +1,95 @@
+from typing import Annotated, List
+
+from rapid_api_client import Path
+from rapid_api_client.annotations import PydanticBody
+
+from remnawave_api.models import (
+    CreateNodeRequestDto,
+    DeleteNodeResponseDto,
+    NodeResponseDto,
+    NodesResponseDto,
+    ReorderNodeRequestDto,
+    RestartNodeResponseDto,
+    UpdateNodeRequestDto,
+)
+from remnawave_api.rapid import AttributeBody, BaseController, delete, get, patch, post
+
+
+class NodesController(BaseController):
+    @post("/nodes/create", response_class=NodeResponseDto)
+    async def create_node(
+        self,
+        body: Annotated[CreateNodeRequestDto, PydanticBody()],
+    ) -> NodeResponseDto:
+        """Create Node"""
+        ...
+
+    @get("/nodes/get-all", response_class=NodesResponseDto)
+    async def get_all_nodes(
+        self,
+    ) -> NodesResponseDto:
+        """Get All Nodes"""
+        ...
+
+    @get("/nodes/get-one/{uuid}", response_class=NodeResponseDto)
+    async def get_one_node(
+        self,
+        uuid: Annotated[str, Path(description="Node UUID")],
+    ) -> NodeResponseDto:
+        """Get One Node"""
+        ...
+
+    @patch("/nodes/enable/{uuid}", response_class=NodeResponseDto)
+    async def enable_node(
+        self,
+        uuid: Annotated[str, Path(description="Node UUID")],
+    ) -> NodeResponseDto:
+        """Enable Node"""
+        ...
+
+    @patch("/nodes/disable/{uuid}", response_class=NodeResponseDto)
+    async def disable_node(
+        self,
+        uuid: Annotated[str, Path(description="Node UUID")],
+    ) -> NodeResponseDto:
+        """Disable Node"""
+        ...
+
+    @delete("/nodes/delete/{uuid}", response_class=DeleteNodeResponseDto)
+    async def delete_node(
+        self,
+        uuid: Annotated[str, Path(description="Node UUID")],
+    ) -> DeleteNodeResponseDto:
+        """Delete Node"""
+        ...
+
+    @post("/nodes/update", response_class=NodeResponseDto)
+    async def update_node(
+        self,
+        body: Annotated[UpdateNodeRequestDto, PydanticBody()],
+    ) -> NodeResponseDto:
+        """Update Node"""
+        ...
+
+    @get("/nodes/restart/{uuid}", response_class=RestartNodeResponseDto)
+    async def restart_node(
+        self,
+        uuid: Annotated[str, Path(description="Node UUID")],
+    ) -> RestartNodeResponseDto:
+        """Restart Node"""
+        ...
+
+    @patch("/nodes/restart-all", response_class=RestartNodeResponseDto)
+    async def restart_all_nodes(
+        self,
+    ) -> RestartNodeResponseDto:
+        """Restart All Nodes"""
+        ...
+
+    @post("/nodes/reorder", response_class=NodesResponseDto)
+    async def reorder_nodes(
+        self,
+        nodes: Annotated[List[ReorderNodeRequestDto], AttributeBody()],
+    ) -> NodesResponseDto:
+        """Reorder Nodes"""
+        ...

remnawave_api/controllers/subscription.py

@@ -0,0 +1,54 @@
+from typing import Annotated
+
+from rapid_api_client import Path
+
+from remnawave_api.enums import ClientType
+from remnawave_api.models import SubscriptionInfoResponseDto
+from remnawave_api.rapid import BaseController, get
+
+
+class SubscriptionController(BaseController):
+    @get("/sub/{short_uuid}/info", response_class=SubscriptionInfoResponseDto)
+    async def get_subscription_info_by_short_uuid(
+        self,
+        short_uuid: Annotated[str, Path(description="Short UUID of the user")],
+    ) -> SubscriptionInfoResponseDto:
+        """None"""
+        ...
+
+    @get("/sub/{short_uuid}", response_class=str)
+    async def get_subscription(
+        self,
+        short_uuid: Annotated[str, Path(description="Short UUID of the user")],
+    ) -> str:
+        """None"""
+        ...
+
+    @get("/sub/{short_uuid}/{client_type}", response_class=str)
+    async def get_subscription_by_client_type(
+        self,
+        client_type: Annotated[ClientType, Path(description="Client type")],
+        short_uuid: Annotated[str, Path(description="Short UUID of the user")],
+    ) -> str:
+        """None"""
+        ...
+
+    @get("/sub/outline/{short_uuid}/{type}/{encoded_tag}", response_class=str)
+    async def get_subscription_with_type(
+        self,
+        short_uuid: Annotated[str, Path(description="Short UUID of the user")],
+        type: Annotated[
+            str,
+            Path(
+                description="Subscription type (required if encodedTag is provided). Only SS is supported for now."
+            ),
+        ] = "ss",
+        encoded_tag: Annotated[
+            str,
+            Path(
+                description="Base64 encoded tag for Outline config. This paramter is optional. It is required only when type=ss."
+            ),
+        ] = "VGVzdGVy",
+    ) -> str:
+        """None"""
+        ...

remnawave_api/controllers/subscriptions_settings.py

@@ -0,0 +1,29 @@
+from typing import Annotated
+
+from rapid_api_client.annotations import PydanticBody
+
+from remnawave_api.models import (
+    SubscriptionSettingsResponseDto,
+    UpdateSubscriptionSettingsRequestDto,
+)
+from remnawave_api.rapid import BaseController, get, post
+
+
+class SubscriptionsSettingsController(BaseController):
+    @get("/subscription-settings/get", response_class=SubscriptionSettingsResponseDto)
+    async def get_settings(
+        self,
+    ) -> SubscriptionSettingsResponseDto:
+        """Get Subscription Settings"""
+        ...
+
+    @post(
+        "/subscription-settings/update",
+        response_class=SubscriptionSettingsResponseDto,
+    )
+    async def update_settings(
+        self,
+        body: Annotated[UpdateSubscriptionSettingsRequestDto, PydanticBody()],
+    ) -> SubscriptionSettingsResponseDto:
+        """Update Subscription Settings"""
+        ...

remnawave_api/controllers/subscriptions_template.py

@@ -0,0 +1,31 @@
+from typing import Annotated
+
+from rapid_api_client.annotations import Path, PydanticBody
+
+from remnawave_api.enums import TemplateType
+from remnawave_api.models import TemplateResponseDto, UpdateTemplateRequestDto
+from remnawave_api.rapid import BaseController, get, post
+
+
+class SubscriptionsTemplateController(BaseController):
+    @get(
+        "/subscription-templates/get-template/{template_type}",
+        response_class=TemplateResponseDto,
+    )
+    async def get_template(
+        self,
+        template_type: Annotated[TemplateType, Path(description="Template type")],
+    ) -> TemplateResponseDto:
+        """Get Template"""
+        ...
+
+    @post(
+        "/subscription-templates/update-template",
+        response_class=TemplateResponseDto,
+    )
+    async def update_template(
+        self,
+        body: Annotated[UpdateTemplateRequestDto, PydanticBody()],
+    ) -> TemplateResponseDto:
+        """Update Template"""
+        ...

remnawave_api/controllers/system.py

@@ -0,0 +1,29 @@
+from remnawave_api.models import (
+    BandwidthStatisticResponseDto,
+    NodesStatisticResponseDto,
+    StatisticResponseDto,
+)
+from remnawave_api.rapid import BaseController, get
+
+
+class SystemController(BaseController):
+    @get("/system/stats", response_class=StatisticResponseDto)
+    async def get_stats(
+        self,
+    ) -> StatisticResponseDto:
+        """Get System Stats"""
+        ...
+
+    @get("/system/bandwidth", response_class=BandwidthStatisticResponseDto)
+    async def get_bandwidth_stats(
+        self,
+    ) -> BandwidthStatisticResponseDto:
+        """Get System Bandwidth Statistics"""
+        ...
+
+    @get("/system/statistics/nodes", response_class=NodesStatisticResponseDto)
+    async def get_nodes_statistics(
+        self,
+    ) -> NodesStatisticResponseDto:
+        """Get Nodes Statistics"""
+        ...