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

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,330 @@ 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_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
+    ):
+        """
+        Sync decorator for handling only private messages with extended filters.
+        """
+
+        def decorator(func: Callable[[Any, Message], None]):
+            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 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
+    ):
+        """
+        Sync decorator for handling only private messages with extended filters.
+        """
+
+        def decorator(func: Callable[[Any, Message], None]):
+            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 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_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
+    ):
+        """
+        Sync decorator for handling only group messages with extended filters.
+        """
+
+        def decorator(func: Callable[[Any, Message], None]):
+            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 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]):
             self._message_handlers.append({
@@ -172,6 +498,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 +518,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 +573,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 +663,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()
+    import datetime
 
-                    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
-
-                            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 +1081,109 @@ class Robot:
         data = response.json()
         return data.get('data', {}).get('file_id')
 
+    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 self.send_message(
+            chat_id=chat_id,
+            text=text,
+            inline_keypad=builder.build(),
+            reply_to_message_id=reply_to_message_id
+        )
+
+
+    def send_button_url(
+        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 self.send_message(
+            chat_id=chat_id,
+            text=text,
+            inline_keypad=builder.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']