xc-bot 1.0.0__py3-none-any.whl

xc_bot/__init__.py

@@ -0,0 +1,42 @@
+"""xc-bot - Python SDK for XaneoConnect Bot API"""
+
+__version__ = "1.0.0"
+
+from .bot import Bot
+from .grpc_client import GrpcBotClient
+from .exceptions import (
+    XcBotError,
+    ApiError,
+    NetworkError,
+    RateLimitError,
+    WebhookConflictError,
+)
+from .types import (
+    User,
+    BotAccount,
+    Message,
+    Chat,
+    ChatType,
+    Update,
+    UpdateType,
+)
+from .webhook import WebhookServer
+
+__all__ = [
+    "Bot",
+    "GrpcBotClient",
+    "WebhookServer",
+    "XcBotError",
+    "ApiError",
+    "NetworkError",
+    "RateLimitError",
+    "WebhookConflictError",
+    "User",
+    "BotAccount",
+    "Message",
+    "Chat",
+    "ChatType",
+    "Update",
+    "UpdateType",
+]
+

xc_bot/api.py

@@ -0,0 +1,175 @@
+"""Async API client for XaneoConnect Bot API"""
+import asyncio
+import logging
+from typing import Any, Optional, TypeVar, Union
+
+import aiohttp
+
+from .exceptions import ApiError, NetworkError, RateLimitError, WebhookConflictError
+
+T = TypeVar("T")
+
+logger = logging.getLogger("xc_bot")
+
+
+class ApiClient:
+    DEFAULT_BASE_URL = "https://xaneo.com/bot"
+    DEFAULT_TIMEOUT = 60
+    MAX_RETRIES = 3
+    RETRY_DELAYS = [1, 2, 4]
+
+    def __init__(
+        self,
+        token: str,
+        base_url: Optional[str] = None,
+        timeout: int = DEFAULT_TIMEOUT,
+    ):
+        self.token = token
+        self.base_url = (base_url or self.DEFAULT_BASE_URL).rstrip("/")
+        self.timeout = aiohttp.ClientTimeout(total=timeout)
+        self._session: Optional[aiohttp.ClientSession] = None
+        self._user_agent = "xc-bot-python/1.0"
+
+    async def _get_session(self) -> aiohttp.ClientSession:
+        if self._session is None or self._session.closed:
+            self._session = aiohttp.ClientSession(
+                timeout=self.timeout,
+                headers={
+                    "Authorization": f"Bot {self.token}",
+                    "User-Agent": self._user_agent,
+                    "Content-Type": "application/json",
+                },
+            )
+        return self._session
+
+    async def close(self) -> None:
+        if self._session and not self._session.closed:
+            await self._session.close()
+
+    async def request(
+        self,
+        method: str,
+        data: Optional[dict] = None,
+        params: Optional[dict] = None,
+    ) -> Any:
+        url = f"{self.base_url}/{method}"
+        session = await self._get_session()
+
+        last_error: Optional[Exception] = None
+
+        for attempt in range(self.MAX_RETRIES):
+            try:
+                if data is not None:
+                    response = await session.post(url, json=data)
+                elif params:
+                    response = await session.get(url, params=params)
+                else:
+                    response = await session.get(url)
+
+                async with response:
+                    result = await self._parse_response(response, method)
+
+                    if result is not None:
+                        return result
+
+            except ApiError:
+                raise
+            except aiohttp.ClientError as e:
+                last_error = NetworkError(str(e))
+                logger.warning(f"Network error on {method} (attempt {attempt + 1}): {e}")
+            except Exception as e:
+                last_error = NetworkError(str(e))
+                logger.warning(f"Unexpected error on {method} (attempt {attempt + 1}): {e}")
+
+            if attempt < self.MAX_RETRIES - 1:
+                delay = self.RETRY_DELAYS[min(attempt, len(self.RETRY_DELAYS) - 1)]
+                logger.debug(f"Retrying {method} in {delay}s...")
+                await asyncio.sleep(delay)
+
+        raise last_error or NetworkError("Unknown error occurred")
+
+    async def _parse_response(self, response: aiohttp.ClientResponse, method: str) -> Any:
+        try:
+            json_data = await response.json()
+        except aiohttp.ContentTypeError:
+            text = await response.text()
+            raise NetworkError(f"Invalid JSON response: {text[:200]}")
+
+        if json_data.get("ok"):
+            return json_data.get("result")
+
+        error_code = json_data.get("error_code", response.status)
+        description = json_data.get("description") or json_data.get("detail") or "Unknown error"
+
+        if error_code == 429:
+            retry_after = response.headers.get("Retry-After")
+            try:
+                retry_after_seconds = float(retry_after) if retry_after else 1.0
+            except ValueError:
+                retry_after_seconds = 1.0
+            raise RateLimitError(description, retry_after_seconds)
+        if error_code == 409:
+            raise WebhookConflictError(description)
+        raise ApiError(error_code, description)
+
+    async def get_me(self) -> dict:
+        return await self.request("getMe")
+
+    async def get_updates(
+        self,
+        offset: int = 0,
+        limit: int = 100,
+        timeout: int = 30,
+    ) -> list:
+        return await self.request("getUpdates", {"offset": offset, "limit": limit, "timeout": timeout})
+
+    async def send_message(
+        self,
+        chat_id: str,
+        text: str,
+        reply_to_message_id: Optional[int] = None,
+    ) -> dict:
+        data: dict = {"chat_id": chat_id, "text": text}
+        if reply_to_message_id:
+            data["reply_to_message_id"] = reply_to_message_id
+        return await self.request("sendMessage", data)
+
+    async def edit_message(self, message_id: int, text: str) -> bool:
+        return await self.request("editMessage", {"message_id": message_id, "text": text})
+
+    async def delete_message(self, message_id: int) -> bool:
+        return await self.request("deleteMessage", {"message_id": message_id})
+
+    async def set_webhook(
+        self,
+        url: str,
+        secret: str = "",
+        allowed_updates: Optional[list] = None,
+    ) -> bool:
+        data: dict = {"url": url}
+        if secret:
+            data["secret"] = secret
+        if allowed_updates:
+            data["allowed_updates"] = allowed_updates
+        return await self.request("setWebhook", data)
+
+    async def delete_webhook(self) -> bool:
+        return await self.request("deleteWebhook", {})
+
+    async def get_webhook_info(self) -> dict:
+        return await self.request("getWebhookInfo")
+
+    async def get_chat(self, chat_id: str) -> dict:
+        return await self.request("getChat", params={"chat_id": chat_id})
+
+    async def get_chat_members(self, chat_id: str) -> list:
+        return await self.request("getChatMembers", params={"chat_id": chat_id})
+
+    async def leave_chat(self, chat_id: str) -> bool:
+        return await self.request("leaveChat", {"chat_id": chat_id})
+
+    async def set_commands(self, commands: list) -> bool:
+        return await self.request("setCommands", {"commands": commands})
+
+    async def get_commands(self) -> list:
+        return await self.request("getCommands")

xc_bot/bot.py

@@ -0,0 +1,156 @@
+"""Main Bot class for xc-bot"""
+import asyncio
+import logging
+import signal
+from typing import Any, Callable, List, Optional, Union
+
+from .api import ApiClient
+from .exceptions import RateLimitError, XcBotError
+from .handlers import HandlerRegistry
+from .types import BotAccount, Chat, Message, Update
+
+logger = logging.getLogger("xc_bot")
+
+
+class Bot:
+    def __init__(
+        self,
+        token: str,
+        base_url: Optional[str] = None,
+    ):
+        self.token = token
+        self._api = ApiClient(token, base_url)
+        self._handlers = HandlerRegistry()
+        self._running = False
+        self._me: Optional[BotAccount] = None
+
+    @property
+    def api(self) -> ApiClient:
+        return self._api
+
+    async def get_me(self) -> BotAccount:
+        data = await self._api.get_me()
+        self._me = BotAccount.from_dict(data)
+        return self._me
+
+    async def send_message(
+        self,
+        chat_id: str,
+        text: str,
+        reply_to_message_id: Optional[int] = None,
+    ) -> Message:
+        data = await self._api.send_message(chat_id, text, reply_to_message_id)
+        author = {
+            "id": self._me.id if self._me else 0,
+            "username": self._me.username if self._me else None,
+            "first_name": self._me.display_name if self._me else None,
+        }
+        return Message.from_dict(
+            {"id": data["message_id"], "chat_id": data["chat_id"], "text": text, "author": author},
+            bot=self,
+        )
+
+    async def edit_message(self, message_id: int, text: str) -> bool:
+        return await self._api.edit_message(message_id, text)
+
+    async def delete_message(self, message_id: int) -> bool:
+        return await self._api.delete_message(message_id)
+
+    async def get_chat(self, chat_id: str) -> Chat:
+        data = await self._api.get_chat(chat_id)
+        return Chat.from_dict(data)
+
+    async def get_chat_members(self, chat_id: str) -> List[dict]:
+        return await self._api.get_chat_members(chat_id)
+
+    async def leave_chat(self, chat_id: str) -> bool:
+        return await self._api.leave_chat(chat_id)
+
+    async def set_commands(self, commands: List[dict]) -> bool:
+        return await self._api.set_commands(commands)
+
+    async def get_commands(self) -> List[dict]:
+        return await self._api.get_commands()
+
+    async def set_webhook(self, url: str, secret: str = "", allowed_updates: Optional[List[str]] = None) -> bool:
+        return await self._api.set_webhook(url, secret, allowed_updates)
+
+    async def delete_webhook(self) -> bool:
+        return await self._api.delete_webhook()
+
+    async def get_webhook_info(self) -> dict:
+        return await self._api.get_webhook_info()
+
+    def command(self, commands: Union[str, List[str]]) -> Callable:
+        def decorator(func: Callable) -> Callable:
+            self._handlers.add_command(commands, func)
+            return func
+        return decorator
+
+    def hears(self, pattern: Union[str, Any]) -> Callable:
+        def decorator(func: Callable) -> Callable:
+            self._handlers.add_regex(pattern, func)
+            return func
+        return decorator
+
+    def message(self, func: Callable) -> Callable:
+        self._handlers.add_message(func)
+        return func
+
+    async def _process_update(self, update_data: dict) -> None:
+        update = Update.from_dict(update_data, bot=self)
+        if update.message:
+            update.message._bot = self
+            try:
+                await self._handlers.process(update.message)
+            except Exception as e:
+                logger.exception(f"Error processing update {update.update_id}: {e}")
+
+    async def polling(self, timeout: int = 30, limit: int = 100) -> None:
+        self._running = True
+        offset = 0
+
+        def signal_handler(sig, frame):
+            nonlocal self
+            logger.info("Received shutdown signal")
+            self._running = False
+
+        signal.signal(signal.SIGINT, signal_handler)
+        signal.signal(signal.SIGTERM, signal_handler)
+
+        logger.info("Starting polling...")
+
+        while self._running:
+            try:
+                updates = await self._api.get_updates(offset=offset, limit=limit, timeout=timeout)
+
+                if not updates:
+                    await asyncio.sleep(1.1)
+                    continue
+
+                for update_data in updates:
+                    if not self._running:
+                        break
+                    await self._process_update(update_data)
+                    offset = update_data.get("update_id", 0) + 1
+
+            except RateLimitError as e:
+                logger.info(f"Rate limited: {e.description}")
+                await asyncio.sleep(max(e.retry_after, 1.0) + 0.25)
+            except XcBotError as e:
+                logger.error(f"Bot error: {e}")
+                await asyncio.sleep(5)
+            except Exception as e:
+                logger.exception(f"Unexpected error in polling: {e}")
+                await asyncio.sleep(5)
+
+        logger.info("Polling stopped")
+
+    def run(self, timeout: int = 30, limit: int = 100) -> None:
+        try:
+            asyncio.run(self.polling(timeout=timeout, limit=limit))
+        except KeyboardInterrupt:
+            logger.info("Bot stopped by user")
+
+    async def close(self) -> None:
+        await self._api.close()

xc_bot/exceptions.py

@@ -0,0 +1,33 @@
+"""xc-bot exceptions"""
+
+
+class XcBotError(Exception):
+    """Base exception for xc-bot"""
+
+
+class ApiError(XcBotError):
+    """API returned an error"""
+
+    def __init__(self, error_code: int, description: str):
+        self.error_code = error_code
+        self.description = description
+        super().__init__(f"API error {error_code}: {description}")
+
+
+class NetworkError(XcBotError):
+    """Network-related error"""
+
+
+class RateLimitError(ApiError):
+    """Rate limit exceeded (429)"""
+
+    def __init__(self, description: str = "Too many requests", retry_after: float = 1.0):
+        self.retry_after = retry_after
+        super().__init__(429, description)
+
+
+class WebhookConflictError(ApiError):
+    """Cannot use getUpdates while webhook is active (409)"""
+
+    def __init__(self, description: str = "Cannot use getUpdates while webhook is active"):
+        super().__init__(409, description)

xc_bot/grpc_client.py

@@ -0,0 +1,59 @@
+import time
+import logging
+import grpc
+
+try:
+    from .pb import bot_service_pb2 as pb2
+    from .pb import bot_service_pb2_grpc as pb2_grpc
+except ImportError:
+    import bot_service_pb2 as pb2
+    import bot_service_pb2_grpc as pb2_grpc
+
+logger = logging.getLogger(__name__)
+
+
+class GrpcBotClient:
+    """
+    gRPC High-Performance Client for Xaneo Bot SDK (xc-bot).
+    Allows real-time streaming of events and sub-millisecond message dispatching.
+    """
+
+    def __init__(self, bot_token: str, server_address: str = "localhost:50052"):
+        self.bot_token = bot_token
+        self.server_address = server_address
+        self.channel = None
+        self.stub = None
+
+    def connect(self):
+        """Establish gRPC connection to Xaneo Bot Platform."""
+        logger.info(f"Connecting to Xaneo Bot gRPC Engine at {self.server_address}...")
+        self.channel = grpc.insecure_channel(self.server_address)
+        self.stub = pb2_grpc.BotEventServiceStub(self.channel)
+        logger.info("✅ gRPC Bot Client Connected Successfully!")
+
+    def send_message(self, chat_id: str, text: str, reply_to_id: str = ""):
+        """Send message via gRPC Unary RPC."""
+        if not self.stub:
+            self.connect()
+
+        try:
+            req = pb2.BotSendMessageRequest(
+                bot_token=self.bot_token,
+                chat_id=str(chat_id),
+                text=text,
+                reply_to_id=reply_to_id
+            )
+            response = self.stub.SendMessage(req)
+            return {
+                "success": response.success,
+                "message_id": response.message_id,
+                "timestamp": response.timestamp,
+                "error": response.error_message
+            }
+        except Exception as e:
+            logger.error(f"Error sending message over gRPC: {e}")
+            return {"success": False, "error": str(e)}
+
+    def close(self):
+        if self.channel:
+            self.channel.close()

xc_bot/handlers/__init__.py

@@ -0,0 +1,4 @@
+"""Handlers package"""
+from .handler import HandlerRegistry, HandlerEntry
+
+__all__ = ["HandlerRegistry", "HandlerEntry"]

xc_bot/handlers/handler.py

@@ -0,0 +1,84 @@
+"""Handler system for xc-bot"""
+import re
+from dataclasses import dataclass, field
+from typing import Any, Callable, Dict, List, Optional, Pattern, Union
+
+from xc_bot.types import Message
+
+
+@dataclass
+class HandlerEntry:
+    handler: Callable
+    priority: int = 0
+    pattern: Optional[Pattern] = None
+    commands: Optional[List[str]] = None
+
+
+class HandlerRegistry:
+    def __init__(self):
+        self._command_handlers: Dict[str, List[HandlerEntry]] = {}
+        self._regex_handlers: List[HandlerEntry] = []
+        self._message_handlers: List[HandlerEntry] = []
+
+    def add_command(self, commands: Union[str, List[str]], handler: Callable) -> None:
+        if isinstance(commands, str):
+            commands = [commands]
+
+        for cmd in commands:
+            cmd_clean = cmd.lstrip("/").lower()
+            if cmd_clean not in self._command_handlers:
+                self._command_handlers[cmd_clean] = []
+            self._command_handlers[cmd_clean].append(HandlerEntry(handler=handler))
+
+    def add_regex(self, pattern: Union[str, Pattern], handler: Callable) -> None:
+        if isinstance(pattern, str):
+            compiled = re.compile(pattern)
+        else:
+            compiled = pattern
+        self._regex_handlers.append(HandlerEntry(handler=handler, pattern=compiled))
+
+    def add_message(self, handler: Callable) -> None:
+        self._message_handlers.append(HandlerEntry(handler=handler))
+
+    async def process(self, message: Message) -> bool:
+        text = message.text or ""
+
+        if text.startswith("/"):
+            parts = text.split(None, 1)
+            command = parts[0].lstrip("/").lower()
+            
+            if "@" in command:
+                command = command.split("@")[0]
+
+            handlers = self._command_handlers.get(command, [])
+            for entry in handlers:
+                try:
+                    result = entry.handler(message)
+                    if result is not None and hasattr(result, "__await__"):
+                        await result
+                    return True
+                except Exception:
+                    continue
+
+        for entry in self._regex_handlers:
+            if entry.pattern:
+                match = entry.pattern.search(text)
+                if match:
+                    try:
+                        result = entry.handler(message, match)
+                        if result is not None and hasattr(result, "__await__"):
+                            await result
+                        return True
+                    except Exception:
+                        continue
+
+        for entry in self._message_handlers:
+            try:
+                result = entry.handler(message)
+                if result is not None and hasattr(result, "__await__"):
+                    await result
+                return True
+            except Exception:
+                continue
+
+        return False

xc_bot/pb/bot_service_pb2.py

@@ -0,0 +1,44 @@
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# NO CHECKED-IN PROTOBUF GENCODE
+# source: bot_service.proto
+# Protobuf Python Version: 7.35.0
+"""Generated protocol buffer code."""
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import descriptor_pool as _descriptor_pool
+from google.protobuf import runtime_version as _runtime_version
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf.internal import builder as _builder
+_runtime_version.ValidateProtobufRuntimeVersion(
+    _runtime_version.Domain.PUBLIC,
+    7,
+    35,
+    0,
+    '',
+    'bot_service.proto'
+)
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x11\x62ot_service.proto\x12\x08xaneo.v1\"v\n\x15\x42otSendMessageRequest\x12\x11\n\tbot_token\x18\x01 \x01(\t\x12\x0f\n\x07\x63hat_id\x18\x02 \x01(\t\x12\x0c\n\x04text\x18\x03 \x01(\t\x12\x13\n\x0breply_to_id\x18\x04 \x01(\t\x12\x16\n\x0einline_buttons\x18\x05 \x03(\t\"g\n\x16\x42otSendMessageResponse\x12\x0f\n\x07success\x18\x01 \x01(\x08\x12\x12\n\nmessage_id\x18\x02 \x01(\t\x12\x15\n\rerror_message\x18\x03 \x01(\t\x12\x11\n\ttimestamp\x18\x04 \x01(\x03\"\xb5\x01\n\x08\x42otEvent\x12\x10\n\x08\x65vent_id\x18\x01 \x01(\t\x12\x12\n\nevent_type\x18\x02 \x01(\t\x12\x0e\n\x06\x62ot_id\x18\x03 \x01(\t\x12\x0f\n\x07\x63hat_id\x18\x04 \x01(\t\x12\x11\n\tsender_id\x18\x05 \x01(\t\x12\x17\n\x0fsender_username\x18\x06 \x01(\t\x12\x0c\n\x04text\x18\x07 \x01(\t\x12\x15\n\rcallback_data\x18\x08 \x01(\t\x12\x11\n\ttimestamp\x18\t \x01(\x03\"q\n\tBotAction\x12\x11\n\tbot_token\x18\x01 \x01(\t\x12\x10\n\x08\x65vent_id\x18\x02 \x01(\t\x12\x13\n\x0b\x61\x63tion_type\x18\x03 \x01(\t\x12\x12\n\nreply_text\x18\x04 \x01(\t\x12\x16\n\x0einline_buttons\x18\x05 \x03(\t2\xa0\x01\n\x0f\x42otEventService\x12;\n\x0cStreamEvents\x12\x13.xaneo.v1.BotAction\x1a\x12.xaneo.v1.BotEvent(\x01\x30\x01\x12P\n\x0bSendMessage\x12\x1f.xaneo.v1.BotSendMessageRequest\x1a .xaneo.v1.BotSendMessageResponseb\x06proto3')
+
+_globals = globals()
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'bot_service_pb2', _globals)
+if not _descriptor._USE_C_DESCRIPTORS:
+  DESCRIPTOR._loaded_options = None
+  _globals['_BOTSENDMESSAGEREQUEST']._serialized_start=31
+  _globals['_BOTSENDMESSAGEREQUEST']._serialized_end=149
+  _globals['_BOTSENDMESSAGERESPONSE']._serialized_start=151
+  _globals['_BOTSENDMESSAGERESPONSE']._serialized_end=254
+  _globals['_BOTEVENT']._serialized_start=257
+  _globals['_BOTEVENT']._serialized_end=438
+  _globals['_BOTACTION']._serialized_start=440
+  _globals['_BOTACTION']._serialized_end=553
+  _globals['_BOTEVENTSERVICE']._serialized_start=556
+  _globals['_BOTEVENTSERVICE']._serialized_end=716
+# @@protoc_insertion_point(module_scope)

xc_bot/pb/bot_service_pb2_grpc.py

@@ -0,0 +1,145 @@
+# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT!
+"""Client and server classes corresponding to protobuf-defined services."""
+import grpc
+import warnings
+
+import bot_service_pb2 as bot__service__pb2
+
+GRPC_GENERATED_VERSION = '1.82.1'
+GRPC_VERSION = grpc.__version__
+_version_not_supported = False
+
+try:
+    from grpc._utilities import first_version_is_lower
+    _version_not_supported = first_version_is_lower(GRPC_VERSION, GRPC_GENERATED_VERSION)
+except ImportError:
+    _version_not_supported = True
+
+if _version_not_supported:
+    raise RuntimeError(
+        f'The grpc package installed is at version {GRPC_VERSION},'
+        + ' but the generated code in bot_service_pb2_grpc.py depends on'
+        + f' grpcio>={GRPC_GENERATED_VERSION}.'
+        + f' Please upgrade your grpc module to grpcio>={GRPC_GENERATED_VERSION}'
+        + f' or downgrade your generated code using grpcio-tools<={GRPC_VERSION}.'
+    )
+
+
+class BotEventServiceStub:
+    """Service for high-performance Bot Platform real-time communication
+    """
+
+    def __init__(self, channel):
+        """Constructor.
+
+        Args:
+            channel: A grpc.Channel.
+        """
+        self.StreamEvents = channel.stream_stream(
+                '/xaneo.v1.BotEventService/StreamEvents',
+                request_serializer=bot__service__pb2.BotAction.SerializeToString,
+                response_deserializer=bot__service__pb2.BotEvent.FromString,
+                _registered_method=True)
+        self.SendMessage = channel.unary_unary(
+                '/xaneo.v1.BotEventService/SendMessage',
+                request_serializer=bot__service__pb2.BotSendMessageRequest.SerializeToString,
+                response_deserializer=bot__service__pb2.BotSendMessageResponse.FromString,
+                _registered_method=True)
+
+
+class BotEventServiceServicer:
+    """Service for high-performance Bot Platform real-time communication
+    """
+
+    def StreamEvents(self, request_iterator, context):
+        """Bi-directional stream for bot events and real-time bot responses
+        """
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+    def SendMessage(self, request, context):
+        """Unary call for fast message sending by bots
+        """
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+
+def add_BotEventServiceServicer_to_server(servicer, server):
+    rpc_method_handlers = {
+            'StreamEvents': grpc.stream_stream_rpc_method_handler(
+                    servicer.StreamEvents,
+                    request_deserializer=bot__service__pb2.BotAction.FromString,
+                    response_serializer=bot__service__pb2.BotEvent.SerializeToString,
+            ),
+            'SendMessage': grpc.unary_unary_rpc_method_handler(
+                    servicer.SendMessage,
+                    request_deserializer=bot__service__pb2.BotSendMessageRequest.FromString,
+                    response_serializer=bot__service__pb2.BotSendMessageResponse.SerializeToString,
+            ),
+    }
+    generic_handler = grpc.method_handlers_generic_handler(
+            'xaneo.v1.BotEventService', rpc_method_handlers)
+    server.add_generic_rpc_handlers((generic_handler,))
+    server.add_registered_method_handlers('xaneo.v1.BotEventService', rpc_method_handlers)
+
+
+ # This class is part of an EXPERIMENTAL API.
+class BotEventService:
+    """Service for high-performance Bot Platform real-time communication
+    """
+
+    @staticmethod
+    def StreamEvents(request_iterator,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.stream_stream(
+            request_iterator,
+            target,
+            '/xaneo.v1.BotEventService/StreamEvents',
+            bot__service__pb2.BotAction.SerializeToString,
+            bot__service__pb2.BotEvent.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True)
+
+    @staticmethod
+    def SendMessage(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(
+            request,
+            target,
+            '/xaneo.v1.BotEventService/SendMessage',
+            bot__service__pb2.BotSendMessageRequest.SerializeToString,
+            bot__service__pb2.BotSendMessageResponse.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True)

xc_bot/types/__init__.py

@@ -0,0 +1,14 @@
+"""xc-bot types"""
+from .user import User, BotAccount
+from .message import Message, Chat, ChatType
+from .update import Update, UpdateType
+
+__all__ = [
+    "User",
+    "BotAccount",
+    "Message",
+    "Chat",
+    "ChatType",
+    "Update",
+    "UpdateType",
+]

xc_bot/types/message.py

@@ -0,0 +1,98 @@
+"""Message and Chat types"""
+from dataclasses import dataclass, field
+from datetime import datetime
+from enum import Enum
+from typing import TYPE_CHECKING, Any, Optional
+
+if TYPE_CHECKING:
+    from xc_bot.bot import Bot
+
+from .user import User
+
+
+class ChatType(Enum):
+    PRIVATE = "private"
+    GROUP = "group"
+    CHANNEL = "channel"
+    UNKNOWN = "unknown"
+
+
+@dataclass
+class Chat:
+    id: str
+    type: ChatType
+    title: Optional[str] = None
+    member_count: Optional[int] = None
+    subscriber_count: Optional[int] = None
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "Chat":
+        chat_type = data.get("type", "unknown")
+        try:
+            chat_type_enum = ChatType(chat_type)
+        except ValueError:
+            chat_type_enum = ChatType.UNKNOWN
+
+        return cls(
+            id=data["chat_id"],
+            type=chat_type_enum,
+            title=data.get("title"),
+            member_count=data.get("member_count"),
+            subscriber_count=data.get("subscriber_count"),
+        )
+
+
+@dataclass
+class Message:
+    id: int
+    chat_id: str
+    author: User
+    text: str
+    created_at: datetime
+    reply_to: Optional[int] = None
+    is_bot_message: bool = False
+    _bot: Optional["Bot"] = field(default=None, repr=False)
+
+    @classmethod
+    def from_dict(cls, data: dict, bot: Optional["Bot"] = None) -> "Message":
+        author_data = data.get("author", {})
+        if isinstance(author_data, dict):
+            author = User.from_dict(author_data)
+        else:
+            author = User(id=data.get("author_id", 0), username=data.get("author_username"))
+
+        created_at = data.get("created_at")
+        if isinstance(created_at, str):
+            created_at = datetime.fromisoformat(created_at.replace("Z", "+00:00"))
+        elif isinstance(created_at, (int, float)):
+            created_at = datetime.fromtimestamp(created_at)
+        else:
+            created_at = datetime.now()
+
+        return cls(
+            id=data["id"],
+            chat_id=data["chat_id"],
+            author=author,
+            text=data.get("text", ""),
+            created_at=created_at,
+            reply_to=data.get("reply_to_id") or data.get("reply_to"),
+            is_bot_message=data.get("is_bot_message", False),
+            _bot=bot,
+        )
+
+    async def reply(self, text: str, **kwargs) -> "Message":
+        if self._bot is None:
+            raise RuntimeError("Message object not linked to Bot instance")
+        return await self._bot.send_message(
+            self.chat_id, text, reply_to_message_id=self.id, **kwargs
+        )
+
+    async def edit(self, text: str) -> bool:
+        if self._bot is None:
+            raise RuntimeError("Message object not linked to Bot instance")
+        return await self._bot.edit_message(self.id, text)
+
+    async def delete(self) -> bool:
+        if self._bot is None:
+            raise RuntimeError("Message object not linked to Bot instance")
+        return await self._bot.delete_message(self.id)

xc_bot/types/update.py

@@ -0,0 +1,46 @@
+"""Update types"""
+from dataclasses import dataclass
+from enum import Enum
+from typing import Any, Optional, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from xc_bot.bot import Bot
+
+from .message import Message
+
+
+class UpdateType(Enum):
+    MESSAGE = "message"
+    EDITED_MESSAGE = "edited_message"
+    DELETED_MESSAGE = "deleted_message"
+    CALLBACK_QUERY = "callback_query"
+    CHAT_MEMBER = "chat_member"
+    UNKNOWN = "unknown"
+
+
+@dataclass
+class Update:
+    update_id: int
+    update_type: UpdateType
+    message: Optional[Message] = None
+    data: dict = None
+
+    @classmethod
+    def from_dict(cls, data: dict, bot: Optional["Bot"] = None) -> "Update":
+        update_type_str = data.get("update_type", "unknown")
+        try:
+            update_type = UpdateType(update_type_str)
+        except ValueError:
+            update_type = UpdateType.UNKNOWN
+
+        message = None
+        message_data = data.get("message")
+        if message_data:
+            message = Message.from_dict(message_data, bot=bot)
+
+        return cls(
+            update_id=data["update_id"],
+            update_type=update_type,
+            message=message,
+            data=data,
+        )

xc_bot/types/user.py

@@ -0,0 +1,42 @@
+"""User types"""
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Optional
+
+
+@dataclass
+class User:
+    id: int
+    username: Optional[str] = None
+    first_name: Optional[str] = None
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "User":
+        return cls(
+            id=data["id"],
+            username=data.get("username"),
+            first_name=data.get("first_name"),
+        )
+
+
+@dataclass
+class BotAccount:
+    id: int
+    username: str
+    display_name: str
+    description: str = ""
+    can_join_groups: bool = True
+    can_read_all_messages: bool = False
+    inline_mode: bool = False
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "BotAccount":
+        return cls(
+            id=data["id"],
+            username=data["username"],
+            display_name=data.get("display_name", ""),
+            description=data.get("description", ""),
+            can_join_groups=data.get("can_join_groups", True),
+            can_read_all_messages=data.get("can_read_all_messages", False),
+            inline_mode=data.get("inline_mode", False),
+        )

xc_bot/webhook/__init__.py

@@ -0,0 +1,4 @@
+"""Webhook package"""
+from .server import WebhookServer
+
+__all__ = ["WebhookServer"]

xc_bot/webhook/server.py

@@ -0,0 +1,99 @@
+"""Webhook server for xc-bot"""
+import hashlib
+import hmac
+import json
+import logging
+from typing import Callable, Optional
+
+from aiohttp import web
+
+logger = logging.getLogger("xc_bot.webhook")
+
+
+class WebhookServer:
+    def __init__(
+        self,
+        bot,
+        path: str = "/webhook",
+        host: str = "0.0.0.0",
+        port: int = 8443,
+        secret: Optional[str] = None,
+    ):
+        self.bot = bot
+        self.path = path
+        self.host = host
+        self.port = port
+        self.secret = secret
+        self._app: Optional[web.Application] = None
+        self._runner: Optional[web.AppRunner] = None
+
+    def _verify_signature(self, payload: bytes, signature: str) -> bool:
+        if not self.secret:
+            return True
+
+        if not signature.startswith("sha256="):
+            return False
+
+        expected_sig = signature[7:]
+        computed_sig = hmac.new(
+            self.secret.encode(),
+            payload,
+            hashlib.sha256,
+        ).hexdigest()
+
+        return hmac.compare_digest(expected_sig, computed_sig)
+
+    async def _handle_webhook(self, request: web.Request) -> web.Response:
+        signature = request.headers.get("X-XC-Signature", "")
+
+        payload = await request.read()
+
+        if not self._verify_signature(payload, signature):
+            logger.warning("Invalid webhook signature")
+            return web.Response(status=401, text="Unauthorized")
+
+        try:
+            data = json.loads(payload)
+        except json.JSONDecodeError:
+            logger.warning("Invalid JSON in webhook payload")
+            return web.Response(status=400, text="Bad Request")
+
+        try:
+            await self.bot._process_update(data)
+        except Exception as e:
+            logger.exception(f"Error processing webhook update: {e}")
+            return web.Response(status=500, text="Internal Server Error")
+
+        return web.Response(text="OK")
+
+    async def start(self) -> None:
+        self._app = web.Application()
+        self._app.router.add_post(self.path, self._handle_webhook)
+
+        self._runner = web.AppRunner(self._app)
+        await self._runner.setup()
+
+        site = web.TCPSite(self._runner, self.host, self.port)
+        await site.start()
+
+        logger.info(f"Webhook server started on http://{self.host}:{self.port}{self.path}")
+
+    async def stop(self) -> None:
+        if self._runner:
+            await self._runner.cleanup()
+        await self.bot.close()
+
+    def run(self) -> None:
+        import asyncio
+
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+
+        try:
+            loop.run_until_complete(self.start())
+            loop.run_forever()
+        except KeyboardInterrupt:
+            pass
+        finally:
+            loop.run_until_complete(self.stop())
+            loop.close()

xc_bot-1.0.0.dist-info/METADATA

@@ -0,0 +1,138 @@
+Metadata-Version: 2.4
+Name: xc-bot
+Version: 1.0.0
+Summary: Python SDK for XaneoConnect Bot API
+Author: Xaneo Team
+Author-email: Xaneo Team <ltpddwk@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/saneome2/xc-bot
+Project-URL: Documentation, https://xaneo.com/bot-api
+Project-URL: Repository, https://github.com/saneome2/xc-bot
+Keywords: xaneo,bot,api,sdk,async
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Framework :: AsyncIO
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: aiohttp>=3.8.0
+Requires-Dist: grpcio>=1.60.0
+Requires-Dist: protobuf>=4.25.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.21.0; extra == "dev"
+Requires-Dist: aioresponses>=0.7.0; extra == "dev"
+Requires-Dist: black>=23.0.0; extra == "dev"
+Requires-Dist: mypy>=1.0.0; extra == "dev"
+Dynamic: author
+Dynamic: license-file
+Dynamic: requires-python
+
+# xc-bot
+
+Python SDK for XaneoConnect Bot API
+
+## Installation
+
+```bash
+pip install xc-bot
+```
+
+## Quick Start
+
+```python
+from xc_bot import Bot
+
+bot = Bot("xbot_12345_abc...")
+
+@bot.command('start')
+async def start(message):
+    await message.reply("Hello! I'm a bot.")
+
+bot.run()
+```
+
+## Features
+
+- Async-only API (Python 3.8+)
+- Decorator-based handlers: `@bot.command()`, `@bot.hears()`, `@bot.message()`
+- Message object with `.reply()`, `.edit()`, `.delete()` methods
+- Webhook server with HMAC signature verification
+- Automatic retry with exponential backoff
+
+## API Methods
+
+| Method                           | Description           |
+| -------------------------------- | --------------------- |
+| `get_me()`                       | Get bot information   |
+| `send_message(chat_id, text)`    | Send a message        |
+| `edit_message(message_id, text)` | Edit a message        |
+| `delete_message(message_id)`     | Delete a message      |
+| `get_chat(chat_id)`              | Get chat info         |
+| `get_chat_members(chat_id)`      | Get chat members      |
+| `leave_chat(chat_id)`            | Leave a chat          |
+| `set_commands(commands)`         | Register bot commands |
+| `set_webhook(url)`               | Set webhook URL       |
+| `delete_webhook()`               | Remove webhook        |
+
+## Handlers
+
+### Commands
+
+```python
+@bot.command(['start', 'help'])
+async def start_handler(message):
+    await message.reply("Welcome!")
+```
+
+### Regex
+
+```python
+@bot.hears(r"^/echo (.+)$")
+async def echo_handler(message, match):
+    await message.reply(match.group(1))
+```
+
+### All Messages
+
+```python
+@bot.message
+async def log_message(message):
+    print(f"[{message.chat_id}] {message.text}")
+```
+
+## Webhook
+
+```python
+from xc_bot import Bot, WebhookServer
+
+bot = Bot("xbot_token")
+
+@bot.command("start")
+async def start(message):
+    await message.reply("Hello!")
+
+# Set webhook
+await bot.set_webhook("https://your-server.com/webhook", secret="your-secret")
+
+# Start webhook server
+server = WebhookServer(bot, port=8443, secret="your-secret")
+server.run()
+```
+
+## Getting a Token
+
+1. Open chat with @BotConstructor in XaneoConnect
+2. Send `/newbot`
+3. Follow the instructions
+
+## License
+
+MIT

xc_bot-1.0.0.dist-info/RECORD

@@ -0,0 +1,21 @@
+xc_bot/__init__.py,sha256=ZSSt2PXe3PLlHGtJDIP7A2sDnmE2LhmqEg-wYIqJdFU,684
+xc_bot/api.py,sha256=n7U2yO1J_HNEtatSbMw0V8d1j0bwO_tBOTAJofKqNAw,6141
+xc_bot/bot.py,sha256=wp56nehOjbGO7SlaxpmvKgEAhlYn9vFNJ3DV3wHvrWQ,5328
+xc_bot/exceptions.py,sha256=VF4jxgmOkaZfK3t4gGLmR-KNLpZp0FmeKgHZSnAzQik,903
+xc_bot/grpc_client.py,sha256=-soGiJCAfydRqeIph5Cq7o3TwREOhJ7qhIHABTFdW-4,1952
+xc_bot/handlers/__init__.py,sha256=TDZzC9e2gUF-HE6rWtPzw49k3VgA64U3KoSQXMz8leQ,121
+xc_bot/handlers/handler.py,sha256=UCnHqj7zCoODRP302rtu2fwKPm5eHPKthWbsZ--IOlc,2895
+xc_bot/pb/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+xc_bot/pb/bot_service_pb2.py,sha256=UUcNanfVAVIqmQwNsZT-MCakmopbFbTauTyhZhmKOe8,2896
+xc_bot/pb/bot_service_pb2_grpc.py,sha256=PqrfJ03HlmBceMUSepnKG2rDH_R6cRoG4xQ5sZ4f8tA,5291
+xc_bot/types/__init__.py,sha256=LBLd1t9fQBpOKpjGokBdZBsp7xfKW2aUvGkIzqsYI3k,258
+xc_bot/types/message.py,sha256=_4Ctfeoazn3a0X9SbGdUUinNaXi9YOiIgrLx1X1BknA,2985
+xc_bot/types/update.py,sha256=dH4NYwBw8Qt6x-h5Uklak8UrWB5Eqbm3im01KFpHWfc,1170
+xc_bot/types/user.py,sha256=B5BOce7wOIO3vSsSJSN64z__Oggyjzn9rKSqI_A92Qg,1110
+xc_bot/webhook/__init__.py,sha256=v2mgclMAvMPJh6VD5AxaRiT6Qwgc6v59uviIPWdnfcU,85
+xc_bot/webhook/server.py,sha256=1jvAyFH3_VNFdDph1pY24UV42wvjfamc4aZvP0ebubE,2829
+xc_bot-1.0.0.dist-info/licenses/LICENSE,sha256=7B4ez0s_T_yYbtXe5iqdQUkU2WYkEvRavLj4QFJMjrA,1067
+xc_bot-1.0.0.dist-info/METADATA,sha256=TPhwkpUssAChuqJrI71eu_dL3lZscgCbdcPz8oSUD6I,3569
+xc_bot-1.0.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+xc_bot-1.0.0.dist-info/top_level.txt,sha256=x1LO3Yess6VFuhcPEQ4VJcGVlHEnYx4cF2EwI3F-EbY,7
+xc_bot-1.0.0.dist-info/RECORD,,

xc_bot-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

xc_bot-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Xaneo Team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

xc_bot-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+xc_bot