RubigramClient 1.7.0__py3-none-any.whl → 1.7.2__py3-none-any.whl

rubigram/__init__.py

@@ -1,6 +1,2 @@
 from .client import Client
-from .rubino import Rubino
-from .state import StateManager
-from . import enums
-from . import filters
-from . import types
+from . import enums, types, filters

rubigram/client.py

@@ -1,22 +1,11 @@
-from typing import Optional, Callable, Union
-from rubigram.types import Update, InlineMessage
-from rubigram.method import Method
-from rubigram.filters import Filter
-from rubigram.state import StateManager
-from datetime import datetime
+from .method import Method
+from .http import Http
+from .handler import Handler
 from aiohttp.web import Application, Request, json_response, run_app
+from datetime import datetime
+from typing import Optional, Callable
+from .logger import logger
 import asyncio
-import logging
-
-
-logging.basicConfig(
-    format="%(asctime)s | %(levelname)s : %(message)s",
-    datefmt="%Y-%m-%d %H:%M:%S",
-    level=logging.DEBUG
-)
-
-logging.getLogger("asyncio").setLevel(logging.WARNING)
-logging.getLogger("aiohttp").setLevel(logging.WARNING)
 
 
 class Client(Method):
@@ -24,173 +13,132 @@ class Client(Method):
         self,
         token: str,
         endpoint: Optional[str] = None,
-        host: str = "0.0.0.0",
-        port: int = 8000
+        host: Optional[str] = "0.0.0.0",
+        port: Optional[int] = 8000,
+        timeout: Optional[float] = 30
     ):
         self.token = token
         self.endpoint = endpoint
         self.host = host
         self.port = port
+        self.timeout = timeout
         self.offset_id = None
+        self.http: Http = Http(timeout)
         self.set_endpoint = True
-        self.ROUTES = []
-        self.MESSAGE_HANDLER = []
-        self.INLINE_HANDLER = []
-        self.EDIT_HANDLER = []
-        self.DELETE_HANDLER = []
-        self.state = StateManager()
-        super().__init__(token)
-        
-    
-    def on_message(self, filters: Optional[Filter] = None):
-        def decorator(func: Callable) -> Callable:
-            async def wrapper(client: Client, update: Update):
-                if filters is None or await filters(update):
-                    await func(client, update)
-                    return True
-                return False
-            self.MESSAGE_HANDLER.append(wrapper)
-            return func
-        return decorator
-
-    def on_inline_message(self, filters: Optional[Filter] = None):
-        def decorator(func: Callable) -> Callable:
-            async def wrapper(client: Client, update: Update):
-                if filters is None or await filters(update):
-                    await func(client, update)
-                    return True
-                return False
-            self.INLINE_HANDLER.append(wrapper)
-            return func
-        return decorator
-    
-    def on_edit_message(self, filters: Optional[Filter] = None):
-        def decorator(func: Callable) -> Callable:
-            async def wrapper(client: Client, update: Update):
-                if filters is None or await filters(update):
-                    await func(client, update)
-                    return True
-                return False
-            self.EDIT_HANDLER.append(wrapper)
-            return func
-        return decorator
-    
-    def on_delete_message(self, filters: Optional[Filter] = None):
-        def decorator(func: Callable) -> Callable:
-            async def wrapper(client: Client, update: Update):
-                if filters is None or await filters(update):
-                    await func(client, update)
-                    return True
-                return False
-            self.DELETE_HANDLER.append(wrapper)
-            return func
-        return decorator
-
-    def on_create_app(self, path: str, method: str = "GET"):
-        def decorator(func):
-            self.ROUTES.append((path, func, method.upper()))
-            return func
-        return decorator
-    
-    async def dispatch(self, update: Union[Update, InlineMessage]):
-        if isinstance(update, InlineMessage):
-            handlers = self.INLINE_HANDLER
-        else:
-            type = update.type
-            if type == "NewMessage":
-                handlers = self.MESSAGE_HANDLER
-            elif type == "UpdatedMessage":
-                handlers = self.EDIT_HANDLER
-            elif type == "RemovedMessage":
-                handlers = self.DELETE_HANDLER
-            else:
-                logging.warning("Update type invalid : {}".format(type))
-
-        for handler in handlers:
-            matched = await handler(self, update)
-            if matched:
-                return
-            
-    async def updater(self, data: dict):
-        if "inline_message" in data:
-            event = InlineMessage.from_dict(data["inline_message"])
-        elif "update" in data:
-            event = Update.from_dict(data["update"])
-        else: return
-        event.client = self
-        await self.dispatch(event)
-        
-    async def set_endpoints(self):
-        endpoint_type = ["ReceiveUpdate", "ReceiveInlineMessage"]
-        for i in endpoint_type:
-            set_endpoint = await self.update_bot_endpoint(f"{self.endpoint}/{i}", i)
-            logging.info(f"status set endpoint for {i} : {set_endpoint["status"]}")
-        
-    async def on_startup(self, app):
+        self.handlers: dict[str, list[Handler]] = {
+            "message": [],
+            "inline": [],
+            "delete": [],
+            "edit": [],
+        }
+        self.on_start_app: list[Callable] = []
+        self.on_stop_app: list[Callable] = []
+        self.routes = []
+        super().__init__(self)
+
+    async def start(self):
+        await self.http.connect()
+
+    async def stop(self):
+        await self.http.disconnect()
+
+    async def __aenter__(self):
+        await self.start()
+        return self
+
+    async def __aexit__(self, *args):
+        await self.stop()
+
+    async def run_start_app(self):
+        for func in self.on_start_app:
+            try:
+                await func(self)
+            except Exception as error:
+                logger.error("[!] On Start App Error : {}".format(error))
+
+    async def run_stop_app(self):
+        for func in self.on_stop_app:
+            try:
+                await func(self)
+            except Exception as error:
+                logger.error("[!] On Stop App Error : {}".format(error))
+
+    async def startup(self, app):
+        await self.run_start_app()
         if self.set_endpoint:
-            await self.set_endpoints()
+            await self.setup_endpoints()
         await self.start()
 
-    async def on_cleanup(self, app):
+    async def cleanup(self, app):
+        await self.run_stop_app()
         await self.stop()
-        
-    def create_request_handler(self):
+
+    def request_handler(self):
         async def wrapper(request: Request):
             data = await request.json()
             await self.updater(data)
             return json_response({"status": "OK"})
         return wrapper
 
-
-    async def update_runner(self):
+    async def run_polling(self):
         try:
+            await self.run_start_app()
+            await self.start()
             while True:
-                get_update = await self.get_update(100, self.offset_id)
-                updates = get_update.updates
+                response = await self.get_updates(100, self.offset_id)
+                updates = response.updates
+
                 if updates:
                     for update in updates:
-                        time = update.new_message.time if update.type == "NewMessage" else update.updated_message.time if update.type == "UpdatedMessage" else None
-                        time = int(time)
-                        now = int(datetime.now().timestamp())
-                        if time and (time >= now or time + 2 >= now):
-                            update.client = self
-                            await self.dispatch(update)
-                    self.offset_id = get_update.next_offset_id
+                        message_time = (
+                            update.new_message.time
+                            if update.type == "NewMessage"
+                            else update.updated_message.time
+                            if update.type == "UpdatedMessage"
+                            else None
+                        )
+
+                        if message_time:
+                            now = int(datetime.now().timestamp())
+                            if int(message_time) + 2 >= now:
+                                update.client = self
+                                await self.dispatch(update)
+
+                    self.offset_id = response.next_offset_id
+
         except Exception as error:
-            logging.error(error)
+            logger.error("[!] {} : {}".format(__class__.__name__, error))
+
         finally:
+            await self.run_stop_app()
             await self.stop()
-    
-    def run(self, set_endpoint = True):
+
+    def run(
+        self,
+        set_endpoint: Optional[bool] = True
+    ):
         self.set_endpoint = set_endpoint
         if self.endpoint:
             app = Application()
-            app.on_startup(self.on_startup)
-            app.on_cleanup(self.on_cleanup)
-            
-            app.router.add_post("/ReceiveUpdate", self.create_request_handler())
-            app.router.add_post("/ReceiveInlineMessage", self.create_request_handler())
-            
-            for path, func, method in self.ROUTES:
-                match method:
-                    case "GET":
-                        app.router.add_get(path, func)
-                    case "POST":
-                        app.router.add_post(path, func)
-                    case "DELETE":
-                        app.router.add_delete(path, func)
-                    case "PUT":
-                        app.router.add_put(path, func)
-                    case "PATCH":
-                        app.router.add_patch(path, func)
-                        
+            app.on_startup.append(self.startup)
+            app.on_cleanup.append(self.cleanup)
+
+            app.router.add_post("/ReceiveUpdate", self.request_handler())
+            app.router.add_post("/ReceiveInlineMessage", self.request_handler())
+
+            for path, func, method in self.routes:
+                app.router.add_route(method, path, func)
+
+            logger.info("[<] Start bot on {}:{}".format(self.host, self.port))
             run_app(app, host=self.host, port=self.port)
 
         else:
             try:
-                logging.info("Start Bot")
-                asyncio.run(self.update_runner())
+                logger.info("[<] Start bot ...")
+                asyncio.run(self.run_polling())
+
             except KeyboardInterrupt:
-                logging.info("Stop Bot")
+                logger.info("[<] Stop bot")
+
             except Exception as error:
-                logging.error(error)
+                logger.error("[!] Unexpected error : {}".format(error))

rubigram/enums.py

@@ -69,6 +69,7 @@ class ButtonLinkType(str, Enum):
     joinchannel = "joinchannel"
     url = "url"
 
+
 class MessageSender(str, Enum):
     User = "User"
     Bot = "Bot"
@@ -94,7 +95,7 @@ class UpdateEndpointType(str, Enum):
     ReceiveQuery = "ReceiveQuery"
     GetSelectionItem = "GetSelectionItem"
     SearchSelectionItems = "SearchSelectionItems"
-    
+
 
 class ButtonType(str, Enum):
     Simple = "Simple"
@@ -118,7 +119,7 @@ class ButtonType(str, Enum):
     AskMyPhoneNumber = "AskMyPhoneNumber"
     AskLocation = "AskLocation"
     Barcode = "Barcode"
-    
+
 
 class FileType(str, Enum):
     File = "File"
@@ -127,7 +128,7 @@ class FileType(str, Enum):
     Gif = "Gif"
     Music = "Music"
     Voice = "Voice"
-    
+
 
 class ChatAction(str, Enum):
     Typing = "Typing"