Telegram-Py-Arang 0.0.1__py3-none-any.whl

pyrogram/__init__.py

@@ -0,0 +1,34 @@
+"""
+TelePy
+~~~~~~
+Pyrogram-style framework for Telegram bots.
+Bot-only. Backend: Telegram Bot API 8.x via aiohttp.
+Tidak ada userbot, tidak ada MTProto, tidak ada crypto.
+"""
+
+__version__ = "0.0.1"
+__license__ = "LGPL-3.0-or-later"
+__author__ = "TelePy Contributors"
+
+from .client import Client
+from .idle import idle
+from .session import Session, MemoryStorage, SQLiteStorage
+from .types import (
+    User, Chat, ChatMember, Message, CallbackQuery, InlineQuery,
+    InlineKeyboardMarkup, InlineKeyboardButton,
+    ReplyKeyboardMarkup, KeyboardButton,
+    ReplyKeyboardRemove, ForceReply, CopyTextButton,
+    LinkPreviewOptions, ReplyParameters,
+)
+from . import filters, enums, errors, handlers, types, utils
+
+__all__ = [
+    "Client", "idle", "Session", "MemoryStorage", "SQLiteStorage",
+    "filters", "enums", "errors", "handlers", "types", "utils",
+    "User", "Chat", "ChatMember", "Message",
+    "CallbackQuery", "InlineQuery",
+    "InlineKeyboardMarkup", "InlineKeyboardButton",
+    "ReplyKeyboardMarkup", "KeyboardButton",
+    "ReplyKeyboardRemove", "ForceReply", "CopyTextButton",
+    "LinkPreviewOptions", "ReplyParameters",
+]

pyrogram/__main__.py

@@ -0,0 +1,18 @@
+"""Entry point CLI: `telepy <script.py>` atau `python -m pyrogram <script.py>`."""
+
+import runpy
+import sys
+
+
+def main():
+    if len(sys.argv) < 2:
+        print("TelePy — Pyrogram bot-only fork")
+        print("Usage: telepy <module.py>")
+        print("   or: python -m pyrogram <module.py>")
+        sys.exit(0)
+
+    runpy.run_path(sys.argv[1], run_name="__main__")
+
+
+if __name__ == "__main__":
+    main()

pyrogram/client.py

@@ -0,0 +1,353 @@
+"""
+Client — pintu masuk utama TelePy.
+
+Contoh:
+    from pyrogram import Client, filters
+
+    app = Client("BOT_TOKEN")
+
+    @app.on_message(filters.text)
+    async def echo(client, message):
+        await message.reply_text(message.text)
+
+    app.run()
+"""
+
+import asyncio
+import logging
+from typing import Optional
+
+from .dispatcher import Dispatcher
+from .errors import map_error
+from .filters import filters
+from .handlers import (
+    MessageHandler,
+    CallbackQueryHandler,
+    InlineQueryHandler,
+    ChatMemberUpdatedHandler,
+    ChatJoinRequestHandler,
+    PollHandler,
+    PollAnswerHandler,
+    MessageReactionHandler,
+    RawUpdateHandler,
+)
+from .http import get_session, close_pool
+from .methods import AllMethods
+from .session import Session, MemoryStorage
+
+log = logging.getLogger(__name__)
+
+DEFAULT_API = "https://api.telegram.org/bot{token}/{method}"
+DEFAULT_FILE = "https://api.telegram.org/file/bot{token}/{path}"
+
+# Update yang diminta dari getUpdates
+ALLOWED_UPDATES = [
+    "message",
+    "edited_message",
+    "channel_post",
+    "edited_channel_post",
+    "callback_query",
+    "inline_query",
+    "chosen_inline_result",
+    "my_chat_member",
+    "chat_member",
+    "chat_join_request",
+    "poll",
+    "poll_answer",
+    "message_reaction",
+    "message_reaction_count",
+    "pre_checkout_query",
+    "shipping_query",
+    "business_connection",
+    "business_message",
+    "edited_business_message",
+    "purchased_paid_media",
+]
+
+
+class Client(AllMethods):
+    """
+    Pyrogram-style bot client. Bot-only. Multi-bot friendly.
+
+    Parameter:
+        bot_token   : Token bot dari @BotFather (wajib).
+        name        : Nama session file (default "pyrogram").
+        parse_mode  : "HTML" / "Markdown" / "MarkdownV2" / None.
+        workers     : Batas konkurensi request.
+        storage     : Objek storage (MemoryStorage default).
+        proxy       : URL proxy aiohttp (opsional).
+        flood_retry : Retry otomatis saat FloodWait (default True).
+        store_raw   : Simpan raw JSON di tipe (default False, hemat RAM).
+        api_url     : URL Bot API kustom (mis. local Bot API server).
+    """
+
+    def __init__(
+        self,
+        bot_token: str = None,
+        name: str = "pyrogram",
+        parse_mode: Optional[str] = None,
+        workers: int = 4,
+        storage=None,
+        proxy: Optional[str] = None,
+        flood_retry: bool = True,
+        store_raw: bool = False,
+        api_url: Optional[str] = None,
+    ):
+        if not bot_token:
+            raise ValueError("bot_token wajib diisi")
+
+        self.bot_token = bot_token
+        self.name = name
+        self.parse_mode = parse_mode
+        self.workers = workers
+        self.proxy = proxy
+        self.flood_retry = flood_retry
+        self.store_raw = store_raw
+
+        self.api_url = api_url or DEFAULT_API
+        self.file_url = DEFAULT_FILE
+
+        self.session = Session(name)
+        self.storage = storage or MemoryStorage()
+        self.dispatcher = Dispatcher(self)
+
+        self._offset = self.session.get("offset", 0)
+        self._running = False
+        self._poll_task = None
+        self._sem = asyncio.Semaphore(workers)
+        self._http = None
+        self.me = None
+
+    # =================== Decorators ===================
+    def on_message(self, filter=None, group: int = 0):
+        f = filter or filters.all
+
+        def deco(func):
+            self.dispatcher.add_handler(
+                MessageHandler(func, f, group, edited=False)
+            )
+            return func
+        return deco
+
+    def on_edited_message(self, filter=None, group: int = 0):
+        f = filter or filters.all
+
+        def deco(func):
+            self.dispatcher.add_handler(
+                MessageHandler(func, f, group, edited=True)
+            )
+            return func
+        return deco
+
+    def on_channel_post(self, filter=None, group: int = 0):
+        f = filter or filters.all
+
+        def deco(func):
+            self.dispatcher.add_handler(
+                MessageHandler(func, f, group, edited=False)
+            )
+            return func
+        return deco
+
+    def on_edited_channel_post(self, filter=None, group: int = 0):
+        f = filter or filters.all
+
+        def deco(func):
+            self.dispatcher.add_handler(
+                MessageHandler(func, f, group, edited=True)
+            )
+            return func
+        return deco
+
+    def on_callback_query(self, filter=None, group: int = 0):
+        f = filter or filters.all
+
+        def deco(func):
+            self.dispatcher.add_handler(CallbackQueryHandler(func, f, group))
+            return func
+        return deco
+
+    def on_inline_query(self, filter=None, group: int = 0):
+        f = filter or filters.all
+
+        def deco(func):
+            self.dispatcher.add_handler(InlineQueryHandler(func, f, group))
+            return func
+        return deco
+
+    def on_chat_member_updated(self, filter=None, group: int = 0):
+        f = filter or filters.all
+
+        def deco(func):
+            self.dispatcher.add_handler(ChatMemberUpdatedHandler(func, f, group))
+            return func
+        return deco
+
+    def on_chat_join_request(self, filter=None, group: int = 0):
+        f = filter or filters.all
+
+        def deco(func):
+            self.dispatcher.add_handler(ChatJoinRequestHandler(func, f, group))
+            return func
+        return deco
+
+    def on_poll(self, filter=None, group: int = 0):
+        f = filter or filters.all
+
+        def deco(func):
+            self.dispatcher.add_handler(PollHandler(func, f, group))
+            return func
+        return deco
+
+    def on_poll_answer(self, filter=None, group: int = 0):
+        f = filter or filters.all
+
+        def deco(func):
+            self.dispatcher.add_handler(PollAnswerHandler(func, f, group))
+            return func
+        return deco
+
+    def on_message_reaction(self, filter=None, group: int = 0):
+        f = filter or filters.all
+
+        def deco(func):
+            self.dispatcher.add_handler(MessageReactionHandler(func, f, group))
+            return func
+        return deco
+
+    def on_raw_update(self, group: int = 0):
+        def deco(func):
+            self.dispatcher.add_handler(RawUpdateHandler(func, filters.all, group))
+            return func
+        return deco
+
+    # =================== Middleware ===================
+    def add_middleware(self, middleware, group: int = 0):
+        self.dispatcher.add_middleware(middleware, group)
+
+    # =================== HTTP ===================
+    async def _ensure_http(self):
+        if self._http is None:
+            self._http = await get_session()
+        return self._http
+
+    async def _request(self, method: str, **params):
+        sess = await self._ensure_http()
+        url = self.api_url.format(token=self.bot_token, method=method)
+        payload = {k: v for k, v in params.items() if v is not None}
+
+        for attempt in range(2):
+            async with self._sem:
+                async with sess.post(url, json=payload, proxy=self.proxy) as resp:
+                    data = await resp.json(content_type=None)
+
+            if data.get("ok"):
+                return data["result"]
+
+            err = map_error(
+                data.get("error_code", 400),
+                data.get("description", "unknown error"),
+            )
+
+            if (
+                self.flood_retry
+                and getattr(err, "seconds", None)
+                and attempt == 0
+            ):
+                log.warning(
+                    "FloodWait %ss — retry %s", err.seconds, method
+                )
+                await asyncio.sleep(err.seconds + 1)
+                continue
+
+            raise err
+
+        raise RuntimeError(f"Request {method} gagal setelah retry")
+
+    # =================== Polling ===================
+    async def _polling_loop(self):
+        while self._running:
+            try:
+                updates = await self._request(
+                    "getUpdates",
+                    offset=self._offset,
+                    timeout=30,
+                    allowed_updates=ALLOWED_UPDATES,
+                )
+
+                for u in updates:
+                    self._offset = u["update_id"] + 1
+                    self.session.set("offset", self._offset)
+                    await self.dispatcher.feed(u)
+
+            except asyncio.CancelledError:
+                break
+            except Exception as e:
+                log.exception("Polling error: %s", e)
+                await asyncio.sleep(3)
+
+    # =================== Lifecycle ===================
+    async def start(self):
+        """Mulai bot: login, ambil info, jalankan polling."""
+        if self._running:
+            return
+
+        await self._ensure_http()
+        self.me = await self.get_me()
+        log.info("Bot started: @%s (id=%s)",
+                 self.me.get("username"), self.me.get("id"))
+
+        self._running = True
+        self._poll_task = asyncio.create_task(self._polling_loop())
+
+    async def stop(self):
+        """Hentikan bot."""
+        self._running = False
+
+        if self._poll_task:
+            self._poll_task.cancel()
+            try:
+                await self._poll_task
+            except asyncio.CancelledError:
+                pass
+            self._poll_task = None
+
+        log.info("Bot stopped")
+
+    async def idle(self):
+        from .idle import idle as _idle
+        try:
+            await _idle()
+        finally:
+            await self.stop()
+
+    def run(self):
+        """
+        Blocking entry point — mirip pyrogram.Client.run().
+
+        Menjalankan start(), menahan sampai Ctrl+C, lalu stop().
+        """
+        async def _main():
+            await self.start()
+            try:
+                await self.idle()
+            except KeyboardInterrupt:
+                await self.stop()
+
+        try:
+            asyncio.run(_main())
+        finally:
+            # Tutup pool aiohttp global (kalau tidak ada client lain)
+            try:
+                loop = asyncio.new_event_loop()
+                loop.run_until_complete(close_pool())
+                loop.close()
+            except Exception:
+                pass
+
+    async def __aenter__(self):
+        await self.start()
+        return self
+
+    async def __aexit__(self, *exc):
+        await self.stop()

pyrogram/dispatcher.py

@@ -0,0 +1,63 @@
+"""
+Dispatcher: menerima update dari polling/webhook dan menyalurkannya
+ke handler sesuai urutan `group`.
+
+Middleware bisa disisipkan dengan `add_middleware(mw, group=...)`.
+Middleware berjalan sebelum handler, bisa memanggil `await next()` untuk
+melanjutkan, atau tidak memanggilnya untuk menggugurkan update.
+"""
+
+import asyncio
+import logging
+
+from .errors import RPCError
+
+log = logging.getLogger(__name__)
+
+
+class Dispatcher:
+    def __init__(self, client):
+        self.client = client
+        self.handlers = []
+        self.middlewares = []
+        self._sem = asyncio.Semaphore(max(4, client.workers))
+
+    def add_handler(self, handler):
+        self.handlers.append(handler)
+        self.handlers.sort(key=lambda h: h.group)
+
+    def add_middleware(self, middleware, group=0):
+        self.middlewares.append((group, middleware))
+        self.middlewares.sort(key=lambda x: x[0])
+
+    async def feed(self, update: dict):
+        """Terima update — dispatch di task terpisah, dibatasi semaphore."""
+        async with self._sem:
+            asyncio.create_task(self._dispatch(update))
+
+    async def _dispatch(self, update: dict):
+        async def terminal():
+            for handler in self.handlers:
+                try:
+                    if await handler.check(self.client, update):
+                        await handler.handle(self.client, update)
+                except RPCError as e:
+                    log.warning("RPC error di handler %r: %s", handler, e)
+                except Exception:
+                    log.exception("Handler error di %r", handler)
+
+        async def run_chain(i=0):
+            if i >= len(self.middlewares):
+                await terminal()
+                return
+            _, mw = self.middlewares[i]
+
+            async def nxt():
+                await run_chain(i + 1)
+
+            try:
+                await mw(self.client, update, nxt)
+            except Exception:
+                log.exception("Middleware error di %r", mw)
+
+        await run_chain()

pyrogram/enums/__init__.py

@@ -0,0 +1,18 @@
+from .chat_action import ChatAction
+from .chat_member_status import ChatMemberStatus
+from .chat_type import ChatType
+from .message_entity_type import MessageEntityType
+from .message_service_type import MessageServiceType
+from .parse_mode import ParseMode
+from .update_type import UpdateType, ALLOWED_UPDATES
+
+__all__ = [
+    "ChatAction",
+    "ChatMemberStatus",
+    "ChatType",
+    "MessageEntityType",
+    "MessageServiceType",
+    "ParseMode",
+    "UpdateType",
+    "ALLOWED_UPDATES",
+]

pyrogram/enums/chat_action.py

@@ -0,0 +1,15 @@
+from enum import Enum
+
+
+class ChatAction(str, Enum):
+    TYPING = "typing"
+    UPLOAD_PHOTO = "upload_photo"
+    RECORD_VIDEO = "record_video"
+    UPLOAD_VIDEO = "upload_video"
+    RECORD_VOICE = "record_voice"
+    UPLOAD_VOICE = "upload_voice"
+    UPLOAD_DOCUMENT = "upload_document"
+    CHOOSE_STICKER = "choose_sticker"
+    FIND_LOCATION = "find_location"
+    RECORD_VIDEO_NOTE = "record_video_note"
+    UPLOAD_VIDEO_NOTE = "upload_video_note"

pyrogram/enums/chat_member_status.py

@@ -0,0 +1,10 @@
+from enum import Enum
+
+
+class ChatMemberStatus(str, Enum):
+    CREATOR = "creator"
+    ADMINISTRATOR = "administrator"
+    MEMBER = "member"
+    RESTRICTED = "restricted"
+    LEFT = "left"
+    KICKED = "kicked"

pyrogram/enums/chat_type.py

@@ -0,0 +1,8 @@
+from enum import Enum
+
+
+class ChatType(str, Enum):
+    PRIVATE = "private"
+    GROUP = "group"
+    SUPERGROUP = "supergroup"
+    CHANNEL = "channel"

pyrogram/enums/message_entity_type.py

@@ -0,0 +1,23 @@
+from enum import Enum
+
+
+class MessageEntityType(str, Enum):
+    MENTION = "mention"
+    HASHTAG = "hashtag"
+    CASHTAG = "cashtag"
+    BOT_COMMAND = "bot_command"
+    URL = "url"
+    EMAIL = "email"
+    PHONE_NUMBER = "phone_number"
+    BOLD = "bold"
+    ITALIC = "italic"
+    UNDERLINE = "underline"
+    STRIKETHROUGH = "strikethrough"
+    SPOILER = "spoiler"
+    BLOCKQUOTE = "blockquote"
+    EXPANDABLE_BLOCKQUOTE = "expandable_blockquote"
+    CODE = "code"
+    PRE = "pre"
+    TEXT_LINK = "text_link"
+    TEXT_MENTION = "text_mention"
+    CUSTOM_EMOJI = "custom_emoji"

pyrogram/enums/message_service_type.py

@@ -0,0 +1,35 @@
+from enum import Enum
+
+
+class MessageServiceType(str, Enum):
+    NEW_CHAT_MEMBERS = "new_chat_members"
+    LEFT_CHAT_MEMBER = "left_chat_member"
+    NEW_CHAT_TITLE = "new_chat_title"
+    NEW_CHAT_PHOTO = "new_chat_photo"
+    DELETE_CHAT_PHOTO = "delete_chat_photo"
+    GROUP_CHAT_CREATED = "group_chat_created"
+    SUPERGROUP_CHAT_CREATED = "supergroup_chat_created"
+    CHANNEL_CHAT_CREATED = "channel_chat_created"
+    MESSAGE_AUTO_DELETE_TIMER_CHANGED = "message_auto_delete_timer_changed"
+    MIGRATE_TO_CHAT_ID = "migrate_to_chat_id"
+    MIGRATE_FROM_CHAT_ID = "migrate_from_chat_id"
+    PINNED_MESSAGE = "pinned_message"
+    FORUM_TOPIC_CREATED = "forum_topic_created"
+    FORUM_TOPIC_EDITED = "forum_topic_edited"
+    FORUM_TOPIC_CLOSED = "forum_topic_closed"
+    FORUM_TOPIC_REOPENED = "forum_topic_reopened"
+    GENERAL_FORUM_TOPIC_HIDDEN = "general_forum_topic_hidden"
+    GENERAL_FORUM_TOPIC_UNHIDDEN = "general_forum_topic_unhidden"
+    VIDEO_CHAT_SCHEDULED = "video_chat_scheduled"
+    VIDEO_CHAT_STARTED = "video_chat_started"
+    VIDEO_CHAT_ENDED = "video_chat_ended"
+    VIDEO_CHAT_PARTICIPANTS_INVITED = "video_chat_participants_invited"
+    WEB_APP_DATA = "web_app_data"
+    BOOST_ADDED = "boost_added"
+    CHAT_BACKGROUND_SET = "chat_background_set"
+    WRITE_ACCESS_ALLOWED = "write_access_allowed"
+    PROXIMITY_ALERT_TRIGGERED = "proximity_alert_triggered"
+    GIVEAWAY_CREATED = "giveaway_created"
+    GIVEAWAY_COMPLETED = "giveaway_completed"
+    GIVEAWAY_WINNERS = "giveaway_winners"
+    CHECKLIST = "checklist"

pyrogram/enums/parse_mode.py

@@ -0,0 +1,7 @@
+from enum import Enum
+
+
+class ParseMode(str, Enum):
+    HTML = "HTML"
+    MARKDOWN = "Markdown"
+    MARKDOWN_V2 = "MarkdownV2"

pyrogram/enums/update_type.py

@@ -0,0 +1,30 @@
+from enum import Enum
+
+
+class UpdateType(str, Enum):
+    MESSAGE = "message"
+    EDITED_MESSAGE = "edited_message"
+    CHANNEL_POST = "channel_post"
+    EDITED_CHANNEL_POST = "edited_channel_post"
+    BUSINESS_CONNECTION = "business_connection"
+    BUSINESS_MESSAGE = "business_message"
+    EDITED_BUSINESS_MESSAGE = "edited_business_message"
+    DELETED_BUSINESS_MESSAGES = "deleted_business_messages"
+    MESSAGE_REACTION = "message_reaction"
+    MESSAGE_REACTION_COUNT = "message_reaction_count"
+    INLINE_QUERY = "inline_query"
+    CHOSEN_INLINE_RESULT = "chosen_inline_result"
+    CALLBACK_QUERY = "callback_query"
+    SHIPPING_QUERY = "shipping_query"
+    PRE_CHECKOUT_QUERY = "pre_checkout_query"
+    PURCHASED_PAID_MEDIA = "purchased_paid_media"
+    POLL = "poll"
+    POLL_ANSWER = "poll_answer"
+    MY_CHAT_MEMBER = "my_chat_member"
+    CHAT_MEMBER = "chat_member"
+    CHAT_JOIN_REQUEST = "chat_join_request"
+    CHAT_BOOST = "chat_boost"
+    REMOVED_CHAT_BOOST = "removed_chat_boost"
+
+
+ALLOWED_UPDATES = [u.value for u in UpdateType]

pyrogram/errors/__init__.py

@@ -0,0 +1,25 @@
+from .rpc_error import RPCError
+from .bad_request import BadRequest
+from .unauthorized import Unauthorized
+from .forbidden import Forbidden
+from .not_found import NotFound
+from .conflict import Conflict
+from .internal_server_error import InternalServerError
+from .service_unavailable import ServiceUnavailable
+from .flood_wait import FloodWait
+from .message_not_modified import MessageNotModified
+from .map_error import map_error
+
+__all__ = [
+    "RPCError",
+    "BadRequest",
+    "Unauthorized",
+    "Forbidden",
+    "NotFound",
+    "Conflict",
+    "InternalServerError",
+    "ServiceUnavailable",
+    "FloodWait",
+    "MessageNotModified",
+    "map_error",
+]

pyrogram/errors/bad_request.py

@@ -0,0 +1,5 @@
+from .rpc_error import RPCError
+
+
+class BadRequest(RPCError):
+    """HTTP 400 — request tidak valid."""

pyrogram/errors/conflict.py

@@ -0,0 +1,5 @@
+from .rpc_error import RPCError
+
+
+class Conflict(RPCError):
+    """HTTP 409 — konflik, mis. dua instance polling memakai token sama."""

pyrogram/errors/flood_wait.py

@@ -0,0 +1,12 @@
+from .rpc_error import RPCError
+
+
+class FloodWait(RPCError):
+    """
+    Bot harus menunggu `seconds` detik sebelum request berikutnya.
+    Dilempar saat Telegram mengembalikan 429 dengan "retry after".
+    """
+
+    def __init__(self, seconds, description=None):
+        super().__init__(f"Flood wait: {seconds}s", code=429, description=description)
+        self.seconds = seconds

pyrogram/errors/forbidden.py

@@ -0,0 +1,5 @@
+from .rpc_error import RPCError
+
+
+class Forbidden(RPCError):
+    """HTTP 403 — bot tidak punya izin untuk aksi ini."""