Rubka 0.1.0__tar.gz

rubka-0.1.0/PKG-INFO

@@ -0,0 +1,315 @@
+Metadata-Version: 2.4
+Name: Rubka
+Version: 0.1.0
+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
+Author: Mahdi Ahmadi
+Author-email: mahdiahmadi.1208@gmail.com
+Maintainer: Mahdi Ahmadi
+Maintainer-email: mahdiahmadi.1208@gmail.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Communications :: Chat
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+Requires-Dist: requests
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: download-url
+Dynamic: home-page
+Dynamic: maintainer
+Dynamic: maintainer-email
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+
+# rubibot
+
+A Python library for interacting with the Rubika Bot API using the Robot class.
+
+## Overview
+rubibot is a powerful and easy-to-use Python SDK designed to simplify building bots for the Rubika platform.
+It supports sending messages, editing, polls, locations, contacts, keyboards, and managing bot commands with a clean and modern interface.
+
+## Installation
+
+```bash
+pip install rubibot
+```
+
+Or install from source:
+
+```bash
+git clone https://github.com/Mahdy-Ahmadi/rubibot.git
+cd rubibot
+pip install .
+```
+
+## Quick Start
+
+```python
+from rubibot import Robot, on_message
+
+bot = Robot(token="YOUR_BOT_TOKEN")
+
+@on_message
+def handle_message(bot, chat_id, message_id, text, sender_id):
+    if text == "/start":
+        bot.send_message(chat_id, "Hello! Welcome to rubibot.")
+
+updates = bot.get_updates(limit=10)
+for update in updates.get("updates", []):
+    handle_message(update, bot)
+```
+
+## API Reference
+
+### Class: Robot
+
+The main class to interact with Rubika Bot API.
+
+#### Methods:
+
+- **get_me()**
+
+  Retrieve information about the bot.
+
+  Returns: `dict` — Bot information object.
+
+  Example:
+
+  ```python
+  info = bot.get_me()
+  print(info)
+  ```
+
+- **send_message(chat_id: str, text: str, chat_keypad: dict = None, inline_keypad: dict = None, disable_notification: bool = False, reply_to_message_id: str = None, chat_keypad_type: str = None)**
+
+  Send a message to a chat with optional keypads.
+
+  Parameters:
+
+  - `chat_id` — Chat identifier.
+  - `text` — Message text.
+  - `chat_keypad` — (Optional) Custom keypad attached to chat.
+  - `inline_keypad` — (Optional) Inline keypad attached to message.
+  - `disable_notification` — (Optional) Disable notification for the message (default False).
+  - `reply_to_message_id` — (Optional) Message ID to reply to.
+  - `chat_keypad_type` — (Optional) Type of keypad ("New" or "Removed").
+
+  Returns: `dict` — Response including the sent message ID.
+
+  Example:
+
+  ```python
+  bot.send_message(
+      chat_id="12345",
+      text="Welcome!",
+      inline_keypad={
+          "rows": [
+              {
+                  "buttons": [
+                      {"id": "100", "type": "Simple", "button_text": "Add Account"}
+                  ]
+              }
+          ]
+      }
+  )
+  ```
+
+- **send_poll(chat_id: str, question: str, options: list[str])**
+
+  Send a poll to a chat.
+
+  Parameters:
+
+  - `chat_id` — Chat identifier.
+  - `question` — Poll question text.
+  - `options` — List of poll options.
+
+  Returns: `dict` — Response with poll message ID.
+
+  Example:
+
+  ```python
+  bot.send_poll(
+      chat_id="12345",
+      question="Do you like this bot?",
+      options=["Yes", "No"]
+  )
+  ```
+
+- **send_location(chat_id: str, latitude: str, longitude: str, disable_notification: bool = False, inline_keypad: dict = None, reply_to_message_id: str = None, chat_keypad_type: str = None)**
+
+  Send a location to a chat.
+
+  Parameters:
+
+  - `chat_id` — Chat identifier.
+  - `latitude` — Latitude coordinate.
+  - `longitude` — Longitude coordinate.
+  - `disable_notification` — (Optional) Disable notification.
+  - `inline_keypad` — (Optional) Inline keypad.
+  - `reply_to_message_id` — (Optional) Reply message ID.
+  - `chat_keypad_type` — (Optional) Keypad type.
+
+  Returns: `dict` — Response with message ID.
+
+- **send_contact(chat_id: str, first_name: str, last_name: str, phone_number: str, chat_keypad: dict = None, disable_notification: bool = False, inline_keypad: dict = None, reply_to_message_id: str = None, chat_keypad_type: str = None)**
+
+  Send a contact to a chat.
+
+  Parameters:
+
+  - `chat_id` — Chat identifier.
+  - `first_name` — Contact's first name.
+  - `last_name` — Contact's last name.
+  - `phone_number` — Contact's phone number.
+
+  Additional optional keypad and notification parameters.
+
+  Returns: `dict` — Response with message ID.
+
+- **get_chat(chat_id: str)**
+
+  Get information about a chat.
+
+  Parameters:
+
+  - `chat_id` — Chat identifier.
+
+  Returns: `dict` — Chat info object.
+
+- **get_updates(offset_id: str = None, limit: int = None)**
+
+  Get recent updates/messages sent to the bot.
+
+  Parameters:
+
+  - `offset_id` — (Optional) Start offset for updates.
+  - `limit` — (Optional) Max number of updates to retrieve.
+
+  Returns: `dict` — Updates list.
+
+- **forward_message(from_chat_id: str, message_id: str, to_chat_id: str, disable_notification: bool = False)**
+
+  Forward a message from one chat to another.
+
+  Parameters:
+
+  - `from_chat_id` — Source chat ID.
+  - `message_id` — Message ID to forward.
+  - `to_chat_id` — Target chat ID.
+  - `disable_notification` — (Optional) Disable notification.
+
+  Returns: `dict` — Response with new message ID.
+
+- **edit_message_text(chat_id: str, message_id: str, text: str)**
+
+  Edit the text of a previously sent message.
+
+  Parameters:
+
+  - `chat_id` — Chat ID.
+  - `message_id` — Message ID to edit.
+  - `text` — New text.
+
+  Returns: `dict` — Response status.
+
+- **edit_inline_keypad(chat_id: str, message_id: str, inline_keypad: dict)**
+
+  Edit the inline keypad of a message.
+
+  Parameters:
+
+  - `chat_id` — Chat ID.
+  - `message_id` — Message ID.
+  - `inline_keypad` — New inline keypad structure.
+
+  Returns: `dict` — Response status.
+
+- **delete_message(chat_id: str, message_id: str)**
+
+  Delete a message in a chat.
+
+  Parameters:
+
+  - `chat_id` — Chat ID.
+  - `message_id` — Message ID.
+
+  Returns: `dict` — Response status.
+
+- **set_commands(bot_commands: list[dict])**
+
+  Set the list of bot commands for the bot menu.
+
+  Parameters:
+
+  - `bot_commands` — List of commands as dictionaries with "command" and "description".
+
+  Returns: `dict` — Response status.
+
+- **update_bot_endpoint(url: str, type: str)**
+
+  Update the bot's webhook or API endpoint URL.
+
+  Parameters:
+
+  - `url` — New URL.
+  - `type` — Type of update endpoint (e.g. "GetSelectionItem").
+
+  Returns: `dict` — Response status.
+
+- **remove_keypad(chat_id: str)**
+
+  Remove keypad from a chat.
+
+  Parameters:
+
+  - `chat_id` — Chat ID.
+
+  Returns: `dict` — Response status.
+
+- **edit_chat_keypad(chat_id: str, chat_keypad: dict)**
+
+  Edit or set a new keypad for a chat.
+
+  Parameters:
+
+  - `chat_id` — Chat ID.
+  - `chat_keypad` — Keypad object.
+
+  Returns: `dict` — Response status.
+
+## Decorators
+
+- **@on_message**
+
+  Decorator for defining a message handler function.
+
+  Automatically parses incoming updates and calls your handler with parameters: `bot, chat_id, message_id, text, sender_id`.
+
+  Usage:
+
+  ```python
+  from rubibot import on_message
+
+  @on_message
+  def my_handler(bot, chat_id, message_id, text, sender_id):
+      # your code here
+  ```
+
+## Contributing
+
+Contributions and feedback are welcome! Please submit issues or pull requests on GitHub.
+
+## License
+
+This project is licensed under the MIT License. See the LICENSE file for details.

rubka-0.1.0/README.md

@@ -0,0 +1,284 @@
+
+# rubibot
+
+A Python library for interacting with the Rubika Bot API using the Robot class.
+
+## Overview
+rubibot is a powerful and easy-to-use Python SDK designed to simplify building bots for the Rubika platform.
+It supports sending messages, editing, polls, locations, contacts, keyboards, and managing bot commands with a clean and modern interface.
+
+## Installation
+
+```bash
+pip install rubibot
+```
+
+Or install from source:
+
+```bash
+git clone https://github.com/Mahdy-Ahmadi/rubibot.git
+cd rubibot
+pip install .
+```
+
+## Quick Start
+
+```python
+from rubibot import Robot, on_message
+
+bot = Robot(token="YOUR_BOT_TOKEN")
+
+@on_message
+def handle_message(bot, chat_id, message_id, text, sender_id):
+    if text == "/start":
+        bot.send_message(chat_id, "Hello! Welcome to rubibot.")
+
+updates = bot.get_updates(limit=10)
+for update in updates.get("updates", []):
+    handle_message(update, bot)
+```
+
+## API Reference
+
+### Class: Robot
+
+The main class to interact with Rubika Bot API.
+
+#### Methods:
+
+- **get_me()**
+
+  Retrieve information about the bot.
+
+  Returns: `dict` — Bot information object.
+
+  Example:
+
+  ```python
+  info = bot.get_me()
+  print(info)
+  ```
+
+- **send_message(chat_id: str, text: str, chat_keypad: dict = None, inline_keypad: dict = None, disable_notification: bool = False, reply_to_message_id: str = None, chat_keypad_type: str = None)**
+
+  Send a message to a chat with optional keypads.
+
+  Parameters:
+
+  - `chat_id` — Chat identifier.
+  - `text` — Message text.
+  - `chat_keypad` — (Optional) Custom keypad attached to chat.
+  - `inline_keypad` — (Optional) Inline keypad attached to message.
+  - `disable_notification` — (Optional) Disable notification for the message (default False).
+  - `reply_to_message_id` — (Optional) Message ID to reply to.
+  - `chat_keypad_type` — (Optional) Type of keypad ("New" or "Removed").
+
+  Returns: `dict` — Response including the sent message ID.
+
+  Example:
+
+  ```python
+  bot.send_message(
+      chat_id="12345",
+      text="Welcome!",
+      inline_keypad={
+          "rows": [
+              {
+                  "buttons": [
+                      {"id": "100", "type": "Simple", "button_text": "Add Account"}
+                  ]
+              }
+          ]
+      }
+  )
+  ```
+
+- **send_poll(chat_id: str, question: str, options: list[str])**
+
+  Send a poll to a chat.
+
+  Parameters:
+
+  - `chat_id` — Chat identifier.
+  - `question` — Poll question text.
+  - `options` — List of poll options.
+
+  Returns: `dict` — Response with poll message ID.
+
+  Example:
+
+  ```python
+  bot.send_poll(
+      chat_id="12345",
+      question="Do you like this bot?",
+      options=["Yes", "No"]
+  )
+  ```
+
+- **send_location(chat_id: str, latitude: str, longitude: str, disable_notification: bool = False, inline_keypad: dict = None, reply_to_message_id: str = None, chat_keypad_type: str = None)**
+
+  Send a location to a chat.
+
+  Parameters:
+
+  - `chat_id` — Chat identifier.
+  - `latitude` — Latitude coordinate.
+  - `longitude` — Longitude coordinate.
+  - `disable_notification` — (Optional) Disable notification.
+  - `inline_keypad` — (Optional) Inline keypad.
+  - `reply_to_message_id` — (Optional) Reply message ID.
+  - `chat_keypad_type` — (Optional) Keypad type.
+
+  Returns: `dict` — Response with message ID.
+
+- **send_contact(chat_id: str, first_name: str, last_name: str, phone_number: str, chat_keypad: dict = None, disable_notification: bool = False, inline_keypad: dict = None, reply_to_message_id: str = None, chat_keypad_type: str = None)**
+
+  Send a contact to a chat.
+
+  Parameters:
+
+  - `chat_id` — Chat identifier.
+  - `first_name` — Contact's first name.
+  - `last_name` — Contact's last name.
+  - `phone_number` — Contact's phone number.
+
+  Additional optional keypad and notification parameters.
+
+  Returns: `dict` — Response with message ID.
+
+- **get_chat(chat_id: str)**
+
+  Get information about a chat.
+
+  Parameters:
+
+  - `chat_id` — Chat identifier.
+
+  Returns: `dict` — Chat info object.
+
+- **get_updates(offset_id: str = None, limit: int = None)**
+
+  Get recent updates/messages sent to the bot.
+
+  Parameters:
+
+  - `offset_id` — (Optional) Start offset for updates.
+  - `limit` — (Optional) Max number of updates to retrieve.
+
+  Returns: `dict` — Updates list.
+
+- **forward_message(from_chat_id: str, message_id: str, to_chat_id: str, disable_notification: bool = False)**
+
+  Forward a message from one chat to another.
+
+  Parameters:
+
+  - `from_chat_id` — Source chat ID.
+  - `message_id` — Message ID to forward.
+  - `to_chat_id` — Target chat ID.
+  - `disable_notification` — (Optional) Disable notification.
+
+  Returns: `dict` — Response with new message ID.
+
+- **edit_message_text(chat_id: str, message_id: str, text: str)**
+
+  Edit the text of a previously sent message.
+
+  Parameters:
+
+  - `chat_id` — Chat ID.
+  - `message_id` — Message ID to edit.
+  - `text` — New text.
+
+  Returns: `dict` — Response status.
+
+- **edit_inline_keypad(chat_id: str, message_id: str, inline_keypad: dict)**
+
+  Edit the inline keypad of a message.
+
+  Parameters:
+
+  - `chat_id` — Chat ID.
+  - `message_id` — Message ID.
+  - `inline_keypad` — New inline keypad structure.
+
+  Returns: `dict` — Response status.
+
+- **delete_message(chat_id: str, message_id: str)**
+
+  Delete a message in a chat.
+
+  Parameters:
+
+  - `chat_id` — Chat ID.
+  - `message_id` — Message ID.
+
+  Returns: `dict` — Response status.
+
+- **set_commands(bot_commands: list[dict])**
+
+  Set the list of bot commands for the bot menu.
+
+  Parameters:
+
+  - `bot_commands` — List of commands as dictionaries with "command" and "description".
+
+  Returns: `dict` — Response status.
+
+- **update_bot_endpoint(url: str, type: str)**
+
+  Update the bot's webhook or API endpoint URL.
+
+  Parameters:
+
+  - `url` — New URL.
+  - `type` — Type of update endpoint (e.g. "GetSelectionItem").
+
+  Returns: `dict` — Response status.
+
+- **remove_keypad(chat_id: str)**
+
+  Remove keypad from a chat.
+
+  Parameters:
+
+  - `chat_id` — Chat ID.
+
+  Returns: `dict` — Response status.
+
+- **edit_chat_keypad(chat_id: str, chat_keypad: dict)**
+
+  Edit or set a new keypad for a chat.
+
+  Parameters:
+
+  - `chat_id` — Chat ID.
+  - `chat_keypad` — Keypad object.
+
+  Returns: `dict` — Response status.
+
+## Decorators
+
+- **@on_message**
+
+  Decorator for defining a message handler function.
+
+  Automatically parses incoming updates and calls your handler with parameters: `bot, chat_id, message_id, text, sender_id`.
+
+  Usage:
+
+  ```python
+  from rubibot import on_message
+
+  @on_message
+  def my_handler(bot, chat_id, message_id, text, sender_id):
+      # your code here
+  ```
+
+## Contributing
+
+Contributions and feedback are welcome! Please submit issues or pull requests on GitHub.
+
+## License
+
+This project is licensed under the MIT License. See the LICENSE file for details.

rubka-0.1.0/Rubka.egg-info/PKG-INFO

@@ -0,0 +1,315 @@
+Metadata-Version: 2.4
+Name: Rubka
+Version: 0.1.0
+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
+Author: Mahdi Ahmadi
+Author-email: mahdiahmadi.1208@gmail.com
+Maintainer: Mahdi Ahmadi
+Maintainer-email: mahdiahmadi.1208@gmail.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Communications :: Chat
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+Requires-Dist: requests
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: download-url
+Dynamic: home-page
+Dynamic: maintainer
+Dynamic: maintainer-email
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+
+# rubibot
+
+A Python library for interacting with the Rubika Bot API using the Robot class.
+
+## Overview
+rubibot is a powerful and easy-to-use Python SDK designed to simplify building bots for the Rubika platform.
+It supports sending messages, editing, polls, locations, contacts, keyboards, and managing bot commands with a clean and modern interface.
+
+## Installation
+
+```bash
+pip install rubibot
+```
+
+Or install from source:
+
+```bash
+git clone https://github.com/Mahdy-Ahmadi/rubibot.git
+cd rubibot
+pip install .
+```
+
+## Quick Start
+
+```python
+from rubibot import Robot, on_message
+
+bot = Robot(token="YOUR_BOT_TOKEN")
+
+@on_message
+def handle_message(bot, chat_id, message_id, text, sender_id):
+    if text == "/start":
+        bot.send_message(chat_id, "Hello! Welcome to rubibot.")
+
+updates = bot.get_updates(limit=10)
+for update in updates.get("updates", []):
+    handle_message(update, bot)
+```
+
+## API Reference
+
+### Class: Robot
+
+The main class to interact with Rubika Bot API.
+
+#### Methods:
+
+- **get_me()**
+
+  Retrieve information about the bot.
+
+  Returns: `dict` — Bot information object.
+
+  Example:
+
+  ```python
+  info = bot.get_me()
+  print(info)
+  ```
+
+- **send_message(chat_id: str, text: str, chat_keypad: dict = None, inline_keypad: dict = None, disable_notification: bool = False, reply_to_message_id: str = None, chat_keypad_type: str = None)**
+
+  Send a message to a chat with optional keypads.
+
+  Parameters:
+
+  - `chat_id` — Chat identifier.
+  - `text` — Message text.
+  - `chat_keypad` — (Optional) Custom keypad attached to chat.
+  - `inline_keypad` — (Optional) Inline keypad attached to message.
+  - `disable_notification` — (Optional) Disable notification for the message (default False).
+  - `reply_to_message_id` — (Optional) Message ID to reply to.
+  - `chat_keypad_type` — (Optional) Type of keypad ("New" or "Removed").
+
+  Returns: `dict` — Response including the sent message ID.
+
+  Example:
+
+  ```python
+  bot.send_message(
+      chat_id="12345",
+      text="Welcome!",
+      inline_keypad={
+          "rows": [
+              {
+                  "buttons": [
+                      {"id": "100", "type": "Simple", "button_text": "Add Account"}
+                  ]
+              }
+          ]
+      }
+  )
+  ```
+
+- **send_poll(chat_id: str, question: str, options: list[str])**
+
+  Send a poll to a chat.
+
+  Parameters:
+
+  - `chat_id` — Chat identifier.
+  - `question` — Poll question text.
+  - `options` — List of poll options.
+
+  Returns: `dict` — Response with poll message ID.
+
+  Example:
+
+  ```python
+  bot.send_poll(
+      chat_id="12345",
+      question="Do you like this bot?",
+      options=["Yes", "No"]
+  )
+  ```
+
+- **send_location(chat_id: str, latitude: str, longitude: str, disable_notification: bool = False, inline_keypad: dict = None, reply_to_message_id: str = None, chat_keypad_type: str = None)**
+
+  Send a location to a chat.
+
+  Parameters:
+
+  - `chat_id` — Chat identifier.
+  - `latitude` — Latitude coordinate.
+  - `longitude` — Longitude coordinate.
+  - `disable_notification` — (Optional) Disable notification.
+  - `inline_keypad` — (Optional) Inline keypad.
+  - `reply_to_message_id` — (Optional) Reply message ID.
+  - `chat_keypad_type` — (Optional) Keypad type.
+
+  Returns: `dict` — Response with message ID.
+
+- **send_contact(chat_id: str, first_name: str, last_name: str, phone_number: str, chat_keypad: dict = None, disable_notification: bool = False, inline_keypad: dict = None, reply_to_message_id: str = None, chat_keypad_type: str = None)**
+
+  Send a contact to a chat.
+
+  Parameters:
+
+  - `chat_id` — Chat identifier.
+  - `first_name` — Contact's first name.
+  - `last_name` — Contact's last name.
+  - `phone_number` — Contact's phone number.
+
+  Additional optional keypad and notification parameters.
+
+  Returns: `dict` — Response with message ID.
+
+- **get_chat(chat_id: str)**
+
+  Get information about a chat.
+
+  Parameters:
+
+  - `chat_id` — Chat identifier.
+
+  Returns: `dict` — Chat info object.
+
+- **get_updates(offset_id: str = None, limit: int = None)**
+
+  Get recent updates/messages sent to the bot.
+
+  Parameters:
+
+  - `offset_id` — (Optional) Start offset for updates.
+  - `limit` — (Optional) Max number of updates to retrieve.
+
+  Returns: `dict` — Updates list.
+
+- **forward_message(from_chat_id: str, message_id: str, to_chat_id: str, disable_notification: bool = False)**
+
+  Forward a message from one chat to another.
+
+  Parameters:
+
+  - `from_chat_id` — Source chat ID.
+  - `message_id` — Message ID to forward.
+  - `to_chat_id` — Target chat ID.
+  - `disable_notification` — (Optional) Disable notification.
+
+  Returns: `dict` — Response with new message ID.
+
+- **edit_message_text(chat_id: str, message_id: str, text: str)**
+
+  Edit the text of a previously sent message.
+
+  Parameters:
+
+  - `chat_id` — Chat ID.
+  - `message_id` — Message ID to edit.
+  - `text` — New text.
+
+  Returns: `dict` — Response status.
+
+- **edit_inline_keypad(chat_id: str, message_id: str, inline_keypad: dict)**
+
+  Edit the inline keypad of a message.
+
+  Parameters:
+
+  - `chat_id` — Chat ID.
+  - `message_id` — Message ID.
+  - `inline_keypad` — New inline keypad structure.
+
+  Returns: `dict` — Response status.
+
+- **delete_message(chat_id: str, message_id: str)**
+
+  Delete a message in a chat.
+
+  Parameters:
+
+  - `chat_id` — Chat ID.
+  - `message_id` — Message ID.
+
+  Returns: `dict` — Response status.
+
+- **set_commands(bot_commands: list[dict])**
+
+  Set the list of bot commands for the bot menu.
+
+  Parameters:
+
+  - `bot_commands` — List of commands as dictionaries with "command" and "description".
+
+  Returns: `dict` — Response status.
+
+- **update_bot_endpoint(url: str, type: str)**
+
+  Update the bot's webhook or API endpoint URL.
+
+  Parameters:
+
+  - `url` — New URL.
+  - `type` — Type of update endpoint (e.g. "GetSelectionItem").
+
+  Returns: `dict` — Response status.
+
+- **remove_keypad(chat_id: str)**
+
+  Remove keypad from a chat.
+
+  Parameters:
+
+  - `chat_id` — Chat ID.
+
+  Returns: `dict` — Response status.
+
+- **edit_chat_keypad(chat_id: str, chat_keypad: dict)**
+
+  Edit or set a new keypad for a chat.
+
+  Parameters:
+
+  - `chat_id` — Chat ID.
+  - `chat_keypad` — Keypad object.
+
+  Returns: `dict` — Response status.
+
+## Decorators
+
+- **@on_message**
+
+  Decorator for defining a message handler function.
+
+  Automatically parses incoming updates and calls your handler with parameters: `bot, chat_id, message_id, text, sender_id`.
+
+  Usage:
+
+  ```python
+  from rubibot import on_message
+
+  @on_message
+  def my_handler(bot, chat_id, message_id, text, sender_id):
+      # your code here
+  ```
+
+## Contributing
+
+Contributions and feedback are welcome! Please submit issues or pull requests on GitHub.
+
+## License
+
+This project is licensed under the MIT License. See the LICENSE file for details.

rubka-0.1.0/Rubka.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+README.md
+setup.py
+Rubka.egg-info/PKG-INFO
+Rubka.egg-info/SOURCES.txt
+Rubka.egg-info/dependency_links.txt
+Rubka.egg-info/requires.txt
+Rubka.egg-info/top_level.txt
+rubka/__init__.py
+rubka/api.py
+rubka/config.py
+rubka/decorators.py
+rubka/keyboards.py
+rubka/logger.py
+rubka/utils.py

rubka-0.1.0/Rubka.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

rubka-0.1.0/Rubka.egg-info/requires.txt

@@ -0,0 +1 @@
+requests

rubka-0.1.0/Rubka.egg-info/top_level.txt

@@ -0,0 +1 @@
+rubka

rubka-0.1.0/rubka/__init__.py

@@ -0,0 +1,11 @@
+from .api import Robot
+from .decorators import on_message
+from .exceptions import APIRequestError
+from .keyboards import create_simple_keyboard
+
+__all__ = [
+    "Robot",
+    "on_message",
+    "APIRequestError",
+    "create_simple_keyboard",
+]

rubka-0.1.0/rubka/api.py

@@ -0,0 +1,211 @@
+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
+        })

rubka-0.1.0/rubka/config.py

@@ -0,0 +1,3 @@
+API_URL = "https://botapi.rubika.ir/v3"
+REQUEST_TIMEOUT = 10
+MAX_RETRY = 3

rubka-0.1.0/rubka/decorators.py

@@ -0,0 +1,30 @@
+from typing import Callable, Dict, Any
+import functools
+
+def on_message(func: Callable):
+    """
+    Decorator to handle incoming message updates from Rubika.
+    Extracts message details and passes them to decorated function.
+    """
+    @functools.wraps(func)
+    def wrapper(update: Dict[str, Any], bot: 'Robot'):
+        message_data = {}
+        if 'update' in update and update['update'].get('type') == 'NewMessage':
+            msg = update['update']['new_message']
+            message_data = {
+                'chat_id': update['update']['chat_id'],
+                'message_id': msg.get('message_id'),
+                'text': msg.get('text'),
+                'sender_id': msg.get('sender_id')
+            }
+        elif 'inline_message' in update:
+            msg = update['inline_message']
+            message_data = {
+                'chat_id': msg.get('chat_id'),
+                'message_id': msg.get('message_id'),
+                'text': msg.get('text'),
+                'sender_id': msg.get('sender_id')
+            }
+        if message_data:
+            return func(bot=bot, **message_data)
+    return wrapper

rubka-0.1.0/rubka/keyboards.py

@@ -0,0 +1,16 @@
+from typing import Dict, List
+
+def create_simple_keyboard(buttons: List[List[str]]) -> Dict:
+    """
+    Create a simple chat keypad (keyboard) structure for Rubika.
+    buttons: List of button rows, each row is a list of button texts.
+    Example:
+    [
+        ["Button1", "Button2"],
+        ["Button3"]
+    ]
+    """
+    keyboard = {"rows": []}
+    for row in buttons:
+        keyboard["rows"].append({"buttons": [{"text": text} for text in row]})
+    return keyboard

rubka-0.1.0/rubka/logger.py

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

rubka-0.1.0/rubka/utils.py

@@ -0,0 +1,3 @@
+def is_valid_phone_number(phone: str) -> bool:
+    """Simple phone number validation."""
+    return phone.isdigit() and (10 <= len(phone) <= 15)

rubka-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

rubka-0.1.0/setup.py

@@ -0,0 +1,34 @@
+from setuptools import setup, find_packages
+
+try:
+    with open('README.md', encoding='utf-8') as f:
+        long_description = f.read()
+except FileNotFoundError:
+    long_description = ''
+
+setup(
+    name='Rubka',
+    version='0.1.0',
+    description='A Python library for interacting with Rubika Bot API.',
+    long_description=long_description,
+    long_description_content_type='text/markdown',
+    author='Mahdi Ahmadi',
+    author_email='mahdiahmadi.1208@gmail.com',
+    maintainer='Mahdi Ahmadi',
+    maintainer_email='mahdiahmadi.1208@gmail.com',
+    url='https://github.com/Mahdy-Ahmadi/Rubka',
+    download_url='https://github.com/Mahdy-Ahmadi/Rubka/archive/refs/tags/v0.1.0.tar.gz',
+    packages=find_packages(),
+    include_package_data=True,
+    classifiers=[
+        'Programming Language :: Python :: 3',
+        'License :: OSI Approved :: MIT License',
+        'Operating System :: OS Independent',
+        'Topic :: Communications :: Chat',
+        'Topic :: Software Development :: Libraries',
+    ],
+    python_requires='>=3.6',
+    install_requires=[
+        'requests',
+    ],
+)