botiksdk 0.1.0__tar.gz

botiksdk-0.1.0/PKG-INFO

@@ -0,0 +1,40 @@
+Metadata-Version: 2.4
+Name: botiksdk
+Version: 0.1.0
+Summary: Vondic Botik SDK
+Author-email: Vondic <support@vondic.com>
+License: MIT
+Project-URL: Homepage, https://github.com/vondic/botiksdk
+Project-URL: Bug Tracker, https://github.com/vondic/botiksdk/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.32.5
+
+# Vondic Botik SDK
+
+A Python SDK for building bots on the Vondic platform.
+
+## Installation
+
+```bash
+pip install botiksdk
+```
+
+## Usage
+
+```python
+from botiksdk import Bot, Dispatcher, Message
+
+bot = Bot(token="YOUR_BOT_TOKEN")
+dp = Dispatcher(bot)
+
+@dp.message_handler()
+async def echo(message: Message):
+    await message.answer(message.text)
+
+if __name__ == "__main__":
+    dp.start_polling()
+```

botiksdk-0.1.0/README.md

@@ -0,0 +1,25 @@
+# Vondic Botik SDK
+
+A Python SDK for building bots on the Vondic platform.
+
+## Installation
+
+```bash
+pip install botiksdk
+```
+
+## Usage
+
+```python
+from botiksdk import Bot, Dispatcher, Message
+
+bot = Bot(token="YOUR_BOT_TOKEN")
+dp = Dispatcher(bot)
+
+@dp.message_handler()
+async def echo(message: Message):
+    await message.answer(message.text)
+
+if __name__ == "__main__":
+    dp.start_polling()
+```

botiksdk-0.1.0/__init__.py

@@ -0,0 +1,20 @@
+from botiksdk.bot import Bot
+from botiksdk.bot_types import Chat, Message, Update, User
+from botiksdk.client import PublicAPIClient
+from botiksdk.dispatcher import Dispatcher
+from botiksdk.filters import Command, F, Text
+from botiksdk.router import Router
+
+__all__ = [
+    "Bot",
+    "PublicAPIClient",
+    "Dispatcher",
+    "Router",
+    "Command",
+    "Text",
+    "F",
+    "Update",
+    "Message",
+    "User",
+    "Chat",
+]

botiksdk-0.1.0/bot.py

@@ -0,0 +1,57 @@
+import logging
+from typing import Optional
+
+from botiksdk.client import PublicAPIClient
+
+
+class Bot:
+    def __init__(
+        self,
+        bot_id: Optional[str] = None,
+        token: Optional[str] = None,
+        *,
+        base_url: str = "http://localhost:5050",
+        api_key: Optional[str] = None,
+    ):
+        self.bot_id = bot_id
+        self.token = token
+        self.api_key = api_key
+        self.public = PublicAPIClient(base_url=base_url)
+
+    def set_token(self, token: str):
+        self.token = token
+        return self
+
+    def set_bot_id(self, bot_id: str):
+        self.bot_id = bot_id
+        return self
+
+    def set_api_key(self, api_key: str):
+        self.api_key = api_key
+        return self
+
+    def _ensure_ready(self):
+        if not self.bot_id:
+            raise ValueError("bot_id is required")
+        if not self.token:
+            raise ValueError("bot token is required")
+
+    def get_updates(self, *, offset: int = 0, limit: int = 100, timeout: int = 20):
+        self._ensure_ready()
+        return self.public.get_updates(
+            self.bot_id,
+            self.token,
+            offset=offset,
+            limit=limit,
+            timeout=timeout,
+        )
+
+    def send_message(self, chat_id: str, text: str):
+        self._ensure_ready()
+        logging.getLogger(__name__).info(
+            "botiksdk_send_message bot_id=%s chat_id=%s text=%s",
+            self.bot_id,
+            chat_id,
+            text,
+        )
+        return self.public.send_message(self.bot_id, self.token, chat_id, text)

botiksdk-0.1.0/bot_types.py

@@ -0,0 +1,87 @@
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Any, Dict, Optional
+
+
+@dataclass
+class User:
+    id: str
+    username: Optional[str] = None
+    avatar_url: Optional[str] = None
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]):
+        if data is None:
+            return None
+        return cls(
+            id=str(data.get("id") or ""),
+            username=data.get("username"),
+            avatar_url=data.get("avatar_url"),
+        )
+
+
+@dataclass
+class Chat:
+    id: str
+    type: str = "private"
+    title: Optional[str] = None
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]):
+        if data is None:
+            return None
+        return cls(
+            id=str(data.get("id") or ""),
+            type=data.get("type") or "private",
+            title=data.get("title"),
+        )
+
+
+@dataclass
+class Message:
+    message_id: str
+    text: Optional[str]
+    from_user: Optional[User]
+    chat: Optional[Chat]
+    date: Optional[datetime]
+    raw: Dict[str, Any]
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]):
+        if data is None:
+            return None
+        ts = data.get("date")
+        if isinstance(ts, (int, float)):
+            date_value = datetime.fromtimestamp(ts)
+        elif isinstance(ts, str):
+            try:
+                date_value = datetime.fromisoformat(ts)
+            except ValueError:
+                date_value = None
+        else:
+            date_value = None
+        return cls(
+            message_id=str(data.get("message_id") or data.get("id") or ""),
+            text=data.get("text"),
+            from_user=User.from_dict(data.get("from_user")),
+            chat=Chat.from_dict(data.get("chat")),
+            date=date_value,
+            raw=data,
+        )
+
+
+@dataclass
+class Update:
+    update_id: str
+    message: Optional[Message]
+    raw: Dict[str, Any]
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]):
+        if data is None:
+            return None
+        return cls(
+            update_id=str(data.get("update_id") or data.get("id") or ""),
+            message=Message.from_dict(data.get("message")),
+            raw=data,
+        )

botiksdk-0.1.0/botiksdk.egg-info/PKG-INFO

@@ -0,0 +1,40 @@
+Metadata-Version: 2.4
+Name: botiksdk
+Version: 0.1.0
+Summary: Vondic Botik SDK
+Author-email: Vondic <support@vondic.com>
+License: MIT
+Project-URL: Homepage, https://github.com/vondic/botiksdk
+Project-URL: Bug Tracker, https://github.com/vondic/botiksdk/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.32.5
+
+# Vondic Botik SDK
+
+A Python SDK for building bots on the Vondic platform.
+
+## Installation
+
+```bash
+pip install botiksdk
+```
+
+## Usage
+
+```python
+from botiksdk import Bot, Dispatcher, Message
+
+bot = Bot(token="YOUR_BOT_TOKEN")
+dp = Dispatcher(bot)
+
+@dp.message_handler()
+async def echo(message: Message):
+    await message.answer(message.text)
+
+if __name__ == "__main__":
+    dp.start_polling()
+```

botiksdk-0.1.0/botiksdk.egg-info/SOURCES.txt

@@ -0,0 +1,27 @@
+README.md
+__init__.py
+bot.py
+bot_types.py
+client.py
+dispatcher.py
+exceptions.py
+filters.py
+pyproject.toml
+router.py
+setup.py
+test_bot.py
+./__init__.py
+./bot.py
+./bot_types.py
+./client.py
+./dispatcher.py
+./exceptions.py
+./filters.py
+./router.py
+./setup.py
+./test_bot.py
+botiksdk.egg-info/PKG-INFO
+botiksdk.egg-info/SOURCES.txt
+botiksdk.egg-info/dependency_links.txt
+botiksdk.egg-info/requires.txt
+botiksdk.egg-info/top_level.txt

botiksdk-0.1.0/botiksdk.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

botiksdk-0.1.0/botiksdk.egg-info/requires.txt

@@ -0,0 +1 @@
+requests>=2.32.5

botiksdk-0.1.0/botiksdk.egg-info/top_level.txt

@@ -0,0 +1 @@
+botiksdk

botiksdk-0.1.0/client.py

@@ -0,0 +1,160 @@
+import json
+import logging
+from typing import Any, Dict, Optional
+
+import requests
+
+from botiksdk.exceptions import (
+    APIError,
+    BadRequestError,
+    NotFoundError,
+    UnauthorizedError,
+)
+
+
+class PublicAPIClient:
+    def __init__(self, base_url: str = "http://localhost:5050"):
+        normalized = (base_url or "http://localhost:5050").strip()
+        if "://" not in normalized:
+            normalized = f"http://{normalized}"
+        self.base_url = normalized.rstrip("/")
+
+    def _request(
+        self,
+        method: str,
+        path: str,
+        *,
+        access_token: Optional[str] = None,
+        api_key: Optional[str] = None,
+        bot_token: Optional[str] = None,
+        params: Optional[Dict[str, Any]] = None,
+        json_body: Optional[Dict[str, Any]] = None,
+    ):
+        url = f"{self.base_url}{path}"
+        logger = logging.getLogger(__name__)
+        headers: Dict[str, str] = {"Content-Type": "application/json"}
+        if access_token:
+            headers["Authorization"] = f"Bearer {access_token}"
+        if api_key:
+            headers["X-API-Key"] = api_key
+        if bot_token:
+            headers["X-Bot-Token"] = bot_token
+        try:
+            response = requests.request(
+                method,
+                url,
+                headers=headers,
+                params=params,
+                json=json_body,
+                timeout=30,
+            )
+        except requests.RequestException:
+            logger.exception(
+                "botiksdk_request_error method=%s url=%s params=%s",
+                method,
+                url,
+                params,
+            )
+            raise
+        if response.ok:
+            if not response.text:
+                return None
+            try:
+                return response.json()
+            except json.JSONDecodeError:
+                return response.text
+        payload = None
+        try:
+            payload = response.json()
+        except json.JSONDecodeError:
+            payload = response.text
+        if response.status_code >= 400:
+            text_preview = str(payload)
+            if len(text_preview) > 500:
+                text_preview = f"{text_preview[:500]}..."
+            logger.info(
+                "botiksdk_request_failed method=%s url=%s status=%s body=%s",
+                method,
+                url,
+                response.status_code,
+                text_preview,
+            )
+        if response.status_code == 401:
+            raise UnauthorizedError(
+                response.status_code, "Unauthorized", payload)
+        if response.status_code == 404:
+            raise NotFoundError(response.status_code, "Not Found", payload)
+        if response.status_code == 400:
+            raise BadRequestError(response.status_code, "Bad Request", payload)
+        raise APIError(response.status_code, "API Error", payload)
+
+    def list_bots(self):
+        return self._request("GET", "/api/public/v1/bots")
+
+    def get_bot(self, bot_id: str):
+        return self._request("GET", f"/api/public/v1/bots/{bot_id}")
+
+    def get_bot_by_name(self, name: str):
+        return self._request("GET", f"/api/public/v1/bots/by-name/{name}")
+
+    def search_bots(self, query: str):
+        return self._request("GET", "/api/public/v1/bots/search", params={"q": query})
+
+    def generate_bot_token(self, bot_id: str, api_key: str):
+        return self._request(
+            "POST",
+            f"/api/public/v1/bots/{bot_id}/token",
+            api_key=api_key,
+        )
+
+    def get_updates(
+        self,
+        bot_id: str,
+        bot_token: str,
+        *,
+        offset: int = 0,
+        limit: int = 100,
+        timeout: int = 20,
+    ):
+        data = self._request(
+            "GET",
+            f"/api/public/v1/bots/{bot_id}/updates",
+            params={"offset": offset, "limit": limit, "timeout": timeout},
+            bot_token=bot_token,
+        )
+        if isinstance(data, dict) and "items" in data:
+            return data["items"]
+        if data is None:
+            return []
+        return data
+
+    def push_update(self, bot_id: str, bot_token: str, message: Dict[str, Any]):
+        return self._request(
+            "POST",
+            f"/api/public/v1/bots/{bot_id}/updates/push",
+            json_body={"message": message},
+            bot_token=bot_token,
+        )
+
+    def send_message(self, bot_id: str, bot_token: str, chat_id: str, text: str):
+        return self._request(
+            "POST",
+            f"/api/public/v1/bots/{bot_id}/send",
+            json_body={"chat_id": chat_id, "text": text},
+            bot_token=bot_token,
+        )
+
+    def get_api_key(self, access_token: str):
+        return self._request(
+            "GET",
+            "/api/public/v1/account/api-key",
+            access_token=access_token,
+        )
+
+    def generate_api_key(self, access_token: str, rotate: bool = False):
+        return self._request(
+            "POST",
+            "/api/public/v1/account/api-key",
+            access_token=access_token,
+            json_body={"rotate": rotate},
+        )

botiksdk-0.1.0/dispatcher.py

@@ -0,0 +1,89 @@
+import asyncio
+import logging
+from typing import Iterable
+
+from botiksdk.bot_types import Message, Update
+from botiksdk.filters import BaseFilter
+from botiksdk.router import Router
+
+
+class Dispatcher:
+    def __init__(self):
+        self._routers = [Router()]
+
+    def include_router(self, router: Router):
+        self._routers.append(router)
+        return self
+
+    def message(self, *filters: BaseFilter):
+        return self._routers[0].message(*filters)
+
+    async def feed_update(self, bot, update: Update):
+        if update is None:
+            return
+        message = update.message
+        if message is not None:
+            logging.getLogger(__name__).info(
+                "botiksdk_update_received bot_id=%s update_id=%s text=%s",
+                getattr(bot, "bot_id", None),
+                update.update_id,
+                message.text,
+            )
+            await self._dispatch_message(bot, message)
+
+    async def _dispatch_message(self, bot, message: Message):
+        for router in self._routers:
+            for handler in router.message_handlers:
+                if await self._check_filters(handler.filters, message):
+                    logging.getLogger(__name__).info(
+                        "botiksdk_handler_matched bot_id=%s text=%s",
+                        getattr(bot, "bot_id", None),
+                        message.text,
+                    )
+                    await handler.callback(message, bot)
+
+    async def _check_filters(self, filters: Iterable[BaseFilter], message: Message):
+        for f in filters:
+            result = f(message)
+            if asyncio.iscoroutine(result):
+                result = await result
+            if not result:
+                return False
+        return True
+
+    async def start_polling(self, *bots):
+        tasks = []
+        for bot in bots:
+            tasks.append(asyncio.create_task(self._poll_bot(bot)))
+        if not tasks:
+            return
+        await asyncio.gather(*tasks)
+
+    async def start_webhook(self, *bots, **kwargs):
+        raise NotImplementedError(
+            "Public API does not provide webhook updates")
+
+    async def _poll_bot(self, bot):
+        offset = 0
+        while True:
+            try:
+                updates = bot.get_updates(offset=offset, timeout=20, limit=100)
+            except Exception:
+                logging.getLogger(__name__).exception(
+                    "botiksdk_poll_error bot_id=%s", getattr(
+                        bot, "bot_id", None)
+                )
+                await asyncio.sleep(1)
+                continue
+            if not updates:
+                await asyncio.sleep(0.2)
+                continue
+            for raw in updates:
+                update = Update.from_dict(raw)
+                if update is None:
+                    continue
+                await self.feed_update(bot, update)
+                try:
+                    offset = max(offset, int(update.update_id))
+                except Exception:
+                    offset = offset

botiksdk-0.1.0/exceptions.py

@@ -0,0 +1,21 @@
+class BotikSDKError(Exception):
+    pass
+
+
+class APIError(BotikSDKError):
+    def __init__(self, status_code, message, payload=None):
+        super().__init__(message)
+        self.status_code = status_code
+        self.payload = payload
+
+
+class UnauthorizedError(APIError):
+    pass
+
+
+class NotFoundError(APIError):
+    pass
+
+
+class BadRequestError(APIError):
+    pass

botiksdk-0.1.0/filters.py

@@ -0,0 +1,101 @@
+import re
+from typing import Any, Iterable, Optional
+
+
+class BaseFilter:
+    def __call__(self, message) -> bool:
+        return True
+
+
+class Command(BaseFilter):
+    def __init__(self, *commands: str, prefix: str = "/"):
+        self.commands = {c.lstrip(prefix).lower() for c in commands if c}
+        self.prefix = prefix
+
+    def __call__(self, message) -> bool:
+        text = getattr(message, "text", None)
+        if not text:
+            return False
+        if not text.startswith(self.prefix):
+            return False
+        cmd = text[len(self.prefix):].split()[0].lower()
+        if not self.commands:
+            return True
+        return cmd in self.commands
+
+
+class Text(BaseFilter):
+    def __init__(self, equals: Optional[str] = None, contains: Optional[str] = None):
+        self.equals = equals
+        self.contains_value = contains
+
+    def __call__(self, message) -> bool:
+        text = getattr(message, "text", None)
+        if text is None:
+            return False
+        if self.equals is not None:
+            return text == self.equals
+        if self.contains_value is not None:
+            return self.contains_value in text
+        return True
+
+
+class Regex(BaseFilter):
+    def __init__(self, pattern: str, flags: int = 0):
+        self.pattern = re.compile(pattern, flags=flags)
+
+    def __call__(self, message) -> bool:
+        text = getattr(message, "text", None)
+        if not text:
+            return False
+        return self.pattern.search(text) is not None
+
+
+class FilterExpression(BaseFilter):
+    def __init__(self, getter, op: str, value: Any):
+        self.getter = getter
+        self.op = op
+        self.value = value
+
+    def __call__(self, message) -> bool:
+        current = self.getter(message)
+        if self.op == "eq":
+            return current == self.value
+        if self.op == "contains":
+            return current is not None and self.value in current
+        if self.op == "in":
+            return current in self.value
+        return False
+
+
+class FieldRef:
+    def __init__(self, path: Iterable[str]):
+        self.path = tuple(path)
+
+    def __getattr__(self, name: str):
+        return FieldRef(self.path + (name,))
+
+    def _get_value(self, message):
+        current = message
+        for name in self.path:
+            if current is None:
+                return None
+            current = getattr(current, name, None)
+        return current
+
+    def __eq__(self, other):
+        return FilterExpression(self._get_value, "eq", other)
+
+    def contains(self, value):
+        return FilterExpression(self._get_value, "contains", value)
+
+    def isin(self, values):
+        return FilterExpression(self._get_value, "in", values)
+
+
+class FieldAccessor:
+    def __getattr__(self, name: str):
+        return FieldRef((name,))
+
+
+F = FieldAccessor()

botiksdk-0.1.0/pyproject.toml

@@ -0,0 +1,32 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "botiksdk"
+version = "0.1.0"
+description = "Vondic Botik SDK"
+readme = "README.md"
+authors = [
+  { name = "Vondic", email = "support@vondic.com" },
+]
+license = { text = "MIT" }
+requires-python = ">=3.9"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+dependencies = [
+    "requests>=2.32.5",
+]
+
+[project.urls]
+"Homepage" = "https://github.com/vondic/botiksdk"
+"Bug Tracker" = "https://github.com/vondic/botiksdk/issues"
+
+[tool.setuptools]
+packages = ["botiksdk"]
+
+[tool.setuptools.package-dir]
+botiksdk = "."

botiksdk-0.1.0/router.py

@@ -0,0 +1,30 @@
+from dataclasses import dataclass
+from typing import Awaitable, Callable, List
+
+from botiksdk.filters import BaseFilter
+
+HandlerCallable = Callable[..., Awaitable[None]]
+
+
+@dataclass
+class Handler:
+    filters: List[BaseFilter]
+    callback: HandlerCallable
+
+
+class Router:
+    def __init__(self):
+        self.message_handlers: List[Handler] = []
+
+    def message(self, *filters: BaseFilter):
+        def decorator(func: HandlerCallable):
+            self.message_handlers.append(
+                Handler(filters=list(filters), callback=func)
+            )
+            return func
+
+        return decorator
+
+    def include_router(self, router: "Router"):
+        self.message_handlers.extend(router.message_handlers)
+        return self

botiksdk-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

botiksdk-0.1.0/setup.py

@@ -0,0 +1,3 @@
+from setuptools import setup
+
+setup()

botiksdk-0.1.0/test_bot.py

@@ -0,0 +1,65 @@
+import asyncio
+import logging
+import os
+
+from botiksdk import Bot, Command, Dispatcher
+
+
+async def main():
+    logging.basicConfig(
+        level=logging.INFO,
+        format="%(asctime)s %(levelname)s %(name)s %(message)s",
+    )
+    bot_id = os.environ.get(
+        "BOTIK_BOT_ID", "eee845bc-8bf7-49da-9ec9-304832e9189b"
+    )
+    bot_token = os.environ.get(
+        "BOTIK_BOT_TOKEN", "ktybQlSZb6xX5FH3j9FoeUKa79xCTUx3Gsio9_5dW3Y"
+    )
+    base_url = os.environ.get("BOTIK_BASE_URL", "http://localhost:5050")
+    logging.getLogger(__name__).info(
+        "botiksdk_config bot_id=%s base_url=%s", bot_id, base_url
+    )
+
+    bot = Bot(bot_id=bot_id, token=bot_token, base_url=base_url)
+    dp = Dispatcher()
+
+    @dp.message(Command("start"))
+    async def start_handler(message, bot_instance):
+        logging.getLogger(__name__).info(
+            "handler_start chat_id=%s", message.chat.id)
+        result = await asyncio.to_thread(
+            bot_instance.send_message,
+            message.chat.id,
+            "Привет! Команды: /id /help",
+        )
+        logging.getLogger(__name__).info("handler_start_result %s", result)
+
+    @dp.message(Command("id"))
+    async def id_handler(message, bot_instance):
+        user_id = message.from_user.id if message.from_user else "unknown"
+        logging.getLogger(__name__).info(
+            "handler_id chat_id=%s", message.chat.id)
+        result = await asyncio.to_thread(
+            bot_instance.send_message,
+            message.chat.id,
+            f"Ваш id: {user_id}",
+        )
+        logging.getLogger(__name__).info("handler_id_result %s", result)
+
+    @dp.message(Command("help"))
+    async def help_handler(message, bot_instance):
+        logging.getLogger(__name__).info(
+            "handler_help chat_id=%s", message.chat.id)
+        result = await asyncio.to_thread(
+            bot_instance.send_message,
+            message.chat.id,
+            "Доступные команды: /start /id /help",
+        )
+        logging.getLogger(__name__).info("handler_help_result %s", result)
+
+    await dp.start_polling(bot)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())