karboai 1.0.0__tar.gz

karboai-1.0.0/PKG-INFO

@@ -0,0 +1,83 @@
+Metadata-Version: 2.4
+Name: karboai
+Version: 1.0.0
+Summary: Python library for https://karboai.com
+Home-page: https://github.com/yourusername/karboai-python
+License: MIT
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: aiohttp>=3.9
+Requires-Dist: python-socketio>=5.10
+Requires-Dist: pydantic>=2.0
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# KarboAI
+
+Python library for [KarboAI](https://karboai.com) bot development.
+
+## Install
+
+```bash
+pip install karboai
+```
+
+## Usage
+
+```python
+from karboai import KarboAI, Router, bold
+
+karbo = KarboAI(token="your-token", id="your-bot-id", enable_logging=True)
+router = Router()
+
+@router.command("/start")
+async def start(ctx):
+    await karbo.text(ctx.message.chat_id, bold("Welcome!"))
+
+@router.on("message")
+async def echo(ctx):
+    await karbo.text(ctx.message.chat_id, ctx.message.content)
+
+karbo.bind(router)
+karbo.attach()
+```
+
+## API
+
+| Method | Description |
+|--------|-------------|
+| `me()` | Bot info |
+| `text(chat_id, content, reply_message_id?)` | Send text |
+| `image(chat_id, images, reply_message_id?)` | Send images |
+| `upload(buffer, file_name?)` | Upload image, returns URL |
+| `message(chat_id, message_id)` | Get message |
+| `members(chat_id, limit?, offset?)` | Chat members |
+| `user(user_id)` | User info |
+| `leave(chat_id)` | Leave chat |
+| `kick(chat_id, user_id)` | Kick user |
+| `attach(callback?)` | Connect to WebSocket |
+| `bind(*routers)` | Bind routers |
+
+## Events
+
+`message`, `join`, `leave`, `voiceStart`, `voiceEnd`, `sticker`
+
+## Text formatting
+
+`bold()`, `italic()`, `centralize()`, `code()`, `strikethrough()`, `underline()`, `hyperlink(text, url)`
+
+## Error handling
+
+```python
+from karboai import KarboError
+
+try:
+    await karbo.me()
+except KarboError as e:
+    print(e.status_code, e.name, e)
+```

karboai-1.0.0/README.md

@@ -0,0 +1,64 @@
+# KarboAI
+
+Python library for [KarboAI](https://karboai.com) bot development.
+
+## Install
+
+```bash
+pip install karboai
+```
+
+## Usage
+
+```python
+from karboai import KarboAI, Router, bold
+
+karbo = KarboAI(token="your-token", id="your-bot-id", enable_logging=True)
+router = Router()
+
+@router.command("/start")
+async def start(ctx):
+    await karbo.text(ctx.message.chat_id, bold("Welcome!"))
+
+@router.on("message")
+async def echo(ctx):
+    await karbo.text(ctx.message.chat_id, ctx.message.content)
+
+karbo.bind(router)
+karbo.attach()
+```
+
+## API
+
+| Method | Description |
+|--------|-------------|
+| `me()` | Bot info |
+| `text(chat_id, content, reply_message_id?)` | Send text |
+| `image(chat_id, images, reply_message_id?)` | Send images |
+| `upload(buffer, file_name?)` | Upload image, returns URL |
+| `message(chat_id, message_id)` | Get message |
+| `members(chat_id, limit?, offset?)` | Chat members |
+| `user(user_id)` | User info |
+| `leave(chat_id)` | Leave chat |
+| `kick(chat_id, user_id)` | Kick user |
+| `attach(callback?)` | Connect to WebSocket |
+| `bind(*routers)` | Bind routers |
+
+## Events
+
+`message`, `join`, `leave`, `voiceStart`, `voiceEnd`, `sticker`
+
+## Text formatting
+
+`bold()`, `italic()`, `centralize()`, `code()`, `strikethrough()`, `underline()`, `hyperlink(text, url)`
+
+## Error handling
+
+```python
+from karboai import KarboError
+
+try:
+    await karbo.me()
+except KarboError as e:
+    print(e.status_code, e.name, e)
+```

karboai-1.0.0/karboai/__init__.py

@@ -0,0 +1,51 @@
+from .client import KarboAI
+from .router import Router
+from .types import (
+    Author,
+    Context,
+    Frame,
+    Member,
+    MembersResponse,
+    Message,
+    MessageResponse,
+    MeResponse,
+    OkResponse,
+    Reaction,
+    UploadResponse,
+    User,
+)
+from .utils import (
+    bold,
+    centralize,
+    code,
+    hyperlink,
+    italic,
+    strikethrough,
+    underline,
+)
+from .errors import KarboError
+
+__all__ = [
+    "KarboAI",
+    "Router",
+    "KarboError",
+    "Context",
+    "Message",
+    "Author",
+    "User",
+    "Member",
+    "Frame",
+    "Reaction",
+    "MeResponse",
+    "MessageResponse",
+    "UploadResponse",
+    "MembersResponse",
+    "OkResponse",
+    "bold",
+    "italic",
+    "centralize",
+    "code",
+    "strikethrough",
+    "underline",
+    "hyperlink",
+]

karboai-1.0.0/karboai/_const.py

@@ -0,0 +1,19 @@
+KARBO_API = "https://api.karboai.com"
+
+SOCKET_TOPICS = {
+    0: "message",
+    1: "join",
+    2: "leave",
+    7: "voiceStart",
+    8: "voiceEnd",
+    12: "sticker",
+}
+
+ERRORS = {
+    400: ("KarboAI.BadRequest", "May empty message, content too long, too many images"),
+    401: ("KarboAI.Unauthorized", "Invalid bot token"),
+    403: ("KarboAI.Forbidden", "Access denied"),
+    404: ("KarboAI.NotFound", "Content doesn't exist"),
+    413: ("KarboAI.FileTooLarge", "Please upload files smaller than XX bytes length"),
+    429: ("KarboAI.TooManyRequests", "Rate limit exceeded"),
+}

karboai-1.0.0/karboai/client.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+from typing import Callable
+
+from .dispatcher import Dispatcher
+from .http import Http
+from .logging import setup_logging
+from .router import Router
+from .types import (
+    MembersResponse,
+    Message,
+    MessageResponse,
+    MeResponse,
+    OkResponse,
+    UploadResponse,
+    User,
+)
+
+
+class KarboAI:
+    def __init__(self, token: str, id: str, enable_logging: bool = False):
+        self._token = token
+        self._id = id
+        self._http = Http(token)
+        self._dispatcher = Dispatcher(self)
+        setup_logging(enable_logging)
+
+    @property
+    def id(self) -> str:
+        return self._id
+
+    async def me(self) -> MeResponse:
+        return await self._http.get("/bot/me", MeResponse)
+
+    async def text(self, chat_id: str, content: str, reply_message_id: str | None = None) -> MessageResponse:
+        return await self._send(chat_id=chat_id, content=content, reply_message_id=reply_message_id)
+
+    async def image(self, chat_id: str, images: list[str], reply_message_id: str | None = None) -> MessageResponse:
+        return await self._send(chat_id=chat_id, images=images, reply_message_id=reply_message_id)
+
+    async def upload(self, buffer: bytes, file_name: str = "file.png") -> str:
+        resp = await self._http.upload("/bot/upload/image", buffer, file_name, UploadResponse)
+        return resp.url
+
+    async def message(self, chat_id: str, message_id: str) -> Message:
+        return await self._http.get(f"/bot/chat/{chat_id}/message/{message_id}", Message)
+
+    async def members(self, chat_id: str, limit: int = 100, offset: int = 0) -> MembersResponse:
+        return await self._http.get(f"/bot/chat/{chat_id}/members?limit={limit}&offset={offset}", MembersResponse)
+
+    async def user(self, user_id: str) -> User:
+        return await self._http.get(f"/bot/user/{user_id}", User)
+
+    async def leave(self, chat_id: str) -> bool:
+        resp = await self._http.post(f"/bot/leave-chat/{chat_id}", {}, OkResponse)
+        return resp.ok
+
+    async def kick(self, chat_id: str, user_id: str) -> bool:
+        resp = await self._http.post(f"/bot/chat/{chat_id}/kick", {"user_id": user_id}, OkResponse)
+        return resp.ok
+
+    def attach(self, callback: Callable[[], None] | None = None) -> None:
+        async def _cb():
+            pass
+        self._dispatcher.attach(self._token, callback or _cb)
+
+    def bind(self, *routers: Router) -> None:
+        self._dispatcher.bind(*routers)
+
+    async def _send(self, *, chat_id: str, content: str | None = None, images: list[str] | None = None, reply_message_id: str | None = None) -> MessageResponse:
+        body: dict = {"chat_id": chat_id}
+        if content:
+            body["content"] = content
+        if images:
+            body["images"] = images
+        if reply_message_id:
+            body["reply_message_id"] = reply_message_id
+        return await self._http.post("/bot/send-message", body, MessageResponse)

karboai-1.0.0/karboai/dispatcher.py

@@ -0,0 +1,65 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import socketio
+
+from ._const import KARBO_API, SOCKET_TOPICS
+from .logging import logger
+from .router import Router
+from .types import Context, Message, _Listener
+
+if TYPE_CHECKING:
+    from .client import KarboAI
+
+
+class Dispatcher:
+    def __init__(self, client: KarboAI):
+        self._client = client
+        self._socket = None
+        self._listeners: dict[str, list[_Listener]] = {}
+
+    def bind(self, *routers: Router) -> None:
+        for router in routers:
+            for event, items in router.listeners.items():
+                if event not in self._listeners:
+                    self._listeners[event] = []
+                self._listeners[event].extend(items)
+            logger.info("bound router: %s", router.name)
+
+    def attach(self, token: str, callback) -> None:
+        sio = socketio.AsyncClient()
+
+        @sio.on("connect")
+        async def _on_connect():
+            logger.info("connected to KarboAI")
+            await callback()
+
+        @sio.on("new_message")
+        async def _on_message(data):
+            msg = Message.model_validate(data)
+            if msg.author.user_id == self._client.id:
+                return
+
+            event = SOCKET_TOPICS.get(msg.type, "message")
+            logger.info(
+                "event=%s chatId=%s userId=%s type=%d",
+                event, msg.chat_id, msg.author.user_id, msg.type,
+            )
+
+            for listener in self._listeners.get(event, []):
+                ok = True
+                for mw in listener.middlewares:
+                    if not await mw(Context(self._client, msg)):
+                        ok = False
+                        break
+                if ok:
+                    await listener.callback(Context(self._client, msg))
+
+        self._socket = sio
+        sio.connect(
+            KARBO_API,
+            socketio_path="/bot/ws",
+            transports=["websocket"],
+            auth={"bot_token": token},
+        )

karboai-1.0.0/karboai/errors.py

@@ -0,0 +1,9 @@
+from ._const import ERRORS
+
+
+class KarboError(Exception):
+    def __init__(self, status_code: int):
+        self.status_code = status_code
+        name, msg = ERRORS.get(status_code, ("KarboAI.Unknown", "Unknown error"))
+        self.name = name
+        super().__init__(msg)

karboai-1.0.0/karboai/http.py

@@ -0,0 +1,49 @@
+import json
+from typing import Type, TypeVar
+
+import aiohttp
+from pydantic import BaseModel
+
+from ._const import KARBO_API
+from .errors import KarboError
+from .logging import logger
+
+T = TypeVar("T", bound=BaseModel)
+
+
+class Http:
+    def __init__(self, token: str):
+        self._headers = {
+            "Content-Type": "application/json",
+            "Bot-Token": token,
+        }
+
+    async def _request(self, method: str, path: str, schema: Type[T], **kwargs) -> T:
+        url = f"{KARBO_API}{path}"
+        async with aiohttp.ClientSession() as session:
+            async with session.request(method, url, headers=self._headers, **kwargs) as resp:
+                if not resp.ok:
+                    logger.error("%s %s -> %d", method, path, resp.status)
+                    raise KarboError(resp.status)
+                logger.info("%s %s -> %d", method, path, resp.status)
+                return schema.model_validate(await resp.json())
+
+    async def get(self, path: str, schema: Type[T]) -> T:
+        return await self._request("GET", path, schema)
+
+    async def post(self, path: str, body: dict, schema: Type[T]) -> T:
+        return await self._request("POST", path, schema, data=json.dumps(body))
+
+    async def upload(self, path: str, buffer: bytes, file_name: str, schema: Type[T]) -> T:
+        import mimetypes
+
+        form = aiohttp.FormData()
+        form.add_field(
+            "file",
+            buffer,
+            filename=file_name,
+            content_type=mimetypes.guess_type(file_name)[0] or "image/png",
+        )
+
+        headers = {k: v for k, v in self._headers.items() if k != "Content-Type"}
+        return await self._request("POST", path, schema, data=form, headers=headers)

karboai-1.0.0/karboai/logging.py

@@ -0,0 +1,20 @@
+import logging
+
+logger = logging.getLogger("karboai")
+_logger_init = False
+
+
+def setup_logging(enabled: bool = False) -> None:
+    global _logger_init
+    if _logger_init:
+        return
+    _logger_init = True
+
+    logger.disabled = not enabled
+    if enabled:
+        handler = logging.StreamHandler()
+        handler.setFormatter(logging.Formatter(
+            "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+        ))
+        logger.addHandler(handler)
+        logger.setLevel(logging.INFO)

karboai-1.0.0/karboai/router.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+from .types import Context, EventHandler, Middleware, _Listener
+from .utils import _router_name
+
+
+def _cmd_middleware(prefix: str) -> Middleware:
+    async def _mw(ctx: Context) -> bool | None:
+        return ctx.message.content.startswith(prefix) or None
+    return _mw
+
+
+class Router:
+    def __init__(self, name: str | None = None):
+        self._name = name or _router_name()
+        self._listeners: dict[str, list[_Listener]] = {}
+        self._middlewares: list[Middleware] = []
+
+    @property
+    def name(self) -> str:
+        return self._name
+
+    @property
+    def listeners(self) -> dict[str, list[_Listener]]:
+        return self._listeners
+
+    def pre(self, middleware: Middleware) -> None:
+        self._middlewares.append(middleware)
+
+    def on(self, event: str, callback: EventHandler) -> None:
+        if event not in self._listeners:
+            self._listeners[event] = []
+        self._listeners[event].append(
+            _Listener(callback, list(self._middlewares))
+        )
+
+    def command(self, prefix: str, callback: EventHandler) -> None:
+        if "message" not in self._listeners:
+            self._listeners["message"] = []
+        self._listeners["message"].append(
+            _Listener(callback, [_cmd_middleware(prefix)] + list(self._middlewares))
+        )

karboai-1.0.0/karboai/types.py

@@ -0,0 +1,118 @@
+from __future__ import annotations
+
+from enum import Enum
+from typing import TYPE_CHECKING, Any, Awaitable, Callable
+
+from pydantic import BaseModel
+
+if TYPE_CHECKING:
+    from .client import KarboAI
+
+
+class BotStatus(str, Enum):
+    NOT_OFFICIAL = "NOT_OFFICIAL"
+    OFFICIAL = "OFFICIAL"
+    BANNED = "BANNED"
+
+
+class Frame(BaseModel):
+    frame_id: str
+    file: str
+
+
+class Reaction(BaseModel):
+    reaction: str
+    is_sticker: bool
+    count: int
+    me: bool
+
+
+class Author(BaseModel):
+    user_id: str
+    nickname: str
+    avatar_url: str
+    avatar_frame: Frame | None = None
+    role: int | None = None
+    app_role: int | None = None
+    panel_color: str | None = None
+    level: int | None = None
+    nickname_color: str | None = None
+    nickname_emoji: str | None = None
+
+
+class User(BaseModel):
+    user_id: str
+    nickname: str
+    avatar: str
+    role: int
+    short_info: str
+
+
+class Member(BaseModel):
+    user_id: str
+    nickname: str
+    avatar: str
+    role: int
+
+
+class Message(BaseModel):
+    message_id: str
+    chat_id: str
+    content: str
+    created_time: int
+    type: int
+    reply_message_id: str | None = None
+    audio: str | None = None
+    sticker: str | None = None
+    images: list[str] = []
+    author: Author
+    audio_duration_ms: int | None = None
+    waveform: list[Any] | None = None
+    video_note: str | None = None
+    video_note_duration_ms: int | None = None
+    transparent: bool | None = None
+    bubble_id: str | None = None
+    bubble_version: int | None = None
+    reactions: list[Reaction] | None = None
+
+
+class MeResponse(BaseModel):
+    bot_id: str
+    name: str
+    status: BotStatus
+
+
+class MessageResponse(BaseModel):
+    message_id: str
+    created_time: int
+
+
+class UploadResponse(BaseModel):
+    url: str
+
+
+class MembersResponse(BaseModel):
+    items: list[User]
+
+
+class OkResponse(BaseModel):
+    ok: bool
+
+
+class Context:
+    __slots__ = ("karbo", "message")
+
+    def __init__(self, karbo: KarboAI, message: Message):
+        self.karbo = karbo
+        self.message = message
+
+
+EventHandler = Callable[[Context], Awaitable[None]]
+Middleware = Callable[[Context], Awaitable[bool | None]]
+ConnectCallback = Callable[[], Awaitable[None]]
+
+
+class _Listener:
+    def __init__(self, callback: EventHandler, middlewares: list[Middleware]):
+        self.callback = callback
+        self.middlewares = middlewares

karboai-1.0.0/karboai/utils.py

@@ -0,0 +1,35 @@
+import random
+import string
+
+
+def bold(text: str) -> str:
+    return f"**{text}**"
+
+
+def italic(text: str) -> str:
+    return f"__{text}__"
+
+
+def centralize(text: str) -> str:
+    return f"[C]{text}"
+
+
+def code(text: str) -> str:
+    return f"`{text}`"
+
+
+def strikethrough(text: str) -> str:
+    return f"~~{text}~~"
+
+
+def underline(text: str) -> str:
+    return f"++{text}++"
+
+
+def hyperlink(text: str, url: str) -> str:
+    return f"[{text}]({url})"
+
+
+def _router_name() -> str:
+    rand = "".join(random.choices(string.ascii_lowercase + string.digits, k=7))
+    return f"router-{rand}"

karboai-1.0.0/karboai.egg-info/PKG-INFO

@@ -0,0 +1,83 @@
+Metadata-Version: 2.4
+Name: karboai
+Version: 1.0.0
+Summary: Python library for https://karboai.com
+Home-page: https://github.com/yourusername/karboai-python
+License: MIT
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: aiohttp>=3.9
+Requires-Dist: python-socketio>=5.10
+Requires-Dist: pydantic>=2.0
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# KarboAI
+
+Python library for [KarboAI](https://karboai.com) bot development.
+
+## Install
+
+```bash
+pip install karboai
+```
+
+## Usage
+
+```python
+from karboai import KarboAI, Router, bold
+
+karbo = KarboAI(token="your-token", id="your-bot-id", enable_logging=True)
+router = Router()
+
+@router.command("/start")
+async def start(ctx):
+    await karbo.text(ctx.message.chat_id, bold("Welcome!"))
+
+@router.on("message")
+async def echo(ctx):
+    await karbo.text(ctx.message.chat_id, ctx.message.content)
+
+karbo.bind(router)
+karbo.attach()
+```
+
+## API
+
+| Method | Description |
+|--------|-------------|
+| `me()` | Bot info |
+| `text(chat_id, content, reply_message_id?)` | Send text |
+| `image(chat_id, images, reply_message_id?)` | Send images |
+| `upload(buffer, file_name?)` | Upload image, returns URL |
+| `message(chat_id, message_id)` | Get message |
+| `members(chat_id, limit?, offset?)` | Chat members |
+| `user(user_id)` | User info |
+| `leave(chat_id)` | Leave chat |
+| `kick(chat_id, user_id)` | Kick user |
+| `attach(callback?)` | Connect to WebSocket |
+| `bind(*routers)` | Bind routers |
+
+## Events
+
+`message`, `join`, `leave`, `voiceStart`, `voiceEnd`, `sticker`
+
+## Text formatting
+
+`bold()`, `italic()`, `centralize()`, `code()`, `strikethrough()`, `underline()`, `hyperlink(text, url)`
+
+## Error handling
+
+```python
+from karboai import KarboError
+
+try:
+    await karbo.me()
+except KarboError as e:
+    print(e.status_code, e.name, e)
+```

karboai-1.0.0/karboai.egg-info/SOURCES.txt

@@ -0,0 +1,17 @@
+README.md
+setup.py
+karboai/__init__.py
+karboai/_const.py
+karboai/client.py
+karboai/dispatcher.py
+karboai/errors.py
+karboai/http.py
+karboai/logging.py
+karboai/router.py
+karboai/types.py
+karboai/utils.py
+karboai.egg-info/PKG-INFO
+karboai.egg-info/SOURCES.txt
+karboai.egg-info/dependency_links.txt
+karboai.egg-info/requires.txt
+karboai.egg-info/top_level.txt

karboai-1.0.0/karboai.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

karboai-1.0.0/karboai.egg-info/requires.txt

@@ -0,0 +1,3 @@
+aiohttp>=3.9
+python-socketio>=5.10
+pydantic>=2.0

karboai-1.0.0/karboai.egg-info/top_level.txt

@@ -0,0 +1 @@
+karboai

karboai-1.0.0/setup.cfg

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

karboai-1.0.0/setup.py

@@ -0,0 +1,21 @@
+from setuptools import setup, find_packages
+
+with open("README.md", "r", encoding="utf-8") as f:
+    long_description = f.read()
+
+setup(
+    name="karboai",
+    version="1.0.0",
+    description="Python library for https://karboai.com",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    url="https://github.com/yourusername/karboai-python",
+    packages=find_packages(),
+    python_requires=">=3.8",
+    install_requires=[
+        "aiohttp>=3.9",
+        "python-socketio>=5.10",
+        "pydantic>=2.0",
+    ],
+    license="MIT",
+)