zafather 0.4.1__py3-none-any.whl

zafather/__init__.py

@@ -0,0 +1,145 @@
+"""
+Zafather — Telegram botlar uchun yengil async framework.
+
+Bot API **10.2** (14-iyul, 2026) imkoniyatlarini qo'llab-quvvatlaydi:
+rangli tugmalar, premium emoji, bot yaratadigan botlar, ephemeral xabarlar,
+guest mode, reaksiyalar, obunalar va boshqalar.
+
+    from zafather import Zafather, Message, InlineKeyboard, emoji, F
+
+    bot = Zafather("TOKEN")
+
+    @bot.command("start")
+    async def start(m: Message):
+        kb = InlineKeyboard().success("✅ Ha", "yes").danger("❌ Yo'q", "no")
+        await m.answer(f"{emoji('5368324170671202286', '🔥')} Salom!", reply_markup=kb)
+
+    bot.run()
+"""
+
+from .app import Zafather
+from .bot import Bot, InputFile, NetworkError, TelegramError
+from .enums import (
+    BOT_API_VERSION,
+    ButtonStyle,
+    ChatAction,
+    ChatTypeEnum,
+    ContentType as ContentTypes,
+    Currency,
+    DiceEmoji,
+    ParseMode,
+    PollType,
+    UpdateType,
+)
+from .filters import (
+    ChatType,
+    Command,
+    ContentType,
+    Ephemeral,
+    Filter,
+    HasCustomEmoji,
+    IsGroup,
+    IsPrivate,
+    Premium,
+    Regex,
+    Service,
+    StateFilter,
+    Text,
+    UserFilter,
+)
+from .fsm import BaseStorage, FSMContext, JSONStorage, MemoryStorage, State, StatesGroup
+from .keyboards import (
+    ForceReply,
+    InlineKeyboard,
+    RemoveKeyboard,
+    ReplyKeyboard,
+    confirm_keyboard,
+)
+from .magic import F
+from .managed import BotFarm, ManagedBots
+from .rich import RichMessage, RichStream, markdown_rich
+from .router import Router, SkipHandler
+from .text import (
+    SafeHTML,
+    TextBuilder,
+    bold,
+    code,
+    emoji,
+    escape,
+    italic,
+    link,
+    mention,
+    pre,
+    quote,
+    spoiler,
+    strike,
+    strip_custom_emoji,
+    underline,
+)
+from .webapp import (
+    MiniApp,
+    WebAppAuthError,
+    WebAppData,
+    WebAppInitData,
+    attach_link,
+    direct_link,
+    is_valid,
+    main_app_link,
+    parse_init_data,
+    validate,
+    validate_third_party,
+)
+from .webserver import MiniAppServer
+from .types import (
+    BotSubscriptionUpdated,
+    BusinessConnection,
+    CallbackQuery,
+    Chat,
+    ChatBoostUpdated,
+    InlineQuery,
+    ManagedBotUpdated,
+    Message,
+    MessageReactionUpdated,
+    TelegramObject,
+    Update,
+    User,
+)
+
+__version__ = "0.4.1"
+__bot_api__ = BOT_API_VERSION
+__author__ = "ismoilov299"
+__license__ = "MIT"
+
+__all__ = [
+    # asosiy
+    "Zafather", "Bot", "Router", "SkipHandler", "F",
+    # tiplar
+    "Message", "CallbackQuery", "InlineQuery", "User", "Chat", "Update",
+    "TelegramObject", "ManagedBotUpdated", "BusinessConnection",
+    "MessageReactionUpdated", "ChatBoostUpdated", "BotSubscriptionUpdated",
+    # filtrlar
+    "Filter", "Command", "Text", "Regex", "ChatType", "ContentType", "UserFilter",
+    "StateFilter", "Service", "Ephemeral", "Premium", "HasCustomEmoji",
+    "IsPrivate", "IsGroup",
+    # FSM
+    "State", "StatesGroup", "FSMContext", "MemoryStorage", "JSONStorage", "BaseStorage",
+    # klaviaturalar
+    "InlineKeyboard", "ReplyKeyboard", "RemoveKeyboard", "ForceReply", "confirm_keyboard",
+    # matn va premium emoji
+    "emoji", "bold", "italic", "underline", "strike", "spoiler", "code", "pre",
+    "link", "mention", "quote", "escape", "TextBuilder", "strip_custom_emoji", "SafeHTML",
+    # managed bots
+    "ManagedBots", "BotFarm",
+    # rich messages
+    "RichMessage", "RichStream", "markdown_rich",
+    # Mini App
+    "validate", "validate_third_party", "is_valid", "parse_init_data",
+    "WebAppInitData", "WebAppAuthError", "WebAppData", "MiniApp", "MiniAppServer",
+    "direct_link", "main_app_link", "attach_link",
+    # konstantalar
+    "ButtonStyle", "UpdateType", "ContentTypes", "ChatAction", "ParseMode",
+    "ChatTypeEnum", "Currency", "DiceEmoji", "PollType", "BOT_API_VERSION",
+    # boshqa
+    "InputFile", "TelegramError", "NetworkError",
+    "__version__", "__bot_api__",
+]

zafather/__main__.py

@@ -0,0 +1,76 @@
+"""Zafather CLI.
+
+    python -m zafather new mybot     # yangi loyiha yaratadi
+    python -m zafather version
+"""
+import os
+import sys
+
+from . import __version__
+
+TEMPLATE = '''"""{name} — Zafather bilan yozilgan bot."""
+import os
+
+from zafather import F, Message, Zafather
+
+TOKEN = os.getenv("BOT_TOKEN", "TOKENNI_SHU_YERGA")
+
+bot = Zafather(TOKEN, parse_mode="HTML")
+
+
+@bot.command("start")
+async def start(m: Message):
+    await m.answer(f"Salom, <b>{{m.from_user.first_name}}</b>!")
+
+
+@bot.message(F.text)
+async def echo(m: Message):
+    await m.answer(m.text)
+
+
+if __name__ == "__main__":
+    bot.run()
+'''
+
+ENV = "BOT_TOKEN=bu_yerga_tokenni_yozing\n"
+
+REQS = "zafather\n"
+
+
+def create(name: str) -> None:
+    if os.path.exists(name):
+        print(f"Xato: '{name}' papkasi allaqachon mavjud.")
+        sys.exit(1)
+    os.makedirs(name)
+    with open(os.path.join(name, "bot.py"), "w", encoding="utf-8") as f:
+        f.write(TEMPLATE.format(name=name))
+    with open(os.path.join(name, ".env"), "w", encoding="utf-8") as f:
+        f.write(ENV)
+    with open(os.path.join(name, "requirements.txt"), "w", encoding="utf-8") as f:
+        f.write(REQS)
+    print(f"✅ '{name}' loyihasi yaratildi.\n")
+    print(f"  cd {name}")
+    print("  # .env faylga tokenni yozing")
+    print("  python bot.py")
+
+
+def main(argv=None) -> None:
+    argv = argv if argv is not None else sys.argv[1:]
+    if not argv or argv[0] in ("-h", "--help", "help"):
+        print(__doc__)
+        return
+    cmd = argv[0]
+    if cmd in ("version", "-v", "--version"):
+        print(f"Zafather {__version__}")
+    elif cmd == "new":
+        if len(argv) < 2:
+            print("Foydalanish: python -m zafather new <loyiha_nomi>")
+            sys.exit(1)
+        create(argv[1])
+    else:
+        print(f"Noma'lum buyruq: {cmd}")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

zafather/app.py

@@ -0,0 +1,284 @@
+"""Zafather — asosiy ilova sinfi (dispatcher + polling)."""
+from __future__ import annotations
+
+import asyncio
+import logging
+import signal
+from typing import Any, Callable, List, Optional, Set
+
+from .bot import Bot, NetworkError, TelegramError
+from .enums import UpdateType
+from .fsm import BaseStorage, FSMContext, MemoryStorage
+from .router import Router
+from .types import Update
+
+log = logging.getLogger("zafather")
+
+BANNER = r"""
+ ______        __        _   _
+|__  / __ _  / _| __ _ | |_| |__   ___ _ __
+  / / / _` || |_ / _` || __| '_ \ / _ \ '__|
+ / /_| (_| ||  _| (_| || |_| | | |  __/ |
+/____|\__,_||_|  \__,_| \__|_| |_|\___|_|
+"""
+
+
+class Zafather(Router):
+    """Botni yaratish va ishga tushirish uchun asosiy sinf.
+
+        bot = Zafather("TOKEN")
+
+        @bot.command("start")
+        async def start(m: Message):
+            await m.answer("Salom!")
+
+        bot.run()
+    """
+
+    def __init__(
+        self,
+        token: str,
+        parse_mode: Optional[str] = "HTML",
+        storage: Optional[BaseStorage] = None,
+        api_url: str = "https://api.telegram.org",
+        polling_timeout: int = 30,
+        concurrent: bool = True,
+        name: str = "zafather",
+    ) -> None:
+        super().__init__(name=name)
+        self.bot = Bot(token, parse_mode=parse_mode, api_url=api_url, timeout=polling_timeout)
+        self.storage: BaseStorage = storage or MemoryStorage()
+        self.polling_timeout = polling_timeout
+        self.concurrent = concurrent
+        self.data: dict = {}  # global kontekst (DB, config va h.k.)
+        self._offset: Optional[int] = None
+        self._running = False
+        self._tasks: Set[asyncio.Task] = set()
+        self._mini_app = None
+        self._startup: List[Callable] = []
+        self._shutdown: List[Callable] = []
+
+    # --- hooks ----------------------------------------------------------------
+    def on_startup(self, func: Callable) -> Callable:
+        self._startup.append(func)
+        return func
+
+    def on_shutdown(self, func: Callable) -> Callable:
+        self._shutdown.append(func)
+        return func
+
+    # --- update'ni qayta ishlash ---------------------------------------------
+    def _make_context(self, event, event_type: str) -> dict:
+        chat = getattr(event, "chat", None)
+        if chat is None:
+            message = getattr(event, "message", None)
+            chat = getattr(message, "chat", None) if message else None
+        user = getattr(event, "from_user", None)
+        chat_id = chat.id if chat else (user.id if user else 0)
+        user_id = user.id if user else chat_id
+        return {"key": (chat_id, user_id), "chat_id": chat_id, "user_id": user_id}
+
+    async def feed_update(self, update: Update) -> bool:
+        """Bitta update'ni handlerlarga uzatadi."""
+        event_type = update.event_type
+        event = update.event
+        if event_type is None or event is None:
+            log.debug("Qo'llab-quvvatlanmaydigan update: %s", update.raw.keys())
+            return False
+
+        ctx = self._make_context(event, event_type)
+        state = FSMContext(self.storage, ctx["key"])
+        data = {
+            **self.data,
+            "bot": self.bot,
+            "app": self,
+            "update": update,
+            "event_type": event_type,
+            "state": state,
+            "raw_state": await state.get_state(),
+            "chat_id": ctx["chat_id"],
+            "user_id": ctx["user_id"],
+        }
+        try:
+            return await self.trigger(event_type, event, data)
+        except asyncio.CancelledError:
+            raise
+        except Exception as exc:  # noqa: BLE001
+            handled = await self.handle_error(event, exc, data)
+            if not handled:
+                log.exception("Handler xatosi (%s): %s", event_type, exc)
+            return False
+
+    async def _spawn(self, update: Update) -> None:
+        task = asyncio.create_task(self.feed_update(update))
+        self._tasks.add(task)
+        task.add_done_callback(self._tasks.discard)
+
+    # --- polling --------------------------------------------------------------
+    async def start_polling(
+        self,
+        skip_updates: bool = True,
+        allowed_updates: Optional[List[str]] = None,
+        banner: bool = False,
+    ) -> None:
+        """Long polling. `allowed_updates=None` — barcha update turlari so'raladi.
+
+        Bu muhim: `managed_bot`, `guest_message`, `message_reaction`,
+        `subscription` kabi yangi turlar aniq so'ralmasa Telegram ularni
+        yubormaydi.
+        """
+        self._running = True
+        if allowed_updates is None:
+            allowed_updates = list(UpdateType.ALL)
+        me = await self.bot.me()
+        log.info("Ishga tushdi: @%s (id=%s)", me.username, me.id)
+
+        for hook in self._startup:
+            await self._maybe_await(hook)
+
+        if skip_updates:
+            pending = await self.bot.call("getUpdates", offset=-1, timeout=0)
+            if pending:
+                self._offset = pending[-1]["update_id"] + 1
+
+        try:
+            while self._running:
+                try:
+                    raw_updates = await self.bot.call(
+                        "getUpdates",
+                        offset=self._offset,
+                        timeout=self.polling_timeout,
+                        allowed_updates=allowed_updates,
+                    )
+                except asyncio.CancelledError:
+                    raise
+                except (NetworkError, TelegramError) as exc:
+                    log.warning("getUpdates xatosi: %s — 3s dan keyin qayta urinish", exc)
+                    await asyncio.sleep(3)
+                    continue
+
+                for raw in raw_updates or []:
+                    self._offset = raw["update_id"] + 1
+                    update = Update(raw, self.bot)
+                    if self.concurrent:
+                        await self._spawn(update)
+                    else:
+                        await self.feed_update(update)
+        finally:
+            await self._cleanup()
+
+    async def _cleanup(self) -> None:
+        self._running = False
+        if self._tasks:
+            await asyncio.gather(*list(self._tasks), return_exceptions=True)
+        for hook in self._shutdown:
+            try:
+                await self._maybe_await(hook)
+            except Exception:  # noqa: BLE001
+                log.exception("on_shutdown xatosi")
+        await self.storage.close()
+        await self.bot.close()
+        log.info("To'xtatildi.")
+
+    async def stop(self) -> None:
+        self._running = False
+
+    @staticmethod
+    async def _maybe_await(func: Callable) -> Any:
+        result = func() if callable(func) else func
+        if asyncio.iscoroutine(result) or asyncio.isfuture(result):
+            return await result
+        return result
+
+    # --- managed bots ---------------------------------------------------------
+    def spawn(self, token: str, **kwargs) -> "Zafather":
+        """Yangi (yaratilgan) bot uchun nusxa qaytaradi — handlerlar meros bo'ladi.
+
+            token = await ManagedBots(bot.bot).token(bot_id)
+            child = bot.spawn(token)
+            await child.start_polling()
+        """
+        child = Zafather(
+            token,
+            parse_mode=kwargs.pop("parse_mode", self.bot.parse_mode),
+            storage=kwargs.pop("storage", self.storage),
+            api_url=kwargs.pop("api_url", self.bot.api_url),
+            name=kwargs.pop("name", f"child:{token.split(':')[0]}"),
+            **kwargs,
+        )
+        child.sub_routers.append(self)   # ota-bot handlerlaridan foydalanadi
+        child.data.update(self.data)
+        child.data["parent"] = self
+        return child
+
+    def farm(self, router=None, **kwargs):
+        """Ko'p bolalar botni yuritish uchun `BotFarm` yaratadi."""
+        from .managed import BotFarm
+
+        return BotFarm(router or self, storage=self.storage, **kwargs)
+
+    # --- Mini App -------------------------------------------------------------
+    @property
+    def mini_app(self):
+        """Mini App metodlari: menyu tugmasi, answerWebAppQuery va h.k."""
+        from .webapp import MiniApp
+
+        if self._mini_app is None:
+            self._mini_app = MiniApp(self.bot)
+        return self._mini_app
+
+    def serve_mini_app(self, static_dir: str = None, **kwargs):
+        """Mini App uchun backend server yaratadi."""
+        from .webserver import MiniAppServer
+
+        return MiniAppServer(self, static_dir=static_dir, **kwargs)
+
+    def validate_init_data(self, init_data: str, max_age: int = 3600):
+        """Mini App'dan kelgan `initData` ni shu botning tokeni bilan tekshiradi."""
+        from .webapp import validate
+
+        return validate(init_data, self.bot.token, max_age)
+
+    # --- webhook uchun --------------------------------------------------------
+    async def handle_webhook(self, payload: dict) -> bool:
+        """Webhook'dan kelgan JSON'ni qayta ishlash (FastAPI/aiohttp bilan)."""
+        return await self.feed_update(Update(payload, self.bot))
+
+    # --- sinxron ishga tushirish ---------------------------------------------
+    def run(
+        self,
+        skip_updates: bool = True,
+        allowed_updates: Optional[List[str]] = None,
+        log_level: int = logging.INFO,
+        banner: bool = True,
+    ) -> None:
+        """Botni ishga tushiradi (Ctrl+C bilan to'xtatiladi)."""
+        logging.basicConfig(
+            level=log_level,
+            format="%(asctime)s | %(levelname)-7s | %(name)s | %(message)s",
+            datefmt="%H:%M:%S",
+        )
+        if banner:
+            print(BANNER)
+
+        async def main() -> None:
+            loop = asyncio.get_running_loop()
+            for sig in (signal.SIGINT, signal.SIGTERM):
+                try:
+                    loop.add_signal_handler(sig, lambda: asyncio.create_task(self.stop()))
+                except (NotImplementedError, AttributeError):
+                    pass  # Windows
+            await self.start_polling(
+                skip_updates=skip_updates,
+                allowed_updates=allowed_updates,
+                banner=False,
+            )
+
+        try:
+            asyncio.run(main())
+        except KeyboardInterrupt:
+            log.info("Ctrl+C — to'xtatilmoqda…")
+
+    def __repr__(self) -> str:
+        total = sum(len(v) for v in self.handlers.values())
+        return f"<Zafather handlers={total} routers={len(self.sub_routers)}>"