RubigramClient 1.5.5__py3-none-any.whl → 1.5.6__py3-none-any.whl

rubigram/client.py

@@ -1,159 +1,115 @@
-from __future__ import annotations
-from typing import Optional, Callable, Literal
-from aiohttp import web
-from functools import wraps
+from typing import Optional, Callable, Literal, Union
 from rubigram.models import Update, InlineMessage
 from rubigram.method import Method
 from rubigram.filters import Filter
 from rubigram.state import StateManager
 from datetime import datetime
+from aiohttp import web
 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.endpoint = endpoint
         self.host = host
         self.port = port
         self.offset_id = None
+        self.MESSAGE_HANDLER = []
+        self.INLINE_HANDLER = []
         self.state = StateManager()
-        self.routes = web.RouteTableDef()
-        self.message_handlers = []
-        self.inline_handlers = []
         super().__init__(token)
-
-    def on_message(self, *filters: Filter):
+        
+            
+    def create_handler(self, type: Literal["message", "inline"], filters: Optional[Filter] = None):
         def decorator(func: Callable) -> Callable:
-            @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 error:
-                    logger.exception("Error {}: {}".format(func.__name__, error))
-
-            self.message_handlers.append(wrapper)
+                if filters is None or await filters(update):
+                    await func(client, update)
+                    return True
+                return False
+            self.MESSAGE_HANDLER.append(wrapper) if type == "message" else self.INLINE_HANDLER.append(wrapper)
             return func
         return decorator
-
-    def on_inline_message(self, *filters: Filter):
-        def decorator(func: Callable) -> Callable:
-            @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 error:
-                    logger.exception("Error {}: {}".format(func.__name__, error))
-
-            self.inline_handlers.append(wrapper)
-            return func
-        return decorator
-
-    async def dispatch(self, update: Update, type: Literal["update", "inline_message"] = "update"):
-        handlers = self.message_handlers if type == "update" else self.inline_handlers
+    
+    def on_message(self, filters: Optional[Filter] = None):
+        return self.create_handler("message", filters)
+
+    def on_inline_message(self, filters: Optional[Filter] = None):
+        return self.create_handler("inline", filters)
+        
+    async def dispatch(self, update: Union[Update, InlineMessage], type: Literal["message", "inline"]):
+        handlers = self.MESSAGE_HANDLER if type == "message" else self.INLINE_HANDLER
         for handler in handlers:
-            try:
-                matched = await handler(self, update)
-                if matched:
-                    return
-            except Exception as error:
-                logger.exception(f"Dispatch Error in handler [ {handler.__name__} ] : {error}")
+            matched = await handler(self, update)
+            if matched:
+                return
 
     async def updater(self, data: dict):
         if "inline_message" in data:
-            event = InlineMessage.from_dict(data.get("inline_message", {}))
-            event.client = self
-            await self.dispatch(event, "inline_message")
+            event = InlineMessage.from_dict(data["inline_message"])
+            type = "inline"
         elif "update" in data:
-            event = Update.from_dict(data.get("update", {}))
-            event.client = self
-            await self.dispatch(event)
-        else:
-            return
-
+            event = Update.from_dict(data["update"])
+            type = "message"
+        else: return
+        event.client = self
+        await self.dispatch(event, type)
+    
     async def set_endpoints(self):
+        endpoint_type = ["ReceiveUpdate", "ReceiveInlineMessage"]
         if self.endpoint:
-            await self.update_bot_endpoint(f"{self.endpoint}/ReceiveUpdate", "ReceiveUpdate")
-            await self.update_bot_endpoint(f"{self.endpoint}/ReceiveInlineMessage", "ReceiveInlineMessage")
-
+            for i in endpoint_type:
+                await self.update_bot_endpoint(f"{self.endpoint}/{i}", i)
+    
+    async def on_startup(self, app):
+        await self.set_endpoints()
+        await self.state.start()
+        await self.start()
+
+    async def on_cleanup(self, app):
+        await self.state.stop()
+        await self.stop()
+        
+    def create_request_handler(self):
+        async def wrapper(request: web.Request):
+            data = await request.json()
+            await self.updater(data)
+            return web.json_response({"status": "OK"})
+        return wrapper
+    
+    async def runner(self):
+        try:
+            await self.state.start()
+            while True:
+                get_updates = await self.get_update(100, self.offset_id)
+                if get_updates.updates:
+                    updates = get_updates.updates
+                    for update in updates:
+                        time = int(update.new_message.time) if update.type == "NewMessage" else int(update.updated_message.time) if update.type == "UpdatedMessage" else None
+                        now = int(datetime.now().timestamp())
+                        if time and time >= now or time + 2 >= now:
+                            update.client = self
+                            await self.dispatch(update, "message")
+                    self.offset_id = get_updates.next_offset_id
+        except Exception as error:
+            print(f"ERROR : {error}")
+        finally:
+            await self.state.stop()
+            await self.stop()
+    
     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(app):
-                await self.set_endpoints()
-                await self.state.start()
-                await self.start()
-
-            async def on_cleanup(app):
-                await self.state.stop()
-                await self.stop()
-
-            app.on_startup.append(on_startup)
-            app.on_cleanup.append(on_cleanup)
+            app = web.Application()            
+            app.router.add_post("/ReceiveUpdate", self.create_request_handler())
+            app.router.add_post("/ReceiveInlineMessage", self.create_request_handler())
             web.run_app(app, host=self.host, port=self.port)
-
         else:
-            async def polling():
-                try:
-                    await self.state.start()
-                    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:
-                                        if isinstance(update, Update):
-                                            update.client = self
-                                        await self.dispatch(update)
-
-                                self.offset_id = get_update.next_offset_id
-                        except Exception as error:
-                            logger.exception("Polling Error : {}".format(error))
-                            await asyncio.sleep(1)
-
-                except:
-                    pass
-                finally:
-                    await self.state.stop()
-                    await self.stop()
-            asyncio.run(polling())
+            try:
+                asyncio.run(self.runner())
+            except:pass

rubigram/filters.py

@@ -3,6 +3,9 @@ from typing import Union, Callable, Awaitable
 import re
 
 
+
+
+
 class Filter:
     def __init__(self, func: Callable[[Union[Update, InlineMessage]], Union[bool, Awaitable[bool]]]):
         self.func = func

{rubigramclient-1.5.5.dist-info → rubigramclient-1.5.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: RubigramClient
-Version: 1.5.5
+Version: 1.5.6
 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
@@ -51,8 +51,8 @@ async def start(_, message: Update):
         rows=[
             KeypadRow(
                 buttons=[
-                    Button("1", "Simple", "Button 1"),
-                    Button("2", "Simple", "Button 2")
+                    Button("1", "Button 1"),
+                    Button("2", "Button 2")
                 ]
             )
         ]

rubigramclient-1.5.6.dist-info/RECORD

@@ -0,0 +1,12 @@
+rubigram/__init__.py,sha256=IWNCN7oDaIBzaP54cGiA-4Sa31ehGBlqj0SuqhNQVgU,162
+rubigram/client.py,sha256=AGb7PaXBdFIoUTB3mTWHgdCQAO0anAjgoAuY2tPph0U,4469
+rubigram/filters.py,sha256=LWc_qCLExsQqqucFCeNKi_3okfyIx6yAVQHMAzAskc8,6224
+rubigram/method.py,sha256=PUP9DTX6XpWVbersiLv12GdlwOFaXzrgx582nJd4i_I,10613
+rubigram/models.py,sha256=42WK68VPKqgKCy14jrRyoP_XRsZ-04S5rUbdpO_UfaQ,13831
+rubigram/network.py,sha256=ErrGwtKpMHN1Dq4IvPHSrMOcDN-TFjUk1CfU-2EuPAY,2364
+rubigram/state.py,sha256=oRk5xXuO4k-cK0qRI2Rz2mdoivJkANlo20zQAkdqFSY,4081
+rubigramclient-1.5.6.dist-info/licenses/LICENSE,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+rubigramclient-1.5.6.dist-info/METADATA,sha256=eoRk-VQNt67olSWe9IsX36MnlKHSQDMuCjay_8NeYws,2300
+rubigramclient-1.5.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+rubigramclient-1.5.6.dist-info/top_level.txt,sha256=Mhg5HfkL6rLec5sI4ClGmwoqYUANAZUz8sVa1sT_cas,9
+rubigramclient-1.5.6.dist-info/RECORD,,

rubigramclient-1.5.5.dist-info/RECORD

@@ -1,12 +0,0 @@
-rubigram/__init__.py,sha256=IWNCN7oDaIBzaP54cGiA-4Sa31ehGBlqj0SuqhNQVgU,162
-rubigram/client.py,sha256=GDdlGzCeSwBAzEP3Truat1g2il5l3nPWbmFw2hRhYoc,6511
-rubigram/filters.py,sha256=EyrcKbEIwqDwf18lucusUoZYP0KIkaKkZc7PnaA0GcU,6218
-rubigram/method.py,sha256=PUP9DTX6XpWVbersiLv12GdlwOFaXzrgx582nJd4i_I,10613
-rubigram/models.py,sha256=42WK68VPKqgKCy14jrRyoP_XRsZ-04S5rUbdpO_UfaQ,13831
-rubigram/network.py,sha256=ErrGwtKpMHN1Dq4IvPHSrMOcDN-TFjUk1CfU-2EuPAY,2364
-rubigram/state.py,sha256=oRk5xXuO4k-cK0qRI2Rz2mdoivJkANlo20zQAkdqFSY,4081
-rubigramclient-1.5.5.dist-info/licenses/LICENSE,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-rubigramclient-1.5.5.dist-info/METADATA,sha256=Abido_4uhjv1iK3kIoUv49ulhGE8DmKfgzfRPoVcED8,2320
-rubigramclient-1.5.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-rubigramclient-1.5.5.dist-info/top_level.txt,sha256=Mhg5HfkL6rLec5sI4ClGmwoqYUANAZUz8sVa1sT_cas,9
-rubigramclient-1.5.5.dist-info/RECORD,,