RubigramClient 1.4.7__py3-none-any.whl → 1.4.9__py3-none-any.whl

rubigram/client.py

@@ -1,5 +1,5 @@
 from __future__ import annotations
-from typing import Optional, Callable, Awaitable
+from typing import Optional, Callable, Literal
 from aiohttp import web
 from functools import wraps
 from rubigram.types import Update, InlineMessage
@@ -9,8 +9,10 @@ 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
@@ -24,74 +26,67 @@ class Client(Method):
         super().__init__(token)
 
     def on_message(self, *filters: Filter):
-        def decorator(func: Callable[[Client, Update], Awaitable]):
+        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 e:
-                    logger.exception(f"Error in message handler {func.__name__}: {e}")
-                    return False
+                except Exception as error:
+                    logger.exception("Error {}: {}".format(func.__name__, error))
+
             self.message_handlers.append(wrapper)
             return func
         return decorator
 
-
     def on_inline_message(self, *filters: Filter):
-        def decorator(func: Callable[[Client, InlineMessage], Awaitable]):
+        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 e:
-                    logger.exception(f"Error in inline handler {func.__name__}: {e}")
-                    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_update(self, update: Update):
-        for handler in self.message_handlers:
+    async def dispatch(self, update: Update, type: Literal["update", "inline_message"] = "update"):
+        handlers = self.message_handlers if type == "update" else self.inline_handlers
+        for handler in 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}")
+                logger.exception(f"Dispatch Error in handler [ {handler.__name__} ] : {error}")
 
     async def updater(self, data: dict):
         if "inline_message" in data:
-            event = InlineMessage.from_dict(data["inline_message"])
-            await self.dispatch_inline(event)
+            event = InlineMessage.from_dict(data.get("inline_message", {}))
+            event.client = self
+            await self.dispatch(event, "inline_message")
         elif "update" in data:
-            event = Update.from_dict(data["update"])
+            event = Update.from_dict(data.get("update", {}))
             event.client = self
-            await self.dispatch_update(event)
-            
+            await self.dispatch(event)
+        else:
+            return
+
     async def set_endpoints(self):
         if self.endpoint:
             await self.update_bot_endpoint(f"{self.endpoint}/ReceiveUpdate", "ReceiveUpdate")
@@ -113,37 +108,40 @@ class Client(Method):
 
             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:
-                                    if isinstance(update, Update):
-                                        update.client = self
-                                    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)
-
-            try:asyncio.run(polling())
-            except:pass
+                try:
+                    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.stop()
+            asyncio.run(polling())

rubigram/filters.py

@@ -4,7 +4,7 @@ import re
 
 
 class Filter:
-    def __init__(self, func: Callable[[Union[Update, InlineMessage]], bool | Awaitable[bool]]):
+    def __init__(self, func: Callable[[Union[Update, InlineMessage]], Union[bool, Awaitable[bool]]]):
         self.func = func
 
     async def __call__(self, update: Union[Update, InlineMessage]) -> bool:

rubigram/method.py

@@ -3,10 +3,12 @@ from typing import Literal, Optional
 from .types import Bot, Chat, Keypad, MessageId, Updates
 
 
+
 class Method(Network):
     def __init__(self, token: str):
         super().__init__(token)
 
+
     async def get_me(self) -> "Bot":
         response = await self.request("getMe", {})
         return Bot.from_dict(response["bot"])
@@ -47,8 +49,7 @@ class Method(Network):
         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}
+        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)
 
@@ -181,12 +182,12 @@ class Method(Network):
 
     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)
+        response = await self.RequestUploadFile(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)
+        response = await self.RequestDownloadFile(download_url, file_name)
         return response
 
     async def send_file(
@@ -194,8 +195,7 @@ class Method(Network):
         chat_id: 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,

rubigram/network.py

@@ -1,47 +1,65 @@
 from aiohttp import ClientSession, FormData
-from typing import Any, Optional, Dict, Union
-import aiofiles
-import re
-import os
+from typing import Any, Optional
+import aiofiles, re, 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}/"
-        
+        self.api: str = f"https://botapi.rubika.ir/v3/{token}/"
+
+    async def start(self):
+        if not self.session:
+            self.session = ClientSession()
+
+    async def stop(self):
+        if self.session:
+            await self.session.close()
+            self.session = None
+
+    async def __aenter__(self):
+        await self.start()
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        await self.stop()
 
-    async def request(self, method: str, json: Dict[str, Any]) -> Optional[Dict[str, Any]]:
-        async with ClientSession() as session:
-            async with session.post(self.api + method, json=json) as response:
+    async def request(self, method: str, json: dict[str, Any]):
+        await self.start()
+        async with self.session.post(self.api + method, json=json) as response:
+            response.raise_for_status()
+            data: dict = await response.json()
+            return data.get("data")
+
+    async def ContentFile(self, url: str) -> bytes:
+        await self.start()
+        async with self.session.get(url) as response:
+            response.raise_for_status()
+            return await response.read()
+
+    async def RequestUploadFile(self, upload_url: str, file: str, name: str):
+        if isinstance(file, str):
+            if re.match(r"^https?://", file):
+                file = await self.ContentFile(file)
+            elif os.path.isfile(file):
+                async with aiofiles.open(file, "rb") as f:
+                    file = await f.read()
+            else:
+                raise Exception("file not found : {}".format(file))
+
+            form = FormData().add_field("file", filename=name, content_type="application/octet-stream")
+            await self.start()
+            async with self.session.post(upload_url, data=form) as response:
                 response.raise_for_status()
                 data: dict = await response.json()
-                return data.get("data")
+                return data.get("data", {}).get("file_id")
 
-    async def request_bytes_file(self, url: str) -> bytes:
-        async with ClientSession() as 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:
-        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 ClientSession() as session:
-            async with session.post(upload_url, data=form) as response:
-                response.raise_for_status()
-                data = await response.json()
-                return data["data"]["file_id"]
+        raise Exception("Format Of file is invalid")
 
-    async def request_download_file(self, url: str, name: str) -> dict[str, Union[str, bool]]:
-        file = await self.request_bytes_file(url)
+    async def RequestDownloadFile(self, url: str, name: str):
+        file = await self.ContentFile(url)
         async with aiofiles.open(name, "wb") as f:
             await f.write(file)
-            return {"status": True, "file": name}
+        return name

rubigram/types.py

@@ -334,6 +334,7 @@ class Message(Dict):
 
 @dataclass
 class InlineMessage(Dict):
+    client: Optional["rubigram.Client"] = None
     sender_id: Optional[str] = None
     text: Optional[str] = None
     message_id: Optional[str] = None
@@ -393,7 +394,7 @@ class Update(Dict):
     updated_message: Optional[Message] = None
     updated_payment: Optional[PaymentStatus] = None
 
-    def __repr__(self):
+    def __str__(self):
         return self.to_json()
 
     async def send_text(self, text: str,) -> "MessageId":

{rubigramclient-1.4.7.dist-info → rubigramclient-1.4.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: RubigramClient
-Version: 1.4.7
+Version: 1.4.9
 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
@@ -28,7 +28,7 @@ from rubigram.types import Update
 
 bot = Client("your_bot_token", "you_endpoint_url")
 
-@bot.on_message(filters.command("start"))
+@bot.on_message(filters.command("start") & filters.private)
 async def start_handler(client, message: Update):    
     await message.reply("Hi, WELCOME TO RUBIGRAM")
 
@@ -68,3 +68,18 @@ async def button(_, message: InlineMessage):
         
 bot.run()
 ```
+
+## Contex Manager
+```python
+from rubigram import Client
+import asyncio
+
+bot = Client("bot_token")
+
+async def main():
+    async with bot:
+        data = await bot.get_me()
+        print(data.bot_id)
+
+asyncio.run(main())
+```

rubigramclient-1.4.9.dist-info/RECORD

@@ -0,0 +1,11 @@
+rubigram/__init__.py,sha256=Z0foTm6Hpy4CDEH5am-IFWifi0bo4jLvpkfj3JQQHPc,107
+rubigram/client.py,sha256=YV4epKXNH-WaqtioIuNdelDfO304Qk2MnSWJZie8bLE,6140
+rubigram/filters.py,sha256=YS1fUmtZON8XTMc6IwzXUH3Qw58uMhXD9cbTeP8cjr4,5750
+rubigram/method.py,sha256=bPK2VMtJtRnrN-wrEXH7ijcPzovm_pqFObmViNfWUHM,10364
+rubigram/network.py,sha256=Dy2M4NSdN2iaNP0wwlmVcS408Omq6QhiWUWExrp9Ers,2340
+rubigram/types.py,sha256=QJ-nzd0HNhxCwhCOC6_fuBmJBG2M6Cg9oWH9sIFRNdA,13603
+rubigramclient-1.4.9.dist-info/licenses/LICENSE,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+rubigramclient-1.4.9.dist-info/METADATA,sha256=uUw_-eLAT3z8PJOXRL_fHsBXbBcoXmRD4mJNN9NjllM,2292
+rubigramclient-1.4.9.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+rubigramclient-1.4.9.dist-info/top_level.txt,sha256=Mhg5HfkL6rLec5sI4ClGmwoqYUANAZUz8sVa1sT_cas,9
+rubigramclient-1.4.9.dist-info/RECORD,,

rubigramclient-1.4.7.dist-info/RECORD

@@ -1,11 +0,0 @@
-rubigram/__init__.py,sha256=Z0foTm6Hpy4CDEH5am-IFWifi0bo4jLvpkfj3JQQHPc,107
-rubigram/client.py,sha256=o-txKYvZJ8nyGeLTYXCUWjjSAHBySh9Hh4G7F3sUF_U,6242
-rubigram/filters.py,sha256=1g1B9wQHOCSxql10g2qjj7SNwstkEk2euJSL5RKgEKE,5744
-rubigram/method.py,sha256=pKqpQY4ALrhPlJVtE4zBW2hZ659U8Fof7Sb5lAn0BtM,10404
-rubigram/network.py,sha256=BbHXfLxA8-GqTbZBWfJ3A_F8PYVSRydWKIOEC1J2gO8,2024
-rubigram/types.py,sha256=PIbj-unWGMQMGyT6eG6VQvSHzx0TWoQOc_Aq2PlSlK8,13556
-rubigramclient-1.4.7.dist-info/licenses/LICENSE,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-rubigramclient-1.4.7.dist-info/METADATA,sha256=DFLhWJzaU_lwiINX0z7repQKfJqFWrtYsCdx4gHhAPA,2035
-rubigramclient-1.4.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-rubigramclient-1.4.7.dist-info/top_level.txt,sha256=Mhg5HfkL6rLec5sI4ClGmwoqYUANAZUz8sVa1sT_cas,9
-rubigramclient-1.4.7.dist-info/RECORD,,