Rubka 0.1.2__tar.gz → 1.2.9__tar.gz

{rubka-0.1.2 → rubka-1.2.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Rubka
-Version: 0.1.2
+Version: 1.2.9
 Summary: A Python library for interacting with Rubika Bot API.
 Home-page: https://github.com/Mahdy-Ahmadi/Rubka
 Download-URL: https://github.com/Mahdy-Ahmadi/Rubka/archive/refs/tags/v0.1.0.tar.gz

{rubka-0.1.2 → rubka-1.2.9}/Rubka.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Rubka
-Version: 0.1.2
+Version: 1.2.9
 Summary: A Python library for interacting with Rubika Bot API.
 Home-page: https://github.com/Mahdy-Ahmadi/Rubka
 Download-URL: https://github.com/Mahdy-Ahmadi/Rubka/archive/refs/tags/v0.1.0.tar.gz

{rubka-0.1.2 → rubka-1.2.9}/Rubka.egg-info/SOURCES.txt

@@ -8,8 +8,11 @@ Rubka.egg-info/top_level.txt
 rubka/__init__.py
 rubka/api.py
 rubka/config.py
+rubka/context.py
 rubka/decorators.py
 rubka/exceptions.py
+rubka/jobs.py
 rubka/keyboards.py
+rubka/keypad.py
 rubka/logger.py
 rubka/utils.py

rubka-1.2.9/rubka/api.py

@@ -0,0 +1,363 @@
+import requests
+from typing import List, Optional, Dict, Any, Literal
+from .exceptions import APIRequestError
+from .logger import logger
+from typing import Callable
+from .context import Message,InlineMessage
+API_URL = "https://botapi.rubika.ir/v3"
+import sys
+import subprocess
+import requests
+def install_package(package_name):
+    try:
+        subprocess.check_call([sys.executable, "-m", "pip", "install", package_name], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+        return True
+    except Exception:return False
+
+def get_importlib_metadata():
+    try:
+        from importlib.metadata import version, PackageNotFoundError
+        return version, PackageNotFoundError
+    except ImportError:
+        if install_package("importlib-metadata"):
+            try:
+                from importlib_metadata import version, PackageNotFoundError
+                return version, PackageNotFoundError
+            except ImportError:
+                return None, None
+        return None, None
+
+version, PackageNotFoundError = get_importlib_metadata()
+def get_installed_version(package_name: str) -> str:
+    if version is None:return "unknown"
+    try:
+        return version(package_name)
+    except PackageNotFoundError:
+        return None
+def get_latest_version(package_name: str) -> str:
+    url = f"https://pypi.org/pypi/{package_name}/json"
+    try:
+        resp = requests.get(url, timeout=5)
+        resp.raise_for_status()
+        data = resp.json()
+        return data["info"]["version"]
+    except Exception:return None
+def check_rubka_version():
+    package_name = "rubka"
+    installed_version = get_installed_version(package_name)
+    if installed_version is None:return
+    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")
+
+check_rubka_version()
+class Robot:
+    """
+    Main class to interact with Rubika Bot API.
+    Initialized with bot token.
+    """
+
+    def __init__(self, token: str):
+        self.token = token
+        self._offset_id = None
+        self.session = requests.Session()
+        self.sessions: Dict[str, Dict[str, Any]] = {}
+        self._callback_handler = None
+        self._message_handler = None
+        self._inline_query_handler = None
+
+
+        logger.info(f"Initialized RubikaBot with token: {token[:8]}***")
+
+    def _post(self, method: str, data: Dict[str, Any]) -> Dict[str, Any]:
+        url = f"{API_URL}/{self.token}/{method}"
+        try:
+            response = self.session.post(url, json=data, timeout=10)
+            response.raise_for_status()
+            try:
+                json_resp = response.json()
+            except ValueError:
+                logger.error(f"Invalid JSON response from {method}: {response.text}")
+                raise APIRequestError(f"Invalid JSON response: {response.text}")
+            if method != "getUpdates":logger.debug(f"API Response from {method}: {json_resp}")
+            
+            return json_resp
+        except requests.RequestException as e:
+            logger.error(f"API request failed: {e}")
+            raise APIRequestError(f"API request failed: {e}") from e
+
+
+    def get_me(self) -> Dict[str, Any]:
+        """Get info about the bot itself."""
+        return self._post("getMe", {})
+    def on_message(self, filters: Optional[Callable[[Message], bool]] = None, commands: Optional[List[str]] = None):
+        def decorator(func: Callable[[Any, Message], None]):
+            self._message_handler = {
+                "func": func,
+                "filters": filters,
+                "commands": commands
+            }
+            return func
+        return decorator
+
+
+    def on_inline_query(self):
+        def decorator(func: Callable[[Any, InlineMessage], None]):
+            self._inline_query_handler = func
+            return func
+        return decorator
+
+
+
+    def _process_update(self, update: Dict[str, Any]):
+        if update.get('type') == 'ReceiveQuery':
+            msg = update.get("inline_message", {})
+            if self._inline_query_handler:
+                context = InlineMessage(bot=self, raw_data=msg)
+                self._inline_query_handler(self, context)
+        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:
+                import time
+                if msg.get("time") and (time.time() - float(msg["time"])) > 10:return
+            except Exception as e:return
+            if self._message_handler:
+                handler = self._message_handler
+                context = Message(bot=self, chat_id=chat_id, message_id=message_id, sender_id=sender_id, text=text, raw_data=msg)
+                if handler["commands"]:
+                    if not context.text or not context.text.startswith("/"):
+                        return
+                    parts = context.text.split()
+                    cmd = parts[0][1:]
+                    if cmd not in handler["commands"]:
+                        return
+                    context.args = parts[1:]
+
+                if handler["filters"]:
+                    if not handler["filters"](context):
+                        return
+
+                handler["func"](self, context)
+
+        elif update.get('type') == 'ReceiveQuery':
+            msg = update.get("inline_message", {})
+            chat_id = msg.get("chat_id")
+            message_id = msg.get("message_id")
+            sender_id = msg.get("sender_id")
+            text = msg.get("text")
+
+            if hasattr(self, "_callback_handler"):
+                context = Message(bot=self, chat_id=chat_id, message_id=message_id, sender_id=sender_id, text=text, raw_data=msg)
+                self._callback_handler(self, context)
+
+
+    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}")
+
+        while True:
+            try:
+                updates = self.get_updates(offset_id=self._offset_id, limit=1)
+                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)
+            except Exception as e:
+                print(f"Error in run loop: {e}")
+
+    def send_message(
+        self,
+        chat_id: str,
+        text: str,
+        chat_keypad: Optional[Dict[str, Any]] = None,
+        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
+    ) -> Dict[str, Any]:
+        """
+        Send a text message to a chat.
+        """
+        payload = {
+            "chat_id": chat_id,
+            "text": text,
+            "disable_notification": disable_notification
+        }
+        if chat_keypad:
+            payload["chat_keypad"] = chat_keypad
+        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 self._post("sendMessage", payload)
+
+    def send_poll(
+        self,
+        chat_id: str,
+        question: str,
+        options: List[str]
+    ) -> Dict[str, Any]:
+        """
+        Send a poll to a chat.
+        """
+        return self._post("sendPoll", {
+            "chat_id": chat_id,
+            "question": question,
+            "options": options
+        })
+
+    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]:
+        """
+        Send a location to a chat.
+        """
+        payload = {
+            "chat_id": chat_id,
+            "latitude": latitude,
+            "longitude": longitude,
+            "disable_notification": disable_notification,
+            "inline_keypad": inline_keypad,
+            "reply_to_message_id": reply_to_message_id,
+            "chat_keypad_type": chat_keypad_type
+        }
+        # Remove None values
+        payload = {k: v for k, v in payload.items() if v is not None}
+        return self._post("sendLocation", payload)
+
+    def send_contact(
+        self,
+        chat_id: str,
+        first_name: str,
+        last_name: str,
+        phone_number: str
+    ) -> Dict[str, Any]:
+        """
+        Send a contact to a chat.
+        """
+        return self._post("sendContact", {
+            "chat_id": chat_id,
+            "first_name": first_name,
+            "last_name": last_name,
+            "phone_number": phone_number
+        })
+
+    def get_chat(self, chat_id: str) -> Dict[str, Any]:
+        """Get chat info."""
+        return self._post("getChat", {"chat_id": chat_id})
+
+    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,
+        from_chat_id: str,
+        message_id: str,
+        to_chat_id: str,
+        disable_notification: bool = False
+    ) -> Dict[str, Any]:
+        """Forward a message from one chat to another."""
+        return self._post("forwardMessage", {
+            "from_chat_id": from_chat_id,
+            "message_id": message_id,
+            "to_chat_id": to_chat_id,
+            "disable_notification": disable_notification
+        })
+
+    def edit_message_text(
+        self,
+        chat_id: str,
+        message_id: str,
+        text: str
+    ) -> Dict[str, Any]:
+        """Edit text of an existing message."""
+        return self._post("editMessageText", {
+            "chat_id": chat_id,
+            "message_id": message_id,
+            "text": text
+        })
+
+    def edit_inline_keypad(
+        self,
+        chat_id: str,
+        message_id: str,
+        inline_keypad: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        """Edit inline keypad of a message."""
+        return self._post("editInlineKeypad", {
+            "chat_id": chat_id,
+            "message_id": message_id,
+            "inline_keypad": inline_keypad
+        })
+
+    def delete_message(self, chat_id: str, message_id: str) -> Dict[str, Any]:
+        """Delete a message from chat."""
+        return self._post("deleteMessage", {
+            "chat_id": chat_id,
+            "message_id": message_id
+        })
+
+    def set_commands(self, bot_commands: List[Dict[str, str]]) -> Dict[str, Any]:
+        """Set bot commands."""
+        return self._post("setCommands", {"bot_commands": bot_commands})
+
+    def update_bot_endpoint(self, url: str, type: str) -> Dict[str, Any]:
+        """Update bot endpoint (Webhook or Polling)."""
+        return self._post("updateBotEndpoints", {
+            "url": url,
+            "type": type
+        })
+
+    def remove_keypad(self, chat_id: str) -> Dict[str, Any]:
+        """Remove chat keypad."""
+        return self._post("editChatKeypad", {
+            "chat_id": chat_id,
+            "chat_keypad_type": "Removed"
+        })
+
+    def edit_chat_keypad(self, chat_id: str, chat_keypad: Dict[str, Any]) -> Dict[str, Any]:
+        """Edit or add new chat keypad."""
+        return self._post("editChatKeypad", {
+            "chat_id": chat_id,
+            "chat_keypad_type": "New",
+            "chat_keypad": chat_keypad
+        })

rubka-1.2.9/rubka/context.py

@@ -0,0 +1,328 @@
+from typing import Any, Dict, List,Optional
+
+class File:
+    def __init__(self, data: dict):
+        self.file_id: str = data.get("file_id")
+        self.file_name: str = data.get("file_name")
+        self.size: str = data.get("size")
+
+
+class Sticker:
+    def __init__(self, data: dict):
+        self.sticker_id: str = data.get("sticker_id")
+        self.emoji_character: str = data.get("emoji_character")
+        self.file = File(data.get("file", {}))
+
+
+# =========================
+# Poll
+# =========================
+class PollStatus:
+    def __init__(self, data: dict):
+        self.state: str = data.get("state")
+        self.selection_index: int = data.get("selection_index")
+        self.percent_vote_options: List[int] = data.get("percent_vote_options", [])
+        self.total_vote: int = data.get("total_vote")
+        self.show_total_votes: bool = data.get("show_total_votes")
+
+
+class Poll:
+    def __init__(self, data: dict):
+        self.question: str = data.get("question")
+        self.options: List[str] = data.get("options", [])
+        self.poll_status = PollStatus(data.get("poll_status", {}))
+
+
+# =========================
+# Location & Contact & ForwardedFrom
+# =========================
+class Location:
+    def __init__(self, data: dict):
+        self.latitude: str = data.get("latitude")
+        self.longitude: str = data.get("longitude")
+
+
+class LiveLocation:
+    def __init__(self, data: dict):
+        self.start_time: str = data.get("start_time")
+        self.live_period: int = data.get("live_period")
+        self.current_location = Location(data.get("current_location", {}))
+        self.user_id: str = data.get("user_id")
+        self.status: str = data.get("status")
+        self.last_update_time: str = data.get("last_update_time")
+
+
+class ContactMessage:
+    def __init__(self, data: dict):
+        self.phone_number: str = data.get("phone_number")
+        self.first_name: str = data.get("first_name")
+        self.last_name: str = data.get("last_name")
+
+
+class ForwardedFrom:
+    def __init__(self, data: dict):
+        self.type_from: str = data.get("type_from")
+        self.message_id: str = data.get("message_id")
+        self.from_chat_id: str = data.get("from_chat_id")
+        self.from_sender_id: str = data.get("from_sender_id")
+
+
+# =========================
+# AuxData
+# =========================
+class AuxData:
+    def __init__(self, data: dict):
+        self.start_id: str = data.get("start_id")
+        self.button_id: str = data.get("button_id")
+
+
+# =========================
+# Button Models
+# =========================
+class ButtonTextbox:
+    def __init__(self, data: dict):
+        self.type_line: str = data.get("type_line")
+        self.type_keypad: str = data.get("type_keypad")
+        self.place_holder: Optional[str] = data.get("place_holder")
+        self.title: Optional[str] = data.get("title")
+        self.default_value: Optional[str] = data.get("default_value")
+
+
+class ButtonNumberPicker:
+    def __init__(self, data: dict):
+        self.min_value: str = data.get("min_value")
+        self.max_value: str = data.get("max_value")
+        self.default_value: Optional[str] = data.get("default_value")
+        self.title: str = data.get("title")
+
+
+class ButtonStringPicker:
+    def __init__(self, data: dict):
+        self.items: List[str] = data.get("items", [])
+        self.default_value: Optional[str] = data.get("default_value")
+        self.title: Optional[str] = data.get("title")
+
+
+class ButtonCalendar:
+    def __init__(self, data: dict):
+        self.default_value: Optional[str] = data.get("default_value")
+        self.type: str = data.get("type")
+        self.min_year: str = data.get("min_year")
+        self.max_year: str = data.get("max_year")
+        self.title: str = data.get("title")
+
+
+class ButtonLocation:
+    def __init__(self, data: dict):
+        self.default_pointer_location = Location(data.get("default_pointer_location", {}))
+        self.default_map_location = Location(data.get("default_map_location", {}))
+        self.type: str = data.get("type")
+        self.title: Optional[str] = data.get("title")
+        self.location_image_url: str = data.get("location_image_url")
+
+
+class ButtonSelectionItem:
+    def __init__(self, data: dict):
+        self.text: str = data.get("text")
+        self.image_url: str = data.get("image_url")
+        self.type: str = data.get("type")
+
+
+class ButtonSelection:
+    def __init__(self, data: dict):
+        self.selection_id: str = data.get("selection_id")
+        self.search_type: str = data.get("search_type")
+        self.get_type: str = data.get("get_type")
+        self.items: List[ButtonSelectionItem] = [ButtonSelectionItem(i) for i in data.get("items", [])]
+        self.is_multi_selection: bool = data.get("is_multi_selection")
+        self.columns_count: str = data.get("columns_count")
+        self.title: str = data.get("title")
+
+
+class Button:
+    def __init__(self, data: dict):
+        self.id: str = data.get("id")
+        self.type: str = data.get("type")
+        self.button_text: str = data.get("button_text")
+        self.button_selection = ButtonSelection(data.get("button_selection", {})) if "button_selection" in data else None
+        self.button_calendar = ButtonCalendar(data.get("button_calendar", {})) if "button_calendar" in data else None
+        self.button_number_picker = ButtonNumberPicker(data.get("button_number_picker", {})) if "button_number_picker" in data else None
+        self.button_string_picker = ButtonStringPicker(data.get("button_string_picker", {})) if "button_string_picker" in data else None
+        self.button_location = ButtonLocation(data.get("button_location", {})) if "button_location" in data else None
+        self.button_textbox = ButtonTextbox(data.get("button_textbox", {})) if "button_textbox" in data else None
+
+
+class KeypadRow:
+    def __init__(self, data: dict):
+        self.buttons: List[Button] = [Button(btn) for btn in data.get("buttons", [])]
+
+
+class Keypad:
+    def __init__(self, data: dict):
+        self.rows: List[KeypadRow] = [KeypadRow(r) for r in data.get("rows", [])]
+        self.resize_keyboard: bool = data.get("resize_keyboard", False)
+        self.on_time_keyboard: bool = data.get("on_time_keyboard", False)
+
+
+class Chat:
+    def __init__(self, data: dict):
+        self.chat_id: str = data.get("chat_id")
+        self.chat_type: str = data.get("chat_type")
+        self.user_id: str = data.get("user_id")
+        self.first_name: str = data.get("first_name")
+        self.last_name: str = data.get("last_name")
+        self.title: str = data.get("title")
+        self.username: str = data.get("username")
+
+
+class Bot:
+    def __init__(self, data: dict):
+        self.bot_id: str = data.get("bot_id")
+        self.bot_title: str = data.get("bot_title")
+        self.avatar = File(data.get("avatar", {}))
+        self.description: str = data.get("description")
+        self.username: str = data.get("username")
+        self.start_message: str = data.get("start_message")
+        self.share_url: str = data.get("share_url")
+class Message:
+    def __init__(self, bot, chat_id, message_id, sender_id, text=None, raw_data=None):
+        self.bot = bot
+        self.chat_id = chat_id
+        self.raw_data = raw_data or {}
+        self.message_id: str = self.raw_data.get("message_id", message_id)
+        self.text: str = self.raw_data.get("text", text)
+        self.sender_id: str = self.raw_data.get("sender_id", sender_id)
+        self.time: str = self.raw_data.get("time")
+        self.is_edited: bool = self.raw_data.get("is_edited", False)
+        self.sender_type: str = self.raw_data.get("sender_type")
+
+        self.args = []
+        self.reply_to_message_id: Optional[str] = self.raw_data.get("reply_to_message_id")
+        self.forwarded_from = ForwardedFrom(self.raw_data["forwarded_from"]) if "forwarded_from" in self.raw_data else None
+        self.file = File(self.raw_data["file"]) if "file" in self.raw_data else None
+        self.sticker = Sticker(self.raw_data["sticker"]) if "sticker" in self.raw_data else None
+        self.contact_message = ContactMessage(self.raw_data["contact_message"]) if "contact_message" in self.raw_data else None
+        self.poll = Poll(self.raw_data["poll"]) if "poll" in self.raw_data else None
+        self.location = Location(self.raw_data["location"]) if "location" in self.raw_data else None
+        self.live_location = LiveLocation(self.raw_data["live_location"]) if "live_location" in self.raw_data else None
+        self.aux_data = AuxData(self.raw_data["aux_data"]) if "aux_data" in self.raw_data else None
+
+    @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, **kwargs):
+        return self.bot.send_message(
+            self.chat_id,
+            text,
+            reply_to_message_id=self.message_id,
+            **kwargs
+        )
+
+    def reply_poll(self, question: str, options: List[str], **kwargs) -> Dict[str, Any]:
+        return self.bot._post("sendPoll", {
+            "chat_id": self.chat_id,
+            "question": question,
+            "options": options,
+            "reply_to_message_id": self.message_id,
+            **kwargs
+        })
+
+    def reply_location(self, latitude: str, longitude: str, **kwargs) -> Dict[str, Any]:
+        return self.bot.send_location(
+            chat_id=self.chat_id,
+            latitude=latitude,
+            longitude=longitude,
+            reply_to_message_id=self.message_id,
+            **kwargs
+        )
+
+    def reply_contact(self, first_name: str, last_name: str, phone_number: str, **kwargs) -> Dict[str, Any]:
+        return self.bot.send_contact(
+            chat_id=self.chat_id,
+            first_name=first_name,
+            last_name=last_name,
+            phone_number=phone_number,
+            reply_to_message_id=self.message_id,
+            **kwargs
+        )
+
+    def reply_keypad(self, text: str, keypad: Dict[str, Any], **kwargs) -> Dict[str, Any]:
+        return self.bot.send_message(
+            chat_id=self.chat_id,
+            text=text,
+            chat_keypad_type="New",
+            chat_keypad=keypad,
+            reply_to_message_id=self.message_id,
+            **kwargs
+        )
+
+    def reply_inline(self, text: str, inline_keypad: Dict[str, Any], **kwargs) -> Dict[str, Any]:
+        return self.bot.send_message(
+            chat_id=self.chat_id,
+            text=text,
+            inline_keypad=inline_keypad,
+            reply_to_message_id=self.message_id,
+            **kwargs
+        )
+
+    def reply_sticker(self, sticker_id: str, **kwargs) -> Dict[str, Any]:
+        return self.bot._post("sendSticker", {
+            "chat_id": self.chat_id,
+            "sticker_id": sticker_id,
+            "reply_to_message_id": self.message_id,
+            **kwargs
+        })
+
+    def reply_file(self, file_id: str, **kwargs) -> Dict[str, Any]:
+        return self.bot._post("sendFile", {
+            "chat_id": self.chat_id,
+            "file_id": file_id,
+            "reply_to_message_id": self.message_id,
+            **kwargs
+        })
+
+    def edit(self, new_text: str) -> Dict[str, Any]:
+        return self.bot.edit_message_text(
+            chat_id=self.chat_id,
+            message_id=self.message_id,
+            text=new_text
+        )
+
+    def delete(self) -> Dict[str, Any]:
+        return self.bot.delete_message(
+            chat_id=self.chat_id,
+            message_id=self.message_id
+        )
+class InlineMessage:
+    def __init__(self, bot, raw_data: dict):
+        self.bot = bot
+        self.raw_data = raw_data
+
+        self.chat_id: str = raw_data.get("chat_id")
+        self.message_id: str = raw_data.get("message_id")
+        self.sender_id: str = raw_data.get("sender_id")
+        self.text: str = raw_data.get("text")
+        self.aux_data = AuxData(raw_data.get("aux_data", {})) if "aux_data" in raw_data else None
+
+    def reply(self, text: str, **kwargs):
+        return self.bot.send_message(
+            chat_id=self.chat_id,
+            text=text,
+            reply_to_message_id=self.message_id,
+            **kwargs
+        )
+
+    def edit(self, new_text: str):
+        return self.bot.edit_message_text(
+            chat_id=self.chat_id,
+            message_id=self.message_id,
+            text=new_text
+        )
+
+    def delete(self):
+        return self.bot.delete_message(
+            chat_id=self.chat_id,
+            message_id=self.message_id
+        )

{rubka-0.1.2 → rubka-1.2.9}/rubka/exceptions.py

@@ -1,4 +1,3 @@
 class APIRequestError(Exception):
     """Raised when an API request fails."""
-    raise Exception
     pass

rubka-1.2.9/rubka/jobs.py

@@ -0,0 +1,15 @@
+import threading
+import time
+from typing import Callable
+
+class Job:
+    def __init__(self, delay: int, callback: Callable):
+        self.delay = delay
+        self.callback = callback
+        thread = threading.Thread(target=self.run)
+        thread.daemon = True
+        thread.start()
+
+    def run(self):
+        time.sleep(self.delay)
+        self.callback()

rubka-1.2.9/rubka/keypad.py

@@ -0,0 +1,48 @@
+from typing import Dict
+
+class InlineBuilder:
+    def __init__(self):
+        self.rows = []
+
+    def row(self, *buttons: Dict[str, str]):
+        self.rows.append({"buttons": list(buttons)})
+        return self
+
+    def button(self, id: str, text: str, type: str = "Simple") -> Dict[str, str]:
+        return {"id": id, "type": type, "button_text": text}
+
+    def build(self):
+        return {"rows": self.rows}
+from typing import List, Dict, Optional
+
+class ChatKeypadBuilder:
+    def __init__(self):
+        self.rows: List[Dict[str, List[Dict[str, str]]]] = []
+
+    def row(self, *buttons: Dict[str, str]) -> "ChatKeypadBuilder":
+        """
+        یک ردیف دکمه به کی‌پد اضافه می‌کند.
+        ورودی: چند دیکشنری که نماینده دکمه‌ها هستند.
+        """
+        self.rows.append({"buttons": list(buttons)})
+        return self
+
+    def button(self, id: str, text: str, type: str = "Simple") -> Dict[str, str]:
+        """
+        دیکشنری یک دکمه می‌سازد.
+        """
+        return {"id": id, "type": type, "button_text": text}
+
+    def build(
+        self,
+        resize_keyboard: bool = True,
+        on_time_keyboard: bool = False
+    ) -> Dict[str, object]:
+        """
+        ساختار نهایی chat_keypad را می‌سازد.
+        """
+        return {
+            "rows": self.rows,
+            "resize_keyboard": resize_keyboard,
+            "on_time_keyboard": on_time_keyboard
+        }

{rubka-0.1.2 → rubka-1.2.9}/rubka/logger.py

@@ -1,10 +1,10 @@
 import logging
 
 logger = logging.getLogger("rubka")
-logger.setLevel(logging.DEBUG)
+logger.setLevel(logging.ERROR)
 
 ch = logging.StreamHandler()
-ch.setLevel(logging.DEBUG)
+ch.setLevel(logging.ERROR)
 
 formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
 ch.setFormatter(formatter)

{rubka-0.1.2 → rubka-1.2.9}/setup.py

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

rubka-0.1.2/rubka/api.py

@@ -1,211 +0,0 @@
-import requests
-from typing import List, Optional, Dict, Any, Literal
-from .exceptions import APIRequestError
-from .logger import logger
-
-API_URL = "https://botapi.rubika.ir/v3"
-
-class Robot:
-    """
-    Main class to interact with Rubika Bot API.
-    Initialized with bot token.
-    """
-
-    def __init__(self, token: str):
-        self.token = token
-        self.session = requests.Session()
-        logger.info(f"Initialized RubikaBot with token: {token[:8]}***")
-
-    def _post(self, method: str, data: Dict[str, Any]) -> Dict[str, Any]:
-        url = f"{API_URL}/{self.token}/{method}"
-        try:
-            response = self.session.post(url, json=data, timeout=10)
-            response.raise_for_status()
-            json_resp = response.json()
-            logger.debug(f"API Response from {method}: {json_resp}")
-            return json_resp
-        except requests.RequestException as e:
-            logger.error(f"API request failed: {e}")
-            raise APIRequestError(f"API request failed: {e}") from e
-
-    def get_me(self) -> Dict[str, Any]:
-        """Get info about the bot itself."""
-        return self._post("getMe", {})
-
-    def send_message(
-        self,
-        chat_id: str,
-        text: str,
-        chat_keypad: Optional[Dict[str, Any]] = None,
-        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
-    ) -> Dict[str, Any]:
-        """
-        Send a text message to a chat.
-        """
-        payload = {
-            "chat_id": chat_id,
-            "text": text,
-            "disable_notification": disable_notification
-        }
-        if chat_keypad:
-            payload["chat_keypad"] = chat_keypad
-        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 self._post("sendMessage", payload)
-
-    def send_poll(
-        self,
-        chat_id: str,
-        question: str,
-        options: List[str]
-    ) -> Dict[str, Any]:
-        """
-        Send a poll to a chat.
-        """
-        return self._post("sendPoll", {
-            "chat_id": chat_id,
-            "question": question,
-            "options": options
-        })
-
-    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]:
-        """
-        Send a location to a chat.
-        """
-        payload = {
-            "chat_id": chat_id,
-            "latitude": latitude,
-            "longitude": longitude,
-            "disable_notification": disable_notification,
-            "inline_keypad": inline_keypad,
-            "reply_to_message_id": reply_to_message_id,
-            "chat_keypad_type": chat_keypad_type
-        }
-        # Remove None values
-        payload = {k: v for k, v in payload.items() if v is not None}
-        return self._post("sendLocation", payload)
-
-    def send_contact(
-        self,
-        chat_id: str,
-        first_name: str,
-        last_name: str,
-        phone_number: str
-    ) -> Dict[str, Any]:
-        """
-        Send a contact to a chat.
-        """
-        return self._post("sendContact", {
-            "chat_id": chat_id,
-            "first_name": first_name,
-            "last_name": last_name,
-            "phone_number": phone_number
-        })
-
-    def get_chat(self, chat_id: str) -> Dict[str, Any]:
-        """Get chat info."""
-        return self._post("getChat", {"chat_id": chat_id})
-
-    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,
-        from_chat_id: str,
-        message_id: str,
-        to_chat_id: str,
-        disable_notification: bool = False
-    ) -> Dict[str, Any]:
-        """Forward a message from one chat to another."""
-        return self._post("forwardMessage", {
-            "from_chat_id": from_chat_id,
-            "message_id": message_id,
-            "to_chat_id": to_chat_id,
-            "disable_notification": disable_notification
-        })
-
-    def edit_message_text(
-        self,
-        chat_id: str,
-        message_id: str,
-        text: str
-    ) -> Dict[str, Any]:
-        """Edit text of an existing message."""
-        return self._post("editMessageText", {
-            "chat_id": chat_id,
-            "message_id": message_id,
-            "text": text
-        })
-
-    def edit_inline_keypad(
-        self,
-        chat_id: str,
-        message_id: str,
-        inline_keypad: Dict[str, Any]
-    ) -> Dict[str, Any]:
-        """Edit inline keypad of a message."""
-        return self._post("editInlineKeypad", {
-            "chat_id": chat_id,
-            "message_id": message_id,
-            "inline_keypad": inline_keypad
-        })
-
-    def delete_message(self, chat_id: str, message_id: str) -> Dict[str, Any]:
-        """Delete a message from chat."""
-        return self._post("deleteMessage", {
-            "chat_id": chat_id,
-            "message_id": message_id
-        })
-
-    def set_commands(self, bot_commands: List[Dict[str, str]]) -> Dict[str, Any]:
-        """Set bot commands."""
-        return self._post("setCommands", {"bot_commands": bot_commands})
-
-    def update_bot_endpoint(self, url: str, type: str) -> Dict[str, Any]:
-        """Update bot endpoint (Webhook or Polling)."""
-        return self._post("updateBotEndpoints", {
-            "url": url,
-            "type": type
-        })
-
-    def remove_keypad(self, chat_id: str) -> Dict[str, Any]:
-        """Remove chat keypad."""
-        return self._post("editChatKeypad", {
-            "chat_id": chat_id,
-            "chat_keypad_type": "Removed"
-        })
-
-    def edit_chat_keypad(self, chat_id: str, chat_keypad: Dict[str, Any]) -> Dict[str, Any]:
-        """Edit or add new chat keypad."""
-        return self._post("editChatKeypad", {
-            "chat_id": chat_id,
-            "chat_keypad_type": "New",
-            "chat_keypad": chat_keypad
-        })