RubigramClient 1.4.0__tar.gz → 1.4.2__tar.gz

{rubigramclient-1.4.0 → rubigramclient-1.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: RubigramClient
-Version: 1.4.0
+Version: 1.4.2
 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

{rubigramclient-1.4.0 → rubigramclient-1.4.2}/RubigramClient.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: RubigramClient
-Version: 1.4.0
+Version: 1.4.2
 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

{rubigramclient-1.4.0 → rubigramclient-1.4.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "RubigramClient"
-version = "1.4.0"
+version = "1.4.2"
 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.0 → rubigramclient-1.4.2}/rubigram/__init__.py

@@ -1,4 +1,4 @@
-from .client import Client
+from .network import Network
 from .method import Method
-from .network import NetWork
+from .client import Client
 from . import filters

rubigramclient-1.4.2/rubigram/client.py

@@ -0,0 +1,146 @@
+from __future__ import annotations
+from typing import Optional, Callable, Awaitable
+from aiohttp import web
+from functools import wraps
+from rubigram.types import Update, InlineMessage
+from rubigram.method import Method
+from rubigram.filters import Filter
+from datetime import datetime
+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.endpoint = endpoint
+        self.host = host
+        self.port = port
+        self.offset_id = None
+        self.routes = web.RouteTableDef()
+        self.message_handlers = []
+        self.inline_handlers = []
+        super().__init__(token)
+
+    def on_message(self, *filters: Filter):
+        def decorator(func: Callable[[Client, Update], Awaitable]):
+            @wraps(func)
+            async def wrapper(client: Client, update: Update):
+                try:
+                    combined_filter = filters[0] if filters else None
+                    for filter in filters[1:]:
+                        combined_filter = combined_filter & filter
+                    
+                    if combined_filter is None or await combined_filter(update):
+                        await func(client, update)
+                        return True
+                    return False
+                except Exception as e:
+                    logger.exception(f"Error in message handler {func.__name__}: {e}")
+                    return False
+            self.message_handlers.append(wrapper)
+            return func
+        return decorator
+
+
+    def on_inline_message(self, *filters: Filter):
+        def decorator(func: Callable[[Client, InlineMessage], Awaitable]):
+            @wraps(func)
+            async def wrapper(client: Client, update: InlineMessage):
+                try:
+                    combined_filter = filters[0] if filters else None
+                    for filter in filters[1:]:
+                        combined_filter = combined_filter & filter
+                    
+                    if combined_filter is None or await combined_filter(update):
+                        await func(client, update)
+                        return True
+                    return False
+                except Exception as e:
+                    logger.exception(f"Error in inline handler {func.__name__}: {e}")
+                    return False
+            self.inline_handlers.append(wrapper)
+            return func
+        return decorator
+
+
+    async def dispatch_update(self, update: Update):
+        for handler in self.message_handlers:
+            try:
+                matched = await handler(self, update)
+                if matched:
+                    return
+            except Exception as error:
+                logger.exception(f"Error in handler dispatch: {error}")
+
+    async def dispatch_inline(self, update: InlineMessage):
+        for handler in self.inline_handlers:
+            try:
+                matched = await handler(self, update)
+                if matched:
+                    return
+            except Exception as error:
+                logger.exception(f"Error in inline handler dispatch: {error}")
+
+    async def updater(self, data: dict):
+        if "inline_message" in data:
+            event = InlineMessage.from_dict(data["inline_message"])
+            await self.dispatch_inline(event)
+        elif "update" in data:
+            event = Update.from_dict(data["update"])
+            event.client = self
+            await self.dispatch_update(event)
+            
+    async def set_endpoints(self):
+        if self.endpoint:
+            await self.update_bot_endpoint(f"{self.endpoint}/ReceiveUpdate", "ReceiveUpdate")
+            await self.update_bot_endpoint(f"{self.endpoint}/ReceiveInlineMessage", "ReceiveInlineMessage")
+
+    def run(self):
+        if self.endpoint:
+            @self.routes.post("/ReceiveUpdate")
+            async def receive_update(request: web.Request):
+                data = await request.json()
+                await self.updater(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.updater(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)
+            
+        else:
+            async def polling():
+                while True:
+                    try:
+                        get_update = await self.get_update(100, self.offset_id)
+                        if get_update.updates:
+                            updates = get_update.updates
+                            for update in updates:
+                                if update.type == "NewMessage":
+                                    message_time = int(update.new_message.time)
+                                elif update.type == "UpdatedMessage":
+                                    message_time = int(update.updated_message.time)
+                                else:
+                                    continue
+
+                                now = int(datetime.now().timestamp())
+                                if message_time >= now or message_time + 2 >= now:
+                                    await self.dispatch_update(update)
+
+                            self.offset_id = get_update.next_offset_id
+                    except Exception as e:
+                        logger.exception(f"Polling error: {e}")
+                        await asyncio.sleep(1)
+
+            asyncio.run(polling())

rubigramclient-1.4.2/rubigram/filters.py

@@ -0,0 +1,165 @@
+from rubigram.types import Update, InlineMessage
+from typing import Union, Callable, Awaitable
+import re
+
+
+class Filter:
+    def __init__(self, func: Callable[[Union[Update, InlineMessage]], bool | Awaitable[bool]]):
+        self.func = func
+
+    async def __call__(self, update: Union[Update, InlineMessage]) -> bool:
+        result = self.func(update)
+        if isinstance(result, Awaitable):
+            return await result
+        return result
+
+    def __and__(self, other: "Filter"):
+        async def combined(update):
+            return await self(update) and await other(update)
+        return Filter(combined)
+
+    def __or__(self, other: "Filter"):
+        async def combined(update):
+            return await self(update) or await other(update)
+        return Filter(combined)
+
+
+class command(Filter):
+    def __init__(self, cmd: Union[str, list[str]], prefix: str = "/"):
+        self.cmd = cmd
+        self.prefix = prefix
+        super().__init__(self.filter)
+
+    def filter(self, update: Update):
+        commands = [self.cmd] if isinstance(self.cmd, str) else self.cmd
+        text = ""
+        if isinstance(update, Update):
+            if update.type == "NewMessage":
+                text = update.new_message.text
+            elif update.type == "UpdatedMessage":
+                text = update.updated_message.text
+
+            for cmd in commands:
+                if text.lower().startswith(self.prefix + cmd.lower()):
+                    return True
+            return False
+
+
+class regex(Filter):
+    def __init__(self, pattern: str):
+        self.pattern = pattern
+        super().__init__(self.filter)
+
+    def filter(self, update: Union[Update, InlineMessage]):
+        text = ""
+        if isinstance(update, Update):
+            if update.type == "NewMessage":
+                text = getattr(update.new_message, "text", "")
+            elif update.type == "UpdatedMessage":
+                text = getattr(update.updated_message, "text", "")
+        elif isinstance(update, InlineMessage):
+            text = getattr(update, "text", "")
+
+        if text:
+            return bool(re.search(self.pattern, text))
+        return False
+
+
+class chat(Filter):
+    def __init__(self, chat_id: Union[str, list[str]]):
+        self.chat_id = chat_id
+        super().__init__(self.filter)
+
+    def filter(self, update: Union[Update, InlineMessage]):
+        chat_ids = [self.chat_id] if isinstance(
+            self.chat_id, str) else self.chat_id
+        return update.chat_id in chat_ids
+
+
+class button(Filter):
+    def __init__(self, button_id: Union[str, list[str]]):
+        self.button_id = button_id
+        super().__init__(self.filter)
+
+    def filter(self, update: InlineMessage):
+        if isinstance(update, InlineMessage):
+            button_ids = [self.button_id] if isinstance(
+                self.button_id, str) else self.button_id
+            return update.aux_data.button_id in button_ids
+
+
+
+def TEXT(update: Update):
+    return bool(update.new_message and getattr(update.new_message, "text", None))
+
+
+def FILE(update: Update):
+    return bool(update.new_message and getattr(update.new_message, "file", None))
+
+
+def LIVE(update: Update):
+    return bool(update.new_message and getattr(update.new_message, "live_location", None))
+
+
+def POLL(update: Update):
+    return bool(update.new_message and getattr(update.new_message, "poll", None))
+
+
+def CONTACT(update: Update):
+    return bool(update.new_message and getattr(update.new_message, "contact_message", None))
+
+
+def STICKER(update: Update):
+    return bool(update.new_message and getattr(update.new_message, "sticker", None))
+
+
+def LOCATION(update: Update):
+    return bool(update.new_message and getattr(update.new_message, "location", None))
+
+
+def FORWARD(update: Update):
+    return bool(update.new_message and getattr(update.new_message, "forwarded_from", None))
+
+
+def EDITED(update: Update):
+    if isinstance(update, Update) and update.type == "UpdatedMessage":
+        return update.updated_message.is_edited
+
+
+def PRIVATE(update: Update):
+    if isinstance(update, Update) and update.type == "NewMessage":
+        return update.new_message.sender_type in ["User", "Bot"]
+    return False
+
+
+def FORWARD_BOT(update: Update):
+    if isinstance(update, Update) and update.type == "NewMessage" and update.new_message.forwarded_from:
+        return update.new_message.forwarded_from.type_from == "Bot"
+    return False
+
+
+def FORWARD_USER(update: Update):
+    if isinstance(update, Update) and update.type == "NewMessage" and update.new_message.forwarded_from:
+        return update.new_message.forwarded_from.type_from == "User"
+    return False
+
+
+def FORWARD_CHANNEL(update: Update):
+    if isinstance(update, Update) and update.type == "NewMessage" and update.new_message.forwarded_from:
+        return update.new_message.forwarded_from.type_from == "Channel"
+    return False
+
+
+text = Filter(TEXT)
+file = Filter(FILE)
+live = Filter(LIVE)
+poll = Filter(POLL)
+edited = Filter(EDITED)
+contact = Filter(CONTACT)
+sticker = Filter(STICKER)
+location = Filter(LOCATION)
+forward = Filter(FORWARD)
+private = Filter(PRIVATE)
+forward_bot = Filter(FORWARD_BOT)
+forward_user = Filter(FORWARD_USER)
+forward_channel = Filter(FORWARD_CHANNEL)

{rubigramclient-1.4.0 → rubigramclient-1.4.2}/rubigram/method.py

@@ -1,86 +1,79 @@
-from rubigram.network import NetWork
+from .network import Network
 from typing import Literal, Optional
-from rubigram.types import Bot, Chat, Update, Keypad, MessageId
+from .types import Bot, Chat, Keypad, MessageId, Updates
 
-class Method(NetWork):
+
+class Method(Network):
     def __init__(self, token: str):
         super().__init__(token)
-        
+
     async def get_me(self) -> "Bot":
         response = await self.request("getMe", {})
-        return Bot.read(response["data"]["bot"])
+        return Bot.from_dict(response["bot"])
 
     async def get_chat(self, chat_id: str) -> "Chat":
         response = await self.request("getChat", {"chat_id": chat_id})
-        return Chat.read(response["data"]["chat"])
-    
-    async def get_update(self, limit: int = 1, offset_id: Optional[int] = None) -> list[Update]:
+        return Chat.from_dict(response["chat"])
+
+    async def get_update(self, limit: int = 1, offset_id: Optional[int] = None) -> "Updates":
         response = await self.request("getUpdates", {"limit": limit, "offset_id": offset_id})
-        return [Update.read(update) for update in response["data"]["updates"]]
-    
+        return Updates.from_dict(response)
+
     async def get_file(self, file_id: str) -> str:
         response = await self.request("getFile", {"file_id": file_id})
-        return response["data"]["download_url"]
-    
+        return response["download_url"]
+
     async def set_command(self, command: list):
         response = await self.request("setCommands", {"bot_commands": command})
         return response
-    
+
     async def update_bot_endpoint(self, url: str, type: Literal["ReceiveUpdate", "ReceiveInlineMessage", "ReceiveQuery", "GetSelectionItem", "SearchSelectionItems"]):
         response = await self.request("updateBotEndpoints", {"url": url, "type": type})
         return response
-    
-    async def request_send_file(self, type: str):
-        response = await self.request("requestSendFile", {"type": type})
-        return response["data"]["upload_url"]
-    
-    async def upload_file(self, path: str, name: str, type: str):
-        upload_url = await self.request_send_file(type)
-        response = await self.request_upload_file(upload_url, path, name)
-        return response
-    
-    async def forward_message(self, from_chat_id: str, message_id: str, to_chat_id: str, disable_notification: bool = False) -> "MessageId":
-        data = {"from_chat_id": from_chat_id, "message_id": message_id, "to_chat_id": to_chat_id, "disable_notification": disable_notification}
-        response = await self.request("forwardMessage", data)
-        return MessageId.read(response["data"])
-    
+
     async def delete_message(self, chat_id: str, message_id: str):
         await self.request("deleteMessage", {"chat_id": chat_id, "message_id": message_id})
-    
+
     async def remove_chat_keypad(self, chat_id: str):
         await self.request("editChatKeypad", {"chat_id": chat_id, "chat_keypad_type": "Remove"})
-        
+
     async def edit_chat_keypad(self, chat_id: str, chat_keypad):
         await self.request("editChatKeypad", {"chat_id": chat_id, "chat_keypad_type": "New", "chat_keypad": chat_keypad})
 
     async def edit_message_keypad(self, chat_id: str, message_id: str, inline_keypad):
         await self.request("editMessageKeypad", {"chat_id": chat_id, "message_id": message_id, "inline_keypad": inline_keypad})
-    
+
     async def edit_message_text(self, chat_id: str, message_id: str, text: str):
         await self.request("editMessageText", {"chat_id": chat_id, "message_id": message_id, "text": text})
-    
+
+    async def forward_message(self, from_chat_id: str, message_id: str, to_chat_id: str, disable_notification: bool = False) -> "MessageId":
+        data = {"from_chat_id": from_chat_id, "message_id": message_id,
+                "to_chat_id": to_chat_id, "disable_notification": disable_notification}
+        response = await self.request("forwardMessage", data)
+        return MessageId.from_dict(response)
+
     async def send_message(
         self,
         chat_id: str,
         text: str,
         chat_keypad: Keypad = None,
-        inline_keypad: Keypad= None,
+        inline_keypad: Keypad = None,
         chat_keypad_type: Literal["New", "Remove"] = None,
         disable_notification: bool = None,
-        reply_to_message_id = None
+        reply_to_message_id=None
     ) -> "MessageId":
         data = {
             "chat_id": chat_id,
             "text": text,
-            "chat_keypad": chat_keypad._dict() if chat_keypad else None,
-            "inline_keypad": inline_keypad._dict() if inline_keypad else None,
+            "chat_keypad": chat_keypad.to_dict() if chat_keypad else None,
+            "inline_keypad": inline_keypad.to_dict() if inline_keypad else None,
             "chat_keypad_type": chat_keypad_type,
             "disable_notification": disable_notification,
             "reply_to_message_id": reply_to_message_id
         }
         response = await self.request("sendMessage", data)
-        return MessageId.read(response["data"])
-    
+        return MessageId.from_dict(response)
+
     async def send_poll(
         self,
         chat_id: str,
@@ -96,15 +89,15 @@ class Method(NetWork):
             "chat_id": chat_id,
             "question": question,
             "options": options,
-            "chat_keypad": chat_keypad._dict() if chat_keypad else None,
-            "inline_keypad": inline_keypad._dict() if inline_keypad else None,
+            "chat_keypad": chat_keypad.to_dict() if chat_keypad else None,
+            "inline_keypad": inline_keypad.to_dict() if inline_keypad else None,
             "disable_notification": disable_notification,
             "reply_to_message_id": reply_to_message_id,
             "chat_keypad_type": chat_keypad_type
         }
         response = await self.request("sendPoll", data)
-        return MessageId.read(response["data"])
-    
+        return MessageId.from_dict(response)
+
     async def send_location(
         self,
         chat_id: str,
@@ -120,15 +113,15 @@ class Method(NetWork):
             "chat_id": chat_id,
             "latitude": latitude,
             "longitude": longitude,
-            "chat_keypad": chat_keypad._dict() if chat_keypad else None,
-            "inline_keypad": inline_keypad._dict() if inline_keypad else None,
+            "chat_keypad": chat_keypad.to_dict() if chat_keypad else None,
+            "inline_keypad": inline_keypad.to_dict() if inline_keypad else None,
             "disable_notification": disable_notification,
             "reply_to_message_id": reply_to_message_id,
             "chat_keypad_type": chat_keypad_type
         }
         response = await self.request("sendLocation", data)
-        return MessageId.read(response["data"])
-    
+        return MessageId.from_dict(response)
+
     async def send_contact(
         self,
         chat_id: str,
@@ -146,15 +139,15 @@ class Method(NetWork):
             "first_name": first_name,
             "last_name": last_name,
             "phone_number": phone_number,
-            "chat_keypad": chat_keypad._dict() if chat_keypad else None,
-            "inline_keypad": inline_keypad._dict() if inline_keypad else None,
+            "chat_keypad": chat_keypad.to_dict() if chat_keypad else None,
+            "inline_keypad": inline_keypad.to_dict() if inline_keypad else None,
             "disable_notification": disable_notification,
             "reply_to_message_id": reply_to_message_id,
             "chat_keypad_type": chat_keypad_type
         }
         response = await self.request("sendContact", data)
-        return MessageId.read(response["data"])
-    
+        return MessageId.from_dict(response)
+
     async def send_sticker(
         self,
         chat_id: str,
@@ -168,41 +161,70 @@ class Method(NetWork):
         data = {
             "chat_id": chat_id,
             "sticker_id": sticker_id,
-            "chat_keypad": chat_keypad._dict() if chat_keypad else None,
-            "inline_keypad": inline_keypad._dict() if inline_keypad else None,
+            "chat_keypad": chat_keypad.to_dict() if chat_keypad else None,
+            "inline_keypad": inline_keypad.to_dict() if inline_keypad else None,
             "disable_notification": disable_notification,
             "reply_to_message_id": reply_to_message_id,
             "chat_keypad_type": chat_keypad_type
         }
+
         response = await self.request("sendSticker", data)
-        return MessageId.read(response["data"])
-    
+        return MessageId.from_dict(response)
+
+    async def request_send_file(self, type: str):
+        response = await self.request("requestSendFile", {"type": type})
+        return response["upload_url"]
+
+    async def upload_file(self, file: str, name: str, type: str):
+        upload_url = await self.request_send_file(type)
+        response = await self.request_upload_file(upload_url, file, name)
+        return response
+
+    async def download_file(self, file_id: str, file_name: str):
+        download_url = await self.get_file(file_id)
+        response = await self.request_download_file(download_url, file_name)
+        return response
+
     async def send_file(
         self,
         chat_id: str,
-        path: str,
+        file: str,
         file_name: str,
-        type: Literal["File", "Image", "Voice", "Music", "Gif", "Video"] = "File",
+        type: Literal["File", "Image", "Voice",
+                      "Music", "Gif", "Video"] = "File",
         chat_keypad: Keypad = None,
         inline_keypad: Keypad = None,
+        chat_keypad_type: Literal["New", "Remove"] = None,
         disable_notification: bool = False,
         reply_to_message_id: str = None,
-        chat_keypad_type: Literal["New", "Remove"] = None,
     ) -> "MessageId":
-        file_id = await self.upload_file(path, file_name, type)
+        file_id = await self.upload_file(file, file_name, type)
         data = {
             "chat_id": chat_id,
             "file_id": file_id,
-            "chat_keypad": chat_keypad._dict() if chat_keypad else None,
-            "inline_keypad": inline_keypad._dict() if inline_keypad else None,
+            "chat_keypad": chat_keypad.to_dict() if chat_keypad else None,
+            "inline_keypad": inline_keypad.to_dict() if inline_keypad else None,
             "disable_notification": disable_notification,
             "reply_to_message_id": reply_to_message_id,
             "chat_keypad_type": chat_keypad_type,
         }
         response = await self.request("sendFile", data)
-        return MessageId.read(response["data"])
-    
-    async def download_file(self, file_id: str, file_name: str):
-        download_url = await self.get_file(file_id)
-        response = await self.request_download_file(download_url, file_name)
-        return response
+        return MessageId.from_dict(response)
+
+    async def send_document(self, chat_id: str, document: str, name: str, **kwargs):
+        return await self.send_file(chat_id, document, name, "File", **kwargs)
+
+    async def send_photo(self, chat_id: str, photo: str, name: str, **kwargs):
+        return await self.send_file(chat_id, photo, name, "Image", **kwargs)
+
+    async def send_video(self, chat_id: str, video: str, name: str, **kwargs):
+        return await self.send_file(chat_id, video, name, "Video", **kwargs)
+
+    async def send_gif(self, chat_id: str, gif: str, name: str, **kwargs):
+        return await self.send_file(chat_id, gif, name, "Gif", **kwargs)
+
+    async def send_music(self, chat_id: str, music: str, name: str, **kwargs):
+        return await self.send_file(chat_id, music, name, "Music", **kwargs)
+
+    async def send_voice(self, chat_id: str, voice: str, name: str, **kwargs):
+        return await self.send_file(chat_id, voice, name, "Voice", **kwargs)

rubigramclient-1.4.2/rubigram/network.py

@@ -0,0 +1,58 @@
+from aiohttp import ClientSession, FormData
+from typing import Any, Optional, Dict, Union
+import aiofiles
+import re
+import os
+
+
+class Network:
+    def __init__(self, token: str) -> None:
+        self.token: str = token
+        self.session: Optional[ClientSession] = None
+        self.api: str = f"https://botapi.rubika.ir/v3/{self.token}/"
+
+    async def get_session(self) -> ClientSession:
+        if self.session is None or self.session.closed:
+            self.session = ClientSession()
+        return self.session
+
+    async def close(self) -> None:
+        if self.session and not self.session.closed:
+            await self.session.close()
+
+    async def request(self, method: str, json: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+        session = await self.get_session()
+        async with session.post(self.api + method, json=json) as response:
+            response.raise_for_status()
+            data: dict = await response.json()
+            return data.get("data")
+
+    async def request_bytes_file(self, url: str) -> bytes:
+        session = await self.get_session()
+        async with session.get(url) as response:
+            response.raise_for_status()
+            return await response.read()
+
+    async def request_upload_file(self, upload_url: str, file: Union[str], name: str) -> str:
+        session = await self.get_session()
+
+        if isinstance(file, str) and re.match(r"^https?://", file):
+            file = await self.request_bytes_file(file)
+            
+        elif isinstance(file, str) and os.path.isfile(file):
+            async with aiofiles.open(file, "rb") as f:
+                file = await f.read()
+
+        form = FormData()
+        form.add_field("file", file, filename=name, content_type="application/octet-stream")
+
+        async with session.post(upload_url, data=form) as response:
+            response.raise_for_status()
+            data = await response.json()
+            return data["data"]["file_id"]
+        
+    async def request_download_file(self, url: str, name: str) -> dict[str, Union[str, bool]]:
+        file = await self.request_bytes_file(url)
+        async with aiofiles.open(name, "wb") as f:
+            await f.write(file)
+            return {"status": True, "file": name}