Rubka 6.8.5__py3-none-any.whl → 7.1.2__py3-none-any.whl

rubka/api.py

@@ -1016,7 +1016,8 @@ class Robot:
         inline_keypad: Optional[Dict[str, Any]] = None,
         disable_notification: bool = False,
         reply_to_message_id: Optional[str] = None,
-        chat_keypad_type: Optional[Literal["New", "Removed"]] = None
+        chat_keypad_type: Optional[Literal["New", "Removed"]] = None,
+        delete_after = None
     ) -> Dict[str, Any]:
         """
         Send a text message to a chat.

rubka/asynco.py

@@ -1,4 +1,4 @@
-import asyncio,aiohttp,aiofiles,time,datetime,json,tempfile,os,sys,subprocess,mimetypes,time, hashlib
+import asyncio,aiohttp,aiofiles,time,datetime,json,tempfile,os,sys,subprocess,mimetypes,time, hashlib,sqlite3
 from typing import List, Optional, Dict, Any, Literal, Callable, Union,Set
 from collections import OrderedDict
 from .exceptions import APIRequestError,raise_for_status,InvalidAccessError,InvalidInputError,TooRequestError,InvalidTokenError
@@ -8,6 +8,8 @@ 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 .button import ChatKeypadBuilder, InlineBuilder
+except (ImportError, ModuleNotFoundError):from button import ChatKeypadBuilder, InlineBuilder
 class FeatureNotAvailableError(Exception):
     pass
 
@@ -19,7 +21,6 @@ from tqdm import tqdm
 API_URL = "https://botapi.rubika.ir/v3"
 
 def install_package(package_name: str) -> bool:
-    """Installs a package using pip."""
     try:
         subprocess.check_call([sys.executable, "-m", "pip", "install", package_name], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
         return True
@@ -27,7 +28,6 @@ def install_package(package_name: str) -> bool:
         return False
 
 def get_importlib_metadata():
-    """Dynamically imports and returns metadata functions from importlib."""
     try:
         from importlib.metadata import version, PackageNotFoundError
         return version, PackageNotFoundError
@@ -43,7 +43,6 @@ def get_importlib_metadata():
 version, PackageNotFoundError = get_importlib_metadata()
 
 def get_installed_version(package_name: str) -> Optional[str]:
-    """Gets the installed version of a package."""
     if version is None:
         return "unknown"
     try:
@@ -52,7 +51,6 @@ def get_installed_version(package_name: str) -> Optional[str]:
         return None
 
 async def get_latest_version(package_name: str) -> Optional[str]:
-    """Fetches the latest version of a package from PyPI asynchronously."""
     url = f"https://pypi.org/pypi/{package_name}/json"
     try:
         async with aiohttp.ClientSession() as session:
@@ -64,7 +62,6 @@ async def get_latest_version(package_name: str) -> Optional[str]:
         return None
 
 async def check_rubka_version():
-    """Checks for outdated 'rubka' package and warns the user."""
     package_name = "rubka"
     installed_version = get_installed_version(package_name)
     if installed_version is None:
@@ -87,7 +84,6 @@ async def check_rubka_version():
 
 
 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):
@@ -170,12 +166,16 @@ max_cache_size and max_msg_age help manage duplicate message processing efficien
         self._max_cache_size = max_cache_size        
         self._callback_handlers: List[dict] = []
         self._edited_message_handlers = []
+        self._message_saver_enabled = False
+        self._max_messages = None
+        self._db_path = os.path.join(os.getcwd(), "RubkaSaveMessage.db")
+        self._ensure_db()
         self._message_handlers: List[dict] = []
 
         logger.info(f"Initialized RubikaBot with token: {token[:8]}***")
     async def _get_session(self) -> aiohttp.ClientSession:
         if self._aiohttp_session is None or self._aiohttp_session.closed:
-            connector = aiohttp.TCPConnector(limit=100, ssl=False)  # limit اتصالات همزمان
+            connector = aiohttp.TCPConnector(limit=100, ssl=False)
             timeout = aiohttp.ClientTimeout(total=self.timeout)
             self._aiohttp_session = aiohttp.ClientSession(connector=connector, timeout=timeout)
         return self._aiohttp_session
@@ -251,15 +251,157 @@ max_cache_size and max_msg_age help manage duplicate message processing efficien
         raw = f"{message_id}:{update_type}:{msg_data.get('text','')}:{msg_data.get('author_guid','')}"
         return hashlib.sha1(raw.encode()).hexdigest()
     async def get_me(self) -> Dict[str, Any]:
-        """Get info about the bot itself."""
         return await self._post("getMe", {})
     async def geteToken(self):
-        """Check if the bot token is valid."""
         if (await self.get_me())['status'] != "OK":
             raise InvalidTokenError("The provided bot token is invalid or expired.")
     from typing import Callable, Any, Optional, List
 
 
+#save message database __________________________
+
+    def _ensure_db(self):
+        conn = sqlite3.connect(self._db_path)
+        cur = conn.cursor()
+        cur.execute("""
+        CREATE TABLE IF NOT EXISTS messages (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            chat_id TEXT NOT NULL,
+            message_id TEXT NOT NULL,
+            sender_id TEXT,
+            text TEXT,
+            raw_data TEXT,
+            time TEXT,
+            saved_at INTEGER
+        );
+        """)
+        cur.execute("CREATE UNIQUE INDEX IF NOT EXISTS idx_chat_message ON messages(chat_id, message_id);")
+        conn.commit()
+        conn.close()
+
+    def _insert_message(self, record: dict):
+        conn = sqlite3.connect(self._db_path)
+        cur = conn.cursor()
+        cur.execute("""
+        INSERT OR IGNORE INTO messages
+        (chat_id, message_id, sender_id, text, raw_data, time, saved_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?)
+        """, (
+            record.get("chat_id"),
+            record.get("message_id"),
+            record.get("sender_id"),
+            record.get("text"),
+            json.dumps(record.get("raw_data") or {}, ensure_ascii=False),
+            record.get("time"),
+            int(time.time())
+        ))
+        conn.commit()
+        if getattr(self, "_max_messages", None) is not None:
+            cur.execute("SELECT COUNT(*) FROM messages")
+            total = cur.fetchone()[0]
+            if total > self._max_messages:
+                remove_count = total - self._max_messages
+                cur.execute(
+                    "DELETE FROM messages WHERE id IN (SELECT id FROM messages ORDER BY saved_at ASC LIMIT ?)",
+                    (remove_count,)
+                )
+                conn.commit()
+
+        conn.close()
+
+    def _fetch_message(self, chat_id: str, message_id: str):
+        conn = sqlite3.connect(self._db_path)
+        cur = conn.cursor()
+        cur.execute(
+            "SELECT chat_id, message_id, sender_id, text, raw_data, time, saved_at FROM messages WHERE chat_id=? AND message_id=?",
+            (chat_id, message_id)
+        )
+        row = cur.fetchone()
+        conn.close()
+        if not row:
+            return None
+        chat_id, message_id, sender_id, text, raw_data_json, time_val, saved_at = row
+        try:
+            raw = json.loads(raw_data_json)
+        except:
+            raw = {}
+        return {
+            "chat_id": chat_id,
+            "message_id": message_id,
+            "sender_id": sender_id,
+            "text": text,
+            "raw_data": raw,
+            "time": time_val,
+            "saved_at": saved_at
+        }
+    async def save_message(self, message: Message):
+        try:
+            record = {
+                "chat_id": getattr(message, "chat_id", None),
+                "message_id": getattr(message, "message_id", None),
+                "sender_id": getattr(message, "author_guid", None),
+                "text": getattr(message, "text", None),
+                "raw_data": getattr(message, "raw_data", {}),
+                "time": getattr(message, "time", None),
+            }
+            await asyncio.to_thread(self._insert_message, record)
+        except Exception as e:
+            print(f"[DB] Error saving message: {e}")
+
+    async def get_message(self, chat_id: str, message_id: str):
+        return await asyncio.to_thread(self._fetch_message, chat_id, message_id)
+
+    def start_save_message(self, max_messages: int = 1000):
+        if self._message_saver_enabled:
+            return
+        self._message_saver_enabled = True
+        self._max_messages = max_messages
+        decorators = [
+            "on_message", "on_edited_message", "on_message_file", "on_message_forwarded",
+            "on_message_reply", "on_message_text", "on_update", "on_callback",
+            "on_callback_query", "callback_query_handler", "callback_query",
+            "on_inline_query", "on_inline_query_prefix", "on_message_private", "on_message_group"
+        ]
+
+        for decorator_name in decorators:
+            if hasattr(self, decorator_name):
+                original_decorator = getattr(self, decorator_name)
+
+                def make_wrapper(orig_decorator):
+                    def wrapper(*args, **kwargs):
+                        decorator = orig_decorator(*args, **kwargs)
+                        def inner_wrapper(func):
+                            async def inner(bot, message, *a, **kw):
+                                try:
+                                    await bot.save_message(message)
+                                    if getattr(self, "_max_messages", None) is not None:
+                                        await asyncio.to_thread(self._prune_old_messages)
+                                except Exception as e:
+                                    print(f"[DB] Save error: {e}")
+                                return await func(bot, message, *a, **kw)
+                            return decorator(inner)
+                        return inner_wrapper
+                    return wrapper
+
+                setattr(self, decorator_name, make_wrapper(original_decorator))
+    def _prune_old_messages(self):
+        if not hasattr(self, "_max_messages") or self._max_messages is None:
+            return
+        conn = sqlite3.connect(self._db_path)
+        cur = conn.cursor()
+        cur.execute("SELECT COUNT(*) FROM messages")
+        total = cur.fetchone()[0]
+        if total > self._max_messages:
+            remove_count = total - self._max_messages
+            cur.execute(
+                "DELETE FROM messages WHERE id IN (SELECT id FROM messages ORDER BY saved_at ASC LIMIT ?)",
+                (remove_count,)
+            )
+            conn.commit()
+        conn.close()
+
+#save message database __________________________ end
+
 #decorator#
 
     def on_message_private(
@@ -852,7 +994,7 @@ max_cache_size and max_msg_age help manage duplicate message processing efficien
                         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
+                        asyncio.create_task(handler_info["func"](self, context))#kir baba kir
                         continue 
         elif update.get("type") == "UpdatedMessage":
             msg = update.get("updated_message", {})
@@ -912,7 +1054,7 @@ max_cache_size and max_msg_age help manage duplicate message processing efficien
     async def run(
     self,
     debug: bool = False,
-    sleep_time: float = 0.2,
+    sleep_time: float = 0.1,
     webhook_timeout: int = 20,
     update_limit: int = 100,
     retry_delay: float = 5.0,

rubka/button.py

@@ -371,7 +371,7 @@ class InlineBuilder:
 
     def build(self) -> Dict:
         return {"rows": self.rows}
-class ChatKeypadBuilder:
+class ChatKeypadBuilder(InlineBuilder):
     def __init__(self):
         self.rows: List[Dict[str, List[Dict[str, str]]]] = []
 

rubka/context.py

@@ -1,7 +1,7 @@
 from typing import Any, Dict, List,Optional
 from typing import Union
 from pathlib import Path
-import re
+import re,inspect
 import asyncio
 class File:
     def __init__(self, data: dict):
@@ -265,24 +265,68 @@ class Message:
             self.bot.sessions[self.chat_id] = {}
         return self.bot.sessions[self.chat_id]
     
-    async def reply(self, text: str, delete_after: int = None, **kwargs):
-        msg = await self.bot.send_message(
-            self.chat_id,
-            text,
-            reply_to_message_id=self.message_id,
-            delete_after=delete_after,
-            **kwargs
-        )
-        class pick:
-            def __init__(self, bot, chat_id, message_id):
-                self.bot = bot
-                self.chat_id = chat_id
-                self.message_id = message_id
-            async def edit(self, new_text):
-                await self.bot.edit_message_text(self.chat_id, self.message_id, new_text)
-            async def delete(self):
-                await self.bot.delete_message(self.chat_id, self.message_id)
-        return pick(self.bot, msg.chat_id, msg.message_id)
+    def reply(self, text: str, delete_after: int = None, **kwargs):
+        async def _reply_async():
+            send_func = self.bot.send_message
+            if inspect.iscoroutinefunction(send_func):
+                msg = await send_func(
+                    self.chat_id,
+                    text,
+                    reply_to_message_id=self.message_id,
+                    delete_after=delete_after,
+                    **kwargs
+                )
+            else:
+                msg = send_func(
+                    self.chat_id,
+                    text,
+                    reply_to_message_id=self.message_id,
+                    delete_after=delete_after,
+                    **kwargs
+                )
+            class Pick:
+                def __init__(self, bot, chat_id, message_id):
+                    self.bot = bot
+                    self.chat_id = chat_id
+                    self.message_id = message_id
+
+                def edit(self, new_text):
+                    async def _edit():
+                        func = self.bot.edit_message_text
+                        if inspect.iscoroutinefunction(func):
+                            await func(self.chat_id, self.message_id, new_text)
+                        else:
+                            func(self.chat_id, self.message_id, new_text)
+
+                    try:
+                        loop = asyncio.get_running_loop()
+                        if loop.is_running():
+                            return asyncio.create_task(_edit())
+                    except RuntimeError:
+                        return asyncio.run(_edit())
+
+                def delete(self):
+                    async def _delete():
+                        func = self.bot.delete_message
+                        if inspect.iscoroutinefunction(func):
+                            await func(self.chat_id, self.message_id)
+                        else:
+                            func(self.chat_id, self.message_id)
+                    try:
+                        loop = asyncio.get_running_loop()
+                        if loop.is_running():
+                            return asyncio.create_task(_delete())
+                    except RuntimeError:
+                        return asyncio.run(_delete())
+            chat_id = msg.get("chat_id") if isinstance(msg, dict) else getattr(msg, "chat_id", self.chat_id)
+            message_id = msg.get("message_id") if isinstance(msg, dict) else getattr(msg, "message_id", self.message_id)
+            return Pick(self.bot, chat_id, message_id)
+        try:
+            loop = asyncio.get_running_loop()
+            if loop.is_running():
+                return asyncio.create_task(_reply_async())
+        except RuntimeError:
+            return asyncio.run(_reply_async())
     def answer(self, text: str, **kwargs):
         return self.bot.send_message(
             self.chat_id,

rubka/rubino.py

@@ -426,8 +426,11 @@ def _req(term, results, lang, start, proxies, timeout):
 import random
 
 class Bot():
-    """rubino class"""
+    """rubino class Regester m.rubika.ir"""
     def __init__(self,auth,platform="m.rubika.ir",lang_code="fa") -> None:
+        """
+        regester m.rubika.ir
+        """
         self.auth=auth
         self.platform=platform
         self.lang_code=lang_code

rubka/tv.py

@@ -28,6 +28,8 @@ class TV:
         - auth: توکن احراز هویت حساب کاربری
         - proxy: پراکسی برای ارسال درخواست‌ها (اختیاری)
         - headers: هدرهای سفارشی برای ارسال درخواست‌ها (اختیاری)
+        # نکته:
+        https://vod.rubika.ir/ 
         """
         self.auth = auth
         self.headers = headers if headers is not None else self.DEFAULT_HEADERS

rubka/update.py

@@ -1,7 +1,7 @@
 from typing import Any, Dict, List,Optional
 from typing import Union
 from pathlib import Path
-import re
+import re,inspect
 import asyncio
 class File:
     def __init__(self, data: dict):
@@ -259,20 +259,74 @@ class Message:
             self.is_archive = name.endswith((".zip", ".rar", ".7z", ".tar", ".gz"))
             self.is_executable = name.endswith((".exe", ".msi", ".bat", ".sh"))
             self.is_font = name.endswith((".ttf", ".otf", ".woff", ".woff2"))
-        self.info = {attr: value for attr, value in vars(self).items()}
     @property
     def session(self):
         if self.chat_id not in self.bot.sessions:
             self.bot.sessions[self.chat_id] = {}
         return self.bot.sessions[self.chat_id]
-    def reply(self, text: str,delete_after :int = None, **kwargs):
-        return self.bot.send_message(
-            self.chat_id,
-            text,
-            reply_to_message_id=self.message_id,
-            delete_after=delete_after,
-            **kwargs
-        )
+    
+    def reply(self, text: str, delete_after: int = None, **kwargs):
+        async def _reply_async():
+            send_func = self.bot.send_message
+            if inspect.iscoroutinefunction(send_func):
+                msg = await send_func(
+                    self.chat_id,
+                    text,
+                    reply_to_message_id=self.message_id,
+                    delete_after=delete_after,
+                    **kwargs
+                )
+            else:
+                msg = send_func(
+                    self.chat_id,
+                    text,
+                    reply_to_message_id=self.message_id,
+                    delete_after=delete_after,
+                    **kwargs
+                )
+            class Pick:
+                def __init__(self, bot, chat_id, message_id):
+                    self.bot = bot
+                    self.chat_id = chat_id
+                    self.message_id = message_id
+
+                def edit(self, new_text):
+                    async def _edit():
+                        func = self.bot.edit_message_text
+                        if inspect.iscoroutinefunction(func):
+                            await func(self.chat_id, self.message_id, new_text)
+                        else:
+                            func(self.chat_id, self.message_id, new_text)
+
+                    try:
+                        loop = asyncio.get_running_loop()
+                        if loop.is_running():
+                            return asyncio.create_task(_edit())
+                    except RuntimeError:
+                        return asyncio.run(_edit())
+
+                def delete(self):
+                    async def _delete():
+                        func = self.bot.delete_message
+                        if inspect.iscoroutinefunction(func):
+                            await func(self.chat_id, self.message_id)
+                        else:
+                            func(self.chat_id, self.message_id)
+                    try:
+                        loop = asyncio.get_running_loop()
+                        if loop.is_running():
+                            return asyncio.create_task(_delete())
+                    except RuntimeError:
+                        return asyncio.run(_delete())
+            chat_id = msg.get("chat_id") if isinstance(msg, dict) else getattr(msg, "chat_id", self.chat_id)
+            message_id = msg.get("message_id") if isinstance(msg, dict) else getattr(msg, "message_id", self.message_id)
+            return Pick(self.bot, chat_id, message_id)
+        try:
+            loop = asyncio.get_running_loop()
+            if loop.is_running():
+                return asyncio.create_task(_reply_async())
+        except RuntimeError:
+            return asyncio.run(_reply_async())
     def answer(self, text: str, **kwargs):
         return self.bot.send_message(
             self.chat_id,

{rubka-6.8.5.dist-info → rubka-7.1.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Rubka
-Version: 6.8.5
+Version: 7.1.2
 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/archive/refs/tags/v6.6.4.zip
@@ -31,6 +31,7 @@ Requires-Dist: Pillow
 Requires-Dist: websocket-client
 Requires-Dist: pycryptodome
 Requires-Dist: aiohttp
+Requires-Dist: httpx
 Requires-Dist: tqdm
 Requires-Dist: mutagen
 Requires-Dist: filetype

{rubka-6.8.5.dist-info → rubka-7.1.2.dist-info}/RECORD

@@ -1,9 +1,9 @@
 rubka/__init__.py,sha256=P6IBiORfp-GqKHe5LZ-5lldWyG7tnrUYUcAQDUgwXmY,1973
-rubka/api.py,sha256=1S8JIcYN_Zxb7JT73eQl9me-qDDDTDzcSk6_qawAfkA,68861
-rubka/asynco.py,sha256=zna9bPhuDo9Kfut6gxT7nbE2kXvjCMp0Vwm8naOTH30,102328
-rubka/button.py,sha256=vU9OvWXCD4MRrTJ8Xmivd4L471-06zrD2qpZBTw5vjY,13305
+rubka/api.py,sha256=fo4X9MH_HqQmLkRNhjJcJJZOHp5lkFZqitCXs2qL_kc,68891
+rubka/asynco.py,sha256=84qCDieEngvNWBZwFgv-Cu7w8Emvkjru7AUjhswuHcQ,108098
+rubka/button.py,sha256=woSzZVd5MtTqOrP-YgkH5b0GS9y4DuKBsFSc9-KuLnk,13320
 rubka/config.py,sha256=Bck59xkOiqioLv0GkQ1qPGnBXVctz1hKk6LT4h2EPx0,78
-rubka/context.py,sha256=qZUhYbc__jBMvh3HEc1tsN-4N-naOeRJyKMmHYw7940,32280
+rubka/context.py,sha256=-oC9h7U_H3CrtqUCDCnFXAvC7zdSmwxlc0CNwL1XLxM,34314
 rubka/decorators.py,sha256=hGwUoE4q2ImrunJIGJ_kzGYYxQf1ueE0isadqraKEts,1157
 rubka/exceptions.py,sha256=DDOGIHEMoliHNW5E7C_s38WZgqqMBv9812fcJGvj7TY,1173
 rubka/filters.py,sha256=DY1bdkpRKIiLtVcy6X3hOnlGPcVOK4HFb3QgmaPx6Oo,12116
@@ -12,9 +12,9 @@ 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=GuXnEUTTSZUw68FMTQBYsB2zG_3rzdDa-krsrl4ib8w,58755
-rubka/tv.py,sha256=o7CW-6EKLhmM--rzcHcKPcXfzOixcL_B4j037R3mHts,5399
-rubka/update.py,sha256=rCqqxInnDJYnwXy659vSzh7rk3snBy0cTqefaDtn0a4,31826
+rubka/rubino.py,sha256=uCNjVk7ZTUo_r8ALWjvGbQHMr4mXDhoaSfAVdoZmHZk,58832
+rubka/tv.py,sha256=4THsAWd5OAOYoSr6ZkWHuJ9rnURFndgXVQVjMqMHTeA,5453
+rubka/update.py,sha256=-oC9h7U_H3CrtqUCDCnFXAvC7zdSmwxlc0CNwL1XLxM,34314
 rubka/utils.py,sha256=XUQUZxQt9J2f0X5hmAH_MH1kibTAfdT1T4AaBkBhBBs,148
 rubka/adaptorrubka/__init__.py,sha256=6o2tCXnVeES7nx-LjnzsuMqjKcWIm9qwKficLE54s-U,83
 rubka/adaptorrubka/enums.py,sha256=cyiakExmZi-QQpYuf_A93HQvfZVmyG_0uVuvTTNT5To,1053
@@ -37,8 +37,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.8.5.dist-info/METADATA,sha256=GBV_8B-GISwQoZ6Z8TDTsI2OLxv0xoeeuHVQBcXkJCM,34269
-rubka-6.8.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-rubka-6.8.5.dist-info/entry_points.txt,sha256=4aESuUmuUOALMUy7Kucv_Gb5YlqhsJmTmdXLlZU9sJ0,46
-rubka-6.8.5.dist-info/top_level.txt,sha256=vy2A4lot11cRMdQS-F4HDCIXL3JK8RKfu7HMDkezJW4,6
-rubka-6.8.5.dist-info/RECORD,,
+rubka-7.1.2.dist-info/METADATA,sha256=ZchdDpS9nxgjR-KdBRc8DV4yFMnm5StlXQ3p_XReUS4,34291
+rubka-7.1.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+rubka-7.1.2.dist-info/entry_points.txt,sha256=4aESuUmuUOALMUy7Kucv_Gb5YlqhsJmTmdXLlZU9sJ0,46
+rubka-7.1.2.dist-info/top_level.txt,sha256=vy2A4lot11cRMdQS-F4HDCIXL3JK8RKfu7HMDkezJW4,6
+rubka-7.1.2.dist-info/RECORD,,