Rubka 6.5.2__py3-none-any.whl → 6.6.4__py3-none-any.whl

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/asynco.py

@@ -1,31 +1,20 @@
-import asyncio
-import aiohttp
-import aiofiles
-from typing import List, Optional, Dict, Any, Literal, Callable, Union
+import asyncio,aiohttp,aiofiles,time,datetime,json,tempfile,os,sys,subprocess,mimetypes
+from typing import List, Optional, Dict, Any, Literal, Callable, Union,Set
 from .exceptions import APIRequestError
 from .adaptorrubka import Client as Client_get
 from .logger import logger
+from .rubino import Bot as Rubino
 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 +24,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 +89,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 +166,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 +179,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 +191,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 +263,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 +275,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 +283,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 +326,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 +350,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 +362,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 +369,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 +410,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 +436,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 +448,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 +456,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 +681,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 +699,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 +719,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 +753,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,72 +775,65 @@ 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,
-        sleep_time: float = 0.2,
-        webhook_timeout: int = 20,
-        update_limit: int = 100,
-        retry_delay: float = 5.0,
-        stop_on_error: bool = False,
-        max_errors: int = 0,
-        auto_restart: bool = False,
-        max_runtime: float | None = None,
-        loop_forever: bool = True,
-        allowed_update_types: list[str] | None = None,
-        ignore_duplicate_messages: bool = True,
-        skip_inline_queries: bool = False,
-        skip_channel_posts: bool = False,
-        skip_service_messages: bool = False,
-        skip_edited_messages: bool = False,
-        skip_bot_messages: bool = False,
-        log_file: str | None = None,
-        log_level: str = "info",
-        print_exceptions: bool = True,
-        error_handler=None,             
-        shutdown_hook=None,             
-        save_unprocessed_updates: bool = False,
-        log_to_console: bool = True,
-        rate_limit: float | None = None,      
-        max_message_size: int | None = None,
-        ignore_users: set[str] | None = None,
-        ignore_groups: set[str] | None = None,
-        require_auth_token: bool = False,
-        only_private_chats: bool = False,
-        only_groups: bool = False,
-        require_admin_rights: bool = False,
-        custom_update_fetcher=None,     
-        custom_update_processor=None,   
-        process_in_background: bool = False,
-        max_queue_size: int = 1000,
-        thread_workers: int = 3,        
-        message_filter=None,            
-        pause_on_idle: bool = False,
-        max_concurrent_tasks: int | None = None,
-        metrics_enabled: bool = False,
-        metrics_handler=None,           
-        notify_on_error: bool = False,
-        notification_handler=None,      
-        watchdog_timeout: float | None = None,
+    self,
+    debug: bool = False,
+    sleep_time: float = 0.2,
+    webhook_timeout: int = 20,
+    update_limit: int = 100,
+    retry_delay: float = 5.0,
+    stop_on_error: bool = False,
+    max_errors: int = 0,
+    auto_restart: bool = False,
+    max_runtime: Optional[float] = None,
+    loop_forever: bool = True,
+    allowed_update_types: Optional[List[str]] = None,
+    ignore_duplicate_messages: bool = True,
+    skip_inline_queries: bool = False,
+    skip_channel_posts: bool = False,
+    skip_service_messages: bool = False,
+    skip_edited_messages: bool = False,
+    skip_bot_messages: bool = False,
+    log_file: Optional[str] = None,
+    log_level: str = "info",
+    print_exceptions: bool = True,
+    error_handler: Optional[Callable[[Exception], Any]] = None,
+    shutdown_hook: Optional[Callable[[], Any]] = None,
+    save_unprocessed_updates: bool = False,
+    log_to_console: bool = True,
+    rate_limit: Optional[float] = None,
+    max_message_size: Optional[int] = None,
+    ignore_users: Optional[Set[str]] = None,
+    ignore_groups: Optional[Set[str]] = None,
+    require_auth_token: bool = False,
+    only_private_chats: bool = False,
+    only_groups: bool = False,
+    require_admin_rights: bool = False,
+    custom_update_fetcher: Optional[Callable[[], Any]] = None,
+    custom_update_processor: Optional[Callable[[Any], Any]] = None,
+    process_in_background: bool = False,
+    max_queue_size: int = 1000,
+    thread_workers: int = 3,
+    message_filter: Optional[Callable[[Any], bool]] = None,
+    pause_on_idle: bool = False,
+    max_concurrent_tasks: Optional[int] = None,
+    metrics_enabled: bool = False,
+    metrics_handler: Optional[Callable[[dict], Any]] = None,
+    notify_on_error: bool = False,
+    notification_handler: Optional[Callable[[str], Any]] = None,
+    watchdog_timeout: Optional[float] = None,
     ):
         """
     Starts the bot's main execution loop with extensive configuration options.
@@ -1449,8 +1353,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 +1363,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 +1390,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 +1413,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 +1482,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 +1525,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 +1539,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 +1560,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 +1576,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 +1649,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 +1668,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 +1708,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

@@ -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/rubino.py

@@ -446,7 +446,7 @@ class Bot():
                 "api_version":"0",
                 "client":{
                     "app_name":"Main",
-                    "app_version":"2.2.4",
+                    "app_version":"2.4.7",
                     "package":"m.rubika.ir",
                     "platform":"PWA"
                 },
@@ -926,6 +926,20 @@ class Bot():
             "profile_id": profile_id
         },methode="getProfileFollowers")
     
+    def get_Highlight_StoryIds(self,highlight_id:str,profile_id:str,target_profile_id:str):
+        return self._reuests_post(data={
+            "highlight_id": highlight_id,
+            "profile_id": profile_id,
+            "target_profile_id": target_profile_id
+        },methode="getHighlightStoryIds")
+    def get_Highlight_Stories(self,highlight_id:str,profile_id:str,target_profile_id:str,story_ids:list):
+        return self._reuests_post(data={
+            "highlight_id": highlight_id,
+            "profile_id": profile_id,
+            "target_profile_id": target_profile_id,
+            "story_ids":story_ids
+        },methode="getHighlightStories")
+    
     def get_NewFollow_Requests(self,sort:str="FromMax",limit:int=50,equal:bool=False,profile_id:str=None):
         return self._reuests_post(data={
             "equal": equal,
@@ -955,14 +969,37 @@ class Bot():
             "track_id": "Related",
             "profile_id": profile_id
         },methode="postBookmarkAction")
-    
-    def get_Saved_Posts(self,sort:str="FromMax",limit:int=51,equal:bool=False,profile_id:str=None):
-        return self._reuests_post(data={
-            "equal": equal,
+    def get_saved_posts(
+    self,
+    max_id: str,
+    limit: int = 20,
+    profile_id: Optional[str] = None,
+    sort: str = "FromMax") -> Dict[str, Any]:
+        """
+        دریافت پست‌های ذخیره‌شده (بوکمارک‌شده)
+
+        Args:
+            max_id (str): شناسه آخرین پست برای صفحه‌بندی.
+            limit (int, optional): تعداد پست‌ها در هر درخواست. پیش‌فرض 20.
+            profile_id (str, optional): شناسه پروفایل (در صورت نیاز).
+            sort (str, optional): نوع مرتب‌سازی. پیش‌فرض "FromMax".
+
+        Returns:
+            Dict[str, Any]: پاسخ سرور شامل لیست پست‌های ذخیره‌شده.
+        """
+        payload = {
             "limit": limit,
-            "sort": sort,
-            "profile_id": profile_id
-        },methode="getBookmarkedPosts")
+            "max_id": max_id,
+            "sort": sort
+        }
+
+        if profile_id is not None:
+            payload["profile_id"] = profile_id
+
+        return self._reuests_post(
+            data=payload,
+            methode="getBookmarkedPosts"
+        )
     
     def search_Page(self,username:str,sort:str="FromMax",limit:int=50,equal:bool=False,profile_id:str=None):
         return self._reuests_post(data={
@@ -994,6 +1031,14 @@ class Bot():
             "record_id": post_id,
             "profile_id": profile_id
         },methode="setReportRecord")
+    def report_Post(self,post_profile_id,post_id:str,reason:int=2,profile_id:str=None):
+        return self._reuests_post(data={
+            "model": "Post",
+            "reason": reason,
+            "post_profile_id":post_profile_id,
+            "record_id": post_id,
+            "profile_id": profile_id
+        },methode="setReportRecord")
 
     def delete_Post(self,post_id:str,profile_id:str=None):
         return self._reuests_post(data={
@@ -1013,6 +1058,12 @@ class Bot():
             "profile_status": profile_status,
             "profile_id": profile_id
         },methode="updateProfile")
+    def get_New_Events(self,limit:int=20,sort:str="FromMax",profile_id:str=None):
+        return self._reuests_post(data={
+            "limit": limit,
+            "profile_id": profile_id,
+            "sort":sort
+        },methode="updateProfile")
 
     def allow_Send_MessagePv(self,is_message_allowed:bool=False,profile_id:str=None):
         return self._reuests_post(data={

{rubka-6.5.2.dist-info → rubka-6.6.4.dist-info}/METADATA

@@ -1,18 +1,29 @@
 Metadata-Version: 2.4
 Name: Rubka
-Version: 6.5.2
-Summary: A Python library for interacting with Rubika Bot API.
+Version: 6.6.4
+Summary: rubika 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
+Download-URL: https://github.com/Mahdy-Ahmadi/rubka/archive/refs/tags/v6.6.4.zip
 Author: Mahdi Ahmadi
 Author-email: mahdiahmadi.1208@gmail.com
 Maintainer: Mahdi Ahmadi
 Maintainer-email: mahdiahmadi.1208@gmail.com
+License: MIT
+Project-URL: Bug Tracker, https://t.me/Bprogrammer
+Project-URL: Documentation, https://github.com/Mahdy-Ahmadi/rubka/blob/main/README.md
+Project-URL: Source Code, https://github.com/Mahdy-Ahmadi/Rubka
+Keywords: rubika bot api library chat messaging rubpy pyrubi rubigram
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
 Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Topic :: Communications :: Chat
 Classifier: Topic :: Software Development :: Libraries
+Classifier: Natural Language :: Persian
 Requires-Python: >=3.6
 Description-Content-Type: text/markdown
 Requires-Dist: requests
@@ -31,8 +42,11 @@ Dynamic: description
 Dynamic: description-content-type
 Dynamic: download-url
 Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
 Dynamic: maintainer
 Dynamic: maintainer-email
+Dynamic: project-url
 Dynamic: requires-dist
 Dynamic: requires-python
 Dynamic: summary
@@ -62,16 +76,16 @@ If `importlib.metadata` is not available, it installs `importlib-metadata` autom
 ## 🚀 Getting Started
 
 ```python
-from rubka import Robot
+from rubka.asynco import Robot
 from rubka.context import Message
-
+import asyncio
 bot = Robot(token="YOUR_TOKEN_HERE")
 
 @bot.on_message(commands=["start"])
-def start(bot: Robot, message: Message):
-    message.reply("سلام! خوش آمدید!")
+async def start(bot: Robot, message: Message):
+    await message.reply("سلام! خوش آمدید!")
 
-bot.run()
+asyncio.run(bot.run())
 ```
 
 ---
@@ -82,8 +96,8 @@ You can handle incoming text messages using `@bot.on_message()`:
 
 ```python
 @bot.on_message(commands=["hello"])
-def greet(bot: Robot, message: Message):
-    message.reply("سلام کاربر عزیز 👋")
+async def greet(bot: Robot, message: Message):
+   await message.reply("سلام کاربر عزیز 👋")
 ```
 
 You can also add filters.

{rubka-6.5.2.dist-info → rubka-6.6.4.dist-info}/RECORD

@@ -1,17 +1,17 @@
 rubka/__init__.py,sha256=TR1DABU5Maz2eO62ZEFiwOqNU0dH6l6HZfqRUxeo4eY,194
-rubka/api.py,sha256=Nu9bX0Vv0AGLEHfUDtS7_SQDbaavk8bZghc-pRH5zRk,68691
-rubka/asynco.py,sha256=8zpKldan71TQLcZk7W8h3G2Aya1OSGZs5oqhn9jNlrM,84336
+rubka/api.py,sha256=FkvXi6lGyDhy-GStfT9IPtmnpir75ggNsC4bsgy2tKw,68838
+rubka/asynco.py,sha256=V0PW63HpBZJ1B39aKRPKU0gHDqriH7u9Z-6LFiFaWQg,83562
 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=hvH48ejEEXX5KEt9KlzZWBep6O8F9c2o1agwg-y7mMc,11101
+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
 rubka/logger.py,sha256=J2I6NiK1z32lrAzC4H1Et6WPMBXxXGCVUsW4jgcAofs,289
-rubka/rubino.py,sha256=uOhvljK_tms_767pX1TSxryyq71rKDyCgiv36ssNXEg,56674
+rubka/rubino.py,sha256=GuXnEUTTSZUw68FMTQBYsB2zG_3rzdDa-krsrl4ib8w,58755
 rubka/update.py,sha256=4YZs7DiZD_HWOqY76hwwajG0J-bLy6wjeKtQT3EatZU,19341
 rubka/utils.py,sha256=XUQUZxQt9J2f0X5hmAH_MH1kibTAfdT1T4AaBkBhBBs,148
 rubka/adaptorrubka/__init__.py,sha256=6o2tCXnVeES7nx-LjnzsuMqjKcWIm9qwKficLE54s-U,83
@@ -35,7 +35,8 @@ 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.5.2.dist-info/METADATA,sha256=ijWtJKisum3EsKK72ILJ9e8B2LL4Z_kqbgqaPO82PFg,33335
-rubka-6.5.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-rubka-6.5.2.dist-info/top_level.txt,sha256=vy2A4lot11cRMdQS-F4HDCIXL3JK8RKfu7HMDkezJW4,6
-rubka-6.5.2.dist-info/RECORD,,
+rubka-6.6.4.dist-info/METADATA,sha256=FH4BjESYZfSWjk76Us_1LFKez1zxqv72MRv6-cINDCE,34043
+rubka-6.6.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+rubka-6.6.4.dist-info/entry_points.txt,sha256=4aESuUmuUOALMUy7Kucv_Gb5YlqhsJmTmdXLlZU9sJ0,46
+rubka-6.6.4.dist-info/top_level.txt,sha256=vy2A4lot11cRMdQS-F4HDCIXL3JK8RKfu7HMDkezJW4,6
+rubka-6.6.4.dist-info/RECORD,,

rubka-6.6.4.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+rubka = rubka.__main__:main