Rubka 6.5.2__tar.gz → 6.6.2__tar.gz

{rubka-6.5.2 → rubka-6.6.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Rubka
-Version: 6.5.2
+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.5.2 → rubka-6.6.2}/Rubka.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Rubka
-Version: 6.5.2
+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.5.2 → rubka-6.6.2}/rubka/api.py

@@ -1669,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-6.5.2 → rubka-6.6.2}/rubka/asynco.py

@@ -1,31 +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
 from . import filters
-try:
-    from .context import Message, InlineMessage
-except (ImportError, ModuleNotFoundError):
-    from context import Message, InlineMessage
+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:
@@ -35,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:
@@ -124,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):
@@ -173,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",
@@ -187,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()
@@ -201,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
@@ -275,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:
@@ -289,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
@@ -299,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,
@@ -346,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:
@@ -380,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:
@@ -394,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
@@ -403,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,
@@ -448,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:
@@ -485,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:
@@ -499,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
@@ -509,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,
@@ -738,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]):
@@ -757,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
@@ -791,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:
                     
@@ -836,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 
@@ -864,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,
@@ -1449,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,
@@ -1460,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")
@@ -1493,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', [])
@@ -1519,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(
@@ -1589,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:
@@ -1646,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:
@@ -1661,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,
@@ -1685,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:
@@ -1706,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)
@@ -1783,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:
@@ -1802,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)
@@ -1854,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-6.5.2 → rubka-6.6.2}/rubka/filters.py

@@ -1,6 +1,11 @@
 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
@@ -49,8 +54,32 @@ class Filter:
 
     def __truediv__(self, other):
         return Filter(lambda m: self(m) / (other(m) if callable(other) else other))
-
-is_text = Filter(lambda m: getattr(m, "is_text", False))
+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)
@@ -59,7 +88,8 @@ 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_command = Filter(lambda m: getattr(m, "is_command", 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))
@@ -67,13 +97,8 @@ 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", "")
@@ -82,26 +107,19 @@ def text_length(min_len: int = 0, max_len: int = None):
         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", "")
@@ -111,49 +129,28 @@ def text_word_count(min_words: int = 1, max_words: int = None):
         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
@@ -162,27 +159,18 @@ def poll_option_count(min_options: int = 1, max_options: int = None):
         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))
 

{rubka-6.5.2 → rubka-6.6.2}/setup.py

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