styledbots 1.0.0__py3-none-any.whl

styledbots/__init__.py

@@ -0,0 +1,38 @@
+"""
+StyledBots - Modern, clean & powerful Telegram Bot library
+Better than / equal to Telebot • Perfect for Pydroid 3
+"""
+
+from .core.bot import Bot
+from .core.exceptions import (
+    StyledBotsError,
+    TelegramAPIError,
+    NetworkError,
+    InvalidTokenError,
+)
+from .core.types import Message, User, Chat, CallbackQuery, Update
+from .styles.style import Style
+from .keyboards.inline import InlineKeyboard
+from .keyboards.reply import ReplyKeyboard
+from .keyboards.builder import KeyboardBuilder
+from .filters.filters import filters
+from .version import __version__
+
+__all__ = [
+    "Bot",
+    "Style",
+    "InlineKeyboard",
+    "ReplyKeyboard",
+    "KeyboardBuilder",
+    "filters",
+    "Message",
+    "User",
+    "Chat",
+    "CallbackQuery",
+    "Update",
+    "StyledBotsError",
+    "TelegramAPIError",
+    "NetworkError",
+    "InvalidTokenError",
+    "__version__",
+]

styledbots/core/__init__.py

@@ -0,0 +1,4 @@
+from .bot import Bot
+from .api import TelegramAPI
+from .exceptions import *
+from .types import *

styledbots/core/api.py

@@ -0,0 +1,184 @@
+import requests
+from typing import Optional, Dict, Any, List, Union
+from .exceptions import TelegramAPIError, NetworkError, InvalidTokenError
+
+
+class TelegramAPI:
+    """Low-level Telegram Bot API client"""
+
+    def __init__(self, token: str, timeout: int = 30):
+        self.token = token
+        self.base_url = f"https://api.telegram.org/bot{token}/"
+        self.timeout = timeout
+        self.session = requests.Session()
+
+    def _request(self, method: str, params: dict = None, files: dict = None) -> dict:
+        url = self.base_url + method
+        try:
+            if files:
+                response = self.session.post(url, data=params, files=files, timeout=self.timeout)
+            else:
+                response = self.session.post(url, json=params or {}, timeout=self.timeout)
+
+            data = response.json()
+
+            if not data.get("ok"):
+                description = data.get("description", "Unknown error")
+                error_code = data.get("error_code")
+                if error_code == 401:
+                    raise InvalidTokenError(description)
+                raise TelegramAPIError(description, error_code)
+
+            return data.get("result")
+
+        except requests.exceptions.RequestException as e:
+            raise NetworkError(f"Network error: {e}")
+
+    # ===== Core methods =====
+
+    def get_me(self) -> dict:
+        return self._request("getMe")
+
+    def get_updates(self, offset: int = None, timeout: int = 25, limit_types: list = None) -> list:
+        params = {"timeout": timeout}
+        if offset is not None:
+            params["offset"] = offset
+        if allowed_updates:
+            params["allowed_updates"] = allowed_updates
+        return self._request("getUpdates", params) or []
+
+    def send_message(
+        self,
+        chat_id: Union[int, str],
+        text: str,
+        parse_mode: str = "HTML",
+        reply_markup: dict = None,
+        reply_to_message_id: int = None,
+        disable_web_page_preview: bool = False,
+        disable_notification: bool = False,
+        **kwargs
+    ) -> dict:
+        params = {
+            "chat_id": chat_id,
+            "text": text,
+            "parse_mode": parse_mode,
+            "disable_web_page_preview": disable_web_page_preview,
+            "disable_notification": disable_notification,
+            **kwargs
+        }
+        if reply_markup:
+            params["reply_markup"] = reply_markup
+        if reply_to_message_id:
+            params["reply_to_message_id"] = reply_to_message_id
+        return self._request("sendMessage", params)
+
+    def edit_message_text(
+        self,
+        text: str,
+        chat_id: Union[int, str] = None,
+        message_id: int = None,
+        inline_message_id: str = None,
+        parse_mode: str = "HTML",
+        reply_markup: dict = None,
+        **kwargs
+    ) -> dict:
+        params = {
+            "text": text,
+            "parse_mode": parse_mode,
+            **kwargs
+        }
+        if chat_id:
+            params["chat_id"] = chat_id
+        if message_id:
+            params["message_id"] = message_id
+        if inline_message_id:
+            params["inline_message_id"] = inline_message_id
+        if reply_markup:
+            params["reply_markup"] = reply_markup
+        return self._request("editMessageText", params)
+
+    def delete_message(self, chat_id: Union[int, str], message_id: int) -> bool:
+        return self._request("deleteMessage", {
+            "chat_id": chat_id,
+            "message_id": message_id
+        })
+
+    def answer_callback_query(
+        self,
+        callback_query_id: str,
+        text: str = None,
+        show_alert: bool = False,
+        url: str = None,
+        cache_time: int = 0
+    ) -> bool:
+        params = {
+            "callback_query_id": callback_query_id,
+            "show_alert": show_alert,
+            "cache_time": cache_time
+        }
+        if text:
+            params["text"] = text
+        if url:
+            params["url"] = url
+        return self._request("answerCallbackQuery", params)
+
+    def send_photo(
+        self,
+        chat_id: Union[int, str],
+        photo: Union[str, bytes],
+        caption: str = None,
+        parse_mode: str = "HTML",
+        reply_markup: dict = None,
+        **kwargs
+    ) -> dict:
+        params = {
+            "chat_id": chat_id,
+            "parse_mode": parse_mode,
+            **kwargs
+        }
+        if caption:
+            params["caption"] = caption
+        if reply_markup:
+            params["reply_markup"] = reply_markup
+
+        if isinstance(photo, str) and (photo.startswith("http") or photo.startswith("AgAC")):
+            params["photo"] = photo
+            return self._request("sendPhoto", params)
+        else:
+            files = {"photo": photo}
+            return self._request("sendPhoto", params, files=files)
+
+    def send_document(
+        self,
+        chat_id: Union[int, str],
+        document: Union[str, bytes],
+        caption: str = None,
+        parse_mode: str = "HTML",
+        reply_markup: dict = None,
+        **kwargs
+    ) -> dict:
+        params = {
+            "chat_id": chat_id,
+            "parse_mode": parse_mode,
+            **kwargs
+        }
+        if caption:
+            params["caption"] = caption
+        if reply_markup:
+            params["reply_markup"] = reply_markup
+
+        if isinstance(document, str) and not document.startswith("/"):
+            params["document"] = document
+            return self._request("sendDocument", params)
+        else:
+            files = {"document": document}
+            return self._request("sendDocument", params, files=files)
+
+    def get_chat(self, chat_id: Union[int, str]) -> dict:
+        return self._request("getChat", {"chat_id": chat_id})
+
+    def get_chat_member(self, chat_id: Union[int, str], user_id: int) -> dict:
+        return self._request("getChatMember", {
+            "chat_id": chat_id,
+            "user_id": user_id
+        })

styledbots/core/bot.py

@@ -0,0 +1,270 @@
+import time
+import threading
+from typing import Callable, Optional, List, Dict, Any, Union
+from .api import TelegramAPI
+from .types import Update, Message, CallbackQuery
+from .exceptions import StyledBotsError, HandlerError
+from ..filters.filters import filters as Filters
+
+
+class Bot:
+    """
+    Main Bot class - Clean, powerful, Telebot-compatible API
+    """
+
+    def __init__(self, token: str, parse_mode: str = "HTML", threaded: bool = True):
+        if not token or ":" not in token:
+            raise ValueError("Invalid bot token")
+
+        self.token = token
+        self.parse_mode = parse_mode
+        self.api = TelegramAPI(token)
+        self.threaded = threaded
+
+        # Handlers storage
+        self.message_handlers: List[dict] = []
+        self.callback_handlers: List[dict] = []
+        self.command_handlers: Dict[str, Callable] = {}
+        self.middlewares: List[Callable] = []
+
+        # State
+        self._offset = 0
+        self._running = False
+        self._stop_event = threading.Event()
+
+        # Bot info
+        self.me = None
+        try:
+            self.me = self.api.get_me()
+            print(f"✅ StyledBots started as @{self.me.get('username')}")
+        except Exception as e:
+            print(f"⚠️ Warning: Could not get bot info: {e}")
+
+    # ==================== Decorators ====================
+
+    def message_handler(self, commands: List[str] = None, regexp: str = None,
+                        func: Callable = None, content_types: List[str] = None,
+                        chat_types: List[str] = None, **kwargs):
+        """
+        Decorator for message handlers (Telebot compatible + better)
+        """
+        def decorator(handler: Callable):
+            filters_list = []
+
+            if commands:
+                filters_list.append(Filters.command(commands))
+            if regexp:
+                filters_list.append(Filters.regexp(regexp))
+            if content_types:
+                filters_list.append(Filters.content_type(content_types))
+            if chat_types:
+                filters_list.append(Filters.chat_type(chat_types))
+            if func:
+                filters_list.append(Filters.func(func))
+
+            self.message_handlers.append({
+                "handler": handler,
+                "filters": filters_list,
+                "kwargs": kwargs
+            })
+            return handler
+        return decorator
+
+    def callback_query_handler(self, func: Callable = None, **kwargs):
+        """Decorator for callback query handlers"""
+        def decorator(handler: Callable):
+            filters_list = []
+            if func:
+                filters_list.append(Filters.func(func))
+
+            self.callback_handlers.append({
+                "handler": handler,
+                "filters": filters_list,
+                "kwargs": kwargs
+            })
+            return handler
+        return decorator
+
+    def command(self, *commands: str):
+        """Simple command decorator: @bot.command("start", "help")"""
+        def decorator(handler: Callable):
+            for cmd in commands:
+                self.command_handlers[cmd.lower()] = handler
+            return handler
+        return decorator
+
+    def middleware_handler(self, update_types: List[str] = None):
+        """Register middleware"""
+        def decorator(handler: Callable):
+            self.middlewares.append(handler)
+            return handler
+        return decorator
+
+    # ==================== Sending methods ====================
+
+    def send_message(self, chat_id: Union[int, str], text: str,
+                     parse_mode: str = None, reply_markup=None,
+                     reply_to_message_id: int = None, **kwargs):
+        if hasattr(reply_markup, "to_dict"):
+            reply_markup = reply_markup.to_dict()
+        return self.api.send_message(
+            chat_id=chat_id,
+            text=text,
+            parse_mode=parse_mode or self.parse_mode,
+            reply_markup=reply_markup,
+            reply_to_message_id=reply_to_message_id,
+            **kwargs
+        )
+
+    def reply_to(self, message: Message, text: str, **kwargs):
+        return self.send_message(
+            chat_id=message.chat.id,
+            text=text,
+            reply_to_message_id=message.message_id,
+            **kwargs
+        )
+
+    def edit_message_text(self, text: str, chat_id=None, message_id=None,
+                          reply_markup=None, **kwargs):
+        if hasattr(reply_markup, "to_dict"):
+            reply_markup = reply_markup.to_dict()
+        return self.api.edit_message_text(
+            text=text,
+            chat_id=chat_id,
+            message_id=message_id,
+            reply_markup=reply_markup,
+            parse_mode=kwargs.pop("parse_mode", self.parse_mode),
+            **kwargs
+        )
+
+    def delete_message(self, chat_id, message_id):
+        return self.api.delete_message(chat_id, message_id)
+
+    def answer_callback_query(self, callback_query_id: str, text: str = None,
+                              show_alert: bool = False, **kwargs):
+        return self.api.answer_callback_query(
+            callback_query_id, text=text, show_alert=show_alert, **kwargs
+        )
+
+    def send_photo(self, chat_id, photo, caption=None, reply_markup=None, **kwargs):
+        if hasattr(reply_markup, "to_dict"):
+            reply_markup = reply_markup.to_dict()
+        return self.api.send_photo(
+            chat_id, photo, caption=caption,
+            reply_markup=reply_markup,
+            parse_mode=kwargs.pop("parse_mode", self.parse_mode),
+            **kwargs
+        )
+
+    def send_document(self, chat_id, document, caption=None, reply_markup=None, **kwargs):
+        if hasattr(reply_markup, "to_dict"):
+            reply_markup = reply_markup.to_dict()
+        return self.api.send_document(
+            chat_id, document, caption=caption,
+            reply_markup=reply_markup,
+            parse_mode=kwargs.pop("parse_mode", self.parse_mode),
+            **kwargs
+        )
+
+    # ==================== Processing ====================
+
+    def _check_filters(self, filters_list: list, obj) -> bool:
+        if not filters_list:
+            return True
+        return all(f(obj) for f in filters_list)
+
+    def process_new_updates(self, updates: list):
+        for update_data in updates:
+            try:
+                update = Update(update_data, bot=self)
+
+                # Middlewares
+                for mw in self.middlewares:
+                    try:
+                        mw(update)
+                    except Exception as e:
+                        print(f"Middleware error: {e}")
+
+                # Commands (fast path)
+                if update.message and update.message.text and update.message.text.startswith("/"):
+                    cmd = update.message.text.split()[0][1:].split("@")[0].lower()
+                    if cmd in self.command_handlers:
+                        try:
+                            self.command_handlers[cmd](update.message)
+                        except Exception as e:
+                            print(f"Command handler error: {e}")
+                        continue
+
+                # Message handlers
+                if update.message:
+                    for h in self.message_handlers:
+                        if self._check_filters(h["filters"], update.message):
+                            try:
+                                h["handler"](update.message)
+                            except Exception as e:
+                                print(f"Message handler error: {e}")
+                            break
+
+                # Callback handlers
+                if update.callback_query:
+                    for h in self.callback_handlers:
+                        if self._check_filters(h["filters"], update.callback_query):
+                            try:
+                                h["handler"](update.callback_query)
+                            except Exception as e:
+                                print(f"Callback handler error: {e}")
+                            break
+
+            except Exception as e:
+                print(f"Update processing error: {e}")
+
+    # ==================== Polling ====================
+
+    def infinity_polling(self, timeout: int = 25, skip_pending: bool = True,
+                         allowed_updates: list = None, **kwargs):
+        """Start infinite polling (Telebot style)"""
+        print("🚀 StyledBots is polling...")
+        self._running = True
+        self._stop_event.clear()
+
+        if skip_pending:
+            # Skip old updates
+            try:
+                updates = self.api.get_updates(timeout=1)
+                if updates:
+                    self._offset = updates[-1]["update_id"] + 1
+            except Exception:
+                pass
+
+        while self._running and not self._stop_event.is_set():
+            try:
+                updates = self.api.get_updates(
+                    offset=self._offset,
+                    timeout=timeout,
+                    allowed_updates=allowed_updates
+                )
+                if updates:
+                    self._offset = updates[-1]["update_id"] + 1
+                    self.process_new_updates(updates)
+            except Exception as e:
+                print(f"Polling error: {e}")
+                time.sleep(3)
+
+        print("🛑 Polling stopped")
+
+    def stop_polling(self):
+        self._running = False
+        self._stop_event.set()
+
+    def polling(self, non_stop: bool = True, **kwargs):
+        """Alias for infinity_polling"""
+        self.infinity_polling(**kwargs)
+
+    # ==================== Helpers ====================
+
+    def get_me(self):
+        return self.api.get_me()
+
+    def __repr__(self):
+        username = self.me.get("username") if self.me else "Unknown"
+        return f"<StyledBots Bot @{username}>"

styledbots/core/exceptions.py

@@ -0,0 +1,26 @@
+class StyledBotsError(Exception):
+    """Base exception for StyledBots"""
+    pass
+
+
+class TelegramAPIError(StyledBotsError):
+    """Raised when Telegram API returns an error"""
+    def __init__(self, description: str, error_code: int = None):
+        self.description = description
+        self.error_code = error_code
+        super().__init__(f"Telegram API Error [{error_code}]: {description}")
+
+
+class NetworkError(StyledBotsError):
+    """Raised on network / connection problems"""
+    pass
+
+
+class InvalidTokenError(StyledBotsError):
+    """Raised when bot token is invalid"""
+    pass
+
+
+class HandlerError(StyledBotsError):
+    """Raised when a handler fails"""
+    pass

styledbots/core/types.py

@@ -0,0 +1,107 @@
+from typing import Optional, Dict, Any, List
+
+
+class User:
+    def __init__(self, data: dict):
+        self.id: int = data.get("id")
+        self.is_bot: bool = data.get("is_bot", False)
+        self.first_name: str = data.get("first_name", "")
+        self.last_name: Optional[str] = data.get("last_name")
+        self.username: Optional[str] = data.get("username")
+        self.language_code: Optional[str] = data.get("language_code")
+        self.is_premium: bool = data.get("is_premium", False)
+        self._raw = data
+
+    @property
+    def full_name(self) -> str:
+        if self.last_name:
+            return f"{self.first_name} {self.last_name}"
+        return self.first_name
+
+    def __repr__(self):
+        return f"<User {self.id} @{self.username or self.first_name}>"
+
+
+class Chat:
+    def __init__(self, data: dict):
+        self.id: int = data.get("id")
+        self.type: str = data.get("type", "private")
+        self.title: Optional[str] = data.get("title")
+        self.username: Optional[str] = data.get("username")
+        self.first_name: Optional[str] = data.get("first_name")
+        self.last_name: Optional[str] = data.get("last_name")
+        self._raw = data
+
+    def __repr__(self):
+        return f"<Chat {self.id} ({self.type})>"
+
+
+class Message:
+    def __init__(self, data: dict, bot=None):
+        self.message_id: int = data.get("message_id")
+        self.date: int = data.get("date")
+        self.chat = Chat(data.get("chat", {}))
+        self.from_user = User(data["from"]) if data.get("from") else None
+        self.text: Optional[str] = data.get("text")
+        self.caption: Optional[str] = data.get("caption")
+        self.content_type: str = self._detect_content_type(data)
+        self.reply_to_message = Message(data["reply_to_message"], bot) if data.get("reply_to_message") else None
+        self._raw = data
+        self._bot = bot
+
+    def _detect_content_type(self, data: dict) -> str:
+        for key in ("text", "photo", "video", "document", "audio", "voice",
+                    "sticker", "animation", "video_note", "contact", "location"):
+            if key in data:
+                return key
+        return "unknown"
+
+    def reply(self, text: str, **kwargs):
+        """Shortcut: reply to this message"""
+        if self._bot:
+            return self._bot.send_message(
+                self.chat.id,
+                text,
+                reply_to_message_id=self.message_id,
+                **kwargs
+            )
+        raise RuntimeError("Bot instance not attached")
+
+    def __repr__(self):
+        return f"<Message {self.message_id} from {self.from_user}>"
+
+
+class CallbackQuery:
+    def __init__(self, data: dict, bot=None):
+        self.id: str = data.get("id")
+        self.from_user = User(data.get("from", {}))
+        self.data: Optional[str] = data.get("data")
+        self.message = Message(data["message"], bot) if data.get("message") else None
+        self.chat_instance: Optional[str] = data.get("chat_instance")
+        self._raw = data
+        self._bot = bot
+
+    def answer(self, text: str = None, show_alert: bool = False, **kwargs):
+        if self._bot:
+            return self._bot.answer_callback_query(
+                self.id,
+                text=text,
+                show_alert=show_alert,
+                **kwargs
+            )
+        raise RuntimeError("Bot instance not attached")
+
+    def __repr__(self):
+        return f"<CallbackQuery {self.id} data={self.data}>"
+
+
+class Update:
+    def __init__(self, data: dict, bot=None):
+        self.update_id: int = data.get("update_id")
+        self.message = Message(data["message"], bot) if data.get("message") else None
+        self.edited_message = Message(data["edited_message"], bot) if data.get("edited_message") else None
+        self.callback_query = CallbackQuery(data["callback_query"], bot) if data.get("callback_query") else None
+        self._raw = data
+
+    def __repr__(self):
+        return f"<Update {self.update_id}>"

styledbots/filters/__init__.py

@@ -0,0 +1 @@
+from .filters import filters