RubigramClient 1.3.9__tar.gz → 1.4.1__tar.gz

rubigramclient-1.4.1/PKG-INFO

@@ -0,0 +1,70 @@
+Metadata-Version: 2.4
+Name: RubigramClient
+Version: 1.4.1
+Summary: A simple and flexible Python library for building advanced Rubika bots with powerful message handling, inline buttons, and custom filters.
+Author-email: Javad RZ <Javad.Py1385@gmail.com>
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: aiohttp
+Requires-Dist: aiofiles
+Dynamic: license-file
+
+# Rubigram
+A lightweight Python library to build Rubika bots easily.
+
+## Installation
+```bash
+pip install RubigramClient
+```
+
+## Send Message
+```python
+from rubigram import Client, filters
+from rubigram.types import Update
+
+bot = Client("your_bot_token", "you_endpoint_url")
+
+@bot.on_message(filters.command("start"))
+async def start_handler(client, message: Update):    
+    await message.reply("Hi, WELCOME TO RUBIGRAM")
+
+bot.run()
+```
+
+## Send Message & Get receiveInlineMessage
+```python
+from rubigram import Client, filters
+from rubigram.types import Update, Button, Keypad, KeypadRow, InlineMessage
+
+
+bot = Client(token="bot_token", endpoint="endpoint_url")
+
+
+@bot.on_message(filters.command("start"))
+async def start(_, message: Update):
+    inline = Keypad(
+        rows=[
+            KeypadRow(
+                buttons=[
+                    Button("1", "Simple", "Button 1"),
+                    Button("2", "Simple", "Button 2")
+                ]
+            )
+        ]
+    )
+    await bot.send_message(message.chat_id, "Hi", inline_keypad=inline)
+    
+
+@bot.on_inline_message(filters.button(["1", "2"]))
+async def button(_, message: InlineMessage):
+    if message.aux_data.button_id == "1":
+        await bot.send_message(message.chat_id, "You Click Button 1")
+    elif message.aux_data.button_id == "2":
+        await bot.send_message(message.chat_id, "You Click Button 2")
+        
+bot.run()
+```

rubigramclient-1.4.1/README.md

@@ -0,0 +1,55 @@
+# Rubigram
+A lightweight Python library to build Rubika bots easily.
+
+## Installation
+```bash
+pip install RubigramClient
+```
+
+## Send Message
+```python
+from rubigram import Client, filters
+from rubigram.types import Update
+
+bot = Client("your_bot_token", "you_endpoint_url")
+
+@bot.on_message(filters.command("start"))
+async def start_handler(client, message: Update):    
+    await message.reply("Hi, WELCOME TO RUBIGRAM")
+
+bot.run()
+```
+
+## Send Message & Get receiveInlineMessage
+```python
+from rubigram import Client, filters
+from rubigram.types import Update, Button, Keypad, KeypadRow, InlineMessage
+
+
+bot = Client(token="bot_token", endpoint="endpoint_url")
+
+
+@bot.on_message(filters.command("start"))
+async def start(_, message: Update):
+    inline = Keypad(
+        rows=[
+            KeypadRow(
+                buttons=[
+                    Button("1", "Simple", "Button 1"),
+                    Button("2", "Simple", "Button 2")
+                ]
+            )
+        ]
+    )
+    await bot.send_message(message.chat_id, "Hi", inline_keypad=inline)
+    
+
+@bot.on_inline_message(filters.button(["1", "2"]))
+async def button(_, message: InlineMessage):
+    if message.aux_data.button_id == "1":
+        await bot.send_message(message.chat_id, "You Click Button 1")
+    elif message.aux_data.button_id == "2":
+        await bot.send_message(message.chat_id, "You Click Button 2")
+        
+bot.run()
+```

rubigramclient-1.4.1/RubigramClient.egg-info/PKG-INFO

@@ -0,0 +1,70 @@
+Metadata-Version: 2.4
+Name: RubigramClient
+Version: 1.4.1
+Summary: A simple and flexible Python library for building advanced Rubika bots with powerful message handling, inline buttons, and custom filters.
+Author-email: Javad RZ <Javad.Py1385@gmail.com>
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: aiohttp
+Requires-Dist: aiofiles
+Dynamic: license-file
+
+# Rubigram
+A lightweight Python library to build Rubika bots easily.
+
+## Installation
+```bash
+pip install RubigramClient
+```
+
+## Send Message
+```python
+from rubigram import Client, filters
+from rubigram.types import Update
+
+bot = Client("your_bot_token", "you_endpoint_url")
+
+@bot.on_message(filters.command("start"))
+async def start_handler(client, message: Update):    
+    await message.reply("Hi, WELCOME TO RUBIGRAM")
+
+bot.run()
+```
+
+## Send Message & Get receiveInlineMessage
+```python
+from rubigram import Client, filters
+from rubigram.types import Update, Button, Keypad, KeypadRow, InlineMessage
+
+
+bot = Client(token="bot_token", endpoint="endpoint_url")
+
+
+@bot.on_message(filters.command("start"))
+async def start(_, message: Update):
+    inline = Keypad(
+        rows=[
+            KeypadRow(
+                buttons=[
+                    Button("1", "Simple", "Button 1"),
+                    Button("2", "Simple", "Button 2")
+                ]
+            )
+        ]
+    )
+    await bot.send_message(message.chat_id, "Hi", inline_keypad=inline)
+    
+
+@bot.on_inline_message(filters.button(["1", "2"]))
+async def button(_, message: InlineMessage):
+    if message.aux_data.button_id == "1":
+        await bot.send_message(message.chat_id, "You Click Button 1")
+    elif message.aux_data.button_id == "2":
+        await bot.send_message(message.chat_id, "You Click Button 2")
+        
+bot.run()
+```

{rubigramclient-1.3.9 → rubigramclient-1.4.1}/RubigramClient.egg-info/SOURCES.txt

@@ -11,4 +11,5 @@ rubigram/client.py
 rubigram/filters.py
 rubigram/method.py
 rubigram/network.py
+rubigram/state.py
 rubigram/types.py

{rubigramclient-1.3.9 → rubigramclient-1.4.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "RubigramClient"
-version = "1.3.9"
+version = "1.4.1"
 description = "A simple and flexible Python library for building advanced Rubika bots with powerful message handling, inline buttons, and custom filters."
 readme = "README.md"
 requires-python = ">=3.7"
@@ -15,5 +15,6 @@ classifiers = [
 ]
 dependencies = [
     "aiohttp",
-    "aiofiles"
+    "aiofiles",
+    
 ]

rubigramclient-1.4.1/rubigram/__init__.py

@@ -0,0 +1,5 @@
+from .network import Network
+from .method import Method
+from .client import Client
+from . import filters
+from . import state

rubigramclient-1.4.1/rubigram/client.py

@@ -0,0 +1,92 @@
+from __future__ import annotations
+from typing import Callable, Awaitable, Optional
+from aiohttp import web
+from functools import wraps
+from rubigram.types import Update, InlineMessage
+from rubigram.method import Method
+import asyncio
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class Client(Method):
+    def __init__(
+        self,
+        token: str,
+        endpoint: Optional[str] = None,
+        host: str = "0.0.0.0",
+        port: int = 8000
+    ):
+        self.token = token
+        self.port = port
+        self.host = host
+        self.endpoint = endpoint
+        self.messages_handler: list[Callable[[Client, Update], Awaitable]] = []
+        self.inlines_handler: list[Callable[[Client, InlineMessage], Awaitable]] = []
+        self.routes = web.RouteTableDef()
+        super().__init__(token)
+
+    def on_message(self, *filters: Callable[[Update], bool]):
+        def decorator(func: Callable[[Client, Update], Awaitable]):
+            @wraps(func)
+            async def wrapper(client: Client, update: Update):
+                try:
+                    if all(f(update) for f in filters):
+                        await func(client, update)
+                except Exception as e:
+                    logger.exception(f"Error in message handler {func.__name__}: {e}")
+            self.messages_handler.append(wrapper)
+            return func
+        return decorator
+
+    def on_inline_message(self, *filters: Callable[[InlineMessage], bool]):
+        def decorator(func: Callable[[Client, InlineMessage], Awaitable]):
+            @wraps(func)
+            async def wrapper(client: Client, update: InlineMessage):
+                try:
+                    if all(f(update) for f in filters):
+                        await func(client, update)
+                except Exception as e:
+                    logger.exception(f"Error in inline handler {func.__name__}: {e}")
+            self.inlines_handler.append(wrapper)
+            return func
+        return decorator
+
+    async def handle_update(self, data: dict):
+        if "inline_message" in data:
+            event = InlineMessage.from_dict(data["inline_message"])
+            await asyncio.gather(*(h(self, event) for h in self.inlines_handler))
+        elif "update" in data:
+            event = Update.from_dict(data["update"])
+            event.client = self
+            await asyncio.gather(*(h(self, event) for h in self.messages_handler))
+            
+
+    async def set_endpoints(self):
+        if not self.endpoint:
+            return
+        await self.update_bot_endpoint(f"{self.endpoint}/ReceiveUpdate", "ReceiveUpdate")
+        await self.update_bot_endpoint(f"{self.endpoint}/ReceiveInlineMessage", "ReceiveInlineMessage")
+
+    def run(self):
+        @self.routes.post("/ReceiveUpdate")
+        async def receive_update(request: web.Request):
+            data = await request.json()
+            await self.handle_update(data)
+            return web.json_response({"status": "OK"})
+
+        @self.routes.post("/ReceiveInlineMessage")
+        async def receive_inline_message(request: web.Request):
+            data = await request.json()
+            await self.handle_update(data)
+            return web.json_response({"status": "OK"})
+
+        app = web.Application()
+        app.add_routes(self.routes)
+
+        async def on_startup(_):
+            await self.set_endpoints()
+
+        app.on_startup.append(on_startup)
+        web.run_app(app, host=self.host, port=self.port)

{rubigramclient-1.3.9 → rubigramclient-1.4.1}/rubigram/filters.py

@@ -1,14 +1,29 @@
 from rubigram.types import Update, InlineMessage
+from rubigram.state import state_manager
 from typing import Union
 import re
 
-def command(commands: Union[str, list[str]], prefixe: str = "/"):
+
+def state(states: Union[str, list[str]]):
+    def filter(message: Union[Update, InlineMessage]):
+        user_state = state_manager.get_state(message.chat_id)
+        return user_state in states if isinstance(states, list) else user_state == states
+    return filter
+
+def edited():
     def filter(message: Update):
-        if isinstance(message, Update) and message.type == "NewMessage" and message.new_message.text:
-            text = message.new_message.text
-            COMMANDS = commands if isinstance(commands, list) else [commands]
-            for cmd in COMMANDS:
-                if text.lower().startswith(prefixe + cmd):
+        if isinstance(message, Update) and message.updated_message:
+            return message.updated_message.is_edited
+        return False
+    return filter
+
+def command(commands: Union[str, list[str]], prefix: str = "/"):
+    def filter(message: Update):
+        if isinstance(message, Update) and message.new_message and message.new_message.text:
+            text = message.new_message.text.strip()
+            cmds = commands if isinstance(commands, list) else [commands]
+            for cmd in cmds:
+                if text.lower().startswith(prefix + cmd.lower()):
                     return True
         return False
     return filter
@@ -62,6 +77,7 @@ def private():
         return False
     return filter
 
+
 def forward():
     def filter(message: Update):
         if isinstance(message, Update) and message.type == "NewMessage":
@@ -69,6 +85,30 @@ def forward():
         return False
     return filter
 
+def forward_channel():
+    def filter(message: Update):
+        if isinstance(message, Update) and message.type == "NewMessage" and message.new_message.forwarded_from:
+            return message.new_message.forwarded_from.from_sender_id == "Channel"
+        return False
+    return filter
+
+
+def forward_user():
+    def filter(message: Update):
+        if isinstance(message, Update) and message.type == "NewMessage" and message.new_message.forwarded_from:
+            return message.new_message.forwarded_from.from_sender_id == "User"
+        return False
+    return filter
+
+
+def forward_bot():
+    def filter(message: Update):
+        if isinstance(message, Update) and message.type == "NewMessage" and message.new_message.forwarded_from:
+            return message.new_message.forwarded_from.from_sender_id == "Bot"
+        return False
+    return filter
+
+
 def location():
     def filter(message: Update):
         if isinstance(message, Update) and message.type == "NewMessage":