Rubka 6.4.8__py3-none-any.whl → 6.6.2__py3-none-any.whl

rubka/api.py

@@ -3,6 +3,7 @@ from typing import List, Optional, Dict, Any, Literal
 from .exceptions import APIRequestError
 from .adaptorrubka import Client as Client_get
 from .logger import logger
+from . import filters
 from typing import Callable
 from .context import Message,InlineMessage
 from typing import Optional, Union, Literal, Dict, Any
@@ -489,14 +490,28 @@ class Robot:
 
         return decorator
 
-    def on_message(self, filters: Optional[Callable[[Message], bool]] = None, commands: Optional[List[str]] = None):
+    def on_message(
+        self, 
+        filters: Optional[Callable[[Message], bool]] = None, 
+        commands: Optional[List[str]] = None
+    ):
         def decorator(func: Callable[[Any, Message], None]):
+            def wrapper(bot, message: Message):
+                if filters and not filters(message):
+                    return
+                if commands:
+                    if not getattr(message, "is_command", False):
+                        return
+                    cmd = message.text.split()[0].lstrip("/") if message.text else ""
+                    if cmd not in commands:
+                        return
+                return func(bot, message)
             self._message_handlers.append({
-                "func": func,
+                "func": wrapper,
                 "filters": filters,
                 "commands": commands
             })
-            return func
+            return wrapper
         return decorator
     def on_message_file(self, filters: Optional[Callable[[Message], bool]] = None, commands: Optional[List[str]] = None):
         def decorator(func: Callable[[Any, Message], None]):
@@ -1654,9 +1669,11 @@ class Robot:
         self,
         chat_id: str,
         message_id: str,
-        inline_keypad: Dict[str, Any]
+        inline_keypad: Dict[str, Any],
+        text : str = None
     ) -> Dict[str, Any]:
         """Edit inline keypad of a message."""
+        if text is not None:self._post("editMessageText", {"chat_id": chat_id,"message_id": message_id,"text": text})
         return self._post("editMessageKeypad", {
             "chat_id": chat_id,
             "message_id": message_id,

rubka/asynco.py

@@ -1,30 +1,19 @@
-import asyncio
-import aiohttp
-import aiofiles
+import asyncio,aiohttp,aiofiles,time,datetime,json,tempfile,os,sys,subprocess,mimetypes
 from typing import List, Optional, Dict, Any, Literal, Callable, Union
 from .exceptions import APIRequestError
 from .adaptorrubka import Client as Client_get
 from .logger import logger
-try:
-    from .context import Message, InlineMessage
-except (ImportError, ModuleNotFoundError):
-    from context import Message, InlineMessage
+from . import filters
+try:from .context import Message, InlineMessage
+except (ImportError, ModuleNotFoundError):from context import Message, InlineMessage
 class FeatureNotAvailableError(Exception):
     pass
 
 from tqdm.asyncio import tqdm
 from urllib.parse import urlparse, parse_qs
 class InvalidTokenError(Exception):pass
-import mimetypes
 from pathlib import Path
-import time
-import datetime,json
-import tempfile
 from tqdm import tqdm
-import os
-import sys
-import subprocess
-
 API_URL = "https://botapi.rubika.ir/v3"
 
 def install_package(package_name: str) -> bool:
@@ -34,31 +23,7 @@ def install_package(package_name: str) -> bool:
         return True
     except Exception:
         return False
-class MessageResponse:
-    def __init__(self, resp: dict, chat_id: str, file_id: str,
-                 type_file: str, reply_to_message_id: str,
-                 disable_notification: bool, text: str = None,
-                 chat_keypad=None, inline_keypad=None, chat_keypad_type="None"):
-        
-        self.status = resp.get("status")
-        self.status_det = resp.get("status_det")
-        self.file_id = file_id
-        self.message_id = resp["data"].get("message_id")
-        self.send_to_chat_id = chat_id
-        self.reply_to_message_id = reply_to_message_id
-        self.disable_notification = disable_notification
-        self.type_file = type_file
-        self.text = text
-        self.chat_keypad = chat_keypad
-        self.inline_keypad = inline_keypad
-        self.chat_keypad_type = chat_keypad_type
-        self.raw_response = resp
-
-    def to_dict(self):
-        return self.__dict__
-
-    def to_json(self):
-        return json.dumps(self.__dict__, ensure_ascii=False, indent=4)
+
 def get_importlib_metadata():
     """Dynamically imports and returns metadata functions from importlib."""
     try:
@@ -123,12 +88,40 @@ def show_last_six_words(text: str) -> str:
     """Returns the last 6 characters of a stripped string."""
     text = text.strip()
     return text[-6:]
-
+class AttrDict(dict):
+    def __getattr__(self, item):
+        value = self.get(item)
+        if isinstance(value, dict):
+            return AttrDict(value)
+        return value
 
 class Robot:
     """
-    Main async class to interact with Rubika Bot API.
-    Initialized with a bot token.
+    Main asynchronous class to interact with the Rubika Bot API.
+
+    This class handles sending and receiving messages, inline queries, callbacks,
+    and manages sessions and API interactions. It is initialized with a bot token
+    and provides multiple optional parameters for configuration.
+
+    Attributes:
+        token (str): Bot token used for authentication with Rubika Bot API.
+        session_name (str | None): Optional session name for storing session data.
+        auth (str | None): Optional authentication string for advanced features.
+        Key (str | None): Optional key for additional authorization if required.
+        platform (str): Platform type, default is 'web'.
+        web_hook (str | None): Optional webhook URL for receiving updates.
+        timeout (int): Timeout for API requests in seconds (default 10).
+        show_progress (bool): Whether to show progress for long operations (default False).
+    Example:
+    ```python
+        import asyncio
+        from rubka.asynco import Robot,filters,Message
+        bot = Robot(token="YOUR_BOT_TOKEN")
+        @bot.on_message(filters.is_command.start)
+        async def start_command(bot: Robot, message: Message):
+            await message.reply("Hello!")
+        asyncio.run(bot.run())
+        
     """
 
     def __init__(self, token: str, session_name: str = None, auth: str = None, Key: str = None, platform: str = "web", web_hook: str = None, timeout: int = 10, show_progress: bool = False):
@@ -172,7 +165,6 @@ class Robot:
                 print(data)
                 json_url = data.get('url', self.web_hook)
                 print(self.web_hook)
-
             for endpoint_type in [
                     "ReceiveUpdate",
                     "ReceiveInlineMessage",
@@ -186,8 +178,6 @@ class Robot:
         except Exception as e:
             logger.error(f"Failed to set webhook from {self.web_hook}: {e}")
             self.web_hook = None
-
-
     async def _post(self, method: str, data: Dict[str, Any]) -> Dict[str, Any]:
         url = f"{API_URL}/{self.token}/{method}"
         session = await self._get_session()
@@ -200,11 +190,9 @@ class Robot:
                     text_resp = await response.text()
                     logger.error(f"Invalid JSON response from {method}: {text_resp}")
                     raise APIRequestError(f"Invalid JSON response: {text_resp}")
-                
                 if method != "getUpdates":
                     logger.debug(f"API Response from {method}: {json_resp}")
-                
-                return json_resp
+                return AttrDict(json_resp)
         except aiohttp.ClientError as e:
             logger.error(f"API request failed: {e}")
             raise APIRequestError(f"API request failed: {e}") from e
@@ -274,8 +262,6 @@ class Robot:
                     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:
@@ -288,8 +274,6 @@ class Robot:
                         return
                     if endswith and not text.endswith(endswith if case_sensitive else endswith.lower()):
                         return
-
-                
                 if commands:
                     if not message.text:
                         return
@@ -298,13 +282,9 @@ class Robot:
                     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,
@@ -345,30 +325,20 @@ class Robot:
                 
                 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:
@@ -379,8 +349,6 @@ class Robot:
                     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:
@@ -393,8 +361,6 @@ class Robot:
                         return
                     if endswith and not text.endswith(endswith if case_sensitive else endswith.lower()):
                         return
-
-                
                 if commands:
                     if not message.text:
                         return
@@ -402,14 +368,10 @@ class Robot:
                     cmd = parts[0].lstrip("/")
                     if cmd not in commands:
                         return
-                    message.args = parts[1:]  
-
-                
+                    message.args = parts[1:]
                 if filters and not filters(message):
                     return
-
                 return await func(bot, message)
-
             self._message_handlers.append({
                 "func": wrapper,
                 "filters": filters,
@@ -447,33 +409,22 @@ class Robot:
 
         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:
@@ -484,8 +435,6 @@ class Robot:
                     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:
@@ -498,8 +447,6 @@ class Robot:
                         return
                     if endswith and not text.endswith(endswith if case_sensitive else endswith.lower()):
                         return
-
-                
                 if commands:
                     if not message.text:
                         return
@@ -508,13 +455,9 @@ class Robot:
                     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,
@@ -527,15 +470,27 @@ class Robot:
             return wrapper
         return decorator
 
-    def on_message(self, filters: Optional[Callable[[Message], bool]] = None, commands: Optional[List[str]] = None):
+    def on_message(
+    self, 
+    filters: Optional[Callable[[Message], bool]] = None, 
+    commands: Optional[List[str]] = None
+    ):
         def decorator(func: Callable[[Any, Message], None]):
+            async def wrapper(bot, message: Message):
+                if filters and not filters(message):return
+                if commands:
+                    if not message.is_command:return
+                    cmd = message.text.split()[0].lstrip("/")
+                    if cmd not in commands:return
+                return await func(bot, message)
             self._message_handlers.append({
-                "func": func,
+                "func": wrapper,
                 "filters": filters,
                 "commands": commands
             })
-            return func
+            return wrapper
         return decorator
+
     
     def on_message_file(self, filters: Optional[Callable[[Message], bool]] = None, commands: Optional[List[str]] = None):
         def decorator(func: Callable[[Any, Message], None]):
@@ -725,13 +680,12 @@ class Robot:
 
     async def _handle_inline_query(self, inline_message: InlineMessage):
         aux_button_id = inline_message.aux_data.button_id if inline_message.aux_data else None
-
         for handler in self._inline_query_handlers:
             if handler["button_id"] is None or handler["button_id"] == aux_button_id:
                 try:
                     await handler["func"](self, inline_message)
                 except Exception as e:
-                    print(f"Error in inline query handler: {e}")
+                    raise Exception(f"Error in inline query handler: {e}")
 
     def on_inline_query(self, button_id: Optional[str] = None):
         def decorator(func: Callable[[Any, InlineMessage], None]):
@@ -744,33 +698,19 @@ class Robot:
     def on_inline_query_prefix(self, prefix: str, button_id: Optional[str] = None):
         if not prefix.startswith('/'):
             prefix = '/' + prefix
-
         def decorator(func: Callable[[Any, InlineMessage], None]):
-            
             async def handler_wrapper(bot_instance, inline_message: InlineMessage):
-                
                 if not inline_message.raw_data or 'text' not in inline_message.raw_data:
                     return
-
                 query_text = inline_message.raw_data['text']
-
-                
                 if query_text.startswith(prefix):
-                    
-                    
-                    
                     try:
                         await func(bot_instance, inline_message)
                     except Exception as e:
-                        print(f"Error in inline query prefix handler '{prefix}': {e}")
-            
-            
+                        raise Exception(f"Error in inline query prefix handler '{prefix}': {e}")
             self._inline_query_handlers.append({
                 "func": handler_wrapper,
-                "button_id": button_id 
-                                        
-                                        
-                                        
+                "button_id": button_id                           
             })
             return func 
         return decorator
@@ -778,40 +718,29 @@ 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
 
         if update.get("type") == "NewMessage":
             msg = update.get("new_message", {})
             try:
-                if msg.get("time") and (time.time() - float(msg["time"])) > 20:
-                    return
-            except (ValueError, TypeError):
-                return
-                
+                if msg.get("time") and (time.time() - float(msg["time"])) > 20:return
+            except (ValueError, TypeError):return
             context = Message(bot=self, 
                               chat_id=update.get("chat_id"), 
                               message_id=msg.get("message_id"), 
                               sender_id=msg.get("sender_id"), 
                               text=msg.get("text"), 
                               raw_data=msg)
-            
-            
             if context.aux_data and self._callback_handlers:
                 for handler in self._callback_handlers:
                     if not handler["button_id"] or context.aux_data.button_id == handler["button_id"]:
                         asyncio.create_task(handler["func"](self, context))
                         return
-
-            
             if self._message_handlers:
                 for handler_info in self._message_handlers:
                     
@@ -823,18 +752,12 @@ class Robot:
                         if cmd not in handler_info["commands"]:
                             continue  
                         context.args = parts[1:]
-                    
-                    
                     if handler_info["filters"]:
                         if not handler_info["filters"](context):
                             continue 
-                    
-                    
                     if not handler_info["commands"] and not handler_info["filters"]:
                         asyncio.create_task(handler_info["func"](self, context))
                         continue 
-                    
-                    
                     if handler_info["commands"] or handler_info["filters"]:
                         asyncio.create_task(handler_info["func"](self, context))#jaq
                         continue 
@@ -851,25 +774,18 @@ class Robot:
         if offset_id: params['offset_id'] = offset_id
         if limit: params['limit'] = limit
         async with session.get(self.web_hook, params=params) as response:
-            response.raise_for_status()
-            
+            response.raise_for_status() 
             return await response.json()
 
     def _is_duplicate(self, message_id: str, max_age_sec: int = 300) -> bool:
         now = time.time()
         expired = [mid for mid, ts in self._processed_message_ids.items() if now - ts > max_age_sec]
-        for mid in expired:
-            del self._processed_message_ids[mid]
-
-        if message_id in self._processed_message_ids:
-            return True
-
+        for mid in expired:del self._processed_message_ids[mid]
+        if message_id in self._processed_message_ids:return True
         self._processed_message_ids[message_id] = now
         return False
     
 
-    
-
     async def run(
         self,
         debug: bool = False,
@@ -1436,8 +1352,7 @@ class Robot:
             
             
             _log("Auto-restart requested. You can call run(...) again as needed.", "warning")
-
-            
+      
     async def send_message(
     self,
     chat_id: str,
@@ -1447,27 +1362,21 @@ class Robot:
     disable_notification: bool = False,
     reply_to_message_id: Optional[str] = None,
     chat_keypad_type: Optional[Literal["New", "Removed"]] = None
-) -> Dict[str, Any]:
+    ) -> Dict[str, Any]:
         payload = {
             "chat_id": chat_id,
             "text": text,
             "disable_notification": disable_notification,
         }
-
         if chat_keypad:
             payload["chat_keypad"] = chat_keypad
             payload["chat_keypad_type"] = chat_keypad_type or "New"
-
         if inline_keypad:
             payload["inline_keypad"] = inline_keypad
-
         if reply_to_message_id:
             payload["reply_to_message_id"] = reply_to_message_id
-
         return await self._post("sendMessage", payload)
 
-
-    
     async def get_url_file(self,file_id):
         data = await self._post("getFile", {'file_id': file_id})
         return data.get("data").get("download_url")
@@ -1480,14 +1389,11 @@ class Robot:
             
     async def check_join(self, channel_guid: str, chat_id: str = None) -> Union[bool, list[str]]:
         client = self._get_client()
-
         if chat_id:
             chat_info_data = await self.get_chat(chat_id)
             chat_info = chat_info_data.get('data', {}).get('chat', {})
             username = chat_info.get('username')
             user_id = chat_info.get('user_id')
-            
-            
             if username:
                 result = await asyncio.to_thread(self.get_all_member, channel_guid, search_text=username)
                 members = result.get('in_chat_members', [])
@@ -1506,7 +1412,6 @@ class Robot:
     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(
@@ -1576,55 +1481,41 @@ class Robot:
                     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):
-        
         client = self._get_client()
         return client.get_all_members(channel_guid, search_text, start_id, just_get_guids)
-
     async def send_poll(self, chat_id: str, question: str, options: List[str]) -> Dict[str, Any]:
         return await self._post("sendPoll", {"chat_id": chat_id, "question": question, "options": options})
-
     async def send_location(self, chat_id: str, latitude: str, longitude: str, disable_notification: bool = False, inline_keypad: Optional[Dict[str, Any]] = None, reply_to_message_id: Optional[str] = None, chat_keypad_type: Optional[Literal["New", "Removed"]] = None) -> Dict[str, Any]:
         payload = {"chat_id": chat_id, "latitude": latitude, "longitude": longitude, "disable_notification": disable_notification}
         if inline_keypad: payload["inline_keypad"] = inline_keypad
         if reply_to_message_id: payload["reply_to_message_id"] = reply_to_message_id
         if chat_keypad_type: payload["chat_keypad_type"] = chat_keypad_type
         return await self._post("sendLocation", {k: v for k, v in payload.items() if v is not None})
-
     async def send_contact(self, chat_id: str, first_name: str, last_name: str, phone_number: str) -> Dict[str, Any]:
         return await self._post("sendContact", {"chat_id": chat_id, "first_name": first_name, "last_name": last_name, "phone_number": phone_number})
-
     async def get_chat(self, chat_id: str) -> Dict[str, Any]:
         return await self._post("getChat", {"chat_id": chat_id})
-
     async def upload_media_file(self, upload_url: str, name: str, path: Union[str, Path]) -> str:
         is_temp_file = False
         session = await self._get_session()
-
         if isinstance(path, str) and path.startswith("http"):
             async with session.get(path) as response:
                 if response.status != 200:
                     raise Exception(f"Failed to download file from URL ({response.status})")
-                
                 content = await response.read()
-                
                 with tempfile.NamedTemporaryFile(delete=False) as temp_file:
                     temp_file.write(content)
                     path = temp_file.name
                     is_temp_file = True
-
         file_size = os.path.getsize(path)
-
         progress_bar = tqdm(total=file_size, unit='B', unit_scale=True, unit_divisor=1024, desc=f'Uploading : {name}', bar_format='{l_bar}{bar:100}{r_bar}', colour='cyan', disable=not self.show_progress)
-
         async def file_progress_generator(file_path, chunk_size=8192):
             async with aiofiles.open(file_path, 'rb') as f:
                 while True:
@@ -1633,7 +1524,6 @@ class Robot:
                         break
                     progress_bar.update(len(chunk))
                     yield chunk
-        
         data = aiohttp.FormData()
         data.add_field('file', file_progress_generator(path), filename=name, content_type='application/octet-stream')
         try:
@@ -1648,12 +1538,9 @@ class Robot:
                 return json_data.get('data', {}).get('file_id')
         except :
             raise FeatureNotAvailableError(f"files is not currently supported by the server.")
-
-
     def get_extension(content_type: str) -> str:
         ext = mimetypes.guess_extension(content_type)
         return ext if ext else ''
-
     async def download(self, file_id: str, save_as: str = None, chunk_size: int = 1024 * 512,timeout_sec: int = 60, verbose: bool = False):
         """
         Download a file from server using its file_id with chunked transfer,
@@ -1672,16 +1559,11 @@ class Robot:
         Returns:
             bool: True if success, raises exceptions otherwise.
         """
-
         try:
             url = await self.get_url_file(file_id)
-            if not url:
-                raise ValueError("Download URL not found in response.")
-        except Exception as e:
-            raise ValueError(f"Failed to get download URL: {e}")
-
+            if not url:raise ValueError("Download URL not found in response.")
+        except Exception as e:raise ValueError(f"Failed to get download URL: {e}")
         timeout = aiohttp.ClientTimeout(total=timeout_sec)
-
         try:
             async with aiohttp.ClientSession(timeout=timeout) as session:
                 async with session.get(url) as resp:
@@ -1693,21 +1575,17 @@ class Robot:
                             message="Failed to download file.",
                             headers=resp.headers
                         )
-
                     if not save_as:
                         content_disp = resp.headers.get("Content-Disposition", "")
                         import re
                         match = re.search(r'filename="?([^\";]+)"?', content_disp)
-                        if match:
-                            save_as = match.group(1)
+                        if match:save_as = match.group(1)
                         else:
                             content_type = resp.headers.get("Content-Type", "").split(";")[0]
                             extension = mimetypes.guess_extension(content_type) or ".bin"
                             save_as = f"{file_id}{extension}"
-
                     total_size = int(resp.headers.get("Content-Length", 0))
                     progress = tqdm(total=total_size, unit="B", unit_scale=True, disable=not verbose)
-
                     async with aiofiles.open(save_as, "wb") as f:
                         async for chunk in resp.content.iter_chunked(chunk_size):
                             await f.write(chunk)
@@ -1770,7 +1648,7 @@ class Robot:
             "inline_keypad":inline_keypad,
             "chat_keypad_type":chat_keypad_type
         }
-        return result
+        return AttrDict(result)
 
     async def _send_file_generic(self, media_type, chat_id, path, file_id, text, file_name, inline_keypad, chat_keypad, reply_to_message_id, disable_notification, chat_keypad_type):
         if path:
@@ -1789,43 +1667,31 @@ class Robot:
         return await self._send_file_generic("File", chat_id, path, file_id, caption, file_name, inline_keypad, chat_keypad, reply_to_message_id, disable_notification, chat_keypad_type)  
     async def send_music(self, chat_id: str, path: Optional[Union[str, Path]] = None, file_id: Optional[str] = None, text: Optional[str] = None, file_name: Optional[str] = "music", inline_keypad: Optional[Dict[str, Any]] = None, chat_keypad: Optional[Dict[str, Any]] = None, reply_to_message_id: Optional[str] = None, disable_notification: bool = False, chat_keypad_type: Optional[Literal["New", "Removed", "None"]] = "None") -> Dict[str, Any]:
         return await self._send_file_generic("File", chat_id, path, file_id, text, f"{file_name}.ogg", inline_keypad, chat_keypad, reply_to_message_id, disable_notification, chat_keypad_type)
-
     async def send_video(self, chat_id: str, path: Optional[Union[str, Path]] = None, file_id: Optional[str] = None, text: Optional[str] = None, file_name: Optional[str] = None, inline_keypad: Optional[Dict[str, Any]] = None, chat_keypad: Optional[Dict[str, Any]] = None, reply_to_message_id: Optional[str] = None, disable_notification: bool = False, chat_keypad_type: Optional[Literal["New", "Removed", "None"]] = "None") -> Dict[str, Any]:
         return await self._send_file_generic("Video", chat_id, path, file_id, text, file_name, inline_keypad, chat_keypad, reply_to_message_id, disable_notification, chat_keypad_type)
-
     async def send_voice(self, chat_id: str, path: Optional[Union[str, Path]] = None, file_id: Optional[str] = None, text: Optional[str] = None, file_name: Optional[str] = None, inline_keypad: Optional[Dict[str, Any]] = None, chat_keypad: Optional[Dict[str, Any]] = None, reply_to_message_id: Optional[str] = None, disable_notification: bool = False, chat_keypad_type: Optional[Literal["New", "Removed", "None"]] = "None") -> Dict[str, Any]:
         return await self._send_file_generic("voice", chat_id, path, file_id, text, file_name, inline_keypad, chat_keypad, reply_to_message_id, disable_notification, chat_keypad_type)
-
     async def send_image(self, chat_id: str, path: Optional[Union[str, Path]] = None, file_id: Optional[str] = None, text: Optional[str] = None, file_name: Optional[str] = None, inline_keypad: Optional[Dict[str, Any]] = None, chat_keypad: Optional[Dict[str, Any]] = None, reply_to_message_id: Optional[str] = None, disable_notification: bool = False, chat_keypad_type: Optional[Literal["New", "Removed", "None"]] = "None") -> Dict[str, Any]:
         return await self._send_file_generic("Image", chat_id, path, file_id, text, file_name, inline_keypad, chat_keypad, reply_to_message_id, disable_notification, chat_keypad_type)
-        
     async def send_gif(self, chat_id: str, path: Optional[Union[str, Path]] = None, file_id: Optional[str] = None, text: Optional[str] = None, file_name: Optional[str] = None, inline_keypad: Optional[Dict[str, Any]] = None, chat_keypad: Optional[Dict[str, Any]] = None, reply_to_message_id: Optional[str] = None, disable_notification: bool = False, chat_keypad_type: Optional[Literal["New", "Removed", "None"]] = "None") -> Dict[str, Any]:
         return await self._send_file_generic("Gif", chat_id, path, file_id, text, file_name, inline_keypad, chat_keypad, reply_to_message_id, disable_notification, chat_keypad_type)
-
     async def forward_message(self, from_chat_id: str, message_id: str, to_chat_id: str, disable_notification: bool = False) -> Dict[str, Any]:
         return await self._post("forwardMessage", {"from_chat_id": from_chat_id, "message_id": message_id, "to_chat_id": to_chat_id, "disable_notification": disable_notification})
-
     async def edit_message_text(self, chat_id: str, message_id: str, text: str) -> Dict[str, Any]:
         return await self._post("editMessageText", {"chat_id": chat_id, "message_id": message_id, "text": text})
-
-    async def edit_inline_keypad(self, chat_id: str, message_id: str, inline_keypad: Dict[str, Any]) -> Dict[str, Any]:
-        return await self._post("editMessageKeypad", {"chat_id": chat_id, "message_id": message_id, "inline_keypad": inline_keypad})
-
+    async def edit_inline_keypad(self,chat_id: str,message_id: str,inline_keypad: Dict[str, Any],text: str = None) -> Dict[str, Any]:
+        if text is not None:await self._post("editMessageText", {"chat_id": chat_id,"message_id": message_id,"text": text})
+        return await self._post("editMessageKeypad", {"chat_id": chat_id,"message_id": message_id,"inline_keypad": inline_keypad})
     async def delete_message(self, chat_id: str, message_id: str) -> Dict[str, Any]:
         return await self._post("deleteMessage", {"chat_id": chat_id, "message_id": message_id})
-
     async def set_commands(self, bot_commands: List[Dict[str, str]]) -> Dict[str, Any]:
         return await self._post("setCommands", {"bot_commands": bot_commands})
-
     async def update_bot_endpoint(self, url: str, type: str) -> Dict[str, Any]:
         return await self._post("updateBotEndpoints", {"url": url, "type": type})
-
     async def remove_keypad(self, chat_id: str) -> Dict[str, Any]:
         return await self._post("editChatKeypad", {"chat_id": chat_id, "chat_keypad_type": "Removed"})
-
     async def edit_chat_keypad(self, chat_id: str, chat_keypad: Dict[str, Any]) -> Dict[str, Any]:
         return await self._post("editChatKeypad", {"chat_id": chat_id, "chat_keypad_type": "New", "chat_keypad": chat_keypad})
-
     async def get_name(self, chat_id: str) -> str:
         try:
             chat = await self.get_chat(chat_id)
@@ -1841,9 +1707,6 @@ class Robot:
                 return title if title else "null"
             else:return "null"
         except Exception:return "null"
-
-    
-
     async def get_username(self, chat_id: str) -> str:
         chat_info = await self.get_chat(chat_id)
         return chat_info.get("data", {}).get("chat", {}).get("username", "None")

rubka/filters.py

@@ -0,0 +1,305 @@
+from typing import Callable
+import re
+class TextFilter:
+    def __call__(self, keyword=None):
+        if keyword is None:
+            return Filter(lambda m: getattr(m, "is_text", False))
+        else:
+            return Filter(lambda m: getattr(m, "is_text", False) and keyword in getattr(m, "text", ""))
+class Filter:
+    def __init__(self, func: Callable):
+        self.func = func
+
+    def __call__(self, message):
+        return self.func(message)
+
+    def __and__(self, other):
+        return Filter(lambda m: self(m) and other(m))
+
+    def __or__(self, other):
+        return Filter(lambda m: self(m) or other(m))
+
+    def __invert__(self):
+        return Filter(lambda m: not self(m))
+
+    def __xor__(self, other):
+        return Filter(lambda m: self(m) != other(m))
+
+    def __eq__(self, other):
+        return Filter(lambda m: self(m) == other)
+
+    def __ne__(self, other):
+        return Filter(lambda m: self(m) != other)
+
+    def __lt__(self, other):
+        return Filter(lambda m: self(m) < other)
+
+    def __le__(self, other):
+        return Filter(lambda m: self(m) <= other)
+
+    def __gt__(self, other):
+        return Filter(lambda m: self(m) > other)
+
+    def __ge__(self, other):
+        return Filter(lambda m: self(m) >= other)
+
+    def __add__(self, other):
+        return Filter(lambda m: self(m) + (other(m) if callable(other) else other))
+
+    def __sub__(self, other):
+        return Filter(lambda m: self(m) - (other(m) if callable(other) else other))
+
+    def __mul__(self, other):
+        return Filter(lambda m: self(m) * (other(m) if callable(other) else other))
+
+    def __truediv__(self, other):
+        return Filter(lambda m: self(m) / (other(m) if callable(other) else other))
+class IsCommand(Filter):
+    def __init__(self, commands=None):
+        if commands is None:
+            func = lambda m: getattr(m, "is_command", False)
+        else:
+            if isinstance(commands, str):
+                commands = [commands]
+            func = lambda m: getattr(m, "is_command", False) and getattr(m, "text", "").lstrip("/").split()[0] in commands
+
+        super().__init__(func)
+
+    def __getattr__(self, name: str):
+        return IsCommand([name])
+
+
+class IsText:
+    def __call__(self, text=None):
+        if text is None:
+            func = lambda m: m.is_text is True and m.is_file is False
+        else:
+            if isinstance(text, str):
+                text = [text]
+            func = lambda m: m.is_text is True and m.is_file is False and m.text in text
+
+        return Filter(func)
+#is_text = Filter(lambda m: getattr(m, "is_text", False))
+is_file = Filter(lambda m: getattr(m, "file", None) is not None)
+is_sticker = Filter(lambda m: getattr(m, "sticker", None) is not None)
+is_contact = Filter(lambda m: getattr(m, "contact_message", None) is not None)
+is_poll = Filter(lambda m: getattr(m, "poll", None) is not None)
+is_location = Filter(lambda m: getattr(m, "location", None) is not None)
+is_live_location = Filter(lambda m: getattr(m, "live_location", None) is not None)
+has_any_media = Filter(lambda m: getattr(m, "has_any_media", False))
+has_media = Filter(lambda m: getattr(m, "has_media", False))
+is_text = IsText()
+is_command = IsCommand()
+is_user = Filter(lambda m: getattr(m, "is_user", False))
+is_private = Filter(lambda m: getattr(m, "is_private", False))
+is_group = Filter(lambda m: getattr(m, "is_group", False))
+is_channel = Filter(lambda m: getattr(m, "is_channel", False))
+is_reply = Filter(lambda m: getattr(m, "is_reply", False))
+is_forwarded = Filter(lambda m: getattr(m, "is_forwarded", False))
+is_edited = Filter(lambda m: getattr(m, "is_edited", False))
+def text(keyword: str):
+    return Filter(lambda m: getattr(m, "text", "") and keyword in m.text)
+def text_length(min_len: int = 0, max_len: int = None):
+    def _filter(m):
+        t = getattr(m, "text", "")
+        if not t: return False
+        if len(t) < min_len: return False
+        if max_len is not None and len(t) > max_len: return False
+        return True
+    return Filter(_filter)
+def text_regex(pattern: str):
+    regex = re.compile(pattern)
+    return Filter(lambda m: getattr(m, "text", "") and regex.search(m.text))
+def text_startswith(prefix: str):
+    return Filter(lambda m: getattr(m, "text", "").startswith(prefix) if getattr(m, "text", None) else False)
+def text_endswith(suffix: str):
+    return Filter(lambda m: getattr(m, "text", "").endswith(suffix) if getattr(m, "text", None) else False)
+def text_upper():
+    return Filter(lambda m: getattr(m, "text", "").isupper() if getattr(m, "text", None) else False)
+def text_lower():
+    return Filter(lambda m: getattr(m, "text", "").islower() if getattr(m, "text", None) else False)
+def text_digit():
+    return Filter(lambda m: getattr(m, "text", "").isdigit() if getattr(m, "text", None) else False)
+def text_word_count(min_words: int = 1, max_words: int = None):
+    def _filter(m):
+        t = getattr(m, "text", "")
+        if not t: return False
+        wc = len(t.split())
+        if wc < min_words: return False
+        if max_words is not None and wc > max_words: return False
+        return True
+    return Filter(_filter)
+def text_contains_any(keywords: list):
+    return Filter(lambda m: getattr(m, "text", "") and any(k in m.text for k in keywords))
+def text_equals(value: str):
+    return Filter(lambda m: getattr(m, "text", None) == value)
+def text_not_equals(value: str):
+    return Filter(lambda m: getattr(m, "text", None) != value)
+def file_size_gt(size: int):
+    return Filter(lambda m: m.file and getattr(m.file, "size", 0) > size)
+def file_size_lt(size: int):
+    return Filter(lambda m: m.file and getattr(m.file, "size", 0) < size)
+def file_name_contains(substring: str):
+    return Filter(lambda m: m.file and substring in getattr(m.file, "file_name", ""))
+def file_extension(ext: str):
+    return Filter(lambda m: m.file and getattr(m.file, "file_name", "").endswith(ext))
+def file_id_is(file_id: str):
+    return Filter(lambda m: m.file and getattr(m.file, "file_id", None) == file_id)
+def sticker_id_is(sid: str):
+    return Filter(lambda m: m.sticker and getattr(m.sticker, "sticker_id", None) == sid)
+def sticker_emoji_is(emoji: str):
+    return Filter(lambda m: m.sticker and getattr(m.sticker, "emoji", None) == emoji)
+def poll_question_contains(keyword: str):
+    return Filter(lambda m: m.poll and keyword in getattr(m.poll, "question", ""))
+def poll_option_count(min_options: int = 1, max_options: int = None):
+    def _filter(m):
+        if not getattr(m, "poll", None): return False
+        options = getattr(m.poll, "options", [])
+        if len(options) < min_options: return False
+        if max_options is not None and len(options) > max_options: return False
+        return True
+    return Filter(_filter)
+def location_within(lat_min, lat_max, long_min, long_max):
+    def _filter(m):
+        loc = getattr(m, "location", None)
+        if not loc: return False
+        return lat_min <= getattr(loc, "lat", 0) <= lat_max and long_min <= getattr(loc, "long", 0) <= long_max
+    return Filter(_filter)
+def live_location_within(lat_min, lat_max, long_min, long_max):
+    def _filter(m):
+        loc = getattr(m, "live_location", None)
+        if not loc: return False
+        return lat_min <= getattr(loc, "lat", 0) <= lat_max and long_min <= getattr(loc, "long", 0) <= long_max
+    return Filter(_filter)
+def has_media_types(types: list):
+    return Filter(lambda m: any(getattr(m, t, None) for t in types))
+
+def message_id_is(mid: str):
+    return Filter(lambda m: getattr(m, "message_id", None) == mid)
+
+def is_reply_to_user(user_id: str):
+    return Filter(lambda m: getattr(m, "reply_to_message_id", None) == user_id)
+
+def is_forwarded_from(user_id: str):
+    return Filter(lambda m: getattr(m.forwarded_from, "sender_id", None) == user_id if getattr(m, "forwarded_from", None) else False)
+
+def edited_text_contains(keyword: str):
+    return Filter(lambda m: getattr(m, "edited_text", "") and keyword in m.edited_text)
+
+def aux_data_contains(key: str, value):
+    return Filter(lambda m: getattr(m.aux_data, key, None) == value if getattr(m, "aux_data", None) else False)
+
+
+
+
+def file_attr(attr_name):
+    return Filter(lambda m: m.file and getattr(m.file, attr_name, None))
+
+def sticker_attr(attr_name):
+    return Filter(lambda m: m.sticker and getattr(m.sticker, attr_name, None))
+
+def poll_attr(attr_name):
+    return Filter(lambda m: m.poll and getattr(m.poll, attr_name, None))
+
+def location_attr(attr_name):
+    return Filter(lambda m: m.location and getattr(m.location, attr_name, None))
+
+def live_location_attr(attr_name):
+    return Filter(lambda m: m.live_location and getattr(m.live_location, attr_name, None))
+
+
+
+
+file_size = file_attr("size")
+file_name = file_attr("file_name")
+sticker_id = sticker_attr("sticker_id")
+poll_question = poll_attr("question")
+location_lat = location_attr("lat")
+location_long = location_attr("long")
+live_location_lat = live_location_attr("lat")
+live_location_long = live_location_attr("long")
+
+_custom_filters = {}
+def chat_title_contains(keyword: str):
+    
+    return Filter(lambda m: getattr(m, "chat", None) and keyword in getattr(m.chat, "title", ""))
+
+def chat_title_equals(value: str):
+    
+    return Filter(lambda m: getattr(m, "chat", None) and getattr(m.chat, "title", "") == value)
+
+def chat_id_is(cid: str):
+    return Filter(lambda m: getattr(m, "chat", None) and getattr(m.chat, "id", None) == cid)
+
+def chat_member_count(min_count: int = 0, max_count: int = None):
+    
+    def _filter(m):
+        c = getattr(m, "chat", None)
+        if not c: return False
+        count = getattr(c, "member_count", 0)
+        if count < min_count: return False
+        if max_count is not None and count > max_count: return False
+        return True
+    return Filter(_filter)
+
+def chat_type_is(chat_type: str):
+    
+    return Filter(lambda m: getattr(m, "chat", None) and getattr(m.chat, "type", None) == chat_type)
+
+def chat_username_contains(keyword: str):
+    
+    return Filter(lambda m: getattr(m, "chat", None) and keyword in getattr(m.chat, "username", ""))
+
+def chat_username_equals(value: str):
+    
+    return Filter(lambda m: getattr(m, "chat", None) and getattr(m.chat, "username", "") == value)
+
+def chat_has_link():
+    
+    return Filter(lambda m: getattr(m, "chat", None) and getattr(m.chat, "invite_link", None) is not None)
+
+def chat_is_private():
+    
+    return Filter(lambda m: getattr(m, "chat", None) and getattr(m.chat, "type", None) in ["group", "channel"])
+
+def chat_member_count_gt(count: int):
+    
+    return Filter(lambda m: getattr(m, "chat", None) and getattr(m.chat, "member_count", 0) > count)
+
+def chat_member_count_lt(count: int):
+    
+    return Filter(lambda m: getattr(m, "chat", None) and getattr(m.chat, "member_count", 0) < count)
+
+def chat_has_username():
+    
+    return Filter(lambda m: getattr(m, "chat", None) and getattr(m.chat, "username", None) is not None)
+
+def chat_type_in(types: list):
+    
+    return Filter(lambda m: getattr(m, "chat", None) and getattr(m.chat, "type", None) in types)
+
+
+def chat_title_regex(pattern: str):
+    regex = re.compile(pattern)
+    return Filter(lambda m: getattr(m, "chat", None) and regex.search(getattr(m.chat, "title", "")))
+
+def chat_username_regex(pattern: str):
+    regex = re.compile(pattern)
+    return Filter(lambda m: getattr(m, "chat", None) and regex.search(getattr(m.chat, "username", "")))
+def custom(name):
+    def wrapper(func):
+        _custom_filters[name] = Filter(func)
+        return _custom_filters[name]
+    return wrapper
+
+def get_custom(name):
+    return _custom_filters.get(name)
+
+def and_(*filters):
+    return Filter(lambda m: all(f(m) for f in filters))
+
+def or_(*filters):
+    return Filter(lambda m: any(f(m) for f in filters))
+
+def not_(filter_):
+    return Filter(lambda m: not filter_(m))

{rubka-6.4.8.dist-info → rubka-6.6.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Rubka
-Version: 6.4.8
+Version: 6.6.2
 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-6.4.8.dist-info → rubka-6.6.2.dist-info}/RECORD

@@ -1,11 +1,12 @@
 rubka/__init__.py,sha256=TR1DABU5Maz2eO62ZEFiwOqNU0dH6l6HZfqRUxeo4eY,194
-rubka/api.py,sha256=J0fa4XXjImFulLXAaJY2pbE46e03i-Y5QggxaAZq6xw,68159
-rubka/asynco.py,sha256=wiuw2oLaYH5a99W7_37sjP29hXabAbThnkLk1sPIzUk,83919
+rubka/api.py,sha256=FkvXi6lGyDhy-GStfT9IPtmnpir75ggNsC4bsgy2tKw,68838
+rubka/asynco.py,sha256=O5sr6Ev7LCsC5egjDk5uzJyeZEPqmxOH27lUBgzHM8A,83517
 rubka/button.py,sha256=vU9OvWXCD4MRrTJ8Xmivd4L471-06zrD2qpZBTw5vjY,13305
 rubka/config.py,sha256=Bck59xkOiqioLv0GkQ1qPGnBXVctz1hKk6LT4h2EPx0,78
 rubka/context.py,sha256=4YZs7DiZD_HWOqY76hwwajG0J-bLy6wjeKtQT3EatZU,19341
 rubka/decorators.py,sha256=hGwUoE4q2ImrunJIGJ_kzGYYxQf1ueE0isadqraKEts,1157
 rubka/exceptions.py,sha256=tujZt1XrhWaw-lmdeVadVceUptpw4XzNgE44sAAY0gs,90
+rubka/filters.py,sha256=DY1bdkpRKIiLtVcy6X3hOnlGPcVOK4HFb3QgmaPx6Oo,12116
 rubka/jobs.py,sha256=GvLMLsVhcSEzRTgkvnPISPEBN71suW2xXI0hUaUZPTo,378
 rubka/keyboards.py,sha256=7nr-dT2bQJVQnQ6RMWPTSjML6EEk6dsBx-4d8pab8xk,488
 rubka/keypad.py,sha256=yGsNt8W5HtUFBzVF1m_p7GySlu1hwIcSvXZ4BTdrlvg,9558
@@ -34,7 +35,7 @@ rubka/adaptorrubka/types/socket/message.py,sha256=0WgLMZh4eow8Zn7AiSX4C3GZjQTkIg
 rubka/adaptorrubka/utils/__init__.py,sha256=OgCFkXdNFh379quNwIVOAWY2NP5cIOxU5gDRRALTk4o,54
 rubka/adaptorrubka/utils/configs.py,sha256=nMUEOJh1NqDJsf9W9PurkN_DLYjO6kKPMm923i4Jj_A,492
 rubka/adaptorrubka/utils/utils.py,sha256=5-LioLNYX_TIbQGDeT50j7Sg9nAWH2LJUUs-iEXpsUY,8816
-rubka-6.4.8.dist-info/METADATA,sha256=2FefyxguhKHS07vKRgGlhhzHBi9ojoGe0U9ymQvDNTg,33335
-rubka-6.4.8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-rubka-6.4.8.dist-info/top_level.txt,sha256=vy2A4lot11cRMdQS-F4HDCIXL3JK8RKfu7HMDkezJW4,6
-rubka-6.4.8.dist-info/RECORD,,
+rubka-6.6.2.dist-info/METADATA,sha256=-XVEYYI0-PnUjEzLHgnEifIpRem8h7RqL3V7sA07jhQ,33335
+rubka-6.6.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+rubka-6.6.2.dist-info/top_level.txt,sha256=vy2A4lot11cRMdQS-F4HDCIXL3JK8RKfu7HMDkezJW4,6
+rubka-6.6.2.dist-info/RECORD,,