Rubka 5.0.0__py3-none-any.whl → 6.4.2__py3-none-any.whl

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,6 +186,327 @@ 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.")
+    from typing import Callable, Any, Optional, List
+
+    def on_message_private(
+        self,
+        chat_id: Optional[Union[str, List[str]]] = None,   
+        commands: Optional[List[str]] = None,              
+        filters: Optional[Callable[[Message], bool]] = None, 
+        sender_id: Optional[Union[str, List[str]]] = None, 
+        sender_type: Optional[str] = None,                 
+        allow_forwarded: bool = True,                      
+        allow_files: bool = True,                          
+        allow_stickers: bool = True,                       
+        allow_polls: bool = True,                          
+        allow_contacts: bool = True,                       
+        allow_locations: bool = True,                      
+        min_text_length: Optional[int] = None,             
+        max_text_length: Optional[int] = None,             
+        contains: Optional[str] = None,                    
+        startswith: Optional[str] = None,                  
+        endswith: Optional[str] = None,                    
+        case_sensitive: bool = False                       
+    ):
+        """
+        Advanced decorator for handling only private messages with extended filters.
+        """
+
+        def decorator(func: Callable[[Any, Message], None]):
+            async def wrapper(bot, message: Message):
+                
+                if not message.is_private:
+                    return
+
+                
+                if chat_id:
+                    if isinstance(chat_id, str) and message.chat_id != chat_id:
+                        return
+                    if isinstance(chat_id, list) and message.chat_id not in chat_id:
+                        return
+
+                
+                if sender_id:
+                    if isinstance(sender_id, str) and message.sender_id != sender_id:
+                        return
+                    if isinstance(sender_id, list) and message.sender_id not in sender_id:
+                        return
+
+                
+                if sender_type and message.sender_type != sender_type:
+                    return
+
+                
+                if not allow_forwarded and message.forwarded_from:
+                    return
+
+                
+                if not allow_files and message.file:
+                    return
+                if not allow_stickers and message.sticker:
+                    return
+                if not allow_polls and message.poll:
+                    return
+                if not allow_contacts and message.contact_message:
+                    return
+                if not allow_locations and (message.location or message.live_location):
+                    return
+
+                
+                if message.text:
+                    text = message.text if case_sensitive else message.text.lower()
+                    if min_text_length and len(message.text) < min_text_length:
+                        return
+                    if max_text_length and len(message.text) > max_text_length:
+                        return
+                    if contains and (contains if case_sensitive else contains.lower()) not in text:
+                        return
+                    if startswith and not text.startswith(startswith if case_sensitive else startswith.lower()):
+                        return
+                    if endswith and not text.endswith(endswith if case_sensitive else endswith.lower()):
+                        return
+
+                
+                if commands:
+                    if not message.text:
+                        return
+                    parts = message.text.strip().split()
+                    cmd = parts[0].lstrip("/")
+                    if cmd not in commands:
+                        return
+                    message.args = parts[1:]  
+
+                
+                if filters and not filters(message):
+                    return
+
+                return await func(bot, message)
+
+            self._message_handlers.append({
+                "func": wrapper,
+                "filters": filters,
+                "commands": commands,
+                "chat_id": chat_id,
+                "private_only": True,
+                "sender_id": sender_id,
+                "sender_type": sender_type
+            })
+            return wrapper
+        return decorator
+    def on_message_channel(
+        self,
+        chat_id: Optional[Union[str, List[str]]] = None,   
+        commands: Optional[List[str]] = None,              
+        filters: Optional[Callable[[Message], bool]] = None, 
+        sender_id: Optional[Union[str, List[str]]] = None, 
+        sender_type: Optional[str] = None,                 
+        allow_forwarded: bool = True,                      
+        allow_files: bool = True,                          
+        allow_stickers: bool = True,                       
+        allow_polls: bool = True,                          
+        allow_contacts: bool = True,                       
+        allow_locations: bool = True,                      
+        min_text_length: Optional[int] = None,             
+        max_text_length: Optional[int] = None,             
+        contains: Optional[str] = None,                    
+        startswith: Optional[str] = None,                  
+        endswith: Optional[str] = None,                    
+        case_sensitive: bool = False                       
+    ):
+        """
+        Advanced decorator for handling only channel messages with extended filters.
+        """
+
+        def decorator(func: Callable[[Any, Message], None]):
+            async def wrapper(bot, message: Message):
+                
+                if not message.is_channel:
+                    return
+
+                
+                if chat_id:
+                    if isinstance(chat_id, str) and message.chat_id != chat_id:
+                        return
+                    if isinstance(chat_id, list) and message.chat_id not in chat_id:
+                        return
+
+                
+                if sender_id:
+                    if isinstance(sender_id, str) and message.sender_id != sender_id:
+                        return
+                    if isinstance(sender_id, list) and message.sender_id not in sender_id:
+                        return
+
+                
+                if sender_type and message.sender_type != sender_type:
+                    return
+
+                
+                if not allow_forwarded and message.forwarded_from:
+                    return
+
+                
+                if not allow_files and message.file:
+                    return
+                if not allow_stickers and message.sticker:
+                    return
+                if not allow_polls and message.poll:
+                    return
+                if not allow_contacts and message.contact_message:
+                    return
+                if not allow_locations and (message.location or message.live_location):
+                    return
+
+                
+                if message.text:
+                    text = message.text if case_sensitive else message.text.lower()
+                    if min_text_length and len(message.text) < min_text_length:
+                        return
+                    if max_text_length and len(message.text) > max_text_length:
+                        return
+                    if contains and (contains if case_sensitive else contains.lower()) not in text:
+                        return
+                    if startswith and not text.startswith(startswith if case_sensitive else startswith.lower()):
+                        return
+                    if endswith and not text.endswith(endswith if case_sensitive else endswith.lower()):
+                        return
+
+                
+                if commands:
+                    if not message.text:
+                        return
+                    parts = message.text.strip().split()
+                    cmd = parts[0].lstrip("/")
+                    if cmd not in commands:
+                        return
+                    message.args = parts[1:]  
+
+                
+                if filters and not filters(message):
+                    return
+
+                return await func(bot, message)
+
+            self._message_handlers.append({
+                "func": wrapper,
+                "filters": filters,
+                "commands": commands,
+                "chat_id": chat_id,
+                "group_only": True,
+                "sender_id": sender_id,
+                "sender_type": sender_type
+            })
+            return wrapper
+        return decorator
+    def on_message_group(
+        self,
+        chat_id: Optional[Union[str, List[str]]] = None,   
+        commands: Optional[List[str]] = None,
+        filters: Optional[Callable[[Message], bool]] = None, 
+        sender_id: Optional[Union[str, List[str]]] = None, 
+        sender_type: Optional[str] = None,                 
+        allow_forwarded: bool = True,                      
+        allow_files: bool = True,                          
+        allow_stickers: bool = True,                       
+        allow_polls: bool = True,                          
+        allow_contacts: bool = True,                       
+        allow_locations: bool = True,                      
+        min_text_length: Optional[int] = None,             
+        max_text_length: Optional[int] = None,             
+        contains: Optional[str] = None,                    
+        startswith: Optional[str] = None,                  
+        endswith: Optional[str] = None,                    
+        case_sensitive: bool = False                       
+    ):
+        """
+        Advanced decorator for handling only group messages with extended filters.
+        """
+
+        def decorator(func: Callable[[Any, Message], None]):
+            async def wrapper(bot, message: Message):
+                
+                if not message.is_group:
+                    return
+
+                
+                if chat_id:
+                    if isinstance(chat_id, str) and message.chat_id != chat_id:
+                        return
+                    if isinstance(chat_id, list) and message.chat_id not in chat_id:
+                        return
+
+                
+                if sender_id:
+                    if isinstance(sender_id, str) and message.sender_id != sender_id:
+                        return
+                    if isinstance(sender_id, list) and message.sender_id not in sender_id:
+                        return
+
+                
+                if sender_type and message.sender_type != sender_type:
+                    return
+
+                
+                if not allow_forwarded and message.forwarded_from:
+                    return
+
+                
+                if not allow_files and message.file:
+                    return
+                if not allow_stickers and message.sticker:
+                    return
+                if not allow_polls and message.poll:
+                    return
+                if not allow_contacts and message.contact_message:
+                    return
+                if not allow_locations and (message.location or message.live_location):
+                    return
+
+                
+                if message.text:
+                    text = message.text if case_sensitive else message.text.lower()
+                    if min_text_length and len(message.text) < min_text_length:
+                        return
+                    if max_text_length and len(message.text) > max_text_length:
+                        return
+                    if contains and (contains if case_sensitive else contains.lower()) not in text:
+                        return
+                    if startswith and not text.startswith(startswith if case_sensitive else startswith.lower()):
+                        return
+                    if endswith and not text.endswith(endswith if case_sensitive else endswith.lower()):
+                        return
+
+                
+                if commands:
+                    if not message.text:
+                        return
+                    parts = message.text.strip().split()
+                    cmd = parts[0].lstrip("/")
+                    if cmd not in commands:
+                        return
+                    message.args = parts[1:]  
+
+                
+                if filters and not filters(message):
+                    return
+
+                return await func(bot, message)
+
+            self._message_handlers.append({
+                "func": wrapper,
+                "filters": filters,
+                "commands": commands,
+                "chat_id": chat_id,
+                "group_only": True,
+                "sender_id": sender_id,
+                "sender_type": sender_type
+            })
+            return wrapper
+        return decorator
 
     def on_message(self, filters: Optional[Callable[[Message], bool]] = None, commands: Optional[List[str]] = None):
         def decorator(func: Callable[[Any, Message], None]):
@@ -204,9 +525,39 @@ 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 on_callback_query(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 +623,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 +713,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 +1104,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 +1119,7 @@ class Robot:
                                 else:
                                     continue
 
+                                
                                 message_id = None
                                 if update.get("type") == "NewMessage":
                                     message_id = update.get("new_message", {}).get("message_id")
@@ -398,17 +1127,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 +1150,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 +1341,93 @@ 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 : Union[str, list],
+    username :  Union[str, list], 
+    text,
+    reply_to_message_id=None, 
+    id="None"):
+        from .button import InlineBuilder
+        builder = InlineBuilder()
+
+        if isinstance(username, (list, tuple)) and isinstance(title_button, (list, tuple)):
+            for t, u in zip(title_button, username):
+                builder = builder.row(
+                    InlineBuilder().button_join_channel(
+                        text=t,
+                        id=id,
+                        username=u
+                    )
+                ) 
+        elif isinstance(username, (list, tuple)) and isinstance(title_button, str):
+            for u in username:
+                builder = builder.row(
+                    InlineBuilder().button_join_channel(
+                        text=title_button,  
+                        id=id,
+                        username=u
+                    )
+                )
+        else:
+            builder = builder.row(
+                InlineBuilder().button_join_channel(
+                    text=title_button,
+                    id=id,
+                    username=username
+                )
+            )
+        return await self.send_message(
+            chat_id=chat_id,
+            text=text,
+            inline_keypad=builder.build(),
+            reply_to_message_id=reply_to_message_id
+        )
+    async def send_button_link(
+    self, 
+    chat_id, 
+    title_button: Union[str, list],
+    url: Union[str, list], 
+    text,
+    reply_to_message_id=None, 
+    id="None"
+    ):
+        from .button import InlineBuilder
+        builder = InlineBuilder()
+        if isinstance(url, (list, tuple)) and isinstance(title_button, (list, tuple)):
+            for t, u in zip(title_button, url):
+                builder = builder.row(
+                    InlineBuilder().button_url_link(
+                        text=t,
+                        id=id,
+                        url=u
+                    )
+                )
+        elif isinstance(url, (list, tuple)) and isinstance(title_button, str):
+            for u in url:
+                builder = builder.row(
+                    InlineBuilder().button_url_link(
+                        text=title_button,
+                        id=id,
+                        url=u
+                    )
+                )
+        else:
+            builder = builder.row(
+                InlineBuilder().button_url_link(
+                    text=title_button,
+                    id=id,
+                    url=url
+                )
+            )
+
+        return await self.send_message(
+            chat_id=chat_id,
+            text=text,
+            inline_keypad=builder.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):