rubigramclient 1.7.35__py3-none-any.whl

rubigram/__init__.py

@@ -0,0 +1,19 @@
+class StopPropagation(StopAsyncIteration):
+    pass
+
+
+class ContinuePropagation(StopAsyncIteration):
+    pass
+
+
+from .rubigram import handlers, sync, types
+
+from .rubigram.storage import Storage
+from .rubigram import enums
+from .rubigram.client import Client
+from .rubigram.bot import Bot
+
+
+__version__ = "1.7.35"
+__author__ = ["PyJavad", "DeveloperYasin"]
+__github__ = "https://github.ocm/DevJavad/rubigram"

rubigram/ask.py

@@ -0,0 +1,145 @@
+# rubigram/ask.py
+
+import asyncio
+import rubigram
+from typing import Optional, Union
+
+from rubigram.filters import Filter
+from rubigram.types import Update
+
+
+class AskManager:
+    """
+    Ask manager for handling interactive conversations with users
+    Compatible with Rubigram's existing Storage and State system
+    """
+    
+    def __init__(self, client:"rubigram.Client"):
+        self.client = client
+        self._pending_asks: dict[str, asyncio.Future] = {}
+        self._pending_filters: dict[str, Optional[Filter]] = {}
+        self._default_timeout = 60
+        
+        # Register internal handler
+        self._register_handler()
+    
+    def _register_handler(self):
+        """Register internal handler to catch user responses"""
+        
+        @self.client.on_message(group=-999)  # Highest priority
+        async def _ask_response_handler(client, update: Update):
+            user_id = str(update.message.author_object_guid)
+            
+            if user_id in self._pending_asks:
+                future = self._pending_asks[user_id]
+                answer_filter = self._pending_filters.get(user_id)
+                
+                # Check if message passes the filter
+                if answer_filter is not None:
+                    if not await self._check_filter(client,answer_filter, update):
+                        return False  # Don't consume, let other handlers process
+                
+                if not future.done():
+                    future.set_result(update)
+                    del self._pending_asks[user_id]
+                    del self._pending_filters[user_id]
+                    return True  # Consumed by ask handler
+            
+            return False
+    
+    async def _check_filter(self,client, filter_obj: Filter, update: Update) -> bool:
+        """Check if update passes the filter"""
+        if callable(filter_obj):
+            result = filter_obj(client, update)
+            if asyncio.iscoroutine(result):
+                return await result
+            return result
+        return True
+    
+    async def ask(
+        self,
+        user_id: Union[str, int],
+        question: str,
+        timeout: Optional[int] = None,
+        filters: Optional[Filter] = None,
+        parse_mode: Optional[str] = None,
+        reply_to_message_id: Optional[str] = None,
+        **kwargs
+    ) -> Update:
+        """
+        Send a question to user and wait for response
+        
+        Args:
+            user_id: User's GUID or ID
+            question: Question text to send
+            timeout: Timeout in seconds (None = infinite)
+            filters: Filter for response (e.g., filters.text, filters.photo)
+            parse_mode: Parse mode for question message
+            reply_to_message_id: Reply to specific message
+            **kwargs: Additional arguments for send_message
+        
+        Returns:
+            Update object containing user's response
+        
+        Raises:
+            TimeoutError: If user doesn't respond within timeout
+        """
+        user_id = str(user_id)
+        
+        # Create future for waiting
+        future = asyncio.Future()
+        
+        # Store pending ask
+        self._pending_asks[user_id] = future
+        self._pending_filters[user_id] = filters
+        
+        # Send question
+        x = await self.client.send_message(
+            user_id,
+            question,
+            parse_mode=parse_mode,
+            reply_to_message_id=reply_to_message_id,
+            **kwargs
+        )
+        
+        # Handle timeout
+        timeout_seconds = timeout if timeout is not None else self._default_timeout
+        
+        try:
+            if timeout_seconds > 0:
+                response = await asyncio.wait_for(future, timeout=timeout_seconds)
+            else:
+                response = await future
+            return response
+        except asyncio.TimeoutError:
+            raise TimeoutError(f"No response received from user {user_id} within {timeout_seconds} seconds")
+        finally:
+            # Cleanup
+            self._pending_asks.pop(user_id, None)
+            self._pending_filters.pop(user_id, None)
+    
+    def is_waiting(self, user_id: Union[str, int]) -> bool:
+        """Check if user has a pending ask"""
+        return str(user_id) in self._pending_asks
+    
+    def cancel(self, user_id: Union[str, int]) -> bool:
+        """Cancel pending ask for a user"""
+        user_id = str(user_id)
+        if user_id in self._pending_asks:
+            self._pending_asks[user_id].cancel()
+            del self._pending_asks[user_id]
+            self._pending_filters.pop(user_id, None)
+            return True
+        return False
+
+
+# Mixin to add to Client class
+class AskMixin:
+    """Mixin to add ask functionality to Client"""
+    
+    @property
+    def ask(self) -> AskManager:
+        """Get ask manager instance"""
+        if not hasattr(self, '_ask_manager'):
+            self._ask_manager = AskManager(self)
+        return self._ask_manager

rubigram/bot/__init__.py

@@ -0,0 +1,2 @@
+from .bot import Bot
+from ...bot import errors, enums, types, filters

rubigram/bot/bot.py

@@ -0,0 +1,255 @@
+import os
+import sys
+import time
+import logging
+
+from pathlib import Path
+from importlib import import_module
+from typing import Optional, Callable
+from asyncio import AbstractEventLoop, Semaphore
+from concurrent.futures.thread import ThreadPoolExecutor as Executor
+
+from rubigram.parser import Parser
+from rubigram import utils, Storage
+from rubigram.bot.methods import Methods
+from rubigram.connection import Connection
+from rubigram.bot.dispatcher import Dispatcher
+from rubigram.server import Server
+from rubigram.bot.enums import ParseMode
+from rubigram.bot.handlers import Handler
+from rubigram.bot.web import Webhook
+from rubigram.bot.types import Bot as Me
+
+
+logger = logging.getLogger(__name__)
+
+
+class Bot(Methods):
+
+    WORKERS = min(32, (os.cpu_count() or 0) + 4)
+    PARENT_DIR = Path(sys.argv[0]).parent
+    WORKDIR = PARENT_DIR
+
+    def __init__(
+        self,
+        token: str,
+        offset_id: Optional[str] = None,
+        auto_delete: Optional[int] = None,
+        parse_mode: "ParseMode" = ParseMode.MARKDOWN,
+
+        use_webhook: bool = False,
+        webhook_url: Optional[str] = None,
+        host: str = "127.0.0.1",
+        port: int = 8080,
+        set_new_webhook: bool = True,
+
+        delay: int = 1,
+        retry: int = 3,
+        backoff: int = 1,
+        workers: int = WORKERS,
+        workdir: ... = WORKDIR,
+
+        plugins: Optional[dict] = None,
+        timeout: int = 15,
+        connect_timeout: int = 20,
+        max_connections: int = 100,
+        socket_read_timeout: int = 20,
+
+        proxy: Optional[str] = None,
+        semaphore: Optional[Semaphore] = None,
+        loop: Optional[AbstractEventLoop] = None
+    ):
+        self.token = token
+        self.offset_id = offset_id or f"{int(time.time()):08x}{'0'*16}"
+        self.parse_mode = parse_mode
+        self.auto_delete = auto_delete
+
+        self.use_webhook = use_webhook
+        self.webhook_url = webhook_url
+        self.host = host
+        self.port = port
+
+        self.delay = delay
+        self.retry = retry
+        self.backoff = backoff
+        self.workers = workers
+        self.plugins = plugins
+
+        self.timeout = timeout
+        self.connect_timeout = connect_timeout
+        self.max_connections = max_connections
+        self.socket_read_timeout = socket_read_timeout
+
+        self.proxy = proxy
+
+        self.semaphore = semaphore or Semaphore(workers)
+        self.executor = Executor(workers, thread_name_prefix="Handler")
+
+        if isinstance(loop, AbstractEventLoop):
+            self.loop = loop
+        else:
+            loop = utils.get_event_loop()
+
+        self.me: Optional["Me"] = None
+
+        self.stop_handler: Optional[Callable] = None
+        self.start_handler: Optional[Callable] = None
+
+        self.storage = Storage()
+        self.parser = Parser(parse_mode)
+
+        self.connection = Connection(
+            timeout,
+            connect_timeout,
+            max_connections,
+            socket_read_timeout
+        )
+
+        self.server = Server(self.connection, retry, delay, backoff, proxy)
+        self.set_new_webhook = set_new_webhook
+
+        self.dispatcher = Dispatcher(self)
+        if use_webhook:
+            self.webhook = Webhook(self)
+        else:
+            self.webhook = None
+
+        self.API_URL: str = "https://botapi.rubika.ir/v3/{}/".format(token)
+
+    def __enter__(self):
+        return self.start()
+
+    def __exit__(self, *args):
+        try:
+            return self.stop()
+        except ConnectionError:
+            pass
+
+    async def __aenter__(self):
+        await self.start()
+        return self
+
+    async def __aexit__(self, *args):
+        try:
+            await self.stop()
+        except ConnectionError:
+            pass
+
+    def load_plugins(self):
+        if self.plugins:
+            plugins = self.plugins.copy()
+
+            for option in ["include", "exclude"]:
+                if plugins.get(option, []):
+                    plugins[option] = [
+                        (i.split()[0], i.split()[1:] or None)
+                        for i in self.plugins[option]
+                    ]
+        else:
+            return
+
+        if plugins.get("enabled", True):
+            root = plugins["root"]
+            include = plugins.get("include", [])
+            exclude = plugins.get("exclude", [])
+
+            count = 0
+
+            if not include:
+                for path in sorted(Path(root.replace(".", "/")).rglob("*.py")):
+                    module_path = '.'.join(path.parent.parts + (path.stem,))
+                    module = import_module(module_path)
+
+                    for name in vars(module).keys():
+                        # noinspection PyBroadException
+                        try:
+                            for handler, group in getattr(module, name).handlers:
+                                if isinstance(handler, Handler) and isinstance(group, int):
+                                    self.add_handler(handler, group)
+
+                                    logger.info('[{}] [LOAD] {}("{}") in group {} from "{}"'.format(
+                                        self.token, type(handler).__name__, name, group, module_path))
+
+                                    count += 1
+                        except Exception:
+                            pass
+            else:
+                for path, handlers in include:
+                    module_path = root + "." + path
+                    warn_non_existent_functions = True
+
+                    try:
+                        module = import_module(module_path)
+                    except ImportError:
+                        logger.warning(
+                            '[%s] [LOAD] Ignoring non-existent module "%s"', self.token, module_path)
+                        continue
+
+                    if "__path__" in dir(module):
+                        logger.warning(
+                            '[%s] [LOAD] Ignoring namespace "%s"', self.token, module_path)
+                        continue
+
+                    if handlers is None:
+                        handlers = vars(module).keys()
+                        warn_non_existent_functions = False
+
+                    for name in handlers:
+                        # noinspection PyBroadException
+                        try:
+                            for handler, group in getattr(module, name).handlers:
+                                if isinstance(handler, Handler) and isinstance(group, int):
+                                    self.add_handler(handler, group)
+
+                                    logger.info('[{}] [LOAD] {}("{}") in group {} from "{}"'.format(
+                                        self.token, type(handler).__name__, name, group, module_path))
+
+                                    count += 1
+                        except Exception:
+                            if warn_non_existent_functions:
+                                logger.warning('[{}] [LOAD] Ignoring non-existent function "{}" from "{}"'.format(
+                                    self.token, name, module_path))
+
+            if exclude:
+                for path, handlers in exclude:
+                    module_path = root + "." + path
+                    warn_non_existent_functions = True
+
+                    try:
+                        module = import_module(module_path)
+                    except ImportError:
+                        logger.warning(
+                            '[%s] [UNLOAD] Ignoring non-existent module "%s"', self.token, module_path)
+                        continue
+
+                    if "__path__" in dir(module):
+                        logger.warning(
+                            '[%s] [UNLOAD] Ignoring namespace "%s"', self.token, module_path)
+                        continue
+
+                    if handlers is None:
+                        handlers = vars(module).keys()
+                        warn_non_existent_functions = False
+
+                    for name in handlers:
+                        # noinspection PyBroadException
+                        try:
+                            for handler, group in getattr(module, name).handlers:
+                                if isinstance(handler, Handler) and isinstance(group, int):
+                                    self.remove_handler(handler, group)
+
+                                    logger.info('[{}] [UNLOAD] {}("{}") from group {} in "{}"'.format(
+                                        self.token, type(handler).__name__, name, group, module_path))
+
+                                    count -= 1
+                        except Exception:
+                            if warn_non_existent_functions:
+                                logger.warning('[{}] [UNLOAD] Ignoring non-existent function "{}" from "{}"'.format(
+                                    self.token, name, module_path))
+
+            if count > 0:
+                logger.info('[{}] Successfully loaded {} plugin{} from "{}"'.format(
+                    self.token, count, "s" if count > 1 else "", root))
+            else:
+                logger.warning('[%s] No plugin loaded from "%s"',
+                               self.token, root)

rubigram/bot/dispatcher.py

@@ -0,0 +1,58 @@
+#  RubigramClient - Rubika API library for python
+#  Copyright (C) 2025-present Javad <https://github.com/DevJavad>
+#  Github - https://github.com/DevJavad/rubigram
+
+
+import logging
+from typing import Union
+
+import rubigram
+from rubigram.bot.handlers import Handler
+from rubigram.bot.types import Update, InlineMessage
+from rubigram import StopPropagation, ContinuePropagation
+
+
+logger = logging.getLogger(__name__)
+
+
+class Dispatcher:
+    def __init__(self, bot: "rubigram.Bot"):
+        self.bot = bot
+        self.handlers: dict[int, list["Handler"]] = {}
+
+    def start(self):
+        ...
+
+    def stop(self):
+        ...
+
+    def add_handler(
+        self,
+        handler: "Handler",
+        group: int = 0
+    ):
+        self.handlers.setdefault(group, [])
+        self.handlers[group].append(handler)
+
+    def remove_handler(
+        self,
+        handler: "Handler",
+        group: int = 0
+    ):
+        if group in self.handlers and handler in self.handlers[group]:
+            self.handlers[group].remove(handler)
+
+    async def dispatch(
+        self,
+        update: Union["Update", "InlineMessage"]
+    ):
+        for group in sorted(self.handlers):
+            for handler in self.handlers.get(group):
+                try:
+                    status, call = await handler.execute(self.bot, update)
+                    if status:
+                        break
+                except ContinuePropagation:
+                    continue
+                except StopPropagation:
+                    raise

rubigram/bot/enums/__init__.py

@@ -0,0 +1,51 @@
+#  RubigramClient - Rubika API library for python
+#  Copyright (C) 2025-present Javad <https://github.com/DevJavad>
+#  Github - https://github.com/DevJavad/rubigram
+
+
+from .buttons import (
+    ButtonCalendarType,
+    ButtonLocationType,
+    ButtonSelectionGetType,
+    ButtonSelectionSearchType,
+    ButtonSelectionType,
+    ButtonTextboxTypeLine,
+    ButtonTextboxTypeKeypad,
+    ButtonType
+)
+from .chat_keypad_type import ChatKeypadType
+from .chat_type import ChatType
+from .file_type import FileType
+from .forwarded_from_type import ForwardedFromType
+from .live_location_status import LiveLocationStatus
+from .message_sender_type import MessageSenderType
+from .parse_mode import ParseMode
+from .payment_status_type import PaymentStatusType
+from .poll_status_type import PollStatusType
+from .update_endpoint_type import UpdateEndpointType
+from .update_type import UpdateType
+from .metadata_type import MetadataType
+
+__all__ = [
+    "ButtonCalendarType",
+    "ButtonLocationType",
+    "ButtonSelectionGetType",
+    "ButtonSelectionSearchType",
+    "ButtonSelectionType",
+    "ButtonTextboxTypeLine",
+    "ButtonTextboxTypeKeypad",
+    "ButtonType",
+    "ChatActionType",
+    "ChatKeypadType",
+    "ChatType",
+    "FileType",
+    "ForwardedFromType",
+    "LiveLocationStatus",
+    "MessageSenderType",
+    "ParseMode",
+    "PaymentStatusType",
+    "PollStatusType",
+    "UpdateEndpointType",
+    "UpdateType",
+    "MetadataType"
+]

rubigram/bot/enums/buttons/__init__.py

@@ -0,0 +1,13 @@
+#  RubigramClient - Rubika API library for python
+#  Copyright (C) 2025-present Javad <https://github.com/DevJavad>
+#  Github - https://github.com/DevJavad/rubigram
+
+
+from .button_calendar_type import ButtonCalendarType
+from .button_location_type import ButtonLocationType
+from .button_selection_get_type import ButtonSelectionGetType
+from .button_selection_search_type import ButtonSelectionSearchType
+from .button_selection_type import ButtonSelectionType
+from .button_textbox_type_line import ButtonTextboxTypeLine
+from .button_textbox_type_keypad import ButtonTextboxTypeKeypad
+from .button_type import ButtonType

rubigram/bot/enums/buttons/button_calendar_type.py

@@ -0,0 +1,11 @@
+#  RubigramClient - Rubika API library for python
+#  Copyright (C) 2025-present Javad <https://github.com/DevJavad>
+#  Github - https://github.com/DevJavad/rubigram
+
+
+from enum import Enum
+
+
+class ButtonCalendarType(Enum):
+    DATE_PERSIAN = "DatePersian"
+    DATE_GREGORIAN = "DateGregorian"

rubigram/bot/enums/buttons/button_location_type.py

@@ -0,0 +1,11 @@
+#  RubigramClient - Rubika API library for python
+#  Copyright (C) 2025-present Javad <https://github.com/DevJavad>
+#  Github - https://github.com/DevJavad/rubigram
+
+
+from enum import Enum
+
+
+class ButtonLocationType(Enum):
+    PICKER = "Picker"
+    VIEW = "View"

rubigram/bot/enums/buttons/button_selection_get_type.py

@@ -0,0 +1,11 @@
+#  RubigramClient - Rubika API library for python
+#  Copyright (C) 2025-present Javad <https://github.com/DevJavad>
+#  Github - https://github.com/DevJavad/rubigram
+
+
+from enum import Enum
+
+
+class ButtonSelectionGetType(Enum):
+    LOCAL = "Local"
+    API = "Api"

rubigram/bot/enums/buttons/button_selection_search_type.py

@@ -0,0 +1,11 @@
+#  RubigramClient - Rubika API library for python
+#  Copyright (C) 2025-present Javad <https://github.com/DevJavad>
+#  Github - https://github.com/DevJavad/rubigram
+
+
+from enum import Enum
+
+
+class ButtonSelectionSearchType(Enum):
+    LOCAL = "Local"
+    API = "Api"

rubigram/bot/enums/buttons/button_selection_type.py

@@ -0,0 +1,12 @@
+#  RubigramClient - Rubika API library for python
+#  Copyright (C) 2025-present Javad <https://github.com/DevJavad>
+#  Github - https://github.com/DevJavad/rubigram
+
+
+from enum import Enum
+
+
+class ButtonSelectionType(Enum):
+    TEXT_ONLY = "TextOnly"
+    TEXT_IMG_THU = "TextImgThu"
+    TEXT_IMG_BIG = "TextImgBig"

rubigram/bot/enums/buttons/button_textbox_type_keypad.py

@@ -0,0 +1,11 @@
+#  RubigramClient - Rubika API library for python
+#  Copyright (C) 2025-present Javad <https://github.com/DevJavad>
+#  Github - https://github.com/DevJavad/rubigram
+
+
+from enum import Enum
+
+
+class ButtonTextboxTypeKeypad(Enum):
+    STRING = "String"
+    NUMBER = "Number"

rubigram/bot/enums/buttons/button_textbox_type_line.py

@@ -0,0 +1,11 @@
+#  RubigramClient - Rubika API library for python
+#  Copyright (C) 2025-present Javad <https://github.com/DevJavad>
+#  Github - https://github.com/DevJavad/rubigram
+
+
+from enum import Enum
+
+
+class ButtonTextboxTypeLine(Enum):
+    SINGLE_LINE = "SingleLine"
+    MULTI_LINE = "MultiLine"

rubigram/bot/enums/buttons/button_type.py

@@ -0,0 +1,30 @@
+#  RubigramClient - Rubika API library for python
+#  Copyright (C) 2025-present Javad <https://github.com/DevJavad>
+#  Github - https://github.com/DevJavad/rubigram
+
+
+from enum import Enum
+
+
+class ButtonType(Enum):
+    SIMPLE = "Simple"
+    SELECTION = "Selection"
+    CALENDAR = "Calendar"
+    NUMBER_PICKER = "NumberPicker"
+    STRING_PICKER = "StringPicker"
+    LOCATION = "Location"
+    PAYMENT = "Payment"
+    CAMERA_IMAGE = "CameraImage"
+    CAMERA_VIDEO = "CameraVideo"
+    GALLERY_IMAGE = "GalleryImage"
+    GALLERY_VIDEO = "GalleryVideo"
+    FILE = "File"
+    AUDIO = "Audio"
+    RECORD_AUDIO = "RecordAudio"
+    MY_PHONE_NUMBER = "MyPhoneNumber"
+    MY_LOCATION = "MyLocation"
+    TEXTBOX = "Textbox"
+    LINK = "Link"
+    ASK_MY_PHONE_NUMBER = "AskMyPhoneNumber"
+    ASK_LOCATION = "AskLocation"
+    BARCODE = "Barcode"

rubigram/bot/enums/chat_keypad_type.py

@@ -0,0 +1,12 @@
+#  RubigramClient - Rubika API library for python
+#  Copyright (C) 2025-present Javad <https://github.com/DevJavad>
+#  Github - https://github.com/DevJavad/rubigram
+
+
+from enum import Enum
+
+
+class ChatKeypadType(Enum):
+    NEW = "New"
+    REMOVE = "Remove"
+    NONE = None