pyrobale 0.2.2__py3-none-any.whl → 0.2.8__py3-none-any.whl

pyrobale.py

@@ -1,19 +1,143 @@
-import requests, json, time, threading
+"""
+PyRobale - A Python library for developing bale bots.
+
+Features:
+- Simple and fast
+- Customizable and Customizes
+- Eazy to learn
+- New and Up to date
+- Internal database management
+"""
+import json
+import time
 from typing import Optional, Dict, Any, List, Union
+import threading
 import traceback
 import sqlite3
 import inspect
-import asyncio
+import requests
+import re
+import sys
+import os
+from urllib.parse import urlparse, unquote
+
+__version__ = '0.2.8'
+
+class ChatActions:
+    """Represents different chat action states that can be sent to Bale"""
+    TYPING: str = 'typing'
+    PHOTO: str = 'upload_photo'
+    VIDEO: str = 'record_video'
+    CHOOSE_STICKER: str = 'choose_sticker'
+class conditions:
+    
+    """
+    A class for defining conditions for message handling.
+    """
+
+    def __init__(
+            self,
+            client: 'Client' = None,
+            user: 'User' = None,
+            message: 'Message' = None,
+            callback: 'CallbackQuery' = None,
+            chat: 'Chat' = None):
+        self.client = client
+        self.user = user
+        self.message = message
+        self.callback = callback
+        self.chat = chat
+
+    def is_joined(self, *chats) -> bool:
+        """Check if user is member of all specified chats"""
+        return all(self.client.is_joined(chat_id, self.user.id)
+                   for chat_id in chats)
+
+    def is_admin(self, chat: 'Chat') -> bool:
+        """Check if user is an admin"""
+        member = self.client.get_chat_member(chat.id, self.user.id)
+        return member.status in ['administrator', 'owner']
+
+    def is_owner(self, chat: 'Chat') -> bool:
+        """Check if user is the owner"""
+        member = self.client.get_chat_member(chat.id, self.user.id)
+        return member.is_creator
+
+    def is_private_chat(self) -> bool:
+        """Check if message is in private chat"""
+        return self.chat.type == 'private'
+
+    def is_group_chat(self) -> bool:
+        """Check if message is in group chat"""
+        return self.chat.type in ['group', 'supergroup']
+
+    def is_channel(self) -> bool:
+        """Check if message is in channel"""
+        return self.chat.type == 'channel'
+
+    def has_text(self) -> bool:
+        """Check if message contains text"""
+        return bool(self.message.text)
+
+    def has_photo(self) -> bool:
+        """Check if message contains photo"""
+        return bool(self.message.photo)
+
+    def has_document(self) -> bool:
+        """Check if message contains document"""
+        return bool(self.message.document)
+
+    def is_reply(self) -> bool:
+        """Check if message is a reply"""
+        return bool(self.message.reply_to_message)
+
+    def is_forwarded(self) -> bool:
+        """Check if message is forwarded"""
+        return bool(self.message.forward_from)
+
+    def at_state(self, state: str) -> bool:
+        """Check if user is in the specified state"""
+        return self.client.get_state(self.chat.id) == state
+
+    def is_bot(self) -> bool:
+        """Check if user is a bot"""
+        return self.user.is_bot
+
+    def is_user(self) -> bool:
+        """Check if user is a user"""
+        return not self.user.is_bot
+
+    def is_admin_or_owner(self, chat: 'Chat') -> bool:
+        """Check if user is an admin or owner"""
+        return self.is_admin(chat) or self.is_owner(chat)
+
+    def matches_regex(self, pattern: str) -> bool:
+        """Check if message text matches regex pattern"""
+        if not self.message.text:
+            return False
+        return bool(re.match(pattern, self.message.text))
+
+    def contains_url(self) -> bool:
+        """Check if message contains url"""
+        if not self.message.text:
+            return False
+        return bool(
+            re.search(
+                r'http[s]?://(?:[a-zA-Z]|[0-9]|[$-_@.&+]|[!*\(\),]|(?:%[0-9a-fA-F][0-9a-fA-F]))+',
+                self.message.text))
 
-__version__ = '0.2.2'
 
 class DataBase:
+    """
+    Database class for managing key-value pairs in a SQLite database.
+    """
+
     def __init__(self, name):
         self.name = name
         self.conn = None
         self.cursor = None
         self._initialize_db()
-        
+
     def _initialize_db(self):
         self.conn = sqlite3.connect(self.name)
         self.cursor = self.conn.cursor()
@@ -21,94 +145,106 @@ class DataBase:
                         (key TEXT PRIMARY KEY, value TEXT, created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
                          updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP)''')
         self.conn.commit()
-        
+
     def __enter__(self):
         return self
-        
+
     def __exit__(self, exc_type, exc_val, exc_tb):
         self.close()
-        
+
     def close(self):
         if self.conn:
             self.conn.close()
             self.conn = None
             self.cursor = None
-            
+
     def read_database(self, include_timestamps=False):
         if not self.conn:
             self._initialize_db()
         if include_timestamps:
-            self.cursor.execute("SELECT key, value, created_at, updated_at FROM key_value_store")
+            self.cursor.execute(
+                "SELECT key, value, created_at, updated_at FROM key_value_store")
             rows = self.cursor.fetchall()
-            return {key: {'value': json.loads(value), 'created_at': created, 'updated_at': updated} 
-                   for key, value, created, updated in rows}
+            return {
+                key: {
+                    'value': json.loads(value),
+                    'created_at': created,
+                    'updated_at': updated} for key,
+                value,
+                created,
+                updated in rows}
         else:
             self.cursor.execute("SELECT key, value FROM key_value_store")
             rows = self.cursor.fetchall()
             return {key: json.loads(value) for key, value in rows}
-            
+
     def write_database(self, data_dict):
         if not self.conn:
             self._initialize_db()
         for key, value in data_dict.items():
             self.cursor.execute("""
-                INSERT INTO key_value_store (key, value, updated_at) 
+                INSERT INTO key_value_store (key, value, updated_at)
                 VALUES (?, ?, CURRENT_TIMESTAMP)
-                ON CONFLICT(key) DO UPDATE SET 
+                ON CONFLICT(key) DO UPDATE SET
                 value=excluded.value, updated_at=CURRENT_TIMESTAMP""",
-                (key, json.dumps(value, default=str)))
+                                (key, json.dumps(value, default=str)))
         self.conn.commit()
-        
+
     def read_key(self, key: str, default=None):
         if not self.conn:
             self._initialize_db()
-        self.cursor.execute("SELECT value FROM key_value_store WHERE key = ?", (key,))
+        self.cursor.execute(
+            "SELECT value FROM key_value_store WHERE key = ?", (key,))
         result = self.cursor.fetchone()
         return json.loads(result[0]) if result else default
-    
+
     def write_key(self, key: str, value):
         if not self.conn:
             self._initialize_db()
         self.cursor.execute("""
-            INSERT INTO key_value_store (key, value, updated_at) 
+            INSERT INTO key_value_store (key, value, updated_at)
             VALUES (?, ?, CURRENT_TIMESTAMP)
-            ON CONFLICT(key) DO UPDATE SET 
+            ON CONFLICT(key) DO UPDATE SET
             value=excluded.value, updated_at=CURRENT_TIMESTAMP""",
-            (key, json.dumps(value, default=str)))
+                            (key, json.dumps(value, default=str)))
         self.conn.commit()
-    
+
     def delete_key(self, key: str):
         if not self.conn:
             self._initialize_db()
-        self.cursor.execute("DELETE FROM key_value_store WHERE key = ?", (key,))
+        self.cursor.execute(
+            "DELETE FROM key_value_store WHERE key = ?", (key,))
         self.conn.commit()
-        
+
     def keys(self):
         if not self.conn:
             self._initialize_db()
         self.cursor.execute("SELECT key FROM key_value_store")
         return [row[0] for row in self.cursor.fetchall()]
-        
+
     def clear(self):
         if not self.conn:
             self._initialize_db()
         self.cursor.execute("DELETE FROM key_value_store")
         self.conn.commit()
-        
+
     def get_metadata(self, key: str):
         if not self.conn:
             self._initialize_db()
         self.cursor.execute("""
-            SELECT created_at, updated_at 
-            FROM key_value_store 
+            SELECT created_at, updated_at
+            FROM key_value_store
             WHERE key = ?""", (key,))
         result = self.cursor.fetchone()
-        return {'created_at': result[0], 'updated_at': result[1]} if result else None
-        
+        return {
+            'created_at': result[0],
+            'updated_at': result[1]} if result else None
+
     def exists(self, key: str) -> bool:
         if not self.conn:
             self._initialize_db()
-        self.cursor.execute("SELECT 1 FROM key_value_store WHERE key = ?", (key,))
+        self.cursor.execute(
+            "SELECT 1 FROM key_value_store WHERE key = ?", (key,))
         return bool(self.cursor.fetchone())
 
 
@@ -116,7 +252,10 @@ class ChatMember:
     def __init__(self, client: 'Client', data: Dict[str, Any]):
         if data:
             self.status = data.get('status')
-            self.user = User(client, {'ok': True, 'result': data.get('user', {})})
+            self.user = User(
+                client, {
+                    'ok': True, 'result': data.get(
+                        'user', {})})
             self.is_anonymous = data.get('is_anonymous')
             self.can_be_edited = data.get('can_be_edited')
             self.can_manage_chat = data.get('can_manage_chat')
@@ -129,12 +268,78 @@ class ChatMember:
             self.can_pin_messages = data.get('can_pin_messages')
             self.can_manage_topics = data.get('can_manage_topics')
             self.is_creator = data.get('status') == 'creator'
+
+
 class BaleException(Exception):
     """Base exception for Bale API errors"""
-    def __init__(self, *args):
-        super().__init__(*args)
-        print(traceback.format_exc())
-        
+
+    def __init__(self, message=None, error_code=None, response=None):
+        self.message = message
+        self.error_code = error_code
+        self.response = response
+
+        error_text = f"Error {error_code}: {message}" if error_code else message
+        super().__init__(error_text)
+
+    def __str__(self):
+        return f"{self.__class__.__name__}: {self.message}"
+
+
+class BaleAPIError(BaleException):
+    """Exception for API-specific errors"""
+    pass
+
+
+class BaleNetworkError(BaleException):
+    """Exception for network-related errors"""
+    pass
+
+
+class BaleAuthError(BaleException):
+    """Exception for authentication errors"""
+    pass
+
+
+class BaleValidationError(BaleException):
+    """Exception for data validation errors"""
+    pass
+
+
+class BaleTimeoutError(BaleException):
+    """Exception for timeout errors"""
+    pass
+
+
+class BaleNotFoundError(BaleException):
+    """Exception for when a resource is not found"""
+    pass
+
+
+class BaleForbiddenError(BaleException):
+    """Exception for forbidden access errors"""
+    pass
+
+
+class BaleServerError(BaleException):
+    """Exception for server-side errors"""
+    pass
+
+
+class BaleRateLimitError(BaleException):
+    """Exception for rate limit errors"""
+    pass
+
+
+class BaleTokenNotFoundError(BaleException):
+    """Exception for when a token is not found"""
+    pass
+
+
+class BaleUnknownError(BaleException):
+    """Exception for unknown errors"""
+    pass
+
+
 class LabeledPrice:
     def __init__(self, label: str, amount: int):
         self.label = label
@@ -144,6 +349,7 @@ class LabeledPrice:
             "amount": self.amount
         }
 
+
 class Document:
     def __init__(self, data: dict):
         if data:
@@ -159,6 +365,7 @@ class Document:
             self.mime_type = None
             self.file_size = None
 
+
 class Invoice:
     def __init__(self, data: dict):
         if data:
@@ -174,8 +381,9 @@ class Invoice:
             self.currency = None
             self.total_amount = None
 
+
 class Photo:
-    def __init__(self,data):
+    def __init__(self, data):
         if data:
             self.file_id = data.get('file_id')
             self.file_unique_id = data.get('file_unique_id')
@@ -189,6 +397,7 @@ class Photo:
             self.height = None
             self.file_size = None
 
+
 class Voice:
     def __init__(self, data: dict):
         if data:
@@ -204,8 +413,9 @@ class Voice:
             self.mime_type = None
             self.file_size = None
 
+
 class Location:
-    def __init__(self,data: dict):
+    def __init__(self, data: dict):
         if data:
             self.long = self.longitude = data.get('longitude')
             self.lat = self.latitude = data.get('latitude')
@@ -213,6 +423,7 @@ class Location:
             self.longitude = self.long = None
             self.latitude = self.lat = None
 
+
 class Contact:
     def __init__(self, data: dict):
         if data:
@@ -226,24 +437,36 @@ class Contact:
             self.last_name = None
             self.user_id = None
 
+
 class MenuKeyboardButton:
-    def __init__(self, text: str, request_contact: bool = False, request_location: bool = False):
+    def __init__(
+            self,
+            text: str,
+            request_contact: bool = False,
+            request_location: bool = False):
         if not text:
             raise ValueError("Text cannot be empty")
         if request_contact and request_location:
             raise ValueError("Cannot request both contact and location")
-        
+
         self.button = {"text": text}
         if request_contact:
             self.button["request_contact"] = True
         if request_location:
             self.button["request_location"] = True
 
+
 class InlineKeyboardButton:
-    def __init__(self, text: str, callback_data: Optional[str] = None, url: Optional[str] = None, web_app: Optional[str] = None):
+    def __init__(
+            self,
+            text: str,
+            callback_data: Optional[str] = None,
+            url: Optional[str] = None,
+            web_app: Optional[str] = None):
         self.button = {"text": text}
         if sum(bool(x) for x in [callback_data, url, web_app]) != 1:
-            raise ValueError("Exactly one of callback_data, url, or web_app must be provided")
+            raise ValueError(
+                "Exactly one of callback_data, url, or web_app must be provided")
         if callback_data:
             self.button["callback_data"] = callback_data
         elif url:
@@ -251,11 +474,13 @@ class InlineKeyboardButton:
         elif web_app:
             self.button["web_app"] = {"url": web_app}
 
+
 class MenuKeyboardMarkup:
     def __init__(self):
         self.menu_keyboard = []
 
-    def add(self, button: MenuKeyboardButton, row: int = 0) -> 'MenuKeyboardMarkup':
+    def add(self, button: MenuKeyboardButton,
+            row: int = 0) -> 'MenuKeyboardMarkup':
         if row < 0:
             raise ValueError("Row index cannot be negative")
         while len(self.menu_keyboard) <= row:
@@ -263,13 +488,13 @@ class MenuKeyboardMarkup:
         self.menu_keyboard[row].append(button.button)
         self.cleanup_empty_rows()
         return self
-    
+
     def cleanup_empty_rows(self) -> None:
         self.menu_keyboard = [row for row in self.menu_keyboard if row]
-    
+
     def clear(self) -> None:
         self.menu_keyboard = []
-    
+
     def remove_button(self, text: str) -> bool:
         found = False
         for row in self.menu_keyboard:
@@ -279,16 +504,18 @@ class MenuKeyboardMarkup:
                     found = True
         self.cleanup_empty_rows()
         return found
-    
+
     @property
     def keyboard(self):
         return {"keyboard": self.menu_keyboard}
-    
+
+
 class InlineKeyboardMarkup:
     def __init__(self):
         self.inline_keyboard = []
 
-    def add(self, button: InlineKeyboardButton, row: int = 0) -> 'InlineKeyboardMarkup':
+    def add(self, button: InlineKeyboardButton,
+            row: int = 0) -> 'InlineKeyboardMarkup':
         if row < 0:
             raise ValueError("Row index cannot be negative")
         while len(self.inline_keyboard) <= row:
@@ -296,13 +523,13 @@ class InlineKeyboardMarkup:
         self.inline_keyboard[row].append(button.button)
         self.cleanup_empty_rows()
         return self
-    
+
     def cleanup_empty_rows(self) -> None:
         self.inline_keyboard = [row for row in self.inline_keyboard if row]
-    
+
     def clear(self) -> None:
         self.inline_keyboard = []
-    
+
     def remove_button(self, text: str) -> bool:
         found = False
         for row in self.inline_keyboard:
@@ -312,13 +539,20 @@ class InlineKeyboardMarkup:
                     found = True
         self.cleanup_empty_rows()
         return found
-    
+
     @property
     def keyboard(self) -> dict:
         return {"inline_keyboard": self.inline_keyboard}
+
+
 class InputFile:
     """Represents a file to be uploaded"""
-    def __init__(self, client: 'Client', file: Union[str, bytes], filename: Optional[str] = None):
+
+    def __init__(self,
+                 client: 'Client',
+                 file: Union[str,
+                             bytes],
+                 filename: Optional[str] = None):
         self.client = client
         self.filename = filename
         if isinstance(file, str):
@@ -329,40 +563,70 @@ class InputFile:
             else:
                 try:
                     self.file = open(file, 'rb')
-                except IOError as e:
-                    raise BaleException(f"Failed to open file: {traceback.format_exc()}")
+                except IOError:
+                    raise BaleException(
+                        f"Failed to open file: {traceback.format_exc()}")
         else:
-            self.file = file    
-            
+            self.file = file
+
     def __del__(self):
         if hasattr(self, 'file') and hasattr(self.file, 'close'):
             self.file.close()
-    
+
     @property
     def to_bytes(self):
         if hasattr(self.file, 'read'):
             return self.file.read()
         return self.file
 
+
 class CallbackQuery:
     """Represents a callback query from a callback button"""
+
     def __init__(self, client: 'Client', data: Dict[str, Any]):
         if not data.get('ok'):
-            raise BaleException(f"API request failed: {traceback.format_exc()}")
+            raise BaleException(
+                f"API request failed: {traceback.format_exc()}")
         self.client = client
         result = data.get('result', {})
         self.id = result.get('id')
-        self.from_user = User(client, {'ok': True, 'result': result.get('from', {})})
-        self.message = Message(client, {'ok': True, 'result': result.get('message', {})})
+        self.from_user = self.user = self.author = User(
+            client, {'ok': True, 'result': result.get('from', {})})
+        self.message = Message(
+            client, {
+                'ok': True, 'result': result.get(
+                    'message', {})})
         self.inline_message_id = result.get('inline_message_id')
         self.chat_instance = result.get('chat_instance')
-        self.data = result.get('data')    
+        self.data = result.get('data')
+
+    def answer(self,
+               text: str,
+               reply_markup: Optional[Union[MenuKeyboardMarkup,
+                                            InlineKeyboardMarkup]] = None) -> 'Message':
+        return self.client.send_message(
+            chat_id=self.message.chat.id,
+            text=text,
+            reply_markup=reply_markup)
+
+    def reply(self,
+              text: str,
+              reply_markup: Optional[Union[MenuKeyboardMarkup,
+                                           InlineKeyboardMarkup]] = None) -> 'Message':
+        return self.client.send_message(
+            chat_id=self.message.chat.id,
+            text=text,
+            reply_markup=reply_markup,
+            reply_to_message=self.message.id)
+
 
 class Chat:
     """Represents a chat conversation"""
+
     def __init__(self, client: 'Client', data: Dict[str, Any]):
         if not data.get('ok'):
-            raise BaleException(f"API request failed: {traceback.format_exc()}")
+            raise BaleException(
+                f"API request failed: {traceback.format_exc()}")
         self.client = client
         result = data.get('result', {})
         self.data = data
@@ -374,139 +638,268 @@ class Chat:
         self.invite_link = result.get('invite_link')
         self.photo = result.get('photo')
 
-    def send_photo(self, photo: Union[str, bytes, InputFile],
-                  caption: Optional[str] = None,
-                  parse_mode: Optional[str] = None,
-                  reply_markup: Union[MenuKeyboardMarkup,InlineKeyboardMarkup] = None) -> 'Message':
+    def send_photo(self,
+                   photo: Union[str,
+                                bytes,
+                                InputFile],
+                   caption: Optional[str] = None,
+                   parse_mode: Optional[str] = None,
+                   reply_markup: Union[MenuKeyboardMarkup,
+                                       InlineKeyboardMarkup] = None) -> 'Message':
         """Send a photo to a chat"""
         files = None
         data = {
             'chat_id': self.id,
             'caption': caption,
             'parse_mode': parse_mode,
-            'reply_markup': reply_markup.keyboard if isinstance(reply_markup, MenuKeyboardMarkup) else reply_markup.keyboard if isinstance(reply_markup, InlineKeyboardMarkup) else None
-        }
-        
+            'reply_markup': reply_markup.keyboard if isinstance(
+                reply_markup,
+                MenuKeyboardMarkup) else reply_markup.keyboard if isinstance(
+                reply_markup,
+                InlineKeyboardMarkup) else None}
+
         if isinstance(photo, (bytes, InputFile)) or hasattr(photo, 'read'):
-            files = {'photo': photo if not isinstance(photo, InputFile) else photo.file}
+            files = {
+                'photo': photo if not isinstance(
+                    photo, InputFile) else photo.file}
         else:
             data['photo'] = photo
-            
-        response = self.client._make_request('POST', 'sendPhoto', data=data, files=files)
-        return Message(self.client, response)    
 
-    def send_message(self, text: str,
-                    parse_mode: Optional[str] = None,
-                    reply_markup: Union[MenuKeyboardMarkup,InlineKeyboardMarkup] = None) -> 'Message':
-        return self.client.send_message(self.id, text, parse_mode, reply_markup)
-    
-    def forward_message(self, from_chat_id: Union[int, str], message_id: int) -> 'Message':
-            """Forward a message from another chat"""
-            return self.client.forward_message(self.id, from_chat_id, message_id)
-    
-    def copy_message(self, from_chat_id: Union[int, str], message_id: int,
-                        caption: Optional[str] = None,
-                        parse_mode: Optional[str] = None,
-                        reply_markup: Union[MenuKeyboardMarkup,InlineKeyboardMarkup] = None) -> 'Message':
-            """Copy a message from another chat"""
-            return self.client.copy_message(self.id, from_chat_id, message_id, caption, parse_mode, reply_markup)
-    
-    def send_audio(self, audio: Union[str, bytes, InputFile],
-                      caption: Optional[str] = None,
-                      parse_mode: Optional[str] = None,
-                      duration: Optional[int] = None,
-                      performer: Optional[str] = None,
-                      title: Optional[str] = None,
-                      reply_markup: Union[MenuKeyboardMarkup,InlineKeyboardMarkup] = None) -> 'Message':
-            """Send an audio file"""
-            return self.client.send_audio(self.id, audio, caption, parse_mode, duration, performer, title, reply_markup)
-    
-    def send_document(self, document: Union[str, bytes, InputFile],
-                         caption: Optional[str] = None,
-                         parse_mode: Optional[str] = None,
-                         reply_markup: Union[MenuKeyboardMarkup,InlineKeyboardMarkup] = None) -> 'Message':
-            """Send a document"""
-            return self.client.send_document(self.id, document, caption, parse_mode, reply_markup)
-    
-    def send_video(self, video: Union[str, bytes, InputFile],
-                      caption: Optional[str] = None,
-                      parse_mode: Optional[str] = None,
-                      duration: Optional[int] = None,
-                      width: Optional[int] = None,
-                      height: Optional[int] = None,
-                      reply_markup: Union[MenuKeyboardMarkup,InlineKeyboardMarkup] = None) -> 'Message':
-            """Send a video"""
-            return self.client.send_video(self.id, video, caption, parse_mode, duration, width, height, reply_markup)
-    
-    def send_animation(self, animation: Union[str, bytes, InputFile],
-                          caption: Optional[str] = None,
-                          parse_mode: Optional[str] = None,
-                          duration: Optional[int] = None,
-                          width: Optional[int] = None,
-                          height: Optional[int] = None,
-                          reply_markup: Union[MenuKeyboardMarkup,InlineKeyboardMarkup] = None) -> 'Message':
-            """Send an animation"""
-            return self.client.send_animation(self.id, animation, caption, parse_mode, duration, width, height, reply_markup)
-    
-    def send_voice(self, voice: Union[str, bytes, InputFile],
+        response = self.client._make_request(
+            'POST', 'sendPhoto', data=data, files=files)
+        return Message(self.client, response)
+
+    def send_message(self,
+                     text: str,
+                     parse_mode: Optional[str] = None,
+                     reply_markup: Union[MenuKeyboardMarkup,
+                                         InlineKeyboardMarkup] = None) -> 'Message':
+        return self.client.send_message(
+            self.id, text, parse_mode, reply_markup)
+
+    def forward_message(
+            self, from_chat_id: Union[int, str], message_id: int) -> 'Message':
+        """Forward a message from another chat"""
+        return self.client.forward_message(self.id, from_chat_id, message_id)
+
+    def copy_message(self,
+                     from_chat_id: Union[int,
+                                         str],
+                     message_id: int,
+                     caption: Optional[str] = None,
+                     parse_mode: Optional[str] = None,
+                     reply_markup: Union[MenuKeyboardMarkup,
+                                         InlineKeyboardMarkup] = None) -> 'Message':
+        """Copy a message from another chat"""
+        return self.client.copy_message(
+            self.id,
+            from_chat_id,
+            message_id,
+            caption,
+            parse_mode,
+            reply_markup)
+
+    def send_audio(self,
+                   audio: Union[str,
+                                bytes,
+                                InputFile],
+                   caption: Optional[str] = None,
+                   parse_mode: Optional[str] = None,
+                   duration: Optional[int] = None,
+                   performer: Optional[str] = None,
+                   title: Optional[str] = None,
+                   reply_markup: Union[MenuKeyboardMarkup,
+                                       InlineKeyboardMarkup] = None) -> 'Message':
+        """Send an audio file"""
+        return self.client.send_audio(
+            self.id,
+            audio,
+            caption,
+            parse_mode,
+            duration,
+            performer,
+            title,
+            reply_markup)
+
+    def send_document(self,
+                      document: Union[str,
+                                      bytes,
+                                      InputFile],
                       caption: Optional[str] = None,
                       parse_mode: Optional[str] = None,
-                      duration: Optional[int] = None,
-                      reply_markup: Union[MenuKeyboardMarkup,InlineKeyboardMarkup] = None) -> 'Message':
-            """Send a voice message"""
-            return self.client.send_voice(self.id, voice, caption, parse_mode, duration, reply_markup)
-    
-    def send_media_group(self, chat_id: Union[int, str],
-                            media: List[Dict],
-                            reply_to_message: Union['Message', int, str] = None) -> List['Message']:
-            """Send a group of photos, videos, documents or audios as an album"""
-            data = {
-                'chat_id': chat_id,
-                'media': media,
-                'reply_to_message_id': reply_to_message.message_id if isinstance(reply_to_message, Message) else reply_to_message
-            }
-            response = self._make_request('POST', 'sendMediaGroup', json=data)
-            return [Message(self, msg) for msg in response]
-    
-    def send_location(self, latitude: float, longitude: float,
-                         live_period: Optional[int] = None,
-                         reply_markup: Union[MenuKeyboardMarkup,InlineKeyboardMarkup] = None) -> 'Message':
-            """Send a location"""
-            return self.client.send_location(self.id, latitude, longitude, live_period, reply_markup)
-    
-    def send_contact(self, phone_number: str, first_name: str,
-                        last_name: Optional[str] = None,
-                        reply_markup: Union[MenuKeyboardMarkup,InlineKeyboardMarkup] = None) -> 'Message':
-            """Send a contact"""
-            return self.client.send_contact(self.id, phone_number, first_name, last_name, reply_markup)
-    
-    def send_invoice(self,title:str,description:str,payload:str,provider_token:str,prices:list,photo_url: Optional[str] = None,reply_to_message: Union[int,str,'Message'] = None, reply_markup: Union[MenuKeyboardMarkup|InlineKeyboardMarkup] = None):
-        return self.client.send_invoice(self.id,title,description,payload,provider_token,prices,photo_url,reply_to_message,reply_markup)
-    
-    def banChatMember(self, user_id: int, until_date: Optional[int] = None) -> bool:
+                      reply_markup: Union[MenuKeyboardMarkup,
+                                          InlineKeyboardMarkup] = None) -> 'Message':
+        """Send a document"""
+        return self.client.send_document(
+            self.id, document, caption, parse_mode, reply_markup)
+
+    def send_video(self,
+                   video: Union[str,
+                                bytes,
+                                InputFile],
+                   caption: Optional[str] = None,
+                   parse_mode: Optional[str] = None,
+                   duration: Optional[int] = None,
+                   width: Optional[int] = None,
+                   height: Optional[int] = None,
+                   reply_markup: Union[MenuKeyboardMarkup,
+                                       InlineKeyboardMarkup] = None) -> 'Message':
+        """Send a video"""
+        return self.client.send_video(
+            self.id,
+            video,
+            caption,
+            parse_mode,
+            duration,
+            width,
+            height,
+            reply_markup)
+
+    def send_animation(self,
+                       animation: Union[str,
+                                        bytes,
+                                        InputFile],
+                       caption: Optional[str] = None,
+                       parse_mode: Optional[str] = None,
+                       duration: Optional[int] = None,
+                       width: Optional[int] = None,
+                       height: Optional[int] = None,
+                       reply_markup: Union[MenuKeyboardMarkup,
+                                           InlineKeyboardMarkup] = None) -> 'Message':
+        """Send an animation"""
+        return self.client.send_animation(
+            self.id,
+            animation,
+            caption,
+            parse_mode,
+            duration,
+            width,
+            height,
+            reply_markup)
+
+    def send_voice(self,
+                   voice: Union[str,
+                                bytes,
+                                InputFile],
+                   caption: Optional[str] = None,
+                   parse_mode: Optional[str] = None,
+                   duration: Optional[int] = None,
+                   reply_markup: Union[MenuKeyboardMarkup,
+                                       InlineKeyboardMarkup] = None) -> 'Message':
+        """Send a voice message"""
+        return self.client.send_voice(
+            self.id,
+            voice,
+            caption,
+            parse_mode,
+            duration,
+            reply_markup)
+
+    def send_media_group(self,
+                         chat_id: Union[int,
+                                        str],
+                         media: List[Dict],
+                         reply_to_message: Union['Message',
+                                                 int,
+                                                 str] = None) -> List['Message']:
+        """Send a group of photos, videos, documents or audios as an album"""
+        data = {
+            'chat_id': chat_id,
+            'media': media,
+            'reply_to_message_id': reply_to_message.message_id if isinstance(
+                reply_to_message,
+                Message) else reply_to_message}
+        response = self._make_request('POST', 'sendMediaGroup', json=data)
+        return [Message(self, msg) for msg in response]
+
+    def send_location(self,
+                      latitude: float,
+                      longitude: float,
+                      live_period: Optional[int] = None,
+                      reply_markup: Union[MenuKeyboardMarkup,
+                                          InlineKeyboardMarkup] = None) -> 'Message':
+        """Send a location"""
+        return self.client.send_location(
+            self.id, latitude, longitude, live_period, reply_markup)
+
+    def send_contact(self,
+                     phone_number: str,
+                     first_name: str,
+                     last_name: Optional[str] = None,
+                     reply_markup: Union[MenuKeyboardMarkup,
+                                         InlineKeyboardMarkup] = None) -> 'Message':
+        """Send a contact"""
+        return self.client.send_contact(
+            self.id,
+            phone_number,
+            first_name,
+            last_name,
+            reply_markup)
+
+    def send_invoice(self,
+                     title: str,
+                     description: str,
+                     payload: str,
+                     provider_token: str,
+                     prices: list,
+                     photo_url: Optional[str] = None,
+                     reply_to_message: Union[int,
+                                             str,
+                                             'Message'] = None,
+                     reply_markup: Union[MenuKeyboardMarkup | InlineKeyboardMarkup] = None):
+        return self.client.send_invoice(
+            self.id,
+            title,
+            description,
+            payload,
+            provider_token,
+            prices,
+            photo_url,
+            reply_to_message,
+            reply_markup)
+    
+    def send_action(self, action: str, how_many_times = 1) -> bool:
+        """Send a chat action"""
+        return self.client.send_chat_action(self.id, action, how_many_times)
+
+    def banChatMember(
+            self,
+            user_id: int,
+            until_date: Optional[int] = None) -> bool:
         """Ban a user from the chat"""
         data = {
             'chat_id': self.id,
             'user_id': user_id,
             'until_date': until_date
         }
-        response = self.client._make_request('POST', 'banChatMember', data=data)
+        response = self.client._make_request(
+            'POST', 'banChatMember', data=data)
         return response.get('ok', False)
 
-    def unbanChatMember(self, user_id: int, only_if_banned: bool = False) -> bool:
+    def unbanChatMember(
+            self,
+            user_id: int,
+            only_if_banned: bool = False) -> bool:
         """Unban a previously banned user from the chat"""
         data = {
             'chat_id': self.id,
             'user_id': user_id,
             'only_if_banned': only_if_banned
         }
-        response = self.client._make_request('POST', 'unbanChatMember', data=data)
+        response = self.client._make_request(
+            'POST', 'unbanChatMember', data=data)
         return response.get('ok', False)
 
-    def promoteChatMember(self, user_id: int, can_change_info: bool = None,
-                         can_post_messages: bool = None, can_edit_messages: bool = None,
-                         can_delete_messages: bool = None, can_manage_video_chats: bool = None,
-                         can_invite_users: bool = None, can_restrict_members: bool = None) -> bool:
+    def promoteChatMember(
+            self,
+            user_id: int,
+            can_change_info: bool = None,
+            can_post_messages: bool = None,
+            can_edit_messages: bool = None,
+            can_delete_messages: bool = None,
+            can_manage_video_chats: bool = None,
+            can_invite_users: bool = None,
+            can_restrict_members: bool = None) -> bool:
         """Promote or demote a chat member"""
         data = {
             'chat_id': self.id,
@@ -519,20 +912,24 @@ class Chat:
             'can_invite_users': can_invite_users,
             'can_restrict_members': can_restrict_members
         }
-        response = self.client._make_request('POST', 'promoteChatMember', data=data)
+        response = self.client._make_request(
+            'POST', 'promoteChatMember', data=data)
         return response.get('ok', False)
-    
+
     def setChatPhoto(self, photo: Union[str, bytes, InputFile]) -> bool:
         """Set a new chat photo"""
         files = None
         data = {'chat_id': self.id}
-        
+
         if isinstance(photo, (bytes, InputFile)) or hasattr(photo, 'read'):
-            files = {'photo': photo if not isinstance(photo, InputFile) else photo.file}
+            files = {
+                'photo': photo if not isinstance(
+                    photo, InputFile) else photo.file}
         else:
             data['photo'] = photo
-            
-        response = self.client._make_request('POST', 'setChatPhoto', data=data, files=files)
+
+        response = self.client._make_request(
+            'POST', 'setChatPhoto', data=data, files=files)
         return response.get('ok', False)
 
     def leaveChat(self) -> bool:
@@ -550,17 +947,22 @@ class Chat:
     def getChatMembersCount(self) -> int:
         """Get the number of members in the chat"""
         data = {'chat_id': self.id}
-        response = self.client._make_request('POST', 'getChatMembersCount', data=data)
+        response = self.client._make_request(
+            'POST', 'getChatMembersCount', data=data)
         return response.get('result', 0)
 
-    def pinChatMessage(self, message_id: int, disable_notification: bool = False) -> bool:
+    def pinChatMessage(
+            self,
+            message_id: int,
+            disable_notification: bool = False) -> bool:
         """Pin a message in the chat"""
         data = {
             'chat_id': self.id,
             'message_id': message_id,
             'disable_notification': disable_notification
         }
-        response = self.client._make_request('POST', 'pinChatMessage', data=data)
+        response = self.client._make_request(
+            'POST', 'pinChatMessage', data=data)
         return response.get('ok', False)
 
     def unPinChatMessage(self, message_id: int) -> bool:
@@ -569,13 +971,15 @@ class Chat:
             'chat_id': self.id,
             'message_id': message_id
         }
-        response = self.client._make_request('POST', 'unpinChatMessage', data=data)
+        response = self.client._make_request(
+            'POST', 'unpinChatMessage', data=data)
         return response.get('ok', False)
 
     def unpinAllChatMessages(self) -> bool:
         """Unpin all messages in the chat"""
         data = {'chat_id': self.id}
-        response = self.client._make_request('POST', 'unpinAllChatMessages', data=data)
+        response = self.client._make_request(
+            'POST', 'unpinAllChatMessages', data=data)
         return response.get('ok', False)
 
     def setChatTitle(self, title: str) -> bool:
@@ -593,19 +997,22 @@ class Chat:
             'chat_id': self.id,
             'description': description
         }
-        response = self.client._make_request('POST', 'setChatDescription', data=data)
+        response = self.client._make_request(
+            'POST', 'setChatDescription', data=data)
         return response.get('ok', False)
 
     def deleteChatPhoto(self) -> bool:
         """Delete the chat photo"""
         data = {'chat_id': self.id}
-        response = self.client._make_request('POST', 'deleteChatPhoto', data=data)
+        response = self.client._make_request(
+            'POST', 'deleteChatPhoto', data=data)
         return response.get('ok', False)
 
     def createChatInviteLink(self) -> str:
         """Create an invite link for the chat"""
         data = {'chat_id': self.id}
-        response = self.client._make_request('POST', 'createChatInviteLink', data=data)
+        response = self.client._make_request(
+            'POST', 'createChatInviteLink', data=data)
         return response.get('result', {}).get('invite_link')
 
     def revokeChatInviteLink(self, invite_link: str) -> bool:
@@ -614,22 +1021,25 @@ class Chat:
             'chat_id': self.id,
             'invite_link': invite_link
         }
-        response = self.client._make_request('POST', 'revokeChatInviteLink', data=data)
+        response = self.client._make_request(
+            'POST', 'revokeChatInviteLink', data=data)
         return response.get('ok', False)
 
     def exportChatInviteLink(self) -> str:
         """Generate a new invite link for the chat"""
         data = {'chat_id': self.id}
-        response = self.client._make_request('POST', 'exportChatInviteLink', data=data)
+        response = self.client._make_request(
+            'POST', 'exportChatInviteLink', data=data)
         return response.get('result')
 
-    
 
 class User:
     """Represents a Bale user"""
+
     def __init__(self, client: 'Client', data: Dict[str, Any]):
         if not data.get('ok'):
-            raise BaleException(f"API request failed: {traceback.format_exc()}")
+            raise BaleException(
+                f"API request failed: {traceback.format_exc()}")
         self.client = client
         result = data.get('result', {})
         self.data = data
@@ -639,233 +1049,521 @@ class User:
         self.first_name = result.get('first_name')
         self.last_name = result.get('last_name')
         self.username = result.get('username')
-    
+
     def set_state(self, state: str) -> None:
         """Set the state for a chat or user"""
         self.client.states[str(self.id)] = state
-    
-    def get_state(self) -> str|None:
+
+    def get_state(self) -> str | None:
         """Get the state for a chat or user"""
         return self.client.states.get(str(self.id))
-    
+
     def del_state(self) -> None:
         """Delete the state for a chat or user"""
         self.client.states.pop(str(self.id), None)
-        
 
-    def send_message(self, text: str, parse_mode: Optional[str] = None, 
-                    reply_markup: Union[MenuKeyboardMarkup,InlineKeyboardMarkup] = None) -> 'Message':
+    def send_message(self,
+                     text: str,
+                     parse_mode: Optional[str] = None,
+                     reply_markup: Union[MenuKeyboardMarkup,
+                                         InlineKeyboardMarkup] = None) -> 'Message':
         """Send a message to this user"""
-        return self.client.send_message(self.id, text, parse_mode, reply_markup)
-        
-    def send_photo(self, photo: Union[str, bytes, InputFile],
-                  caption: Optional[str] = None,
-                  parse_mode: Optional[str] = None,
-                  reply_markup: Union[MenuKeyboardMarkup,InlineKeyboardMarkup] = None) -> 'Message':
+        return self.client.send_message(
+            self.id, text, parse_mode, reply_markup)
+
+    def send_photo(self,
+                   photo: Union[str,
+                                bytes,
+                                InputFile],
+                   caption: Optional[str] = None,
+                   parse_mode: Optional[str] = None,
+                   reply_markup: Union[MenuKeyboardMarkup,
+                                       InlineKeyboardMarkup] = None) -> 'Message':
         """Send a photo to a chat"""
-        return self.client.send_photo(self.id, photo, caption, parse_mode, reply_markup)
-    
-    def forward_message(self, from_chat_id: Union[int, str], message_id: int) -> 'Message':
-            """Forward a message to this user"""
-            self.client.forward_message(self.id,from_chat_id,message_id)
-    
-    def copy_message(self, from_chat_id: Union[int, str], message_id: int) -> 'Message':
-            """Copy a message to this user"""
-            self.client.copy_message(self.id,from_chat_id,message_id)
-    
-    def send_audio(self, audio: Union[str, bytes, InputFile],
-                      caption: Optional[str] = None,
-                      parse_mode: Optional[str] = None,
-                      reply_markup: Union[MenuKeyboardMarkup,InlineKeyboardMarkup] = None, reply_to_message: Union[str,int,'Message'] = None) -> 'Message':
-            """Send an audio file to this user"""
-            self.client.send_audio(self.id, audio, caption, parse_mode, reply_markup, reply_to_message)
-    
-    def send_document(self, document: Union[str, bytes, InputFile],
-                         caption: Optional[str] = None,
-                         parse_mode: Optional[str] = None,
-                         reply_markup: Union[MenuKeyboardMarkup,InlineKeyboardMarkup] = None, reply_to_message: Union[str,int,'Message'] = None) -> 'Message':
-            """Send a document to this user"""
-            self.client.send_document(self.id, document, caption, parse_mode, reply_markup, reply_markup)
-    
-    def send_video(self, video: Union[str, bytes, InputFile],
+        return self.client.send_photo(
+            self.id, photo, caption, parse_mode, reply_markup)
+
+    def forward_message(
+            self, from_chat_id: Union[int, str], message_id: int) -> 'Message':
+        """Forward a message to this user"""
+        self.client.forward_message(self.id, from_chat_id, message_id)
+
+    def copy_message(self,
+                     from_chat_id: Union[int,
+                                         str],
+                     message_id: int) -> 'Message':
+        """Copy a message to this user"""
+        self.client.copy_message(self.id, from_chat_id, message_id)
+
+    def send_audio(self,
+                   audio: Union[str,
+                                bytes,
+                                InputFile],
+                   caption: Optional[str] = None,
+                   parse_mode: Optional[str] = None,
+                   reply_markup: Union[MenuKeyboardMarkup,
+                                       InlineKeyboardMarkup] = None,
+                   reply_to_message: Union[str,
+                                           int,
+                                           'Message'] = None) -> 'Message':
+        """Send an audio file to this user"""
+        self.client.send_audio(
+            self.id,
+            audio,
+            caption,
+            parse_mode,
+            reply_markup,
+            reply_to_message)
+
+    def send_document(self,
+                      document: Union[str,
+                                      bytes,
+                                      InputFile],
                       caption: Optional[str] = None,
                       parse_mode: Optional[str] = None,
-                      reply_markup: Union[MenuKeyboardMarkup,InlineKeyboardMarkup] = None, reply_to_message: Union[str,int,'Message'] = None) -> 'Message':
-            """Send a video to this user"""
-            self.client.send_video(self.id,video,caption,parse_mode,reply_markup,reply_to_message)
-    
-    def send_animation(self, animation: Union[str, bytes, InputFile],
-                          caption: Optional[str] = None,
-                          parse_mode: Optional[str] = None,
-                          reply_markup: Union[MenuKeyboardMarkup,InlineKeyboardMarkup] = None, reply_to_message: Union[int,str,'Message'] = None) -> 'Message':
-            """Send an animation to this user"""
-            return self.client.send_animation(self.id,animation,caption,parse_mode,reply_markup,reply_to_message)
-    
-    def send_voice(self, voice: Union[str, bytes, InputFile],
-                    caption: Optional[str] = None,
-                    parse_mode: Optional[str] = None,
-                    reply_markup: Union[MenuKeyboardMarkup,InlineKeyboardMarkup] = None,reply_to_message: Union[int,str,'Message'] = None) -> 'Message':        
+                      reply_markup: Union[MenuKeyboardMarkup,
+                                          InlineKeyboardMarkup] = None,
+                      reply_to_message: Union[str,
+                                              int,
+                                              'Message'] = None) -> 'Message':
+        """Send a document to this user"""
+        self.client.send_document(
+            self.id,
+            document,
+            caption,
+            parse_mode,
+            reply_markup,
+            reply_markup)
+
+    def send_video(self,
+                   video: Union[str,
+                                bytes,
+                                InputFile],
+                   caption: Optional[str] = None,
+                   parse_mode: Optional[str] = None,
+                   reply_markup: Union[MenuKeyboardMarkup,
+                                       InlineKeyboardMarkup] = None,
+                   reply_to_message: Union[str,
+                                           int,
+                                           'Message'] = None) -> 'Message':
+        """Send a video to this user"""
+        self.client.send_video(
+            self.id,
+            video,
+            caption,
+            parse_mode,
+            reply_markup,
+            reply_to_message)
+
+    def send_animation(self,
+                       animation: Union[str,
+                                        bytes,
+                                        InputFile],
+                       caption: Optional[str] = None,
+                       parse_mode: Optional[str] = None,
+                       reply_markup: Union[MenuKeyboardMarkup,
+                                           InlineKeyboardMarkup] = None,
+                       reply_to_message: Union[int,
+                                               str,
+                                               'Message'] = None) -> 'Message':
+        """Send an animation to this user"""
+        return self.client.send_animation(
+            self.id,
+            animation,
+            caption,
+            parse_mode,
+            reply_markup,
+            reply_to_message)
+
+    def send_voice(self,
+                   voice: Union[str,
+                                bytes,
+                                InputFile],
+                   caption: Optional[str] = None,
+                   parse_mode: Optional[str] = None,
+                   reply_markup: Union[MenuKeyboardMarkup,
+                                       InlineKeyboardMarkup] = None,
+                   reply_to_message: Union[int,
+                                           str,
+                                           'Message'] = None) -> 'Message':
         """Send a voice message to this user"""
-        return self.client.send_voice(self.id,voice,caption,parse_mode,reply_markup,reply_to_message)
-    
-    def send_media_group(self, chat_id: Union[int, str],
-                            media: List[Dict],
-                            reply_to_message: Union['Message', int, str] = None) -> List['Message']:
-            """Send a group of photos, videos, documents or audios as an album"""
-            return self.client.send_media_group(chat_id, media, reply_to_message)
-        
-    
-    def send_location(self, latitude: float, longitude: float,
-                         reply_markup: Union[MenuKeyboardMarkup,InlineKeyboardMarkup] = None,reply_to_message: Union[str,int,'Message'] = None) -> 'Message':
-            """Send a location to this user"""
-            return self.send_location(latitude,longitude,reply_markup,reply_to_message)
-    
-    def send_contact(self, phone_number: str, first_name: str,last_name: Optional[str] = None,reply_markup: Union[MenuKeyboardMarkup,InlineKeyboardMarkup] = None, reply_to_message: Union[str,int,'Message'] = None) -> 'Message':
-            """Send a contact to this user"""
-            return self.client.send_contact(self.id,phone_number,first_name,last_name,reply_markup,reply_to_message)
-    
-    def send_invoice(self,title:str,description:str,payload:str,provider_token:str,prices:list,photo_url: Optional[str] = None,reply_to_message: Union[int,str,'Message'] = None, reply_markup: Union[MenuKeyboardMarkup|InlineKeyboardMarkup] = None):
-        return self.client.send_invoice(self.id,title,description,payload,provider_token,prices,photo_url,reply_to_message,reply_markup)
+        return self.client.send_voice(
+            self.id,
+            voice,
+            caption,
+            parse_mode,
+            reply_markup,
+            reply_to_message)
+
+    def send_media_group(self,
+                         chat_id: Union[int,
+                                        str],
+                         media: List[Dict],
+                         reply_to_message: Union['Message',
+                                                 int,
+                                                 str] = None) -> List['Message']:
+        """Send a group of photos, videos, documents or audios as an album"""
+        return self.client.send_media_group(chat_id, media, reply_to_message)
+
+    def send_location(self,
+                      latitude: float,
+                      longitude: float,
+                      reply_markup: Union[MenuKeyboardMarkup,
+                                          InlineKeyboardMarkup] = None,
+                      reply_to_message: Union[str,
+                                              int,
+                                              'Message'] = None) -> 'Message':
+        """Send a location to this user"""
+        return self.send_location(
+            latitude,
+            longitude,
+            reply_markup,
+            reply_to_message)
+
+    def send_contact(self,
+                     phone_number: str,
+                     first_name: str,
+                     last_name: Optional[str] = None,
+                     reply_markup: Union[MenuKeyboardMarkup,
+                                         InlineKeyboardMarkup] = None,
+                     reply_to_message: Union[str,
+                                             int,
+                                             'Message'] = None) -> 'Message':
+        """Send a contact to this user"""
+        return self.client.send_contact(
+            self.id,
+            phone_number,
+            first_name,
+            last_name,
+            reply_markup,
+            reply_to_message)
+
+    def send_invoice(self,
+                     title: str,
+                     description: str,
+                     payload: str,
+                     provider_token: str,
+                     prices: list,
+                     photo_url: Optional[str] = None,
+                     reply_to_message: Union[int,
+                                             str,
+                                             'Message'] = None,
+                     reply_markup: Union[MenuKeyboardMarkup | InlineKeyboardMarkup] = None):
+        return self.client.send_invoice(
+            self.id,
+            title,
+            description,
+            payload,
+            provider_token,
+            prices,
+            photo_url,
+            reply_to_message,
+            reply_markup)
+    def send_action(self, action: str, how_many_times: int = 1):
+        """Send a chat action to this user"""
+        return self.client.send_chat_action(self.id, action, how_many_times)
+
 
 class Message:
     """Represents a message in Bale"""
+
     def __init__(self, client: 'Client', data: Dict[str, Any]):
         if not data.get('ok'):
-            raise BaleException(f"API request failed: {traceback.format_exc()}")
+            raise BaleException(
+                f"API request failed: {traceback.format_exc()}")
         self.client = client
         self.ok = data.get('ok')
         result = data.get('result', {})
-        
-        self.message_id = result.get('message_id')
-        self.from_user = User(client,{'ok': True, 'result': result.get('from', {})})
+        self.json_result = result
+
+        self.message_id = self.id = result.get('message_id')
+        self.from_user = self.author = User(
+            client, {'ok': True, 'result': result.get('from', {})})
         self.date = result.get('date')
-        self.chat = Chat(client, {'ok': True, 'result': result.get('chat', {})})
+        self.chat = Chat(
+            client, {
+                'ok': True, 'result': result.get(
+                    'chat', {})})
         self.text = result.get('text')
         self.caption = result.get('caption')
         self.document = Document(result.get('document'))
-        self.photo = result.get('photo')
-        self.video = result.get('video')
-        self.audio = result.get('audio')
+        self.photo = Document(result.get('photo'))
+        self.video = Document(result.get('video'))
+        self.audio = Document(result.get('audio'))
         self.voice = Voice(result.get('voice'))
         self.animation = result.get('animation')
         self.contact = Contact(result.get('contact'))
         self.location = Location(result.get('location'))
-        self.forward_from = User(client, {'ok': True, 'result': result.get('forward_from', {})})
+        self.forward_from = User(client, {'ok': True, 'result': result.get(
+            'forward_from', {})}) if result.get('forward_from') else None
         self.forward_from_message_id = result.get('forward_from_message_id')
         self.invoice = Invoice(result.get('invoice'))
+        self.reply_to_message = Message(client, {'ok': True, 'result': result.get(
+            'reply_to_message', {})}) if result.get('reply_to_message') else None
+        self.reply = self.reply_message
+        self.send = lambda text, parse_mode=None, reply_markup=None: self.client.send_message(
+            self.chat.id, text, parse_mode, reply_markup, reply_to_message=self)
+        
+        self.command = None
+        self.args = None
+        txt = self.text.split(' ')
         
+        self.command = txt[0]
+        self.has_slash_command = self.command.startswith('/')
+        self.args = txt[1:]
+        
+        self.start = self.command == '/start'
 
-    def edit(self, text: str, parse_mode: Optional[str] = None, 
-            reply_markup: Union[MenuKeyboardMarkup,InlineKeyboardMarkup] = None) -> 'Message':
+    def edit(self,
+             text: str,
+             parse_mode: Optional[str] = None,
+             reply_markup: Union[MenuKeyboardMarkup,
+                                 InlineKeyboardMarkup] = None) -> 'Message':
         """Edit this message"""
-        return self.client.edit_message(self.chat.id, self.message_id, text, parse_mode, reply_markup)
-        
+        return self.client.edit_message(
+            self.chat.id,
+            self.message_id,
+            text,
+            parse_mode,
+            reply_markup)
+
     def delete(self) -> bool:
         """Delete this message"""
         return self.client.delete_message(self.chat.id, self.message_id)
-        
-    def reply_message(self, text: str, parse_mode: Optional[str] = None, 
-                    reply_markup: Union[MenuKeyboardMarkup,InlineKeyboardMarkup] = None) -> 'Message':
+
+    def reply_message(self,
+                      text: str,
+                      parse_mode: Optional[str] = None,
+                      reply_markup: Union[MenuKeyboardMarkup,
+                                          InlineKeyboardMarkup] = None) -> 'Message':
         """Send a message to this user"""
-        return self.client.send_message(self.chat.id, text, parse_mode, reply_markup,reply_to_message=self)
-        
-    def reply_photo(self, photo: Union[str, bytes, InputFile],
-                  caption: Optional[str] = None,
-                  parse_mode: Optional[str] = None,
-                  reply_markup: Union[MenuKeyboardMarkup,InlineKeyboardMarkup] = None) -> 'Message':
+        return self.client.send_message(
+            self.chat.id,
+            text,
+            parse_mode,
+            reply_markup,
+            reply_to_message=self)
+
+    def reply_photo(self,
+                    photo: Union[str,
+                                 bytes,
+                                 InputFile],
+                    caption: Optional[str] = None,
+                    parse_mode: Optional[str] = None,
+                    reply_markup: Union[MenuKeyboardMarkup,
+                                        InlineKeyboardMarkup] = None) -> 'Message':
         """Send a photo to a chat"""
-        return self.client.send_photo(self.chat.id, photo, caption, parse_mode, reply_markup,reply_to_message=self)
-    
-    
-    def reply_audio(self, audio: Union[str, bytes, InputFile],
-                      caption: Optional[str] = None,
-                      parse_mode: Optional[str] = None,
-                      reply_markup: Union[MenuKeyboardMarkup,InlineKeyboardMarkup] = None) -> 'Message':
-            """Send an audio file to this user"""
-            self.client.send_audio(self.chat.id, audio, caption, parse_mode, reply_markup, reply_to_message=self)
-    
-    def reply_document(self, document: Union[str, bytes, InputFile],
-                         caption: Optional[str] = None,
-                         parse_mode: Optional[str] = None,
-                         reply_markup: Union[MenuKeyboardMarkup,InlineKeyboardMarkup] = None) -> 'Message':
-            """Send a document to this user"""
-            self.client.send_document(self.chat.id, document, caption, parse_mode, reply_markup, reply_markup, reply_to_message=self)
-    
-    def reply_video(self, video: Union[str, bytes, InputFile],
-                      caption: Optional[str] = None,
-                      parse_mode: Optional[str] = None,
-                      reply_markup: Union[MenuKeyboardMarkup,InlineKeyboardMarkup] = None) -> 'Message':
-            """Send a video to this user"""
-            self.client.send_video(self.chat.id,video,caption,parse_mode,reply_markup, reply_to_message=self)
-    
-    def reply_animation(self, animation: Union[str, bytes, InputFile],
-                          caption: Optional[str] = None,
-                          parse_mode: Optional[str] = None,
-                          reply_markup: Union[MenuKeyboardMarkup,InlineKeyboardMarkup] = None) -> 'Message':
-            """Send an animation to this user"""
-            return self.client.send_animation(self.chat.id,animation,caption,parse_mode,reply_markup, reply_to_message=self)
-    
-    def reply_voice(self, voice: Union[str, bytes, InputFile],
+        return self.client.send_photo(
+            self.chat.id,
+            photo,
+            caption,
+            parse_mode,
+            reply_markup,
+            reply_to_message=self)
+
+    def reply_audio(self,
+                    audio: Union[str,
+                                 bytes,
+                                 InputFile],
+                    caption: Optional[str] = None,
+                    parse_mode: Optional[str] = None,
+                    reply_markup: Union[MenuKeyboardMarkup,
+                                        InlineKeyboardMarkup] = None) -> 'Message':
+        """Send an audio file to this user"""
+        self.client.send_audio(
+            self.chat.id,
+            audio,
+            caption,
+            parse_mode,
+            reply_markup,
+            reply_to_message=self)
+
+    def reply_document(self,
+                       document: Union[str,
+                                       bytes,
+                                       InputFile],
+                       caption: Optional[str] = None,
+                       parse_mode: Optional[str] = None,
+                       reply_markup: Union[MenuKeyboardMarkup,
+                                           InlineKeyboardMarkup] = None) -> 'Message':
+        """Send a document to this user"""
+        self.client.send_document(
+            self.chat.id,
+            document,
+            caption,
+            parse_mode,
+            reply_markup,
+            reply_markup,
+            reply_to_message=self)
+
+    def reply_video(self,
+                    video: Union[str,
+                                 bytes,
+                                 InputFile],
                     caption: Optional[str] = None,
                     parse_mode: Optional[str] = None,
-                    reply_markup: Union[MenuKeyboardMarkup,InlineKeyboardMarkup] = None) -> 'Message':        
+                    reply_markup: Union[MenuKeyboardMarkup,
+                                        InlineKeyboardMarkup] = None) -> 'Message':
+        """Send a video to this user"""
+        self.client.send_video(
+            self.chat.id,
+            video,
+            caption,
+            parse_mode,
+            reply_markup,
+            reply_to_message=self)
+
+    def reply_animation(self,
+                        animation: Union[str,
+                                         bytes,
+                                         InputFile],
+                        caption: Optional[str] = None,
+                        parse_mode: Optional[str] = None,
+                        reply_markup: Union[MenuKeyboardMarkup,
+                                            InlineKeyboardMarkup] = None) -> 'Message':
+        """Send an animation to this user"""
+        return self.client.send_animation(
+            self.chat.id,
+            animation,
+            caption,
+            parse_mode,
+            reply_markup,
+            reply_to_message=self)
+
+    def reply_voice(self,
+                    voice: Union[str,
+                                 bytes,
+                                 InputFile],
+                    caption: Optional[str] = None,
+                    parse_mode: Optional[str] = None,
+                    reply_markup: Union[MenuKeyboardMarkup,
+                                        InlineKeyboardMarkup] = None) -> 'Message':
         """Send a voice message to this user"""
-        return self.client.send_voice(self.chat.id,voice,caption,parse_mode,reply_markup, reply_to_message=self)
-    
-    def reply_media_group(self, media: List[Dict],
-                            reply_to_message: Union['Message', int, str] = None) -> List['Message']:
-            """Send a group of photos, videos, documents or audios as an album"""
-            return self.client.send_media_group(self.chat.id, media, reply_to_message=self)
-        
-    
-    def reply_location(self, latitude: float, longitude: float,
-                         reply_markup: Union[MenuKeyboardMarkup,InlineKeyboardMarkup] = None) -> 'Message':
-            """Send a location to this user"""
-            return self.client.send_location(self.chat.id,latitude,longitude,reply_markup, reply_to_message=self)
-    
-    def reply_contact(self, phone_number: str, first_name: str,last_name: Optional[str] = None,reply_markup: Union[MenuKeyboardMarkup,InlineKeyboardMarkup] = None, reply_to_message: Union[str,int,'Message'] = None) -> 'Message':
-            """Send a contact to this user"""
-            return self.client.send_contact(self.chat.id,phone_number,first_name,last_name,reply_markup,reply_to_message)
-    
-    def reply_invoice(self,title:str,description:str,payload:str,provider_token:str,prices:list,photo_url: Optional[str] = None, reply_markup: Union[MenuKeyboardMarkup|InlineKeyboardMarkup] = None):
-        return self.client.send_invoice(self.chat.id,title,description,payload,provider_token,prices,photo_url,self,reply_markup)
+        return self.client.send_voice(
+            self.chat.id,
+            voice,
+            caption,
+            parse_mode,
+            reply_markup,
+            reply_to_message=self)
+
+    def reply_media_group(self,
+                          media: List[Dict],
+                          reply_to_message: Union['Message',
+                                                  int,
+                                                  str] = None) -> List['Message']:
+        """Send a group of photos, videos, documents or audios as an album"""
+        return self.client.send_media_group(
+            self.chat.id, media, reply_to_message=self)
+
+    def reply_location(self,
+                       latitude: float,
+                       longitude: float,
+                       reply_markup: Union[MenuKeyboardMarkup,
+                                           InlineKeyboardMarkup] = None) -> 'Message':
+        """Send a location to this user"""
+        return self.client.send_location(
+            self.chat.id,
+            latitude,
+            longitude,
+            reply_markup,
+            reply_to_message=self)
+
+    def reply_contact(self,
+                      phone_number: str,
+                      first_name: str,
+                      last_name: Optional[str] = None,
+                      reply_markup: Union[MenuKeyboardMarkup,
+                                          InlineKeyboardMarkup] = None,
+                      reply_to_message: Union[str,
+                                              int,
+                                              'Message'] = None) -> 'Message':
+        """Send a contact to this user"""
+        return self.client.send_contact(
+            self.chat.id,
+            phone_number,
+            first_name,
+            last_name,
+            reply_markup,
+            reply_to_message)
+
+    def reply_invoice(self,
+                      title: str,
+                      description: str,
+                      payload: str,
+                      provider_token: str,
+                      prices: list,
+                      photo_url: Optional[str] = None,
+                      reply_markup: Union[MenuKeyboardMarkup | InlineKeyboardMarkup] = None):
+        return self.client.send_invoice(
+            self.chat.id,
+            title,
+            description,
+            payload,
+            provider_token,
+            prices,
+            photo_url,
+            self,
+            reply_markup)
+
 
 class Client:
     """Main client class for interacting with Bale API"""
-    def __init__(self, token: str, session: str = 'https://tapi.bale.ai', database_name='database.db'):
+
+    def __init__(
+            self,
+            token: str,
+            session: str = 'https://tapi.bale.ai',
+            database_name='database.db',
+            auto_log_start_message: bool = True,
+    ):
         self.token = token
         self.session = session
         self.states = {}
         self.database_name = database_name
+        self.auto_log_start_message = auto_log_start_message
         self._base_url = f"{session}/bot{token}"
         self._session = requests.Session()
         self._message_handler = None
+        self._message_edit_handler = None
+        self._callback_handler = None
+        self._member_leave_handler = None
+        self._member_join_handler = None
         self._threads = []
-    
-    def set_state(self, chat_or_user_id: Union[Chat,User,int,str], state: str) -> None:
+
+    def set_state(self,
+                  chat_or_user_id: Union[Chat,
+                                         User,
+                                         int,
+                                         str],
+                  state: str) -> None:
         """Set the state for a chat or user"""
         if isinstance(chat_or_user_id, (Chat, User)):
             chat_or_user_id = chat_or_user_id.id
         self.states[str(chat_or_user_id)] = state
-    
-    def get_state(self, chat_or_user_id: Union[Chat,User,int,str]) -> str|None:
+
+    def get_state(self,
+                  chat_or_user_id: Union[Chat,
+                                         User,
+                                         int,
+                                         str]) -> str | None:
         """Get the state for a chat or user"""
         if isinstance(chat_or_user_id, (Chat, User)):
             chat_or_user_id = chat_or_user_id.id
         return self.states.get(str(chat_or_user_id))
-    
-    def del_state(self, chat_or_user_id: Union[Chat,User,int,str]) -> None:
+
+    def del_state(self, chat_or_user_id: Union[Chat, User, int, str]) -> None:
         """Delete the state for a chat or user"""
         if isinstance(chat_or_user_id, (Chat, User)):
             chat_or_user_id = chat_or_user_id.id
         self.states.pop(str(chat_or_user_id), None)
-    
+
     @property
     def database(self) -> DataBase:
         """Get the database name"""
-        return DataBase(self.database_name)
-    
-    
+        db = DataBase(self.database_name)
+        return db
+
     def get_chat(self, chat_id: int) -> Optional[Dict]:
         """Get chat information from database"""
         conn = sqlite3.connect(self.database)
@@ -882,39 +1580,29 @@ class Client:
             }
         return None
 
-        
-    def _make_request(self, method: str, endpoint: str, **kwargs) -> Dict[str, Any]:
+    def _make_request(self, method: str, endpoint: str,
+                      **kwargs) -> Dict[str, Any]:
         """Make an HTTP request to Bale API"""
         url = f"{self._base_url}/{endpoint}"
         response = self._session.request(method, url, **kwargs)
         response_data = response.json()
         if not response_data.get('ok'):
-            raise BaleException(response_data['error_code'], response_data['description'])
+            raise BaleException(
+                response_data['error_code'],
+                response_data['description'])
         return response_data
-        
+
     def __del__(self):
         if hasattr(self, '_session'):
             self._session.close()
-            
+
     def get_me(self) -> User:
         """Get information about the bot"""
         data = self._make_request('GET', 'getMe')
         return User(self, data)
-        
-    def get_updates(self, offset: Optional[int] = None, 
-                   limit: Optional[int] = None,
-                   timeout: Optional[int] = None) -> List[Dict[str, Any]]:
-        """Get latest updates/messages"""
-        params = {
-            'offset': offset,
-            'limit': limit,
-            'timeout': timeout
-        }
-        response = self._make_request('GET', 'getUpdates', params=params)
-        return response.get('result', [])
-        
+
     def set_webhook(self, url: str, certificate: Optional[str] = None,
-                   max_connections: Optional[int] = None) -> bool:
+                    max_connections: Optional[int] = None) -> bool:
         """Set webhook for getting updates"""
         data = {
             'url': url,
@@ -922,33 +1610,39 @@ class Client:
             'max_connections': max_connections
         }
         return self._make_request('POST', 'setWebhook', json=data)
-        
+
     def get_webhook_info(self) -> Dict[str, Any]:
         """Get current webhook status"""
         return self._make_request('GET', 'getWebhookInfo')
-        
-    def send_message(self, chat_id: Union[int, str], text: str,
-                parse_mode: Optional[str] = None,
-                reply_markup: Union[MenuKeyboardMarkup,InlineKeyboardMarkup] = None,
-                reply_to_message: Union[Message,int,str] = None) -> Message:
+
+    def send_message(self,
+                     chat_id: Union[int,
+                                    str],
+                     text: str,
+                     parse_mode: Optional[str] = None,
+                     reply_markup: Union[MenuKeyboardMarkup,
+                                         InlineKeyboardMarkup] = None,
+                     reply_to_message: Union[Message,
+                                             int,
+                                             str] = None) -> Message:
         """Send a message to a chat"""
-        # Convert text to string if it isn't already
+
         text = str(text)
-        
+
         data = {
             'chat_id': chat_id,
             'text': text,
             'parse_mode': parse_mode,
             'reply_markup': reply_markup.keyboard if reply_markup else None,
-            'reply_to_message_id': reply_to_message.message_id if isinstance(reply_to_message, Message) else reply_to_message
-        }
+            'reply_to_message_id': reply_to_message.message_id if isinstance(
+                reply_to_message,
+                Message) else reply_to_message}
         response = self._make_request('POST', 'sendMessage', json=data)
         return Message(self, response)
 
-        
     def forward_message(self, chat_id: Union[int, str],
-                       from_chat_id: Union[int, str],
-                       message_id: int) -> Message:
+                        from_chat_id: Union[int, str],
+                        message_id: int) -> Message:
         """Forward a message from one chat to another"""
         data = {
             'chat_id': chat_id,
@@ -957,12 +1651,20 @@ class Client:
         }
         response = self._make_request('POST', 'forwardMessage', json=data)
         return Message(self, response)
-        
-    def send_photo(self, chat_id: Union[int, str], photo: Union[str, bytes, InputFile],
-                  caption: Optional[str] = None,
-                  parse_mode: Optional[str] = None,
-                  reply_markup: Union[MenuKeyboardMarkup,InlineKeyboardMarkup] = None,
-                  reply_to_message: Union[Message, int, str] = None) -> Message:
+
+    def send_photo(self,
+                   chat_id: Union[int,
+                                  str],
+                   photo: Union[str,
+                                bytes,
+                                InputFile],
+                   caption: Optional[str] = None,
+                   parse_mode: Optional[str] = None,
+                   reply_markup: Union[MenuKeyboardMarkup,
+                                       InlineKeyboardMarkup] = None,
+                   reply_to_message: Union[Message,
+                                           int,
+                                           str] = None) -> Message:
         """Send a photo to a chat"""
         files = None
         data = {
@@ -970,35 +1672,43 @@ class Client:
             'caption': caption,
             'parse_mode': parse_mode,
             'reply_markup': reply_markup.keyboard if reply_markup else None,
-            'reply_to_message_id': reply_to_message.message_id if isinstance(reply_to_message, Message) else reply_to_message
-        }
-        
+            'reply_to_message_id': reply_to_message.message_id if isinstance(
+                reply_to_message,
+                Message) else reply_to_message}
+
         if isinstance(photo, (bytes, InputFile)) or hasattr(photo, 'read'):
-            files = {'photo': photo if not isinstance(photo, InputFile) else photo.file}
+            files = {
+                'photo': photo if not isinstance(
+                    photo, InputFile) else photo.file}
         else:
             data['photo'] = photo
-            
-        response = self._make_request('POST', 'sendPhoto', data=data, files=files)
+
+        response = self._make_request(
+            'POST', 'sendPhoto', data=data, files=files)
         return Message(self, response)
-        
+
     def delete_message(self, chat_id: Union[int, str],
-                      message_id: int) -> bool:
+                       message_id: int) -> bool:
         """Delete a message from a chat"""
         data = {
             'chat_id': chat_id,
             'message_id': message_id
         }
-        return self._make_request('POST', 'deleteMessage', json=data) 
-        
+        return self._make_request('POST', 'deleteMessage', json=data)
+
     def get_user(self, user_id: Union[int, str]) -> User:
         """Get information about a user"""
         data = self._make_request('POST', 'getChat', json={'chat_id': user_id})
         return User(self, data)
-        
-    def edit_message(self, chat_id: Union[int, str],
-                    message_id: int, text: str,
-                    parse_mode: Optional[str] = None,
-                    reply_markup: Union[MenuKeyboardMarkup,InlineKeyboardMarkup] = None) -> Message:
+
+    def edit_message(self,
+                     chat_id: Union[int,
+                                    str],
+                     message_id: int,
+                     text: str,
+                     parse_mode: Optional[str] = None,
+                     reply_markup: Union[MenuKeyboardMarkup,
+                                         InlineKeyboardMarkup] = None) -> Message:
         """Edit a message in a chat"""
         data = {
             'chat_id': chat_id,
@@ -1009,17 +1719,23 @@ class Client:
         }
         response = self._make_request('POST', 'editMessageText', json=data)
         return Message(self, response)
-        
+
     def get_chat(self, chat_id: Union[int, str]) -> Chat:
         """Get information about a chat"""
         data = self._make_request('POST', 'getChat', json={'chat_id': chat_id})
         return Chat(self, data)
-    
-    def send_audio(self, chat_id: Union[int, str], audio,
-                  caption: Optional[str] = None,
-                  parse_mode: Optional[str] = None,
-                  reply_markup: Union[MenuKeyboardMarkup,InlineKeyboardMarkup] = None,
-                  reply_to_message: Union[Message, int, str] = None) -> Message:
+
+    def send_audio(self,
+                   chat_id: Union[int,
+                                  str],
+                   audio,
+                   caption: Optional[str] = None,
+                   parse_mode: Optional[str] = None,
+                   reply_markup: Union[MenuKeyboardMarkup,
+                                       InlineKeyboardMarkup] = None,
+                   reply_to_message: Union[Message,
+                                           int,
+                                           str] = None) -> Message:
         """Send an audio file"""
         files = None
         data = {
@@ -1027,21 +1743,31 @@ class Client:
             'caption': caption,
             'parse_mode': parse_mode,
             'reply_markup': reply_markup.keyboard if reply_markup else None,
-            'reply_to_message_id': reply_to_message.message_id if isinstance(reply_to_message, Message) else reply_to_message
-        }
+            'reply_to_message_id': reply_to_message.message_id if isinstance(
+                reply_to_message,
+                Message) else reply_to_message}
         if isinstance(audio, (bytes, InputFile)) or hasattr(audio, 'read'):
-            files = {'audio': audio if not isinstance(audio, InputFile) else audio.file}
+            files = {
+                'audio': audio if not isinstance(
+                    audio, InputFile) else audio.file}
         else:
             data['audio'] = audio
-                            
-        response = self._make_request('POST', 'sendAudio', data=data, files=files)
+
+        response = self._make_request(
+            'POST', 'sendAudio', data=data, files=files)
         return Message(self, response)
-            
-    def send_document(self, chat_id: Union[int, str], document,
-                        caption: Optional[str] = None,
-                        parse_mode: Optional[str] = None,
-                        reply_markup: Union[MenuKeyboardMarkup,InlineKeyboardMarkup] = None,
-                        reply_to_message: Union[Message, int, str] = None) -> Message:
+
+    def send_document(self,
+                      chat_id: Union[int,
+                                     str],
+                      document,
+                      caption: Optional[str] = None,
+                      parse_mode: Optional[str] = None,
+                      reply_markup: Union[MenuKeyboardMarkup,
+                                          InlineKeyboardMarkup] = None,
+                      reply_to_message: Union[Message,
+                                              int,
+                                              str] = None) -> Message:
         """Send a document"""
         files = None
         data = {
@@ -1049,131 +1775,196 @@ class Client:
             'caption': caption,
             'parse_mode': parse_mode,
             'reply_markup': reply_markup.keyboard if reply_markup else None,
-            'reply_to_message_id': reply_to_message.message_id if isinstance(reply_to_message, Message) else reply_to_message
-            }
-            
-        if isinstance(document, (bytes, InputFile)) or hasattr(document, 'read'):
-            files = {'document': document if not isinstance(document, InputFile) else document.file}
+            'reply_to_message_id': reply_to_message.message_id if isinstance(
+                reply_to_message,
+                Message) else reply_to_message}
+
+        if isinstance(
+                document, (bytes, InputFile)) or hasattr(
+                document, 'read'):
+            files = {'document': document if not isinstance(
+                document, InputFile) else document.file}
         else:
             data['document'] = document
-                
-        response = self._make_request('POST', 'sendDocument', data=data, files=files)
+
+        response = self._make_request(
+            'POST', 'sendDocument', data=data, files=files)
         return Message(self, response)
-            
-    def send_video(self, chat_id: Union[int, str], video,
-                       caption: Optional[str] = None,
-                       parse_mode: Optional[str] = None,
-                       reply_markup: Union[MenuKeyboardMarkup,InlineKeyboardMarkup] = None,
-                       reply_to_message: Union[Message, int, str] = None) -> Message:
-            """Send a video"""
-            files = None
-            data = {
-                'chat_id': chat_id,
-                'caption': caption,
-                'parse_mode': parse_mode,
-                'reply_markup': reply_markup.keyboard if reply_markup else None,
-                'reply_to_message_id': reply_to_message.message_id if isinstance(reply_to_message, Message) else reply_to_message
-            }
-            
-            if isinstance(video, (bytes, InputFile)) or hasattr(video, 'read'):
-                files = {'video': video if not isinstance(video, InputFile) else video.file}
-            else:
-                data['video'] = video
-                
-            response = self._make_request('POST', 'sendVideo', data=data, files=files)
-            return Message(self, response)
-            
-    def send_animation(self, chat_id: Union[int, str], animation,
-                          caption: Optional[str] = None,
-                          parse_mode: Optional[str] = None,
-                          reply_markup: Union[MenuKeyboardMarkup,InlineKeyboardMarkup] = None,
-                          reply_to_message: Union[Message, int, str] = None) -> Message:
-            """Send an animation (GIF or H.264/MPEG-4 AVC video without sound)"""
-            files = None
-            data = {
-                'chat_id': chat_id,
-                'caption': caption,
-                'parse_mode': parse_mode,
-                'reply_markup': reply_markup.keyboard if reply_markup else None,
-                'reply_to_message_id': reply_to_message.message_id if isinstance(reply_to_message, Message) else reply_to_message
-            }
-            
-            if isinstance(animation, (bytes, InputFile)) or hasattr(animation, 'read'):
-                files = {'animation': animation if not isinstance(animation, InputFile) else animation.file}
-            else:
-                data['animation'] = animation
-                
-            response = self._make_request('POST', 'sendAnimation', data=data, files=files)
-            return Message(self, response)
-            
-    def send_voice(self, chat_id: Union[int, str], voice,
+
+    def send_video(self,
+                   chat_id: Union[int,
+                                  str],
+                   video,
+                   caption: Optional[str] = None,
+                   parse_mode: Optional[str] = None,
+                   reply_markup: Union[MenuKeyboardMarkup,
+                                       InlineKeyboardMarkup] = None,
+                   reply_to_message: Union[Message,
+                                           int,
+                                           str] = None) -> Message:
+        """Send a video"""
+        files = None
+        data = {
+            'chat_id': chat_id,
+            'caption': caption,
+            'parse_mode': parse_mode,
+            'reply_markup': reply_markup.keyboard if reply_markup else None,
+            'reply_to_message_id': reply_to_message.message_id if isinstance(
+                reply_to_message,
+                Message) else reply_to_message}
+
+        if isinstance(video, (bytes, InputFile)) or hasattr(video, 'read'):
+            files = {
+                'video': video if not isinstance(
+                    video, InputFile) else video.file}
+        else:
+            data['video'] = video
+
+        response = self._make_request(
+            'POST', 'sendVideo', data=data, files=files)
+        return Message(self, response)
+
+    def send_animation(self,
+                       chat_id: Union[int,
+                                      str],
+                       animation,
                        caption: Optional[str] = None,
                        parse_mode: Optional[str] = None,
-                       reply_markup: Union[MenuKeyboardMarkup,InlineKeyboardMarkup] = None,
-                       reply_to_message: Union[Message, int, str] = None) -> Message:
-            """Send a voice message"""
-            files = None
-            data = {
-                'chat_id': chat_id,
-                'caption': caption,
-                'parse_mode': parse_mode,
-                'reply_markup': reply_markup.keyboard if reply_markup else None,
-                'reply_to_message_id': reply_to_message.message_id if isinstance(reply_to_message, Message) else reply_to_message
-            }
-            
-            if isinstance(voice, (bytes, InputFile)) or hasattr(voice, 'read'):
-                files = {'voice': voice if not isinstance(voice, InputFile) else voice.file}
-            else:
-                data['voice'] = voice
-                
-            response = self._make_request('POST', 'sendVoice', data=data, files=files)
-            return Message(self, response)
-            
-    def send_media_group(self, chat_id: Union[int, str],
-                            media: List[Dict],
-                            reply_to_message: Union[Message, int, str] = None) -> List[Message]:
-            """Send a group of photos, videos, documents or audios as an album"""
-            data = {
-                'chat_id': chat_id,
-                'media': media,
-                'reply_to_message_id': reply_to_message.message_id if isinstance(reply_to_message, Message) else reply_to_message
-            }
-            response = self._make_request('POST', 'sendMediaGroup', json=data)
-            return [Message(self, msg) for msg in response]
-            
-    def send_location(self, chat_id: Union[int, str],
-                         latitude: float, longitude: float,
-                         reply_markup: Union[MenuKeyboardMarkup,InlineKeyboardMarkup] = None,
-                         reply_to_message: Union[Message, int, str] = None) -> Message:
-            """Send a point on the map"""
-            data = {
-                'chat_id': chat_id,
-                'latitude': latitude,
-                'longitude': longitude,
-                'reply_markup': reply_markup.keyboard if reply_markup else None,
-                'reply_to_message_id': reply_to_message.message_id if isinstance(reply_to_message, Message) else reply_to_message
-            }
-            response = self._make_request('POST', 'sendLocation', json=data)
-            return Message(self, response)
-            
-    def send_contact(self, chat_id: Union[int, str],
-                        phone_number: str, first_name: str,
-                        last_name: Optional[str] = None,
-                        reply_markup: Union[MenuKeyboardMarkup,InlineKeyboardMarkup] = None,
-                        reply_to_message: Union[Message, int, str] = None) -> Message:
-            """Send a phone contact"""
-            data = {
-                'chat_id': chat_id,
-                'phone_number': phone_number,
-                'first_name': first_name,
-                'last_name': last_name,
-                'reply_markup': reply_markup.keyboard if reply_markup else None,
-                'reply_to_message_id': reply_to_message.message_id if isinstance(reply_to_message, Message) else reply_to_message
-            }
-            response = self._make_request('POST', 'sendContact', json=data)
-            return Message(self, response)
-    
-    def send_invoice(self,chat_id: Union[int,str],title:str,description:str,payload:str,provider_token:str,prices:list,photo_url: Optional[str] = None,reply_to_message: Union[int|str|Message] = None, reply_markup: Union[MenuKeyboardMarkup|InlineKeyboardMarkup] = None) -> Message:
+                       reply_markup: Union[MenuKeyboardMarkup,
+                                           InlineKeyboardMarkup] = None,
+                       reply_to_message: Union[Message,
+                                               int,
+                                               str] = None) -> Message:
+        """Send an animation (GIF or H.264/MPEG-4 AVC video without sound)"""
+        files = None
+        data = {
+            'chat_id': chat_id,
+            'caption': caption,
+            'parse_mode': parse_mode,
+            'reply_markup': reply_markup.keyboard if reply_markup else None,
+            'reply_to_message_id': reply_to_message.message_id if isinstance(
+                reply_to_message,
+                Message) else reply_to_message}
+
+        if isinstance(
+                animation, (bytes, InputFile)) or hasattr(
+                animation, 'read'):
+            files = {'animation': animation if not isinstance(
+                animation, InputFile) else animation.file}
+        else:
+            data['animation'] = animation
+
+        response = self._make_request(
+            'POST', 'sendAnimation', data=data, files=files)
+        return Message(self, response)
+
+    def send_voice(self,
+                   chat_id: Union[int,
+                                  str],
+                   voice,
+                   caption: Optional[str] = None,
+                   parse_mode: Optional[str] = None,
+                   reply_markup: Union[MenuKeyboardMarkup,
+                                       InlineKeyboardMarkup] = None,
+                   reply_to_message: Union[Message,
+                                           int,
+                                           str] = None) -> Message:
+        """Send a voice message"""
+        files = None
+        data = {
+            'chat_id': chat_id,
+            'caption': caption,
+            'parse_mode': parse_mode,
+            'reply_markup': reply_markup.keyboard if reply_markup else None,
+            'reply_to_message_id': reply_to_message.message_id if isinstance(
+                reply_to_message,
+                Message) else reply_to_message}
+
+        if isinstance(voice, (bytes, InputFile)) or hasattr(voice, 'read'):
+            files = {
+                'voice': voice if not isinstance(
+                    voice, InputFile) else voice.file}
+        else:
+            data['voice'] = voice
+
+        response = self._make_request(
+            'POST', 'sendVoice', data=data, files=files)
+        return Message(self, response)
+
+    def send_media_group(self,
+                         chat_id: Union[int,
+                                        str],
+                         media: List[Dict],
+                         reply_to_message: Union[Message,
+                                                 int,
+                                                 str] = None) -> List[Message]:
+        """Send a group of photos, videos, documents or audios as an album"""
+        data = {
+            'chat_id': chat_id,
+            'media': media,
+            'reply_to_message_id': reply_to_message.message_id if isinstance(
+                reply_to_message,
+                Message) else reply_to_message}
+        response = self._make_request('POST', 'sendMediaGroup', json=data)
+        return [Message(self, msg) for msg in response]
+
+    def send_location(self,
+                      chat_id: Union[int,
+                                     str],
+                      latitude: float,
+                      longitude: float,
+                      reply_markup: Union[MenuKeyboardMarkup,
+                                          InlineKeyboardMarkup] = None,
+                      reply_to_message: Union[Message,
+                                              int,
+                                              str] = None) -> Message:
+        """Send a point on the map"""
+        data = {
+            'chat_id': chat_id,
+            'latitude': latitude,
+            'longitude': longitude,
+            'reply_markup': reply_markup.keyboard if reply_markup else None,
+            'reply_to_message_id': reply_to_message.message_id if isinstance(
+                reply_to_message,
+                Message) else reply_to_message}
+        response = self._make_request('POST', 'sendLocation', json=data)
+        return Message(self, response)
+
+    def send_contact(self,
+                     chat_id: Union[int,
+                                    str],
+                     phone_number: str,
+                     first_name: str,
+                     last_name: Optional[str] = None,
+                     reply_markup: Union[MenuKeyboardMarkup,
+                                         InlineKeyboardMarkup] = None,
+                     reply_to_message: Union[Message,
+                                             int,
+                                             str] = None) -> Message:
+        """Send a phone contact"""
+        data = {
+            'chat_id': chat_id,
+            'phone_number': phone_number,
+            'first_name': first_name,
+            'last_name': last_name,
+            'reply_markup': reply_markup.keyboard if reply_markup else None,
+            'reply_to_message_id': reply_to_message.message_id if isinstance(
+                reply_to_message,
+                Message) else reply_to_message}
+        response = self._make_request('POST', 'sendContact', json=data)
+        return Message(self, response)
+
+    def send_invoice(self,
+                     chat_id: Union[int,
+                                    str],
+                     title: str,
+                     description: str,
+                     payload: str,
+                     provider_token: str,
+                     prices: list,
+                     photo_url: Optional[str] = None,
+                     reply_to_message: Union[int | str | Message] = None,
+                     reply_markup: Union[MenuKeyboardMarkup | InlineKeyboardMarkup] = None) -> Message:
         """Send a invoice"""
         r = []
         for x in prices:
@@ -1187,54 +1978,88 @@ class Client:
             'provider_token': provider_token,
             'prices': prices,
             'photo_url': photo_url,
-            'reply_to_message_id': reply_to_message.message_id if isinstance(reply_to_message, Message) else reply_to_message,
-            'reply_markup': reply_markup.keyboard if reply_markup else None
-        }
+            'reply_to_message_id': reply_to_message.message_id if isinstance(
+                reply_to_message,
+                Message) else reply_to_message,
+            'reply_markup': reply_markup.keyboard if reply_markup else None}
         response = self._make_request('POST', 'sendInvoice', json=data)
         return Message(self, response)
     
-    def copy_message(self, chat_id: Union[int,str,'Chat'], from_chat_id: Union[int,str,'Chat'], message_id: Union[int,str,'Chat']):
+    def send_chat_action(self, chat: Union[int, str, 'Chat'], action: str, how_many_times: int = 1) -> bool:
+        """Send a chat action"""
+        if not chat:
+            raise ValueError("Chat ID cannot be empty")
+            
         data = {
-            'chat_id': chat_id if isinstance(chat_id, (int, str)) else chat_id.id,
-            'from_chat_id': from_chat_id if isinstance(from_chat_id, (int, str)) else from_chat_id.id,
-            'message_id': message_id if isinstance(message_id, (int, str)) else message_id.id
+            'chat_id': str(chat) if isinstance(chat, (int, str)) else str(chat.id),
+            'action': action
         }
+        res = []
+        for _ in range(how_many_times):
+            response = self._make_request('POST', 'sendChatAction', json=data)
+            res.append(response.get('ok', False))
+        return all(res)
+
+    def copy_message(self,
+                     chat_id: Union[int,
+                                    str,
+                                    'Chat'],
+                     from_chat_id: Union[int,
+                                         str,
+                                         'Chat'],
+                     message_id: Union[int,
+                                       str,
+                                       'Chat']):
+        data = {
+            'chat_id': chat_id if isinstance(
+                chat_id, (int, str)) else chat_id.id, 'from_chat_id': from_chat_id if isinstance(
+                from_chat_id, (int, str)) else from_chat_id.id, 'message_id': message_id if isinstance(
+                message_id, (int, str)) else message_id.id}
         response = self._make_request('POST', 'copyMessage', json=data)
         return Message(self, response)
-    
-    def get_chat_member(self, chat: Union[int,str,'Chat'], user: Union[int,str,'User']) -> ChatMember:
-            """Get information about a member of a chat including their permissions"""
-            data = {
-                'chat_id': chat if isinstance(chat, (int, str)) else chat.id,
-                'user_id': user if isinstance(user, (int, str)) else user.id
-            }
-            response = self._make_request('POST', 'getChatMember', json=data)
-            return ChatMember(self, response['result'])
 
-    def get_chat_administrators(self, chat: Union[int,str,'Chat']) -> List[ChatMember]:
+    def get_chat_member(self,
+                        chat: Union[int,
+                                    str,
+                                    'Chat'],
+                        user: Union[int,
+                                    str,
+                                    'User']) -> ChatMember:
+        """Get information about a member of a chat including their permissions"""
+        data = {
+            'chat_id': chat if isinstance(chat, (int, str)) else chat.id,
+            'user_id': user if isinstance(user, (int, str)) else user.id
+        }
+        response = self._make_request('POST', 'getChatMember', json=data)
+        return ChatMember(self, response['result'])
+
+    def get_chat_administrators(
+            self, chat: Union[int, str, 'Chat']) -> List[ChatMember]:
         """Get a list of administrators in a chat"""
         data = {'chat_id': getattr(chat, 'id', chat)}
-        response = self._make_request('POST', 'getChatAdministrators', json=data)
-        return [ChatMember(self, member) for member in response.get('result', [])]
-    
-    def get_chat_members_count(self, chat: Union[int,str,'Chat']) -> int:
-            """Get the number of members in a chat"""
-            data = {
-                'chat_id': chat if isinstance(chat, (int, str)) else chat.id
-            }
-            response = self._make_request('GET', 'getChatMembersCount', json=data)
-            return response['result']
-    
-    def is_joined(self, user: Union[User,int,str], chat: Union[Chat,int,str]) -> bool:
-            """Check if user is a member of the chat"""
-            data = {
-                'chat_id': chat if isinstance(chat, (int, str)) else chat.id,
-                'user_id': user if isinstance(user, (int, str)) else user.id
-            }
-            response = self._make_request('GET', 'getChatMember', json=data)
-            return response.get('status') not in ['left', 'kicked']
-    
-    
+        response = self._make_request(
+            'POST', 'getChatAdministrators', json=data)
+        return [ChatMember(self, member)
+                for member in response.get('result', [])]
+
+    def get_chat_members_count(self, chat: Union[int, str, 'Chat']) -> int:
+        """Get the number of members in a chat"""
+        data = {
+            'chat_id': chat if isinstance(chat, (int, str)) else chat.id
+        }
+        response = self._make_request('GET', 'getChatMembersCount', json=data)
+        return response['result']
+
+    def is_joined(self, user: Union[User, int, str],
+                  chat: Union[Chat, int, str]) -> bool:
+        """Check if user is a member of the chat"""
+        data = {
+            'chat_id': chat if isinstance(chat, (int, str)) else chat.id,
+            'user_id': user if isinstance(user, (int, str)) else user.id
+        }
+        response = self._make_request('GET', 'getChatMember', json=data)
+        return response.get('status') not in ['left', 'kicked']
+
     def on_message(self, func):
         """Decorator for handling new messages"""
         self._message_handler = func
@@ -1244,16 +2069,15 @@ class Client:
         """Decorator for handling callback queries"""
         self._callback_handler = func
         return func
-    
+
     def on_tick(self, seconds: int):
         """Decorator for handling periodic events"""
         def decorator(func):
-            if not hasattr(self, '_tick_handlers'):
-                self._tick_handlers = {}
+            self._tick_handlers = getattr(self, '_tick_handlers', {})
             self._tick_handlers[func] = {'interval': seconds, 'last_run': 0}
             return func
         return decorator
-    
+
     def on_close(self, func):
         """Decorator for handling close event"""
         self._close_handler = func
@@ -1283,43 +2107,86 @@ class Client:
         """Decorator for handling edited messages"""
         self._message_edit_handler = func
         return func
-    
+
+    def on_command(self, command: str = None):
+        """Decorator for handling specific text commands"""
+        def decorator(func):
+            self._text_handlers = getattr(self, '_text_handlers', {})
+            cmd = f"/{func.__name__}" if command is None else f"/{command.lstrip('/')}"
+            self._text_handlers[cmd] = func
+            return func
+        return decorator
+
     def _create_thread(self, handler, *args):
         """Helper method to create and start a thread"""
-        thread = threading.Thread(target=handler, args=args)
+        thread = threading.Thread(target=handler, args=args, daemon=True)
         thread.start()
         self._threads.append(thread)
-        
+
     def _handle_message(self, message, update):
         """Handle different types of messages"""
-        if 'message' in update and 'new_chat_members' in update['message'] and hasattr(self, '_member_join_handler'):
-            chat = update['message']['chat']
-            user = update['message']['new_chat_members'][0]
-            self._create_thread(self._member_join_handler, message, Chat(self,{"ok":True,"result":chat}), User(self,{"ok":True,"result":user}))
-        elif 'message' in update and 'left_chat_member' in update['message'] and hasattr(self, '_member_leave_handler'):
-            chat = update['message']['chat']
-            user = update['message']['left_chat_member']
-            self._create_thread(self._member_leave_handler, message, Chat(self,{"ok":True,"result":chat}), User(self,{"ok":True,"result":user}))
-        elif self._message_handler:
-            args = (message, update) if len(inspect.signature(self._message_handler).parameters) > 1 else (message,)
+        msg_data = update.get('message', {})
+
+        if 'new_chat_members' in msg_data and hasattr(self, '_member_join_handler'):
+            chat, user = msg_data['chat'], msg_data['new_chat_members'][0]
+            self._create_thread(
+                self._member_join_handler,
+                message,
+                Chat(self, {"ok": True, "result": chat}),
+                User(self, {"ok": True, "result": user})
+            )
+            return
+
+        if 'left_chat_member' in msg_data and hasattr(self, '_member_leave_handler'):
+            chat, user = msg_data['chat'], msg_data['left_chat_member']
+            self._create_thread(
+                self._member_leave_handler,
+                message,
+                Chat(self, {"ok": True, "result": chat}),
+                User(self, {"ok": True, "result": user})
+            )
+            return
+
+        if 'text' in msg_data and hasattr(self, '_text_handlers'):
+            text = msg_data['text']
+            for command, handler in self._text_handlers.items():
+                if text.startswith(command):
+                    conds = conditions(self, message.author, message, None, message.chat)
+                    params = inspect.signature(handler).parameters
+                    args = (message, conds) if len(params) > 1 else (message,)
+                    self._create_thread(handler, *args)
+                    return
+
+        if self._message_handler:
+            conds = conditions(self, message.author, message, None, message.chat)
+            params = inspect.signature(self._message_handler).parameters
+            args = ((message, update, conds) if len(params) > 2 else 
+                   (message, update) if len(params) > 1 else (message,))
             self._create_thread(self._message_handler, *args)
-    
+
     def _handle_update(self, update):
         if hasattr(self, '_update_handler'):
             self._create_thread(self._update_handler, update)
-            
-        if 'message' in update:
-            message = Message(self, {'ok': True, 'result': update['message']})
-            self._handle_message(message, update)
-        elif 'edited_message' in update and hasattr(self, '_message_edit_handler'):
-            edited_message = Message(self, {'ok': True, 'result': update['edited_message']})
-            args = (edited_message, update) if len(inspect.signature(self._message_edit_handler).parameters) > 1 else (edited_message,)
-            self._create_thread(self._message_edit_handler, *args)
-        elif 'callback_query' in update and self._callback_handler:
-            callback_query = CallbackQuery(self, {'ok': True, 'result': update['callback_query']})
-            args = (callback_query, update) if len(inspect.signature(self._callback_handler).parameters) > 1 else (callback_query,)
-            self._create_thread(self._callback_handler, *args)
 
+        # Handle message and edited message
+        message_types = {
+            'message': (Message, self._handle_message),
+            'edited_message': (Message, self._message_edit_handler)
+        }
+
+        for update_type, (cls, handler) in message_types.items():
+            if update_type in update:
+                message = cls(self, {'ok': True, 'result': update[update_type]})
+                handler(message, update)
+                return
+
+        if 'callback_query' in update and self._callback_handler:
+            obj = CallbackQuery(self, {'ok': True, 'result': update['callback_query']})
+            params = inspect.signature(self._callback_handler).parameters
+            conds = conditions(self, obj.author, None, obj, obj.chat)
+            args = (obj, update, conds) if len(params) > 2 else (obj, update)
+            self._create_thread(self._callback_handler, *args)
+            
     def _handle_tick_events(self, current_time):
         """Handle periodic tick events"""
         if hasattr(self, '_tick_handlers'):
@@ -1327,45 +2194,65 @@ class Client:
                 if current_time - info['last_run'] >= info['interval']:
                     self._create_thread(handler)
                     info['last_run'] = current_time
-            
-    def run(self):
-        """Start polling for new messages"""
+
+    def run(self, debug=False):
+        """Start p-olling for new messages"""
+        try:
+            self.get_me()
+        except BaseException:
+            raise BaleTokenNotFoundError("token not found")
+
         self._polling = True
         offset = 0
-        past_updates = []
-        
+        past_updates = set()
+        source_file = inspect.getfile(self.__class__)
+        last_modified = os.path.getmtime(source_file)
+
+        if self.auto_log_start_message:
+            print(f"-+-+-+ [logged in as @{self.get_me().username}] +-+-+-")
         if hasattr(self, '_ready_handler'):
             self._ready_handler()
-            
+
         while self._polling:
             try:
-                updates = self.get_updates(offset=offset)
+                if debug:
+                    current_modified = os.path.getmtime(source_file)
+                    if current_modified > last_modified:
+                        last_modified = current_modified
+                        print("Source file changed, restarting...")
+                        python = sys.executable
+                        os.execl(python, python, *sys.argv)
+                    
+                updates = self.get_updates(offset=offset, timeout=30)
                 for update in updates:
                     update_id = update['update_id']
-                    if update_id not in [u['update_id'] for u in past_updates]:
+                    if update_id not in past_updates:
                         self._handle_update(update)
                         offset = update_id + 1
-                        past_updates.append(update)
-                        if len(past_updates) > 30:
-                            past_updates.pop(0)
-                
-                self._handle_tick_events(time.time())
+                        past_updates.add(update_id)
+                        if len(past_updates) > 100:
+                            past_updates = set(sorted(list(past_updates))[-50:])
+
+                current_time = time.time()
+                self._handle_tick_events(current_time)
                 self._threads = [t for t in self._threads if t.is_alive()]
-                time.sleep(0.5)
-            except Exception as e:
+                time.sleep(0.1)
+            except Exception:
                 print(f"Error in polling: {traceback.format_exc()}")
                 time.sleep(1)
-                continue
 
-    def get_updates(self, offset: Optional[int] = None, 
-                   limit: Optional[int] = None,
+    def _check_source_file_changed(self, source_file, last_modified):
+        try:
+            current_mtime = os.path.getmtime(source_file)
+            return current_mtime != last_modified
+        except (FileNotFoundError, OSError) as e:
+            print(f"Error checking file modification time: {e}")
+            return False
+
+    def get_updates(self, offset: Optional[int] = None,
+                   limit: Optional[int] = None, 
                    timeout: Optional[int] = None) -> List[Dict[str, Any]]:
-        """Get latest updates/messages"""
-        params = {
-            'offset': offset,
-            'limit': limit,
-            'timeout': timeout
-        }
+        params = {k: v for k, v in locals().items() if k != 'self' and v is not None}
         response = self._make_request('GET', 'getUpdates', params=params)
         return response.get('result', [])
 
@@ -1373,50 +2260,10 @@ class Client:
         """Close the client and stop polling"""
         self._polling = False
         for thread in self._threads:
-            try:
-                thread.join()
-            except:
-                pass
+            thread.join(timeout=1.0)
         self._threads.clear()
         if hasattr(self, '_close_handler'):
             self._close_handler()
-
-def run_multiple_clients(*clients):
-    """Run multiple clients concurrently using asyncio"""
-    async def run_client(client):
-        if hasattr(client, '_ready_handler'):
-            client._ready_handler()
-            
-        offset = None
-        past_updates = []
-        
-        while client._polling:
-            try:
-                updates = await client.get_updates(offset=offset)
-                for update in updates:
-                    update_id = update['update_id']
-                    if update_id not in [u['update_id'] for u in past_updates]:
-                        await client._handle_update(update)
-                        offset = update_id + 1
-                        past_updates.append(update)
-                        if len(past_updates) > 30:
-                            past_updates.pop(0)
-                
-                await client._handle_tick_events(time.time())
-                await asyncio.sleep(0.5)
-            except Exception as e:
-                print(f"Error in polling: {traceback.format_exc()}")
-                await asyncio.sleep(1)
-                continue
-
-    loop = asyncio.get_event_loop()
-    tasks = [loop.create_task(run_client(client)) for client in clients]
     
-    try:
-        loop.run_until_complete(asyncio.gather(*tasks))
-    except KeyboardInterrupt:
-        for client in clients:
-            client.safe_close()
-        loop.run_until_complete(asyncio.gather(*[task.cancel() for task in tasks]))
-    finally:
-        loop.close()
+    def create_ref_link(self, data: str):
+        return f"https://ble.ir/{self.get_me().username}?start={data}"