RubigramClient 1.4.0__py3-none-any.whl → 1.4.2__py3-none-any.whl

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

rubigram/client.py

@@ -1,90 +1,146 @@
 from __future__ import annotations
-from typing import Callable, Awaitable, Optional
+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
-    ):
+    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.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: Callable[[Update], bool]):
+    def on_message(self, *filters: Filter):
         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):
+                    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}")
-            self.messages_handler.append(wrapper)
+                    return False
+            self.message_handlers.append(wrapper)
             return func
         return decorator
 
-    def on_inline_message(self, *filters: Callable[[InlineMessage], bool]):
+
+    def on_inline_message(self, *filters: Filter):
         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):
+                    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}")
-            self.inlines_handler.append(wrapper)
+                    return False
+            self.inline_handlers.append(wrapper)
             return func
         return decorator
 
-    async def handle_update(self, data: dict):
+
+    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.read(data["inline_message"])
-            await asyncio.gather(*(h(self, event) for h in self.inlines_handler))
+            event = InlineMessage.from_dict(data["inline_message"])
+            await self.dispatch_inline(event)
         elif "update" in data:
-            event = Update.read(data["update"], self)
-            await asyncio.gather(*(h(self, event) for h in self.messages_handler))
-
+            event = Update.from_dict(data["update"])
+            event.client = self
+            await self.dispatch_update(event)
+            
     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")
+        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):
-        @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"})
+        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"})
 
-        @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)
+            
+        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
 
-        app = web.Application()
-        app.add_routes(self.routes)
+                                now = int(datetime.now().timestamp())
+                                if message_time >= now or message_time + 2 >= now:
+                                    await self.dispatch_update(update)
 
-        async def on_startup(_):
-            await self.set_endpoints()
+                            self.offset_id = get_update.next_offset_id
+                    except Exception as e:
+                        logger.exception(f"Polling error: {e}")
+                        await asyncio.sleep(1)
 
-        app.on_startup.append(on_startup)
-        web.run_app(app, host=self.host, port=self.port)
+            asyncio.run(polling())

rubigram/filters.py

@@ -1,113 +1,165 @@
 from rubigram.types import Update, InlineMessage
-# from rubigram.state import state_manager
-from typing import Union
+from typing import Union, Callable, Awaitable
 import re
 
 
-# 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
+class Filter:
+    def __init__(self, func: Callable[[Union[Update, InlineMessage]], bool | Awaitable[bool]]):
+        self.func = func
 
-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
-
-def button(id: Union[str, list[str]]):
-    def filter(message: InlineMessage):
-        if isinstance(message, InlineMessage):
-            button_id = message.aux_data.button_id
-            ID = id if isinstance(id, list) else [id]
-            for i in ID:
-                if button_id == i:
+    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
-    return filter
+            return False
 
-def chat(chat_id: Union[str, list[str]]):
-    def filter(message: Union[Update, InlineMessage]):
-        chat_ids = chat_id if isinstance(chat_id, list) else [chat_id]
-        if isinstance(message, Update) or isinstance(message, InlineMessage):
-            return message.chat_id in chat_ids
-        return False
-    return filter
-
-def regex(pattern: str):
-    def filter(message: Union[Update, InlineMessage]):
-        if isinstance(message, Update) and message.type == "NewMessage" and message.new_message.text:
-            return bool(re.search(pattern, message.new_message.text))
-        elif isinstance(message, InlineMessage) and message.text:
-            return bool(re.search(pattern, message.text))
-        return False
-    return filter
-            
-def text():
-    def filter(message: Update):
-        if isinstance(message, Update) and message.type == "NewMessage":
-            return message.new_message.text is None
-        return False
-    return filter
 
-def file():
-    def filter(message: Update):
-        if isinstance(message, Update) and message.type == "NewMessage":
-            return message.new_message.file is None
-        return False
-    return filter
+class regex(Filter):
+    def __init__(self, pattern: str):
+        self.pattern = pattern
+        super().__init__(self.filter)
 
-def private():
-    def filter(message: Update):
-        if isinstance(message, Update) and message.type == "NewMessage":
-            return message.new_message.sender_type in ["User", "Bot"]
-        return False
-    return 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", "")
 
-def forward():
-    def filter(message: Update):
-        if isinstance(message, Update) and message.type == "NewMessage":
-            return message.new_message.forwarded_from is None
+        if text:
+            return bool(re.search(self.pattern, text))
         return False
-    return filter
 
-def location():
-    def filter(message: Update):
-        if isinstance(message, Update) and message.type == "NewMessage":
-            return message.new_message.location is None
-        return False
-    return filter
 
-def sticker():
-    def filter(message: Update):
-        if isinstance(message, Update) and message.type == "NewMessage":
-            return message.new_message.sticker is None
-        return False
-    return filter
+class chat(Filter):
+    def __init__(self, chat_id: Union[str, list[str]]):
+        self.chat_id = chat_id
+        super().__init__(self.filter)
 
-def contact():
-    def filter(message: Update):
-        if isinstance(message, Update) and message.type == "NewMessage":
-            return message.new_message.contact_message is None
-        return False
-    return 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
 
-def poll():
-    def filter(message: Update):
-        if isinstance(message, Update) and message.type == "NewMessage":
-            return message.new_message.poll is None
-        return False
-    return filter
 
-def live():
-    def filter(message: Update):
-        if isinstance(message, Update) and message.type == "NewMessage":
-            return message.new_message.live_location is None
-        return False
-    return filter
+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)