styledbots 1.0.0__py3-none-any.whl

styledbots/filters/filters.py

@@ -0,0 +1,88 @@
+import re
+from typing import Callable, List, Union, Any
+
+
+class filters:
+    """Filter factory - Telebot style + more power"""
+
+    @staticmethod
+    def text(value: str = None) -> Callable:
+        def f(message) -> bool:
+            if not message.text:
+                return False
+            if value is None:
+                return True
+            return message.text == value
+        return f
+
+    @staticmethod
+    def command(commands: Union[str, List[str]]) -> Callable:
+        if isinstance(commands, str):
+            commands = [commands]
+        commands = [c.lower().lstrip("/") for c in commands]
+
+        def f(message) -> bool:
+            if not message.text or not message.text.startswith("/"):
+                return False
+            cmd = message.text.split()[0][1:].split("@")[0].lower()
+            return cmd in commands
+        return f
+
+    @staticmethod
+    def regexp(pattern: str, flags=0) -> Callable:
+        compiled = re.compile(pattern, flags)
+
+        def f(message) -> bool:
+            if not message.text:
+                return False
+            return bool(compiled.search(message.text))
+        return f
+
+    @staticmethod
+    def content_type(types: Union[str, List[str]]) -> Callable:
+        if isinstance(types, str):
+            types = [types]
+
+        def f(message) -> bool:
+            return message.content_type in types
+        return f
+
+    @staticmethod
+    def chat_type(types: Union[str, List[str]]) -> Callable:
+        if isinstance(types, str):
+            types = [types]
+
+        def f(message) -> bool:
+            return message.chat.type in types
+        return f
+
+    @staticmethod
+    def private() -> Callable:
+        return filters.chat_type("private")
+
+    @staticmethod
+    def group() -> Callable:
+        return filters.chat_type(["group", "supergroup"])
+
+    @staticmethod
+    def func(function: Callable) -> Callable:
+        """Custom filter function"""
+        return function
+
+    @staticmethod
+    def user(user_ids: Union[int, List[int]]) -> Callable:
+        if isinstance(user_ids, int):
+            user_ids = [user_ids]
+
+        def f(message) -> bool:
+            return message.from_user and message.from_user.id in user_ids
+        return f
+
+    @staticmethod
+    def chat(chat_ids: Union[int, List[int]]) -> Callable:
+        if isinstance(chat_ids, int):
+            chat_ids = [chat_ids]
+
+        def f(message) -> bool:
+            return message.chat.id in chat_ids
+        return f

styledbots/handlers/__init__.py

@@ -0,0 +1,2 @@
+# Handlers are integrated into Bot class for simplicity
+# This module is reserved for future advanced handler systems

styledbots/keyboards/__init__.py

@@ -0,0 +1,3 @@
+from .inline import InlineKeyboard, InlineButton
+from .reply import ReplyKeyboard, ReplyButton
+from .builder import KeyboardBuilder

styledbots/keyboards/builder.py

@@ -0,0 +1,28 @@
+from .inline import InlineKeyboard, InlineButton
+from .reply import ReplyKeyboard
+
+
+class KeyboardBuilder:
+    """
+    Super simple keyboard factory
+    """
+
+    @staticmethod
+    def inline() -> InlineKeyboard:
+        return InlineKeyboard()
+
+    @staticmethod
+    def reply(resize: bool = True, one_time: bool = False) -> ReplyKeyboard:
+        return ReplyKeyboard(resize_keyboard=resize, one_time_keyboard=one_time)
+
+    @staticmethod
+    def yes_no(yes_data: str = "yes", no_data: str = "no") -> InlineKeyboard:
+        kb = InlineKeyboard()
+        kb.button("✅ Yes", yes_data).button("❌ No", no_data)
+        return kb
+
+    @staticmethod
+    def confirm_cancel(confirm_data: str = "confirm", cancel_data: str = "cancel") -> InlineKeyboard:
+        kb = InlineKeyboard()
+        kb.button("✅ Confirm", confirm_data).button("🚫 Cancel", cancel_data)
+        return kb

styledbots/keyboards/inline.py

@@ -0,0 +1,98 @@
+from typing import List, Optional, Union
+
+
+class InlineButton:
+    def __init__(self, text: str, callback_data: str = None, url: str = None,
+                 switch_inline_query: str = None, switch_inline_query_current_chat: str = None):
+        self.text = text
+        self.callback_data = callback_data
+        self.url = url
+        self.switch_inline_query = switch_inline_query
+        self.switch_inline_query_current_chat = switch_inline_query_current_chat
+
+    def to_dict(self) -> dict:
+        data = {"text": self.text}
+        if self.callback_data is not None:
+            data["callback_data"] = str(self.callback_data)
+        if self.url:
+            data["url"] = self.url
+        if self.switch_inline_query is not None:
+            data["switch_inline_query"] = self.switch_inline_query
+        if self.switch_inline_query_current_chat is not None:
+            data["switch_inline_query_current_chat"] = self.switch_inline_query_current_chat
+        return data
+
+
+class InlineKeyboard:
+    """
+    Fluent Inline Keyboard builder
+    Example:
+        kb = InlineKeyboard()
+        kb.button("Yes", "yes").button("No", "no")
+        kb.row()
+        kb.button("Cancel", "cancel")
+    """
+
+    def __init__(self):
+        self.keyboard: List[List[dict]] = []
+        self._current_row: List[dict] = []
+
+    def button(self, text: str, callback_data: str = None, url: str = None, **kwargs):
+        btn = InlineButton(text, callback_data=callback_data, url=url, **kwargs)
+        self._current_row.append(btn.to_dict())
+        return self
+
+    def add(self, *buttons: InlineButton):
+        """Add multiple buttons to current row"""
+        for btn in buttons:
+            self._current_row.append(btn.to_dict() if isinstance(btn, InlineButton) else btn)
+        return self
+
+    def row(self, *buttons):
+        """Finish current row and optionally start new one with buttons"""
+        if self._current_row:
+            self.keyboard.append(self._current_row)
+            self._current_row = []
+        if buttons:
+            for btn in buttons:
+                if isinstance(btn, InlineButton):
+                    self._current_row.append(btn.to_dict())
+                elif isinstance(btn, dict):
+                    self._current_row.append(btn)
+                else:
+                    # assume (text, callback)
+                    self._current_row.append(InlineButton(btn[0], btn[1]).to_dict())
+        return self
+
+    def adjust(self, *sizes: int):
+        """
+        Automatically arrange buttons in rows of given sizes.
+        Example: kb.adjust(2, 1, 3)
+        """
+        all_buttons = []
+        for row in self.keyboard:
+            all_buttons.extend(row)
+        if self._current_row:
+            all_buttons.extend(self._current_row)
+
+        self.keyboard = []
+        self._current_row = []
+        idx = 0
+        for size in sizes:
+            row = all_buttons[idx:idx + size]
+            if row:
+                self.keyboard.append(row)
+            idx += size
+        # remaining
+        if idx < len(all_buttons):
+            self.keyboard.append(all_buttons[idx:])
+        return self
+
+    def to_dict(self) -> dict:
+        if self._current_row:
+            self.keyboard.append(self._current_row)
+            self._current_row = []
+        return {"inline_keyboard": self.keyboard}
+
+    def __repr__(self):
+        return f"<InlineKeyboard rows={len(self.keyboard)}>"

styledbots/keyboards/reply.py

@@ -0,0 +1,75 @@
+from typing import List, Optional
+
+
+class ReplyButton:
+    def __init__(self, text: str, request_contact: bool = False, request_location: bool = False):
+        self.text = text
+        self.request_contact = request_contact
+        self.request_location = request_location
+
+    def to_dict(self) -> dict:
+        data = {"text": self.text}
+        if self.request_contact:
+            data["request_contact"] = True
+        if self.request_location:
+            data["request_location"] = True
+        return data
+
+
+class ReplyKeyboard:
+    """
+    Reply Keyboard builder
+    """
+
+    def __init__(self, resize_keyboard: bool = True, one_time_keyboard: bool = False,
+                 input_field_placeholder: str = None, selective: bool = False):
+        self.keyboard: List[List[dict]] = []
+        self._current_row: List[dict] = []
+        self.resize_keyboard = resize_keyboard
+        self.one_time_keyboard = one_time_keyboard
+        self.input_field_placeholder = input_field_placeholder
+        self.selective = selective
+
+    def button(self, text: str, request_contact: bool = False, request_location: bool = False):
+        btn = ReplyButton(text, request_contact, request_location)
+        self._current_row.append(btn.to_dict())
+        return self
+
+    def row(self, *texts: str):
+        if self._current_row:
+            self.keyboard.append(self._current_row)
+            self._current_row = []
+        if texts:
+            self._current_row = [{"text": t} for t in texts]
+        return self
+
+    def add(self, *texts: str):
+        for t in texts:
+            self._current_row.append({"text": t})
+        return self
+
+    def to_dict(self) -> dict:
+        if self._current_row:
+            self.keyboard.append(self._current_row)
+            self._current_row = []
+
+        data = {
+            "keyboard": self.keyboard,
+            "resize_keyboard": self.resize_keyboard,
+            "one_time_keyboard": self.one_time_keyboard,
+            "selective": self.selective
+        }
+        if self.input_field_placeholder:
+            data["input_field_placeholder"] = self.input_field_placeholder
+        return data
+
+    def __repr__(self):
+        return f"<ReplyKeyboard rows={len(self.keyboard)}>"
+
+
+class ReplyKeyboardRemove:
+    def __init__(self, selective: bool = False):
+        self.selective = selective
+
+    def to_dict(self) -> dict:
+        return {"remove_keyboard": True, "selective": self.selective}

styledbots/storage/__init__.py

@@ -0,0 +1,3 @@
+from .base import BaseStorage
+from .memory import MemoryStorage
+from .file import FileStorage

styledbots/storage/base.py

@@ -0,0 +1,23 @@
+from abc import ABC, abstractmethod
+from typing import Any, Optional
+
+
+class BaseStorage(ABC):
+    @abstractmethod
+    def get(self, key: str, default: Any = None) -> Any:
+        pass
+
+    @abstractmethod
+    def set(self, key: str, value: Any) -> None:
+        pass
+
+    @abstractmethod
+    def delete(self, key: str) -> None:
+        pass
+
+    @abstractmethod
+    def exists(self, key: str) -> bool:
+        pass
+
+    def clear(self) -> None:
+        pass

styledbots/storage/file.py

@@ -0,0 +1,46 @@
+import json
+import os
+from typing import Any
+from .base import BaseStorage
+
+
+class FileStorage(BaseStorage):
+    """Simple JSON file storage (persistent)"""
+
+    def __init__(self, filename: str = "styledbots_data.json"):
+        self.filename = filename
+        self._data = {}
+        self._load()
+
+    def _load(self):
+        if os.path.exists(self.filename):
+            try:
+                with open(self.filename, "r", encoding="utf-8") as f:
+                    self._data = json.load(f)
+            except Exception:
+                self._data = {}
+        else:
+            self._data = {}
+
+    def _save(self):
+        with open(self.filename, "w", encoding="utf-8") as f:
+            json.dump(self._data, f, ensure_ascii=False, indent=2)
+
+    def get(self, key: str, default: Any = None) -> Any:
+        return self._data.get(key, default)
+
+    def set(self, key: str, value: Any) -> None:
+        self._data[key] = value
+        self._save()
+
+    def delete(self, key: str) -> None:
+        if key in self._data:
+            del self._data[key]
+            self._save()
+
+    def exists(self, key: str) -> bool:
+        return key in self._data
+
+    def clear(self) -> None:
+        self._data.clear()
+        self._save()

styledbots/storage/memory.py

@@ -0,0 +1,27 @@
+from typing import Any, Dict
+from .base import BaseStorage
+
+
+class MemoryStorage(BaseStorage):
+    """Simple in-memory storage (fast, lost on restart)"""
+
+    def __init__(self):
+        self._data: Dict[str, Any] = {}
+
+    def get(self, key: str, default: Any = None) -> Any:
+        return self._data.get(key, default)
+
+    def set(self, key: str, value: Any) -> None:
+        self._data[key] = value
+
+    def delete(self, key: str) -> None:
+        self._data.pop(key, None)
+
+    def exists(self, key: str) -> bool:
+        return key in self._data
+
+    def clear(self) -> None:
+        self._data.clear()
+
+    def all(self) -> Dict[str, Any]:
+        return self._data.copy()

styledbots/styles/__init__.py

@@ -0,0 +1,3 @@
+from .style import Style
+from .formatter import format_text, escape_html
+from .templates import Templates

styledbots/styles/formatter.py

@@ -0,0 +1,40 @@
+import html
+from typing import Optional
+
+
+def escape_html(text: str) -> str:
+    """Escape special HTML characters"""
+    return html.escape(str(text))
+
+
+def format_text(
+    text: str,
+    bold: bool = False,
+    italic: bool = False,
+    underline: bool = False,
+    strike: bool = False,
+    code: bool = False,
+    spoiler: bool = False,
+    link: Optional[str] = None
+) -> str:
+    """
+    Quickly format a text with multiple styles
+    """
+    result = escape_html(text)
+
+    if code:
+        result = f"<code>{result}</code>"
+    if bold:
+        result = f"<b>{result}</b>"
+    if italic:
+        result = f"<i>{result}</i>"
+    if underline:
+        result = f"<u>{result}</u>"
+    if strike:
+        result = f"<s>{result}</s>"
+    if spoiler:
+        result = f"<tg-spoiler>{result}</tg-spoiler>"
+    if link:
+        result = f'<a href="{link}">{result}</a>'
+
+    return result

styledbots/styles/style.py

@@ -0,0 +1,57 @@
+class Style:
+    """
+    Beautiful message styling helpers.
+    Use with parse_mode="HTML" (default in StyledBots)
+    """
+
+    @staticmethod
+    def bold(text: str) -> str:
+        return f"<b>{text}</b>"
+
+    @staticmethod
+    def italic(text: str) -> str:
+        return f"<i>{text}</i>"
+
+    @staticmethod
+    def underline(text: str) -> str:
+        return f"<u>{text}</u>"
+
+    @staticmethod
+    def strike(text: str) -> str:
+        return f"<s>{text}</s>"
+
+    @staticmethod
+    def code(text: str) -> str:
+        return f"<code>{text}</code>"
+
+    @staticmethod
+    def pre(text: str, language: str = "") -> str:
+        if language:
+            return f'<pre><code class="language-{language}">{text}</code></pre>'
+        return f"<pre>{text}</pre>"
+
+    @staticmethod
+    def spoiler(text: str) -> str:
+        return f"<tg-spoiler>{text}</tg-spoiler>"
+
+    @staticmethod
+    def link(text: str, url: str) -> str:
+        return f'<a href="{url}">{text}</a>'
+
+    @staticmethod
+    def mention(user_id: int, name: str) -> str:
+        return f'<a href="tg://user?id={user_id}">{name}</a>'
+
+    @staticmethod
+    def quote(text: str) -> str:
+        return f"<blockquote>{text}</blockquote>"
+
+    # Shortcuts
+    b = bold
+    i = italic
+    u = underline
+    s = strike
+    c = code
+    p = pre
+    sp = spoiler
+    a = link

styledbots/styles/templates.py

@@ -0,0 +1,36 @@
+from .style import Style
+
+
+class Templates:
+    """Pre-made beautiful message templates"""
+
+    @staticmethod
+    def welcome(name: str) -> str:
+        return (
+            f"👋 Hello {Style.bold(name)}!\n\n"
+            f"Welcome to the bot.\n"
+            f"Use /help to see available commands."
+        )
+
+    @staticmethod
+    def error(message: str = "Something went wrong") -> str:
+        return f"❌ {Style.bold('Error')}\n\n{message}"
+
+    @staticmethod
+    def success(message: str) -> str:
+        return f"✅ {Style.bold('Success')}\n\n{message}"
+
+    @staticmethod
+    def info(title: str, body: str) -> str:
+        return f"ℹ️ {Style.bold(title)}\n\n{body}"
+
+    @staticmethod
+    def warning(message: str) -> str:
+        return f"⚠️ {Style.bold('Warning')}\n\n{message}"
+
+    @staticmethod
+    def code_block(title: str, code: str, language: str = "python") -> str:
+        return (
+            f"{Style.bold(title)}\n"
+            f"{Style.pre(code, language)}"
+        )

styledbots/utils/__init__.py

@@ -0,0 +1 @@
+from .helpers import *

styledbots/utils/helpers.py

@@ -0,0 +1,26 @@
+from typing import Optional
+
+
+def extract_args(text: str) -> list:
+    """Extract arguments from command text"""
+    if not text:
+        return []
+    parts = text.split(maxsplit=1)
+    if len(parts) < 2:
+        return []
+    return parts[1].split()
+
+
+def extract_command(text: str) -> Optional[str]:
+    """Extract command name from text"""
+    if not text or not text.startswith("/"):
+        return None
+    return text.split()[0][1:].split("@")[0].lower()
+
+
+def mention_html(user_id: int, name: str) -> str:
+    return f'<a href="tg://user?id={user_id}">{name}</a>'
+
+
+def mention_markdown(user_id: int, name: str) -> str:
+    return f"[{name}](tg://user?id={user_id})"

styledbots/version.py

@@ -0,0 +1,3 @@
+__version__ = "1.0.0"
+__author__ = "StyledBots Team"
+__description__ = "Modern Telegram Bot library - Better than Telebot"