Rubka 6.6.2__py3-none-any.whl → 7.1.17__py3-none-any.whl

rubka/__init__.py

@@ -1,6 +1,76 @@
+"""
+🔹 Synchronous Example
+```python
+from rubka import Robot, Message
+
+bot = Robot(token="YOUR_BOT_TOKEN")
+
+@bot.on_message(commands=["start", "help"])
+def handle_start(bot: Robot, message: Message):
+    message.reply("👋 Hello! Welcome to the Rubka bot (sync example).")
+
+bot.run()
+```
+
+Explanation
+
+Robot is created with your bot token.
+@bot.on_message registers a handler for incoming messages.
+
+The function handle_start runs synchronously (step by step, blocking).
+
+message.reply sends a message back to the user immediately.
+
+Finally, bot.run() starts the event loop and keeps the bot running.
+
+This approach is simpler and best for small bots or basic logic where you don’t need concurrency.
+
+🔹 Asynchronous Example
+```python
+import asyncio
+from rubka.asynco import Robot, Message
+
+bot = Robot(token="YOUR_BOT_TOKEN")
+
+@bot.on_message(commands=["start", "help"])
+async def handle_start(bot: Robot, message: Message):
+    await message.reply("⚡ Hello! This is the async version of Rubka.")
+
+async def main():
+    await bot.run()
+
+asyncio.run(main())
+```
+Explanation
+
+Uses rubka.asynco.Robot for asynchronous operation.
+
+The handler handle_start is defined with async def.
+
+await message.reply(...) is non-blocking: the bot can process other tasks while waiting for Rubika’s response.
+
+asyncio.run(main()) starts the async event loop.
+
+This approach is more powerful and recommended for larger bots or when you:
+
+Need to call external APIs.
+
+Handle multiple long-running tasks.
+
+Want better performance and scalability.
+
+👉 In short:
+
+Sync = simple, step-by-step, blocking.
+
+Async = scalable, concurrent, non-blocking.
+"""
+
 from .api import Robot
 from .rubino import Bot
 from .exceptions import APIRequestError
+from .rubino import Bot as rubino
+from .tv import TV as TvRubika
 
 __all__ = [
     "Robot",

rubka/api.py

@@ -4,6 +4,7 @@ from .exceptions import APIRequestError
 from .adaptorrubka import Client as Client_get
 from .logger import logger
 from . import filters
+from . import helpers
 from typing import Callable
 from .context import Message,InlineMessage
 from typing import Optional, Union, Literal, Dict, Any
@@ -53,22 +54,8 @@ def get_latest_version(package_name: str) -> str:
         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\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):
     text = text.strip()
     return text[-6:]
@@ -1015,7 +1002,9 @@ 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,
+        parse_mode = None
     ) -> Dict[str, Any]:
         """
         Send a text message to a chat.