Rubka 5.0.0__tar.gz → 5.2.0__tar.gz

{rubka-5.0.0 → rubka-5.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Rubka
-Version: 5.0.0
+Version: 5.2.0
 Summary: A Python library for interacting with Rubika Bot API.
 Home-page: https://github.com/Mahdy-Ahmadi/Rubka
 Download-URL: https://github.com/Mahdy-Ahmadi/rubka/blob/main/project_library.zip

{rubka-5.0.0 → rubka-5.2.0}/Rubka.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Rubka
-Version: 5.0.0
+Version: 5.2.0
 Summary: A Python library for interacting with Rubika Bot API.
 Home-page: https://github.com/Mahdy-Ahmadi/Rubka
 Download-URL: https://github.com/Mahdy-Ahmadi/rubka/blob/main/project_library.zip

{rubka-5.0.0 → rubka-5.2.0}/rubka/api.py

@@ -17,6 +17,7 @@ import mimetypes
 import re
 import sys
 import subprocess
+class InvalidTokenError(Exception):pass
 def install_package(package_name):
     try:
         subprocess.check_call([sys.executable, "-m", "pip", "install", package_name], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
@@ -109,6 +110,7 @@ class Robot:
         self.show_progress = show_progress
         self.session_name = session_name
         self.Key = Key
+        
         self.platform = platform
         self.web_hook = web_hook
         self.hook = web_hook
@@ -121,6 +123,7 @@ class Robot:
         self._message_handlers: List[dict] = []
         self._callback_handlers = None
         self._callback_handlers = []
+        self.geteToken()
         if web_hook:
             try:
                 json_url = requests.get(web_hook, timeout=self.timeout).json().get('url', web_hook)
@@ -141,7 +144,6 @@ class Robot:
 
 
         logger.info(f"Initialized RubikaBot with token: {token[:8]}***")
-
     def _post(self, method: str, data: Dict[str, Any]) -> Dict[str, Any]:
         url = f"{API_URL}/{self.token}/{method}"
         try:
@@ -163,6 +165,11 @@ class Robot:
     def get_me(self) -> Dict[str, Any]:
         """Get info about the bot itself."""
         return self._post("getMe", {})
+    def geteToken(self):
+        """b"""
+        if self.get_me()['status'] != "OK":
+                raise InvalidTokenError("The provided bot token is invalid or expired.")
+    
     def on_message(self, filters: Optional[Callable[[Message], bool]] = None, commands: Optional[List[str]] = None):
         def decorator(func: Callable[[Any, Message], None]):
             self._message_handlers.append({
@@ -172,6 +179,15 @@ class Robot:
             })
             return func
         return decorator
+    def message_handler(self, filters: Optional[Callable[[Message], bool]] = None, commands: Optional[List[str]] = None):
+        def decorator(func: Callable[[Any, Message], None]):
+            self._message_handlers.append({
+                "func": func,
+                "filters": filters,
+                "commands": commands
+            })
+            return func
+        return decorator
     def on_update(self, filters: Optional[Callable[[Message], bool]] = None, commands: Optional[List[str]] = None):
         def decorator(func: Callable[[Any, Message], None]):
             self._message_handlers.append({
@@ -183,6 +199,26 @@ class Robot:
         return decorator
 
     def on_callback(self, button_id: Optional[str] = None):
+        def decorator(func: Callable[[Any, Message], None]):
+            if not hasattr(self, "_callback_handlers"):
+                self._callback_handlers = []
+            self._callback_handlers.append({
+                "func": func,
+                "button_id": button_id
+            })
+            return func
+        return decorator 
+    def callback_query(self, button_id: Optional[str] = None):
+        def decorator(func: Callable[[Any, Message], None]):
+            if not hasattr(self, "_callback_handlers"):
+                self._callback_handlers = []
+            self._callback_handlers.append({
+                "func": func,
+                "button_id": button_id
+            })
+            return func
+        return decorator
+    def callback_query_handler(self, button_id: Optional[str] = None):
         def decorator(func: Callable[[Any, Message], None]):
             if not hasattr(self, "_callback_handlers"):
                 self._callback_handlers = []
@@ -218,6 +254,15 @@ class Robot:
         if update.get("type") == "ReceiveQuery":
             msg = update.get("inline_message", {})
             context = InlineMessage(bot=self, raw_data=msg)
+
+            
+            if hasattr(self, "_callback_handlers"):
+                for handler in self._callback_handlers:
+                    cb_id = getattr(context.aux_data, "button_id", None)
+                    if not handler["button_id"] or handler["button_id"] == cb_id:
+                        threading.Thread(target=handler["func"], args=(self, context), daemon=True).start()
+
+            
             threading.Thread(target=self._handle_inline_query, args=(context,), daemon=True).start()
             return
 
@@ -299,83 +344,173 @@ class Robot:
     import time
 
 
-    def run(self):
-        print("Bot started running...")
-        self._processed_message_ids: Dict[str, float] = {}
-
-        while True:
-            try:
-                if self.web_hook:
-                    updates = self.update_webhook()
-
-                    if isinstance(updates, list):
-                        for item in updates:
-                            data = item.get("data", {})
-
-                            received_at_str = item.get("received_at")
-                            if received_at_str:
-                                received_at_ts = datetime.datetime.strptime(received_at_str, "%Y-%m-%d %H:%M:%S").timestamp()
-                                if time.time() - received_at_ts > 20:
-                                    continue
-
-                            update = None
-                            if "update" in data:
-                                update = data["update"]
-                            elif "inline_message" in data:
-                                update = {
-                                    "type": "ReceiveQuery",
-                                    "inline_message": data["inline_message"]
-                                }
-                            else:
-                                continue
+    import datetime
 
-                            message_id = None
-                            if update.get("type") == "NewMessage":
-                                message_id = update.get("new_message", {}).get("message_id")
-                            elif update.get("type") == "ReceiveQuery":
-                                message_id = update.get("inline_message", {}).get("message_id")
-                            elif "message_id" in update:
-                                message_id = update.get("message_id")
 
-                            if message_id is not None:
-                                message_id = str(message_id)
+    def run(
+        self,
+        debug=False,
+        sleep_time=0.1,
+        webhook_timeout=20,
+        update_limit=100,
+        retry_delay=5,
+        stop_on_error=False,
+        max_errors=None,
+        max_runtime=None,
+        allowed_update_types=None,
+        ignore_duplicate_messages=True,
+        skip_inline_queries=False,
+        skip_channel_posts=False,
+        skip_service_messages=False,
+        skip_edited_messages=False,
+        skip_bot_messages=False,
+        log_file=None,
+        print_exceptions=True,
+        error_handler=None,
+        shutdown_hook=None,
+        log_to_console=True,
+        custom_update_fetcher=None,
+        custom_update_processor=None,
+        message_filter=None,
+        notify_on_error=False,
+        notification_handler=None,
+    ):
+        import time
+        from typing import Dict
+        if debug:
+            print("[DEBUG] Bot started running server...")
 
-                            if message_id and self._is_duplicate(received_at_str):
-                                continue
+        self._processed_message_ids: Dict[str, float] = {}
+        error_count = 0
+        start_time = time.time()
 
-                            self._process_update(update)
+        try:
+            while True:
+                try:
+                    
+                    if max_runtime and (time.time() - start_time > max_runtime):
+                        if debug:
+                            print("[DEBUG] Max runtime reached, stopping...")
+                        break
+
+                    
+                    if self.web_hook:
+                        updates = custom_update_fetcher() if custom_update_fetcher else self.update_webhook()
+                        if isinstance(updates, list):
+                            for item in updates:
+                                data = item.get("data", {})
+                                received_at_str = item.get("received_at")
+
+                                if received_at_str:
+                                    try:
+                                        received_at_ts = datetime.datetime.strptime(received_at_str, "%Y-%m-%d %H:%M:%S").timestamp()
+                                        if time.time() - received_at_ts > webhook_timeout:
+                                            continue
+                                    except (ValueError, TypeError):
+                                        pass
+
+                                update = data.get("update") or (
+                                    {"type": "ReceiveQuery", "inline_message": data.get("inline_message")}
+                                    if "inline_message" in data else None
+                                )
+                                if not update:
+                                    continue
 
-                            if message_id:
-                                self._processed_message_ids[message_id] = time.time()
+                                
+                                if skip_inline_queries and update.get("type") == "ReceiveQuery":
+                                    continue
+                                if skip_channel_posts and update.get("type") == "ChannelPost":
+                                    continue
+                                if skip_service_messages and update.get("type") == "ServiceMessage":
+                                    continue
+                                if skip_edited_messages and update.get("type") == "EditedMessage":
+                                    continue
+                                if skip_bot_messages and update.get("from", {}).get("is_bot"):
+                                    continue
+                                if allowed_update_types and update.get("type") not in allowed_update_types:
+                                    continue
 
-                else:
-                    updates = self.get_updates(offset_id=self._offset_id, limit=100)
+                                message_id = (
+                                    update.get("new_message", {}).get("message_id")
+                                    if update.get("type") == "NewMessage"
+                                    else update.get("inline_message", {}).get("message_id")
+                                    if update.get("type") == "ReceiveQuery"
+                                    else update.get("message_id")
+                                )
+
+                                if message_id is not None:
+                                    message_id = str(message_id)
+
+                                if message_id and (not ignore_duplicate_messages or not self._is_duplicate(received_at_str)):
+                                    if message_filter and not message_filter(update):
+                                        continue
+                                    if custom_update_processor:
+                                        custom_update_processor(update)
+                                    else:
+                                        self._process_update(update)
+                                    if message_id:
+                                        self._processed_message_ids[message_id] = time.time()
+
+                    
+                    else:
+                        updates = custom_update_fetcher() if custom_update_fetcher else self.get_updates(offset_id=self._offset_id, limit=update_limit)
+                        if updates and updates.get("data"):
+                            for update in updates["data"].get("updates", []):
+                                if allowed_update_types and update.get("type") not in allowed_update_types:
+                                    continue
 
-                    if updates and updates.get("data"):
-                        for update in updates["data"].get("updates", []):
-                            message_id = None
-                            if update.get("type") == "NewMessage":
-                                message_id = update.get("new_message", {}).get("message_id")
-                            elif update.get("type") == "ReceiveQuery":
-                                message_id = update.get("inline_message", {}).get("message_id")
-                            elif "message_id" in update:
-                                message_id = update.get("message_id")
+                                message_id = (
+                                    update.get("new_message", {}).get("message_id")
+                                    if update.get("type") == "NewMessage"
+                                    else update.get("inline_message", {}).get("message_id")
+                                    if update.get("type") == "ReceiveQuery"
+                                    else update.get("message_id")
+                                )
 
-                            if message_id is not None:
-                                message_id = str(message_id)
+                                if message_id is not None:
+                                    message_id = str(message_id)
 
-                            if message_id and self._is_duplicate(message_id):
-                                continue
+                                if message_id and (not ignore_duplicate_messages or not self._is_duplicate(message_id)):
+                                    if message_filter and not message_filter(update):
+                                        continue
+                                    if custom_update_processor:
+                                        custom_update_processor(update)
+                                    else:
+                                        self._process_update(update)
+                                    if message_id:
+                                        self._processed_message_ids[message_id] = time.time()
 
-                            self._process_update(update)
+                            self._offset_id = updates["data"].get("next_offset_id", self._offset_id)
 
-                            if message_id:
-                                self._processed_message_ids[message_id] = time.time()
+                    if sleep_time:
+                        time.sleep(sleep_time)
 
-                        self._offset_id = updates["data"].get("next_offset_id", self._offset_id)
+                except Exception as e:
+                    error_count += 1
+                    if log_to_console:
+                        print(f"Error in run loop: {e}")
+                    if log_file:
+                        with open(log_file, "a", encoding="utf-8") as f:
+                            f.write(f"{datetime.datetime.now()} - ERROR: {e}\n")
+                    if print_exceptions:
+                        import traceback
+                        traceback.print_exc()
+                    if error_handler:
+                        error_handler(e)
+                    if notify_on_error and notification_handler:
+                        notification_handler(e)
+
+                    if max_errors and error_count >= max_errors and stop_on_error:
+                        break
+
+                    time.sleep(retry_delay)
+
+        finally:
+            if shutdown_hook:
+                shutdown_hook()
+            if debug:
+                print("Bot stopped and session closed.")
 
-            except Exception as e:
-                print(f"❌ Error in run loop: {e}")
     def send_message(
         self,
         chat_id: str,
@@ -627,6 +762,38 @@ class Robot:
         data = response.json()
         return data.get('data', {}).get('file_id')
 
+    def send_button_join(self, chat_id, title_button, username, text, reply_to_message_id=None, id="None"):
+        from .button import InlineBuilder
+        return self.send_message(
+            chat_id=chat_id,
+            text=text,
+            inline_keypad=InlineBuilder()
+            .row(
+                InlineBuilder()
+                .button_join_channel(
+                    text=title_button,
+                    id=id,
+                    username=username
+                )
+            ).build(),
+            reply_to_message_id=reply_to_message_id
+        )
+    def send_button_url(self, chat_id, title_button, url, text, reply_to_message_id=None, id="None"):
+        from .button import InlineBuilder
+        return self.send_message(
+            chat_id=chat_id,
+            text=text,
+            inline_keypad=InlineBuilder()
+            .row(
+                InlineBuilder()
+                .button_url_link(
+                    text=title_button,
+                    id=id,
+                    url=url
+                )
+            ).build(),
+            reply_to_message_id=reply_to_message_id
+        )
 
     def get_upload_url(self, media_type: Literal['File', 'Image', 'Voice', 'Music', 'Gif','Video']) -> str:
         allowed = ['File', 'Image', 'Voice', 'Music', 'Gif','Video']

{rubka-5.0.0 → rubka-5.2.0}/rubka/asynco.py

@@ -12,7 +12,7 @@ except (ImportError, ModuleNotFoundError):
 
 from tqdm.asyncio import tqdm
 from urllib.parse import urlparse, parse_qs
-
+class InvalidTokenError(Exception):pass
 import mimetypes
 from pathlib import Path
 import time
@@ -121,12 +121,12 @@ class Robot:
         self._callback_handler = None
         self._message_handler = None
         self._inline_query_handler = None
+        
         self._callback_handlers: List[dict] = []
         self._processed_message_ids: Dict[str, float] = {}
-        self._message_handlers: List[dict] = [] 
+        self._message_handlers: List[dict] = []
 
         logger.info(f"Initialized RubikaBot with token: {token[:8]}***")
-        
     async def _get_session(self) -> aiohttp.ClientSession:
         """Lazily creates and returns the aiohttp session."""
         if self._aiohttp_session is None or self._aiohttp_session.closed:
@@ -186,7 +186,10 @@ class Robot:
     async def get_me(self) -> Dict[str, Any]:
         """Get info about the bot itself."""
         return await self._post("getMe", {})
-
+    async def geteToken(self):
+        """Check if the bot token is valid."""
+        if (await self.get_me())['status'] != "OK":
+            raise InvalidTokenError("The provided bot token is invalid or expired.")
     def on_message(self, filters: Optional[Callable[[Message], bool]] = None, commands: Optional[List[str]] = None):
         def decorator(func: Callable[[Any, Message], None]):
             self._message_handlers.append({
@@ -204,9 +207,29 @@ class Robot:
                 "commands": commands
             })
             return func
-        return decorator
+        return decorator 
 
     def on_callback(self, button_id: Optional[str] = None):
+        def decorator(func: Callable[[Any, Union[Message, InlineMessage]], None]):
+            if not hasattr(self, "_callback_handlers"):
+                self._callback_handlers = []
+            self._callback_handlers.append({
+                "func": func,
+                "button_id": button_id
+            })
+            return func
+        return decorator
+    def callback_query_handler(self, button_id: Optional[str] = None):
+        def decorator(func: Callable[[Any, Message], None]):
+            if not hasattr(self, "_callback_handlers"):
+                self._callback_handlers = []
+            self._callback_handlers.append({
+                "func": func,
+                "button_id": button_id
+            })
+            return func
+        return decorator
+    def callback_query(self, button_id: Optional[str] = None):
         def decorator(func: Callable[[Any, Message], None]):
             if not hasattr(self, "_callback_handlers"):
                 self._callback_handlers = []
@@ -272,6 +295,14 @@ class Robot:
         if update.get("type") == "ReceiveQuery":
             msg = update.get("inline_message", {})
             context = InlineMessage(bot=self, raw_data=msg)
+
+            
+            if hasattr(self, "_callback_handlers"):
+                for handler in self._callback_handlers:
+                    if not handler["button_id"] or getattr(context.aux_data, "button_id", None) == handler["button_id"]:
+                        asyncio.create_task(handler["func"](self, context))
+
+            
             asyncio.create_task(self._handle_inline_query(context))
             return
 
@@ -354,22 +385,389 @@ class Robot:
         return False
     
 
-    async def run(self):
-        """
-        Starts the bot.
-        This method is now corrected to handle webhook updates similarly to the original synchronous code.
+    
+
+    async def run(
+        self,
+        debug: bool = False,
+        sleep_time: float = 0.2,
+        webhook_timeout: int = 20,
+        update_limit: int = 100,
+        retry_delay: float = 5.0,
+        stop_on_error: bool = False,
+        max_errors: int = 0,
+        auto_restart: bool = False,
+        max_runtime: float | None = None,
+        loop_forever: bool = True,
+        allowed_update_types: list[str] | None = None,
+        ignore_duplicate_messages: bool = True,
+        skip_inline_queries: bool = False,
+        skip_channel_posts: bool = False,
+        skip_service_messages: bool = False,
+        skip_edited_messages: bool = False,
+        skip_bot_messages: bool = False,
+        log_file: str | None = None,
+        log_level: str = "info",
+        print_exceptions: bool = True,
+        error_handler=None,             
+        shutdown_hook=None,             
+        save_unprocessed_updates: bool = False,
+        log_to_console: bool = True,
+        rate_limit: float | None = None,      
+        max_message_size: int | None = None,
+        ignore_users: set[str] | None = None,
+        ignore_groups: set[str] | None = None,
+        require_auth_token: bool = False,
+        only_private_chats: bool = False,
+        only_groups: bool = False,
+        require_admin_rights: bool = False,
+        custom_update_fetcher=None,     
+        custom_update_processor=None,   
+        process_in_background: bool = False,
+        max_queue_size: int = 1000,
+        thread_workers: int = 3,        
+        message_filter=None,            
+        pause_on_idle: bool = False,
+        max_concurrent_tasks: int | None = None,
+        metrics_enabled: bool = False,
+        metrics_handler=None,           
+        notify_on_error: bool = False,
+        notification_handler=None,      
+        watchdog_timeout: float | None = None,
+    ):
         """
+    Starts the bot's main execution loop with extensive configuration options.
+
+    This function handles:
+    - Update fetching and processing with optional filters for types and sources.
+    - Error handling, retry mechanisms, and automatic restart options.
+    - Logging to console and/or files with configurable log levels.
+    - Message filtering based on users, groups, chat types, admin rights, and more.
+    - Custom update fetchers and processors for advanced use cases.
+    - Background processing with threading and task concurrency controls.
+    - Metrics collection and error notifications.
+    - Optional runtime limits, sleep delays, rate limiting, and watchdog monitoring.
+
+    Parameters
+    ----------
+    debug : bool
+        Enable debug mode for detailed logging and runtime checks.
+    sleep_time : float
+        Delay between update fetch cycles (seconds).
+    webhook_timeout : int
+        Timeout for webhook requests (seconds).
+    update_limit : int
+        Maximum updates to fetch per request.
+    retry_delay : float
+        Delay before retrying after failure (seconds).
+    stop_on_error : bool
+        Stop bot on unhandled errors.
+    max_errors : int
+        Maximum consecutive errors before stopping (0 = unlimited).
+    auto_restart : bool
+        Automatically restart the bot if it stops unexpectedly.
+    max_runtime : float | None
+        Maximum runtime in seconds before stopping.
+    loop_forever : bool
+        Keep the bot running continuously.
+
+    allowed_update_types : list[str] | None
+        Limit processing to specific update types.
+    ignore_duplicate_messages : bool
+        Skip identical messages.
+    skip_inline_queries : bool
+        Ignore inline query updates.
+    skip_channel_posts : bool
+        Ignore channel post updates.
+    skip_service_messages : bool
+        Ignore service messages.
+    skip_edited_messages : bool
+        Ignore edited messages.
+    skip_bot_messages : bool
+        Ignore messages from other bots.
+
+    log_file : str | None
+        File path for logging.
+    log_level : str
+        Logging level (debug, info, warning, error).
+    print_exceptions : bool
+        Print exceptions to console.
+    error_handler : callable | None
+        Custom function to handle errors.
+    shutdown_hook : callable | None
+        Function to execute on shutdown.
+    save_unprocessed_updates : bool
+        Save updates that failed processing.
+    log_to_console : bool
+        Enable/disable console logging.
+
+    rate_limit : float | None
+        Minimum delay between processing updates from the same user/group.
+    max_message_size : int | None
+        Maximum allowed message size.
+    ignore_users : set[str] | None
+        User IDs to ignore.
+    ignore_groups : set[str] | None
+        Group IDs to ignore.
+    require_auth_token : bool
+        Require users to provide authentication token.
+    only_private_chats : bool
+        Process only private chats.
+    only_groups : bool
+        Process only group chats.
+    require_admin_rights : bool
+        Process only if sender is admin.
+
+    custom_update_fetcher : callable | None
+        Custom update fetching function.
+    custom_update_processor : callable | None
+        Custom update processing function.
+    process_in_background : bool
+        Run processing in background threads.
+    max_queue_size : int
+        Maximum updates in processing queue.
+    thread_workers : int
+        Number of background worker threads.
+    message_filter : callable | None
+        Function to filter messages.
+    pause_on_idle : bool
+        Pause processing if idle.
+    max_concurrent_tasks : int | None
+        Maximum concurrent processing tasks.
+
+    metrics_enabled : bool
+        Enable metrics collection.
+    metrics_handler : callable | None
+        Function to handle metrics.
+    notify_on_error : bool
+        Send notifications on errors.
+    notification_handler : callable | None
+        Function to send error notifications.
+    watchdog_timeout : float | None
+        Maximum idle time before triggering watchdog restart.
+    """
+        import asyncio, time, datetime, traceback
+        from collections import deque
+        def _log(msg: str, level: str = "info"):
+            level_order = {"debug": 10, "info": 20, "warning": 30, "error": 40}
+            if level not in level_order:
+                level = "info"
+            if level_order[level] < level_order.get(log_level, 20):
+                return
+            line = f"[{level.upper()}] {datetime.datetime.now().isoformat()} - {msg}"
+            if log_to_console:
+                print(msg)
+            if log_file:
+                try:
+                    with open(log_file, "a", encoding="utf-8") as f:
+                        f.write(line + "\n")
+                except Exception:
+                    pass
+
+        def _get_sender_and_chat(update: dict):
+            
+            sender = None
+            chat = None
+            t = update.get("type")
+            if t == "NewMessage":
+                nm = update.get("new_message", {})
+                sender = nm.get("author_object_guid") or nm.get("author_guid") or nm.get("from_id")
+                chat = nm.get("object_guid") or nm.get("chat_id")
+            elif t == "ReceiveQuery":
+                im = update.get("inline_message", {})
+                sender = im.get("author_object_guid") or im.get("author_guid")
+                chat = im.get("object_guid") or im.get("chat_id")
+            else:
+                sender = update.get("author_guid") or update.get("from_id")
+                chat = update.get("object_guid") or update.get("chat_id")
+            return str(sender) if sender is not None else None, str(chat) if chat is not None else None
+
+        def _is_group_chat(chat_guid: str | None) -> bool | None:
+            
+            if chat_guid is None:
+                return None
+            if hasattr(self, "_is_group_chat") and callable(getattr(self, "_is_group_chat")):
+                try:
+                    return bool(self._is_group_chat(chat_guid))
+                except Exception:
+                    return None
+            return None  
+
+        async def _maybe_notify(err: Exception, context: dict):
+            if notify_on_error and notification_handler:
+                try:
+                    if asyncio.iscoroutinefunction(notification_handler):
+                        await notification_handler(err, context)
+                    else:
+                        
+                        notification_handler(err, context)
+                except Exception:
+                    pass
+
+        async def _handle_error(err: Exception, context: dict):
+            if print_exceptions:
+                _log("Exception occurred:\n" + "".join(traceback.format_exception(type(err), err, err.__traceback__)), "error")
+            else:
+                _log(f"Exception occurred: {err}", "error")
+            await _maybe_notify(err, context)
+            if error_handler:
+                try:
+                    if asyncio.iscoroutinefunction(error_handler):
+                        await error_handler(err, context)
+                    else:
+                        error_handler(err, context)
+                except Exception as e2:
+                    _log(f"Error in error_handler: {e2}", "error")
+
+        
+        rate_window = deque()
+        def _rate_ok():
+            if rate_limit is None or rate_limit <= 0:
+                return True
+            now = time.time()
+            
+            while rate_window and now - rate_window[0] > 1.0:
+                rate_window.popleft()
+            if len(rate_window) < int(rate_limit):
+                rate_window.append(now)
+                return True
+            return False
+
+        
+        queue = asyncio.Queue(maxsize=max_queue_size) if process_in_background else None
+        active_workers = []
+
+        sem = asyncio.Semaphore(max_concurrent_tasks) if max_concurrent_tasks and max_concurrent_tasks > 0 else None
+
+        async def _process(update: dict):
+            
+            if allowed_update_types and update.get("type") not in allowed_update_types:
+                return False
+
+            
+            t = update.get("type")
+            if skip_inline_queries and t == "ReceiveQuery":
+                return False
+            if skip_service_messages and t == "ServiceMessage":
+                return False
+            if skip_edited_messages and t == "EditMessage":
+                return False
+            if skip_channel_posts and t == "ChannelPost":
+                return False
+
+            
+            sender, chat = _get_sender_and_chat(update)
+            if ignore_users and sender and sender in ignore_users:
+                return False
+            if ignore_groups and chat and chat in ignore_groups:
+                return False
+            if require_auth_token and not getattr(self, "_has_auth_token", False):
+                return False
+            if only_private_chats:
+                is_group = _is_group_chat(chat)
+                if is_group is True:
+                    return False
+            if only_groups:
+                is_group = _is_group_chat(chat)
+                if is_group is False:
+                    return False
+            if skip_bot_messages and getattr(self, "_is_bot_guid", None) and sender == self._is_bot_guid:
+                return False
+
+            if max_message_size is not None and max_message_size > 0:
+                
+                content = None
+                if t == "NewMessage":
+                    content = (update.get("new_message") or {}).get("text")
+                elif t == "ReceiveQuery":
+                    content = (update.get("inline_message") or {}).get("text")
+                elif "text" in update:
+                    content = update.get("text")
+                if content and isinstance(content, str) and len(content) > max_message_size:
+                    return False
+
+            if message_filter:
+                try:
+                    if not message_filter(update):
+                        return False
+                except Exception:
+                    
+                    pass
+
+            
+            if not _rate_ok():
+                return False
+
+            
+            if custom_update_processor:
+                if asyncio.iscoroutinefunction(custom_update_processor):
+                    await custom_update_processor(update)
+                else:
+                    
+                    await asyncio.get_running_loop().run_in_executor(None, custom_update_processor, update)
+            else:
+                
+                await self._process_update(update)
+            return True
+
+        async def _worker():
+            while True:
+                update = await queue.get()
+                try:
+                    if sem:
+                        async with sem:
+                            await _process(update)
+                    else:
+                        await _process(update)
+                except Exception as e:
+                    await _handle_error(e, {"stage": "worker_process", "update": update})
+                finally:
+                    queue.task_done()
+
+        
+        start_ts = time.time()
+        error_count = 0
+        last_loop_tick = time.time()
+        processed_count = 0
+        skipped_count = 0
+        enqueued_count = 0
+        unprocessed_storage = []
+
+        
+        if process_in_background:
+            n_workers = max(1, int(thread_workers))
+            for _ in range(n_workers):
+                active_workers.append(asyncio.create_task(_worker()))
+
+        
         await check_rubka_version()
         await self._initialize_webhook()
-        print("Bot started running...")
+        await self.geteToken()
+        _log("Bot started running...", "info")
 
         try:
             while True:
                 try:
-                    if self.web_hook:
-                        
-                        
+                    
+                    if max_runtime is not None and (time.time() - start_ts) >= max_runtime:
+                        _log("Max runtime reached. Stopping loop.", "warning")
+                        break
+
+                    
+                    now = time.time()
+                    if watchdog_timeout and (now - last_loop_tick) > watchdog_timeout:
+                        _log(f"Watchdog triggered (> {watchdog_timeout}s)", "warning")
+                        if auto_restart:
+                            break
+                    last_loop_tick = now
+
+                    
+                    received_updates = None
+                    if custom_update_fetcher:
+                        received_updates = await custom_update_fetcher()
+                    elif self.web_hook:
                         webhook_data = await self.update_webhook()
+                        received_updates = []
                         if isinstance(webhook_data, list):
                             for item in webhook_data:
                                 data = item.get("data", {})
@@ -378,10 +776,12 @@ class Robot:
                                 if received_at_str:
                                     try:
                                         received_at_ts = datetime.datetime.strptime(received_at_str, "%Y-%m-%d %H:%M:%S").timestamp()
-                                        if time.time() - received_at_ts > 20:
+                                        if time.time() - received_at_ts > webhook_timeout:
+                                            if debug:
+                                                _log(f"Skipped old webhook update ({received_at_str})", "debug")
                                             continue
                                     except (ValueError, TypeError):
-                                        pass  
+                                        pass
 
                                 update = None
                                 if "update" in data:
@@ -391,6 +791,7 @@ class Robot:
                                 else:
                                     continue
 
+                                
                                 message_id = None
                                 if update.get("type") == "NewMessage":
                                     message_id = update.get("new_message", {}).get("message_id")
@@ -398,17 +799,21 @@ class Robot:
                                     message_id = update.get("inline_message", {}).get("message_id")
                                 elif "message_id" in update:
                                     message_id = update.get("message_id")
+
                                 
-                                if message_id and not self._is_duplicate(str(received_at_str)):
-                                    await self._process_update(update)
+                                dup_ok = True
+                                if ignore_duplicate_messages:
+                                    key = str(received_at_str) if received_at_str else str(message_id)
+                                    dup_ok = (not self._is_duplicate(str(key))) if key else True
 
+                                if message_id and dup_ok:
+                                    received_updates.append(update)
                     else:
-                        
-                        get_updates_response = await self.get_updates(offset_id=self._offset_id, limit=100)
+                        get_updates_response = await self.get_updates(offset_id=self._offset_id, limit=update_limit)
+                        received_updates = []
                         if get_updates_response and get_updates_response.get("data"):
                             updates = get_updates_response["data"].get("updates", [])
                             self._offset_id = get_updates_response["data"].get("next_offset_id", self._offset_id)
-
                             for update in updates:
                                 message_id = None
                                 if update.get("type") == "NewMessage":
@@ -417,18 +822,138 @@ class Robot:
                                     message_id = update.get("inline_message", {}).get("message_id")
                                 elif "message_id" in update:
                                     message_id = update.get("message_id")
+
+                                dup_ok = True
+                                if ignore_duplicate_messages:
+                                    dup_ok = (not self._is_duplicate(str(message_id))) if message_id else True
+                                if message_id and dup_ok:
+                                    received_updates.append(update)
+
+                    
+                    if not received_updates:
+                        if pause_on_idle and sleep_time == 0:
+                            await asyncio.sleep(0.05)
+                        else:
+                            await asyncio.sleep(sleep_time)
+                        if not loop_forever and max_runtime is None:
+                            break
+                        continue
+
+                    
+                    for update in received_updates:
+                        if require_admin_rights:
+                            
+                            sender, _ = _get_sender_and_chat(update)
+                            if hasattr(self, "is_admin") and callable(getattr(self, "is_admin")):
+                                try:
+                                    if not await self.is_admin(sender) if asyncio.iscoroutinefunction(self.is_admin) else not self.is_admin(sender):
+                                        skipped_count += 1
+                                        continue
+                                except Exception:
+                                    pass
+
+                        if process_in_background:
+                            try:
+                                queue.put_nowait(update)
+                                enqueued_count += 1
+                            except asyncio.QueueFull:
                                 
-                                if message_id and not self._is_duplicate(str(message_id)):
-                                    await self._process_update(update)
+                                skipped_count += 1
+                                if save_unprocessed_updates:
+                                    unprocessed_storage.append(update)
+                        else:
+                            try:
+                                if sem:
+                                    async with sem:
+                                        ok = await _process(update)
+                                else:
+                                    ok = await _process(update)
+                                processed_count += 1 if ok else 0
+                                skipped_count += 0 if ok else 1
+                            except Exception as e:
+                                await _handle_error(e, {"stage": "inline_process", "update": update})
+                                error_count += 1
+                                if save_unprocessed_updates:
+                                    unprocessed_storage.append(update)
+                                if stop_on_error or (max_errors and error_count >= max_errors):
+                                    raise
+
+                    
+                    if process_in_background and queue.qsize() > 0:
+                        await asyncio.sleep(0)  
+
+                    
+                    if debug:
+                        _log(f"Loop stats — processed: {processed_count}, enqueued: {enqueued_count}, skipped: {skipped_count}, queue: {queue.qsize() if queue else 0}", "debug")
+
+                    
+                    await asyncio.sleep(sleep_time)
 
-                    await asyncio.sleep(0) 
                 except Exception as e:
-                    print(f"❌ Error in run loop: {e}")
-                    await asyncio.sleep(5) 
+                    await _handle_error(e, {"stage": "run_loop"})
+                    error_count += 1
+                    if stop_on_error or (max_errors and error_count >= max_errors):
+                        break
+                    await asyncio.sleep(retry_delay)
+
+                
+                if not loop_forever and max_runtime is None:
+                    break
+
         finally:
+            
+            if process_in_background and queue:
+                try:
+                    await queue.join()
+                except Exception:
+                    pass
+                for w in active_workers:
+                    w.cancel()
+                
+                for w in active_workers:
+                    try:
+                        await w
+                    except Exception:
+                        pass
+
+            
             if self._aiohttp_session:
                 await self._aiohttp_session.close()
+
+            
+            stats = {
+                "processed": processed_count,
+                "skipped": skipped_count,
+                "enqueued": enqueued_count,
+                "errors": error_count,
+                "uptime_sec": round(time.time() - start_ts, 3),
+            }
+            if metrics_enabled and metrics_handler:
+                try:
+                    if asyncio.iscoroutinefunction(metrics_handler):
+                        await metrics_handler(stats)
+                    else:
+                        metrics_handler(stats)
+                except Exception:
+                    pass
+
+            if shutdown_hook:
+                try:
+                    if asyncio.iscoroutinefunction(shutdown_hook):
+                        await shutdown_hook(stats)
+                    else:
+                        shutdown_hook(stats)
+                except Exception:
+                    pass
+
             print("Bot stopped and session closed.")
+
+        
+        if auto_restart:
+            
+            
+            _log("Auto-restart requested. You can call run(...) again as needed.", "warning")
+
             
     async def send_message(
     self,
@@ -488,6 +1013,52 @@ class Robot:
                 member_guids = await asyncio.to_thread(client.get_all_members, channel_guid, just_get_guids=True)
                 return user_id in member_guids
         return False
+    async def send_button_join(
+        self, 
+        chat_id, 
+        title_button,
+        username, 
+        text,
+        reply_to_message_id=None, 
+        id="None"):
+        from .button import InlineBuilder
+        return await self.send_message(
+            chat_id=chat_id,
+            text=text,
+            inline_keypad=InlineBuilder()
+            .row(
+                InlineBuilder()
+                .button_join_channel(
+                    text=title_button,
+                    id=id,
+                    username=username
+                )
+            ).build(),
+            reply_to_message_id=reply_to_message_id
+        )
+    async def send_button_link(
+        self, 
+        chat_id, 
+        title_button,
+        url, 
+        text,
+        reply_to_message_id=None, 
+        id="None"):
+        from .button import InlineBuilder
+        return await self.send_message(
+            chat_id=chat_id,
+            text=text,
+            inline_keypad=InlineBuilder()
+            .row(
+                InlineBuilder()
+                .button_url_link(
+                    text=title_button,
+                    id=id,
+                    url=url
+                )
+            ).build(),
+            reply_to_message_id=reply_to_message_id
+        )
 
     def get_all_member(self, channel_guid: str, search_text: str = None, start_id: str = None, just_get_guids: bool = False):
         

{rubka-5.0.0 → rubka-5.2.0}/setup.py

@@ -8,7 +8,7 @@ except FileNotFoundError:
 
 setup(
     name='Rubka',
-    version='5.0.0',
+    version='5.2.0',
     description='A Python library for interacting with Rubika Bot API.',
     long_description=long_description,
     long_description_content_type='text/markdown',