maxbot-api-client-python 1.1.0__py3-none-any.whl

maxbot_api_client_python/__init__.py

@@ -0,0 +1,7 @@
+from maxbot_api_client_python.api import API
+from maxbot_api_client_python.client import Config, Client
+from maxbot_api_client_python.types import models
+from maxbot_api_client_python.types import constants
+from maxbot_api_client_python import utils
+
+__all__ = ["API", "Config", "Client", "models", "constants", "utils"]

maxbot_api_client_python/api.py

@@ -0,0 +1,35 @@
+from typing import Any, Self
+
+from maxbot_api_client_python.client import Client, Config
+from maxbot_api_client_python import tools
+
+class API:
+    def __init__(self, cfg: Config) -> None:
+        self.client = Client(cfg)
+
+        self.bots = tools.Bots(self.client)
+        self.chats = tools.Chats(self.client)
+        self.helpers = tools.Helpers(self.client)
+        self.messages = tools.Messages(self.client)
+        self.subscriptions = tools.Subscriptions(self.client)
+        self.uploads = tools.Uploads(self.client)
+
+    def __enter__(self) -> Self:
+        self.client.__enter__()
+        return self
+
+    def __exit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> None:
+        self.client.__exit__(exc_type, exc_val, exc_tb)
+
+    async def __aenter__(self) -> Self:
+        await self.client.__aenter__()
+        return self
+
+    async def __aexit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> None:
+        await self.client.__aexit__(exc_type, exc_val, exc_tb)
+
+    def close(self) -> None:
+        self.client.close()
+
+    async def aclose(self) -> None:
+        await self.client.aclose()

maxbot_api_client_python/client.py

@@ -0,0 +1,195 @@
+import asyncio, httpx, json, logging, time, threading
+from dataclasses import dataclass
+from functools import wraps
+from typing import Any
+from urllib.parse import urljoin
+
+from maxbot_api_client_python.exceptions import build_api_error
+logger = logging.getLogger(__name__)
+
+class RateLimiter:
+    def __init__(self, rps: int):
+        self._lock = threading.Lock()
+        self._alock = asyncio.Lock()
+        self.last_request_time = 0.0
+        self.set_limit(rps)
+
+    def set_limit(self, rps: int) -> None:
+        self.limit = rps
+        self.interval = 1.0 / rps if rps > 0 else 0.0
+
+    def wait(self) -> None:
+        if self.interval <= 0:
+            return
+
+        with self._lock:
+            now = time.monotonic()
+            elapsed = now - self.last_request_time
+            delay = max(0.0, self.interval - elapsed)
+            self.last_request_time = now + delay 
+            
+        if delay > 0:
+            time.sleep(delay)
+
+    async def async_wait(self) -> None:
+        if self.interval <= 0:
+            return
+
+        async with self._alock:
+            now = time.monotonic()
+            elapsed = now - self.last_request_time
+            delay = max(0.0, self.interval - elapsed)
+            self.last_request_time = now + delay
+            
+        if delay > 0:
+            await asyncio.sleep(delay)
+
+@dataclass
+class Config:
+    base_url: str
+    token: str
+    timeout: int = 35
+    ratelimiter: int = 25
+    max_retries: int = 3
+    retry_delay_sec: int = 3
+
+class Client:
+    def __init__(self, cfg: Config):
+        if not cfg.base_url or not cfg.token:
+            raise ValueError("base_url and token must be set")
+
+        self.base_url = cfg.base_url.rstrip("/") + "/"
+        self.token = cfg.token
+
+        self.timeout = cfg.timeout if cfg.timeout > 0 else 35
+        self.global_limiter = RateLimiter(cfg.ratelimiter if cfg.ratelimiter > 0 else 25)
+        self.max_retries = cfg.max_retries
+        self.retry_delay_sec = cfg.retry_delay_sec
+
+        self.headers = {"Authorization": self.token}
+
+        self._sync_client = httpx.Client(timeout=self.timeout)
+        self._async_client: httpx.AsyncClient | None = None
+
+    def __enter__(self) -> "Client":
+        return self
+        
+    def __exit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> None:
+        self.close()
+
+    async def __aenter__(self) -> "Client":
+        return self
+        
+    async def __aexit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> None:
+        await self.aclose()
+
+    async def get_async_client(self) -> httpx.AsyncClient:
+        if self._async_client is None:
+            self._async_client = httpx.AsyncClient(timeout=self.timeout)
+        return self._async_client
+
+    def close(self) -> None:
+        self._sync_client.close()
+
+    async def aclose(self) -> None:
+        if self._async_client:
+            await self._async_client.aclose()
+
+    def _build_url(self, path: str) -> str:
+        if path.startswith(("http://", "https://")):
+            return path
+        return urljoin(self.base_url, path.lstrip("/"))
+
+    def _prepare_data(self, payload: Any) -> Any:
+        if hasattr(payload, "model_dump"):
+            return payload.model_dump(exclude_none=True)
+        return payload
+
+    def request(
+        self, 
+        method: str, 
+        path: str, 
+        query: dict[str, Any] | None = None, 
+        payload: Any = None, 
+        files: dict[str, Any] | None = None
+    ) -> bytes:
+        self.global_limiter.wait()
+        
+        headers = self.headers.copy()
+        if not files:
+            headers["Content-Type"] = "application/json"
+
+        response = self._sync_client.request(
+            method=method,
+            url=self._build_url(path),
+            params=query,
+            json=self._prepare_data(payload) if not files else None,
+            data=None if not files else payload,
+            files=files,
+            headers=headers
+        )
+        logger.debug(f"Response body: {response.text}")
+        return self._handle_response(response)
+
+    async def arequest(
+        self, 
+        method: str, 
+        path: str, 
+        query: dict[str, Any] | None = None, 
+        payload: Any = None, 
+        files: dict[str, Any] | None = None
+    ) -> bytes:
+        await self.global_limiter.async_wait()
+        
+        api = await self.get_async_client()
+        headers = self.headers.copy()
+        if not files:
+            headers["Content-Type"] = "application/json"
+
+        response = await api.request(
+            method=method,
+            url=self._build_url(path),
+            params=query,
+            json=self._prepare_data(payload) if not files else None,
+            data=None if not files else payload,
+            files=files,
+            headers=headers
+        )
+        logger.debug(f"Response body: {response.text}")
+        return self._handle_response(response)
+
+    def _handle_response(self, response: httpx.Response) -> bytes:
+        if not (200 <= response.status_code < 300):
+            raise build_api_error(response)
+        return response.content
+    
+    def _parse_response[T](self, data: bytes, model_class: type[T]) -> T:
+        if not data or data.strip() == b"":
+            return model_class()
+        if data.strip() == b'<retval>1</retval>':
+            return model_class()
+        
+        try:
+            parsed_json = json.loads(data)
+        except json.JSONDecodeError:
+            decoded_snippet = data[:100].decode('utf-8', errors='replace')
+            logger.warning(f"Server returned non-JSON response: {decoded_snippet}")
+            return model_class()
+
+        if hasattr(model_class, "model_validate"):
+            return model_class.model_validate(parsed_json)
+        return parsed_json
+    
+def decode[T](client: Client, method: str, path: str, model_class: type[T], **kwargs: Any) -> T:
+    response = client.request(method, path, **kwargs)
+    return client._parse_response(response, model_class)
+
+async def adecode[T](client: Client, method: str, path: str, model_class: type[T], **kwargs: Any) -> T:
+    response = await client.arequest(method, path, **kwargs)
+    return client._parse_response(response, model_class)
+
+def as_async(func: Any) -> Any:
+    @wraps(func)
+    async def wrapper(*args: Any, **kwargs: Any) -> Any:
+        return await asyncio.to_thread(func, *args, **kwargs)
+    return wrapper

maxbot_api_client_python/exceptions.py

@@ -0,0 +1,36 @@
+import httpx
+
+class MaxBotError(Exception):
+    default_message = "unexpected API error"
+    
+    def __init__(self, message: str | None = None, status_code: int | None = None, response: str | None = None):
+        msg = message or self.default_message
+        full_message = f"{msg}: status code {status_code}, response: {response}"
+        super().__init__(full_message)
+        self.status_code = status_code
+        self.response = response
+
+class BadRequestError(MaxBotError): default_message = "bad request"
+class UnauthorizedError(MaxBotError): default_message = "unauthorized"
+class NotFoundError(MaxBotError): default_message = "not found"
+class MethodNotAllowedError(MaxBotError): default_message = "method not allowed"
+class TooManyRequestsError(MaxBotError): default_message = "too many requests"
+class ServiceUnavailableError(MaxBotError): default_message = "service unavailable"
+
+_ERROR_MAP = {
+    400: BadRequestError,
+    401: UnauthorizedError,
+    404: NotFoundError,
+    405: MethodNotAllowedError,
+    429: TooManyRequestsError,
+    503: ServiceUnavailableError,
+}
+
+def get_exception_for_status(status_code: int) -> type[MaxBotError]:
+    return _ERROR_MAP.get(status_code, MaxBotError)
+
+def build_api_error(response: httpx.Response) -> MaxBotError:
+    body_str = response.text 
+    ExceptionClass = get_exception_for_status(response.status_code)
+    
+    return ExceptionClass(status_code=response.status_code, response=body_str)

maxbot_api_client_python/tools/__init__.py

@@ -0,0 +1,8 @@
+from maxbot_api_client_python.tools.bots import Bots
+from maxbot_api_client_python.tools.chats import Chats
+from maxbot_api_client_python.tools.messages import Messages
+from maxbot_api_client_python.tools.subscriptions import Subscriptions
+from maxbot_api_client_python.tools.uploads import Uploads
+from maxbot_api_client_python.tools.helpers import Helpers
+
+__all__ = ["Bots", "Chats", "Messages", "Subscriptions", "Uploads", "Helpers"]

maxbot_api_client_python/tools/bots.py

@@ -0,0 +1,52 @@
+from maxbot_api_client_python.client import Client, decode, adecode
+from maxbot_api_client_python.types.constants import Paths
+from maxbot_api_client_python.types.models import BotInfo, BotPatch
+
+class Bots:
+    def __init__(self, client: Client):
+        self.client = client
+
+    def GetBot(self) -> BotInfo:
+        """
+        Retrieves information about the current bot, such as its user ID, name, and description.
+
+        Example:
+            response = api.bots.GetBot()
+        """
+        return decode(self.client, "GET", Paths.ME, BotInfo)
+
+    def PatchBot(self, **kwargs) -> BotInfo:
+        """
+        Edits current bot info.
+        Fill only the fields you want to update - all remaining fields will stay untouched.
+
+        Example:
+            response = api.bots.PatchBot(
+                name="New Name",
+                description="New description"
+            )
+        """
+        req = BotPatch(**kwargs)
+        return decode(self.client, "PATCH", Paths.ME, BotInfo, payload=req)
+    
+    async def GetBotAsync(self) -> BotInfo:
+        """
+        Async version of GetBot.
+        
+        Example:
+            response = await api.bots.GetBotAsync()
+        """
+        return await adecode(self.client, "GET", Paths.ME, BotInfo)
+    
+    async def PatchBotAsync(self, **kwargs) -> BotInfo:
+        """
+        Async version of PatchBot.
+
+        Example:
+            response = await api.bots.PatchBotAsync(
+                name="New Name",
+                description="New description"
+            )
+        """
+        req = BotPatch(**kwargs)
+        return await adecode(self.client, "PATCH", Paths.ME, BotInfo, payload=req)