RubigramClient 1.6.4__py3-none-any.whl → 1.6.5__py3-none-any.whl

rubigram/__init__.py

@@ -2,5 +2,6 @@ from .network import Network
 from .method import Method
 from .client import Client
 from .state import StateManager
-from . import models
-from . import filters
+from . import enums
+from . import filters
+from . import types

rubigram/client.py

@@ -1,13 +1,16 @@
 from typing import Optional, Callable, Literal, Union
-from rubigram.models import Update, InlineMessage
+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 aiohttp import web
 import asyncio
+import logging
 
 
+logging.basicConfig(format=("%(levelname)s | %(message)s"))
+
 
 class Client(Method):
     def __init__(
@@ -96,7 +99,7 @@ class Client(Method):
                             await self.dispatch(update, "message")
                     self.offset_id = get_updates.next_offset_id
         except Exception as error:
-            print(f"ERROR : {error}")
+            logging.error(error)
         finally:
             await self.stop()
     
@@ -122,5 +125,6 @@ class Client(Method):
         else:
             try:
                 asyncio.run(self.runner())
+            except KeyboardInterrupt:pass
             except Exception as error:
-                print(f"ERROR : {error}")
+                logging.error(error)

rubigram/enums.py

@@ -0,0 +1,129 @@
+from enum import Enum
+
+
+class ChatType(str, Enum):
+    User = "User"
+    Bot = "Bot"
+    Group = "Group"
+    Channel = "Channel"
+
+
+class ForwardedFrom(str, Enum):
+    User = "User"
+    Bot = "Bot"
+    Channel = "Channel"
+
+
+class PaymentStatus(str, Enum):
+    Paid = "Paid"
+    NotPaid = "NotPaid"
+
+
+class PollStatus(str, Enum):
+    Open = "Open"
+    Closed = "Closed"
+
+
+class LiveLocationStatus(str, Enum):
+    Stopped = "Stopped"
+    Live = "Live"
+
+
+class ButtonSelectionType(str, Enum):
+    TextOnly = "TextOnly"
+    TextImgThu = "TextImgThu"
+    TextImgBig = "TextImgBig"
+
+
+class ButtonSelectionSearch(str, Enum):
+    Local = "Local"
+    Api = "Api"
+
+
+class ButtonSelectionGet(str, Enum):
+    Local = "Local"
+    Api = "Api"
+
+
+class ButtonCalendarType(str, Enum):
+    DatePersian = "DatePersian"
+    DateGregorian = "DateGregorian"
+
+
+class ButtonTextboxTypeKeypad(str, Enum):
+    String = "String"
+    Number = "Number"
+
+
+class ButtonTextboxTypeLine(str, Enum):
+    SingleLine = "SingleLine"
+    MultiLine = "MultiLine"
+
+
+class ButtonLocationType(str, Enum):
+    Picker = "Picker"
+    View = "View"
+
+
+class ButtonLinkType(str, Enum):
+    joinchannel = "joinchannel"
+    url = "url"
+
+class MessageSender(str, Enum):
+    User = "User"
+    Bot = "Bot"
+
+
+class UpdateType(str, Enum):
+    UpdatedMessage = "UpdatedMessage"
+    NewMessage = "NewMessage"
+    RemovedMessage = "RemovedMessage"
+    StartedBot = "StartedBot"
+    StoppedBot = "StoppedBot"
+    UpdatedPayment = "UpdatedPayment"
+
+
+class ChatKeypadType(str, Enum):
+    New = "New"
+    Remove = "Remove"
+
+
+class UpdateEndpointType(str, Enum):
+    ReceiveUpdate = "ReceiveUpdate"
+    ReceiveInlineMessage = "ReceiveInlineMessage"
+    ReceiveQuery = "ReceiveQuery"
+    GetSelectionItem = "GetSelectionItem"
+    SearchSelectionItems = "SearchSelectionItems"
+    
+
+class ButtonType(str, Enum):
+    Simple = "Simple"
+    Selection = "Selection"
+    Calendar = "Calendar"
+    NumberPicker = "NumberPicker"
+    StringPicker = "StringPicker"
+    Location = "Location"
+    Payment = "Payment"
+    CameraImage = "CameraImage"
+    CameraVideo = "CameraVideo"
+    GalleryImage = "GalleryImage"
+    GalleryVideo = "GalleryVideo"
+    File = "File"
+    Audio = "Audio"
+    RecordAudio = "RecordAudio"
+    MyPhoneNumber = "MyPhoneNumber"
+    MyLocation = "MyLocation"
+    Textbox = "Textbox"
+    Link = "Link"
+    AskMyPhoneNumber = "AskMyPhoneNumber"
+    AskLocation = "AskLocation"
+    Barcode = "Barcode"
+    
+
+class FileType(str, Enum):
+    File = "File"
+    Image = "Image"
+    Video = "Video"
+    Gif = "Gif"
+    Music = "Music"
+    Voice = "Voice"

rubigram/filters.py

@@ -1,4 +1,4 @@
-from rubigram.models import Update, InlineMessage
+from rubigram.types import Update, InlineMessage
 from typing import Union
 import re
 
@@ -108,36 +108,45 @@ forward_channel = Filter(FORWARD_CHANNEL)
 
 
 class state(Filter):
-    def __init__(self, states: Union[str, list[str]]):
-        self.states = states
+    def __init__(self, state: Union[str, list[str]]):
+        self.states = state if isinstance(state, list) else [state]
         super().__init__(self.filter)
         
     async def filter(self, update: Union[Update, InlineMessage]):
-        states = self.states if isinstance(self.states, list) else [self.states]
-        user = await update.client.state.get_state(update.chat_id)
-        return user.lower() in states if user else False
+        user_state = await update.client.state.get_state(update.chat_id)
+        return user_state in self.states
             
 
 class command(Filter):
-    def __init__(self, cmd: Union[str, list[str]], prefix: str = "/"):
-        self.cmd = cmd
-        self.prefix = prefix
+    def __init__(self, command: Union[str, list[str]], prefix: Union[str, list[str]] = "/", case_sensitive: bool = False):
+        self.commands = [c if case_sensitive else c.lower() for c in (command if isinstance(command, list) else [command])]
+        self.prefixs = prefix if isinstance(prefix, list) else [prefix]
+        self.cmds = [p + c for p in self.prefixs for c in self.commands]
+        self.case_sensitive = case_sensitive
         super().__init__(self.filter)
 
     async def filter(self, update: Update):
-        commands = self.cmd if isinstance(self.cmd, list) 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
-            if text:
-                for cmd in commands:
-                    if text.lower().startswith(self.prefix + cmd.lower()):
-                        return True
-                return False
+        if isinstance(update, Update) and update.type == "NewMessage":
+            text = update.new_message.text or ""
+            text = text if self.case_sensitive else text.lower()
+            return any(text.startswith(cmd) for cmd in self.cmds)
+        return False
+    
 
+class button(Filter):
+    def __init__(self, button_id: Union[str, list[str]], prefix: Union[str, list[str]] = "", case_sensitive: bool = False):
+        self.button_ids = [btn_id if case_sensitive else btn_id.lower() for btn_id in (button_id if isinstance(button_id, list) else [button_id])]
+        self.prefixs = prefix if isinstance(prefix, list) else [prefix]
+        self.btn_ids = [p + b for p in self.prefixs for b in self.button_ids]
+        self.case_sensitive = case_sensitive
+        super().__init__(self.filter)
+
+    async def filter(self, update: InlineMessage):
+        if isinstance(update, InlineMessage):
+            text = update.text or ""
+            text = text if self.case_sensitive else text.lower()
+            return any(text.startswith(btn) for btn in self.btn_ids)
+        return False
 
 class regex(Filter):
     def __init__(self, pattern: str):
@@ -166,19 +175,4 @@ class chat(Filter):
 
     async def filter(self, update: Union[Update, InlineMessage]):
         chat_ids = self.chat_id if isinstance(self.chat_id, list) else [self.chat_id]
-        return update.chat_id in chat_ids
-
-
-class button(Filter):
-    def __init__(self, button_id: Union[str, list[str]], prefix: str = ""):
-        self.button_id = button_id
-        self.prefix = prefix
-        super().__init__(self.filter)
-
-    async def filter(self, update: InlineMessage):
-        if isinstance(update, InlineMessage):
-            button_ids = self.button_id if isinstance(self.button_id, list) else [self.button_id]
-            for btn_id in button_ids:
-                if update.aux_data.button_id.startswith(self.prefix + btn_id):
-                    return True
-            return False
+        return update.chat_id in chat_ids

rubigram/method.py

@@ -1,12 +1,16 @@
 from .network import Network
-from typing import Literal, Optional
-from rubigram.models import Bot, Chat, Keypad, MessageId, Updates
+from . import enums
+from typing import Optional
+from rubigram.types import Bot, Chat, Keypad, MessageId, Updates, BotCommand
 
 
 class Method(Network):
     def __init__(self, token: str):
         super().__init__(token)
-
+        
+    def clean_data(self, data: dict):
+        return {key: value for key, value in data.items() if value is not None}
+        
     async def get_me(self) -> "Bot":
         response = await self.request("getMe", {})
         return Bot.from_dict(response["bot"])
@@ -23,11 +27,11 @@ class Method(Network):
         response = await self.request("getFile", {"file_id": file_id})
         return response["download_url"]
 
-    async def set_command(self, command: list):
-        response = await self.request("setCommands", {"bot_commands": command})
+    async def set_command(self, commands: list[BotCommand]):
+        response = await self.request("setCommands", {"bot_commands": [command.to_dict() for command in commands]})
         return response
 
-    async def update_bot_endpoint(self, url: str, type: Literal["ReceiveUpdate", "ReceiveInlineMessage", "ReceiveQuery", "GetSelectionItem", "SearchSelectionItems"]):
+    async def update_bot_endpoint(self, url: str, type: enums.UpdateEndpointType):
         response = await self.request("updateBotEndpoints", {"url": url, "type": type})
         return response
 
@@ -49,7 +53,10 @@ class Method(Network):
     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)
+        message = MessageId.from_dict(response)
+        message.chat_id = to_chat_id
+        message.client = self
+        return message
 
     async def send_message(
         self,
@@ -57,7 +64,7 @@ class Method(Network):
         text: str,
         chat_keypad: Keypad = None,
         inline_keypad: Keypad = None,
-        chat_keypad_type: Literal["New", "Remove"] = None,
+        chat_keypad_type: Optional[enums.ChatKeypadType] = None,
         disable_notification: bool = None,
         reply_to_message_id=None
     ) -> "MessageId":
@@ -70,9 +77,11 @@ class Method(Network):
             "disable_notification": disable_notification,
             "reply_to_message_id": reply_to_message_id
         }
-        data = {key: value for key, value in data.items() if value is not None}
-        response = await self.request("sendMessage", data)
-        return MessageId.from_dict(response)
+        response = await self.request("sendMessage", self.clean_data(data))
+        message = MessageId.from_dict(response)
+        message.chat_id = chat_id
+        message.client = self
+        return message
 
     async def send_poll(
         self,
@@ -81,9 +90,9 @@ class Method(Network):
         options: list[str],
         chat_keypad: Keypad = None,
         inline_keypad: Keypad = None,
+        chat_keypad_type: Optional[enums.ChatKeypadType] = None,
         disable_notification: bool = False,
         reply_to_message_id: str = None,
-        chat_keypad_type: Literal["New", "Remove"] = None
     ) -> "MessageId":
         data = {
             "chat_id": chat_id,
@@ -95,9 +104,11 @@ class Method(Network):
             "reply_to_message_id": reply_to_message_id,
             "chat_keypad_type": chat_keypad_type
         }
-        data = {key: value for key, value in data.items() if value is not None}
-        response = await self.request("sendPoll", data)
-        return MessageId.from_dict(response)
+        response = await self.request("sendPoll", self.clean_data(data))
+        message = MessageId.from_dict(response)
+        message.chat_id = chat_id
+        message.client = self
+        return message
 
     async def send_location(
         self,
@@ -106,9 +117,9 @@ class Method(Network):
         longitude: str,
         chat_keypad: Keypad = None,
         inline_keypad: Keypad = None,
+        chat_keypad_type: Optional[enums.ChatKeypadType] = None,
         disable_notification: bool = False,
         reply_to_message_id: str = None,
-        chat_keypad_type: Literal["New", "Remove"] = None
     ) -> "MessageId":
         data = {
             "chat_id": chat_id,
@@ -120,9 +131,11 @@ class Method(Network):
             "reply_to_message_id": reply_to_message_id,
             "chat_keypad_type": chat_keypad_type
         }
-        data = {key: value for key, value in data.items() if value is not None}
-        response = await self.request("sendLocation", data)
-        return MessageId.from_dict(response)
+        response = await self.request("sendLocation", self.clean_data(data))
+        message = MessageId.from_dict(response)
+        message.chat_id = chat_id
+        message.client = self
+        return message
 
     async def send_contact(
         self,
@@ -132,9 +145,9 @@ class Method(Network):
         phone_number: str,
         chat_keypad: Keypad = None,
         inline_keypad: Keypad = None,
+        chat_keypad_type: Optional[enums.ChatKeypadType] = None,
         disable_notification: bool = False,
         reply_to_message_id: str = None,
-        chat_keypad_type: Literal["New", "Remove"] = None
     ) -> "MessageId":
         data = {
             "chat_id": chat_id,
@@ -147,9 +160,11 @@ class Method(Network):
             "reply_to_message_id": reply_to_message_id,
             "chat_keypad_type": chat_keypad_type
         }
-        data = {key: value for key, value in data.items() if value is not None}
-        response = await self.request("sendContact", data)
-        return MessageId.from_dict(response)
+        response = await self.request("sendContact", self.clean_data(data))
+        message = MessageId.from_dict(response)
+        message.chat_id = chat_id
+        message.client = self
+        return message
 
     async def send_sticker(
         self,
@@ -157,9 +172,9 @@ class Method(Network):
         sticker_id: str,
         chat_keypad: Keypad = None,
         inline_keypad: Keypad = None,
+        chat_keypad_type: Optional[enums.ChatKeypadType] = None,
         disable_notification: bool = False,
         reply_to_message_id: str = None,
-        chat_keypad_type: Literal["New", "Remove"] = None,
     ) -> "MessageId":
         data = {
             "chat_id": chat_id,
@@ -170,9 +185,11 @@ class Method(Network):
             "reply_to_message_id": reply_to_message_id,
             "chat_keypad_type": chat_keypad_type
         }
-        data = {key: value for key, value in data.items() if value is not None}
-        response = await self.request("sendSticker", data)
-        return MessageId.from_dict(response)
+        response = await self.request("sendSticker", self.clean_data(data))
+        message = MessageId.from_dict(response)
+        message.chat_id = chat_id
+        message.client = self
+        return message
 
     async def request_send_file(self, type: str):
         response = await self.request("requestSendFile", {"type": type})
@@ -194,10 +211,10 @@ class Method(Network):
         file: str,
         file_name: str,
         caption: str = None,
-        type: Literal["File", "Image", "Voice", "Music", "Gif", "Video"] = "File",
+        type: enums.FileType = enums.FileType.File,
         chat_keypad: Keypad = None,
         inline_keypad: Keypad = None,
-        chat_keypad_type: Literal["New", "Remove"] = None,
+        chat_keypad_type: Optional[enums.ChatKeypadType] = None,
         disable_notification: bool = False,
         reply_to_message_id: str = None,
     ) -> "MessageId":
@@ -212,9 +229,12 @@ class Method(Network):
             "reply_to_message_id": reply_to_message_id,
             "chat_keypad_type": chat_keypad_type,
         }
-        data = {key: value for key, value in data.items() if value is not None}
-        response = await self.request("sendFile", data)
-        return MessageId.from_dict(response)
+        response = await self.request("sendFile", self.clean_data(data))
+        message = MessageId.from_dict(response)
+        message.chat_id = chat_id
+        message.file_id = file_id
+        message.client = self
+        return message
 
     async def send_document(self, chat_id: str, document: str, name: str, caption: str = None, **kwargs):
         return await self.send_file(chat_id, document, name, caption, "File", **kwargs)

rubigram/state.py

@@ -1,98 +1,35 @@
-# from aiosqlite import connect as conn, Connection
-# from typing import Optional
+from typing import Any
 
-
-# class ManageDB:
-#     def __init__(self, database: str):
-#         self.database = database
-#         self.connection: Optional[Connection] = None
-    
-    
-#     async def connect(self):
-#         if not self.connection:
-#             self.connection = await conn(self.database)
-    
-    
-#     async def disconnect(self):
-#         if self.connection:
-#             await self.connection.close()
-#             self.connection = None
-    
-            
-#     async def create(self):
-#         await self.connect()
-#         await self.connection.execute("""CREATE TABLE IF NOT EXISTS states (user_id TEXT PRIMARY KEY, state TEXT)""")
-#         await self.connection.execute("CREATE TABLE IF NOT EXISTS user_data (user_id TEXT, var TEXT, res TEXT, PRIMARY KEY (user_id, var))")
-#         await self.connection.commit()
-    
-    
-#     async def set_state(self, user_id: str, state: str) -> None:
-#         await self.connect()
-#         await self.connection.execute("INSERT INTO states (user_id, state) VALUES (?, ?) ON CONFLICT(user_id) DO UPDATE SET state=excluded.state ", (user_id, str(state)))
-#         await self.connection.commit()
-        
-        
-#     async def get_state(self, user_id: str) -> Optional[str]:
-#         await self.connect()
-#         async with self.connection.execute("SELECT state FROM states WHERE user_id = ?", (user_id,)) as cursor:
-#             data = await cursor.fetchone()
-#             return data[0] if data else None
-        
-
-#     async def remove_state(self, user_id: str):
-#         await self.connect()
-#         await self.connection.execute("DELETE FROM states WHERE user_id = ?", (user_id,))
-#         await self.connection.commit()
-        
-    
-#     async def set_data(self, user_id: str, key: str, value: str):
-#         await self.connect()
-#         await self.connection.execute("INSERT OR REPLACE INTO user_data (user_id, var, res) VALUES (?, ?, ?)", (user_id, key, str(value)))
-#         await self.connection.commit()
-        
-    
-#     async def get_data(self, user_id: str, key: str = None):
-#         await self.connect()
-#         if key:
-#             async with self.connection.execute("SELECT res FROM user_data WHERE user_id = ? AND var = ?", (user_id, key)) as cursor:
-#                 data = await cursor.fetchone()
-#                 return data[0] if data else None
-#         else:
-#             async with self.connection.execute("SELECT var, res FROM user_data WHERE user_id = ?", (user_id,)) as cursor:
-#                 data = await cursor.fetchall()
-#             return {k: v for k, v in data} if data else {}
-
-            
-#     async def remove_data(self, user_id: str, key: str = None):
-#         await self.connect()
-#         if key:
-#             await self.connection.execute("DELETE FROM user_data WHERE user_id = ? AND var = ?", (user_id, key))
-#         else:
-#             await self.connection.execute("DELETE FROM user_data WHERE user_id = ?", (user_id,))
-#         await self.connection.commit()
-              
-        
 class StateManager:
     def __init__(self):
-        self.DATA = {}
-        self.STATE = {}
+        self.DATA: dict[str, dict[str, Any]] = {}
+        self.STATE: dict[str, str] = {}
+
         
     async def set_state(self, user_id: str, state: str):
         self.STATE[user_id] = state
     
+    
     async def get_state(self, user_id: str):
         return self.STATE.get(user_id)
+
     
     async def remove_state(self, user_id: str):
         self.STATE.pop(user_id, None)
+
         
     async def set_data(self, user_id: str, **data):
         if user_id not in self.DATA:
             self.DATA[user_id] = {}
         self.DATA[user_id].update(data)
+
     
     async def get_data(self, user_id: str, key: str = None):
-        return self.DATA.get(user_id, {}).get(key) if key else self.DATA.get(user_id, {})
+        data = self.DATA.get(user_id, {})
+        return data.get(key) if key else data
+
 
     async def remove_data(self, user_id: str, key: str = None):
-        self.DATA.get(user_id, {}).pop(key, None) if key else self.DATA.pop(user_id, None)
+        if key:
+            return self.DATA.get(user_id, {}).pop(key, None)
+        return self.DATA.pop(user_id, None)