Rubka 4.4.6__py3-none-any.whl → 4.4.19__py3-none-any.whl

rubka/adaptorrubka/network/socket.py

@@ -1,12 +1,19 @@
+import sys
+import subprocess
 
-try:
-    from websocket import WebSocketApp
-except:
-    import os
+def install_and_import(package_name):
     try:
-        os.system("pip install websocket-client")
-    except:
-        os.system("python -m pip install websocket-client")
+        __import__(package_name)
+    except ModuleNotFoundError:
+        print(f"Module '{package_name}' not found. Installing...")
+        subprocess.check_call([sys.executable, "-m", "pip", "install", package_name])
+    finally:
+        globals()[package_name] = __import__(package_name)
+
+install_and_import("websocket")
+
+from websocket import WebSocketApp
+
 from .helper import Helper
 from json import dumps, loads
 from threading import Thread
@@ -21,4 +28,4 @@ class Socket:
         self.methods = methods
         self.handlers = {}
 
-    ...
+    ...

rubka/api.py

@@ -8,7 +8,8 @@ from .context import Message,InlineMessage
 from typing import Optional, Union, Literal, Dict, Any
 from pathlib import Path
 import requests
-
+import time
+import datetime
 API_URL = "https://botapi.rubika.ir/v3"
 import sys
 import subprocess
@@ -54,10 +55,13 @@ def check_rubka_version():
     latest_version = get_latest_version(package_name)
     if latest_version is None:return
     if installed_version != latest_version:
-        print(f"\n\n⚠️ WARNING: Your installed version of '{package_name}' is outdated!")
-        print(f"Installed version: {installed_version}")
-        print(f"Latest version:    {latest_version}")
-        print(f"Please update it using:\n\npip install --upgrade {package_name}\n")
+        print(f"\n\nWARNING: Your installed version of '{package_name}' is OUTDATED and may cause errors or security risks!")
+        print(f"Installed version : {installed_version}")
+        print(f"Latest available version : {latest_version}")
+        print(f"Please update IMMEDIATELY by running:")
+        print(f"\npip install {package_name}=={latest_version}\n")
+        print(f"Not updating may lead to malfunctions or incompatibility.")
+        print(f"To see new methods : @rubka_library\n\n")
 
 check_rubka_version()
 def show_last_six_words(text):
@@ -74,7 +78,7 @@ class Robot:
     Initialized with bot token.
     """
 
-    def __init__(self, token: str,session_name : str = None,auth : str = None , Key : str = None,platform : str ="web",timeout : int =10):
+    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):
         """
     راه‌اندازی اولیه ربات روبیکا و پیکربندی پارامترهای پایه.
 
@@ -95,11 +99,14 @@ class Robot:
         >>> bot = Robot(token="BOT_TOKEN", platform="android", timeout=15)
     """
         self.token = token
+        self._inline_query_handlers = []
+        self._inline_query_handlers: List[dict] = []
         self.timeout = timeout
         self.auth = auth
         self.session_name = session_name
         self.Key = Key
         self.platform = platform
+        self.web_hook = web_hook
         self._offset_id = None
         self.session = requests.Session()
         self.sessions: Dict[str, Dict[str, Any]] = {}
@@ -108,6 +115,11 @@ class Robot:
         self._inline_query_handler = None
         self._callback_handlers = None
         self._callback_handlers = []  # ✅ این خط مهمه
+        json_url = requests.get(web_hook).json()['url']
+        if web_hook:
+            for endpoint_type in ["ReceiveUpdate", "ReceiveInlineMessage", "ReceiveQuery", "GetSelectionItem", "SearchSelectionItems"]:
+                print(self.update_bot_endpoint(web_hook, endpoint_type))
+            self.web_hook = json_url
 
 
         logger.info(f"Initialized RubikaBot with token: {token[:8]}***")
@@ -153,48 +165,65 @@ class Robot:
             })
             return func
         return decorator
-    def on_inline_query(self):
+    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:
+                    handler["func"](self, inline_message)
+                except Exception as e:
+                    print(f"Error in inline query handler: {e}")
+
+    def on_inline_query(self, button_id: Optional[str] = None):
         def decorator(func: Callable[[Any, InlineMessage], None]):
-            self._inline_query_handler = func
+            self._inline_query_handlers.append({
+                "func": func,
+                "button_id": button_id
+            })
             return func
         return decorator
+
     
-    def _process_update(self, update: Dict[str, Any]):
+    def _process_update(self, update: dict):
         import threading, time
 
-        if update.get('type') == 'ReceiveQuery':
+        # هندل پیام inline (معمولاً type = ReceiveQuery)
+        if update.get("type") == "ReceiveQuery":
             msg = update.get("inline_message", {})
-            if self._inline_query_handler:
+            if update.get("type") == "ReceiveQuery":
+                msg = update.get("inline_message", {})
                 context = InlineMessage(bot=self, raw_data=msg)
-                threading.Thread(target=self._inline_query_handler, args=(self, context), daemon=True).start()
-            return  # اگر inline بود ادامه نده
+                threading.Thread(target=self._handle_inline_query, args=(context,), daemon=True).start()
+                return
 
-        if update.get('type') == 'NewMessage':
-            msg = update.get('new_message', {})
-            chat_id = update.get('chat_id')
-            message_id = msg.get('message_id')
-            sender_id = msg.get('sender_id')
-            text = msg.get('text')
+        # هندل پیام جدید متنی
+        if update.get("type") == "NewMessage":
+            msg = update.get("new_message", {})
+            chat_id = update.get("chat_id")
+            message_id = msg.get("message_id")
+            sender_id = msg.get("sender_id")
+            text = msg.get("text")
 
-            # فیلتر زمان قدیمی
+            # فیلتر زمان پیام (مثلاً پیام‌های خیلی قدیمی)
             try:
                 if msg.get("time") and (time.time() - float(msg["time"])) > 20:
                     return
             except Exception:
                 return
 
-            # ساخت context یکجا
+            # ساخت context پیام
             context = Message(bot=self, chat_id=chat_id, message_id=message_id, sender_id=sender_id, text=text, raw_data=msg)
 
-            # 💠 اول بررسی دکمه‌ها (callback)
+            # هندل callback ها (دکمه‌ها)
             if context.aux_data and hasattr(self, "_callback_handlers"):
                 for handler in self._callback_handlers:
                     if not handler["button_id"] or context.aux_data.button_id == handler["button_id"]:
                         threading.Thread(target=handler["func"], args=(self, context), daemon=True).start()
-                        return  # فقط اولین callback اجرا شود
+                        return  # فقط یک callback اجرا شود
 
-            # 💠 بعد بررسی پیام‌های متنی معمولی
-            if self._message_handler:
+            # هندل پیام‌های متنی معمولی
+            if hasattr(self, "_message_handler") and self._message_handler:
                 handler = self._message_handler
 
                 if handler["commands"]:
@@ -214,30 +243,137 @@ class Robot:
 
 
 
+
+    def get_updates(
+        self,
+        offset_id: Optional[str] = None,
+        limit: Optional[int] = None
+    ) -> Dict[str, Any]:
+        """Get updates."""
+        data = {}
+        if offset_id:
+            data["offset_id"] = offset_id
+        if limit:
+            data["limit"] = limit
+        return self._post("getUpdates", data)
+    def update_webhook(
+        self,
+        offset_id: Optional[str] = None,
+        limit: Optional[int] = None
+    ) -> Dict[str, Any]:
+        data = {}
+        if offset_id:
+            data["offset_id"] = offset_id
+        if limit:
+            data["limit"] = limit
+        return list(requests.get(self.web_hook).json())
+    def _is_duplicate(self, message_id: str, max_age_sec: int = 300) -> bool:
+        now = time.time()
+
+        # حذف پیام‌های قدیمی‌تر از max_age_sec
+        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
+
+        self._processed_message_ids[message_id] = now
+        return False
+
+
+    import time
+
+
     def run(self):
         print("Bot started running...")
-        if self._offset_id is None:
-            try:
-                latest = self.get_updates(limit=100)
-                if latest and latest.get("data") and latest["data"].get("updates"):
-                    updates = latest["data"]["updates"]
-                    last_update = updates[-1]
-                    self._offset_id = latest["data"].get("next_offset_id")
-                    print(f"Offset initialized to: {self._offset_id}")
-                else:
-                    print("No updates found.")
-            except Exception as e:
-                print(f"Failed to fetch latest message: {e}")
+        self._processed_message_ids: Dict[str, float] = {}
+        # self._offset_id می‌تواند قبلاً مقداردهی شده باشد
 
         while True:
             try:
-                updates = self.get_updates(offset_id=self._offset_id, limit=100)
-                if updates and updates.get("data"):
-                    for update in updates["data"].get("updates", []):
-                        self._process_update(update)
-                    self._offset_id = updates["data"].get("next_offset_id", self._offset_id)
+                if self.web_hook:
+                    updates = self.update_webhook()
+
+                    if isinstance(updates, list):
+                        for item in updates:
+                            data = item.get("data", {})
+
+                            # بررسی زمان دریافت پیام و رد کردن پیام‌های قدیمی (بیش از 20 ثانیه)
+                            received_at_str = item.get("received_at")
+                            if received_at_str:
+                                received_at_ts = datetime.datetime.strptime(received_at_str, "%Y-%m-%d %H:%M:%S").timestamp()
+                                if time.time() - received_at_ts > 20:
+                                    continue  # رد کردن پیام قدیمی
+
+                            update = None
+                            if "update" in data:
+                                update = data["update"]
+                            elif "inline_message" in data:
+                                update = {
+                                    "type": "ReceiveQuery",
+                                    "inline_message": data["inline_message"]
+                                }
+                            else:
+                                continue
+
+                            message_id = None
+                            if update.get("type") == "NewMessage":
+                                message_id = update.get("new_message", {}).get("message_id")
+                            elif update.get("type") == "ReceiveQuery":
+                                message_id = update.get("inline_message", {}).get("message_id")
+                            elif "message_id" in update:
+                                message_id = update.get("message_id")
+
+                            if message_id is not None:
+                                message_id = str(message_id)
+
+                            if message_id and self._is_duplicate(message_id):
+                                continue
+
+                            self._process_update(update)
+
+                            # ثبت پیام به عنوان پردازش شده
+                            if message_id:
+                                self._processed_message_ids[message_id] = time.time()
+
+                else:
+                    updates = self.get_updates(offset_id=self._offset_id, limit=100)
+
+                    if updates and updates.get("data"):
+                        for update in updates["data"].get("updates", []):
+                            message_id = None
+                            if update.get("type") == "NewMessage":
+                                message_id = update.get("new_message", {}).get("message_id")
+                            elif update.get("type") == "ReceiveQuery":
+                                message_id = update.get("inline_message", {}).get("message_id")
+                            elif "message_id" in update:
+                                message_id = update.get("message_id")
+
+                            if message_id is not None:
+                                message_id = str(message_id)
+
+                            if message_id and self._is_duplicate(message_id):
+                                continue
+
+                            self._process_update(update)
+
+                            if message_id:
+                                self._processed_message_ids[message_id] = time.time()
+
+                        self._offset_id = updates["data"].get("next_offset_id", self._offset_id)
+
             except Exception as e:
-                print(f"Error in run loop: {e}")
+                print(f"❌ Error in run loop: {e}")
+
+
+
+
+
+
+
+
 
     def send_message(
         self,
@@ -573,18 +709,7 @@ class Robot:
             chat_keypad_type=chat_keypad_type
         )
 
-    def get_updates(
-        self,
-        offset_id: Optional[str] = None,
-        limit: Optional[int] = None
-    ) -> Dict[str, Any]:
-        """Get updates."""
-        data = {}
-        if offset_id:
-            data["offset_id"] = offset_id
-        if limit:
-            data["limit"] = limit
-        return self._post("getUpdates", data)
+    
 
     def forward_message(
         self,
@@ -621,7 +746,7 @@ class Robot:
         inline_keypad: Dict[str, Any]
     ) -> Dict[str, Any]:
         """Edit inline keypad of a message."""
-        return self._post("editInlineKeypad", {
+        return self._post("editMessageKeypad", {
             "chat_id": chat_id,
             "message_id": message_id,
             "inline_keypad": inline_keypad

rubka/context.py

@@ -408,6 +408,12 @@ class Message:
             chat_id=self.chat_id,
             message_id=self.message_id
         )
+class AuxData:
+    def __init__(self, data: dict):
+        self.start_id = data.get("start_id")
+        self.button_id = data.get("button_id")
+
+# نمونه کلاس InlineMessage با ویژگی aux_data که شامل دکمه است
 class InlineMessage:
     def __init__(self, bot, raw_data: dict):
         self.bot = bot
@@ -438,4 +444,4 @@ class InlineMessage:
         return self.bot.delete_message(
             chat_id=self.chat_id,
             message_id=self.message_id
-        )
+        )