Update utils.py

utils.py

@@ -1,5 +1,10 @@
-import logging, os, re, asyncio, requests, aiohttp 
-from pyrogram.errors import InputUserDeactivated, UserNotParticipant, FloodWait, UserIsBlocked, PeerIdInvalid                             
+import logging
+import os
+import re
+import asyncio
+import requests
+import aiohttp
+from pyrogram.errors import InputUserDeactivated, UserNotParticipant, FloodWait, UserIsBlocked, PeerIdInvalid
 from pyrogram.types import Message, InlineKeyboardButton
 from pyrogram import filters, enums
 from info import AUTH_CHANNEL, LONG_IMDB_DESCRIPTION, MAX_LIST_ELM, SHORT_URL, SHORT_API
@@ -9,22 +14,19 @@ from datetime import datetime, timedelta
 from database.users_chats_db import db
 from bs4 import BeautifulSoup
 
-# Initialize logger with enhanced configuration
+logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
-logger.setLevel(logging.INFO)
+logger.info("Imported necessary modules.")
 
-# Log regex pattern compilation
-BTN_URL_REGEX = re.compile(r"(\[([^\[]+?)\]\((buttonurl|buttonalert):(?:/{0,2})(.+?)(:same)?\))")
-logger.debug("Button URL regex pattern compiled successfully")
+BTN_URL_REGEX = re.compile(r"($$([^\[]+?)$$$$(buttonurl|buttonalert):(?:/{0,2})(.+?)(:same)?$$)")
+logger.info("Defined regex for button URLs.")
 
-BANNED = {}
 SMART_OPEN = '“'
 SMART_CLOSE = '”'
 START_CHAR = ('\'', '"', SMART_OPEN)
+logger.info("Defined smart quote constants.")
 
-# Temporary database class with logging
 class temp(object):
-    logger.info("Initializing temporary storage for banned users/chats and settings")
     BANNED_USERS = []
     BANNED_CHATS = []
     CURRENT = 0
@@ -37,355 +39,316 @@ class temp(object):
     PM_BUTTONS = {}
     PM_SPELL = {}
     GP_SPELL = {}
+logger.info("Initialized temporary object for caching data.")
 
 async def is_subscribed(bot, query):
-    """Check if user is subscribed to auth channel with detailed logging"""
-    logger.debug(f"Checking subscription status for user {query.from_user.id}")
+    logger.debug(f"Checking subscription for user {query.from_user.id} in channel {AUTH_CHANNEL}.")
     try:
         user = await bot.get_chat_member(AUTH_CHANNEL, query.from_user.id)
-        logger.info(f"User {query.from_user.id} membership status: {user.status}")
-        
-        if user.status != enums.ChatMemberStatus.BANNED:
-            logger.info(f"User {query.from_user.id} is valid subscriber")
-            return True
-        logger.warning(f"User {query.from_user.id} is banned in auth channel")
     except UserNotParticipant:
-        logger.warning(f"User {query.from_user.id} not in auth channel")
+        logger.debug(f"User {query.from_user.id} is not a participant in {AUTH_CHANNEL}.")
+        pass
     except Exception as e:
-        logger.error(f"Subscription check error for {query.from_user.id}: {str(e)}")
+        logger.error(f"Error in is_subscribed: {e}")
+    else:
+        if user.status != enums.ChatMemberStatus.BANNED:
+            logger.debug(f"User {query.from_user.id} is subscribed and not banned in {AUTH_CHANNEL}.")
+            return True
+    logger.debug(f"User {query.from_user.id} is either not subscribed or banned in {AUTH_CHANNEL}.")
     return False
 
 async def get_poster(query, bulk=False, id=False, file=None):
-    """Fetch movie details from IMDb with comprehensive logging"""
-    logger.info(f"Starting IMDb lookup for: {query}")
+    logger.debug(f"Fetching poster for query: {query}, bulk: {bulk}, id: {id}, file: {file}")
     imdb = Cinemagoer()
-    
-    try:
-        if not id:
-            logger.debug("Processing title-based search")
-            query = (query.strip()).lower()
-            title = query
-            year = re.findall(r'[1-2]\d{3}$', query, re.IGNORECASE)
-            
+    if not id:
+        query = (query.strip()).lower()
+        title = query
+        year = re.findall(r'[1-2]\d{3}$', query, re.IGNORECASE)
+        if year:
+            year = list_to_str(year[:1])
+            title = (query.replace(year, "")).strip()
+        elif file is not None:
+            year = re.findall(r'[1-2]\d{3}', file, re.IGNORECASE)
             if year:
-                logger.debug(f"Year found in query: {year}")
                 year = list_to_str(year[:1])
-                title = (query.replace(year, "")).strip()
-            elif file is not None:
-                logger.debug("Extracting year from filename")
-                year = re.findall(r'[1-2]\d{3}', file, re.IGNORECASE)
-                if year:
-                    year = list_to_str(year[:1])
-            else:
-                year = None
-                logger.debug("No year information found")
-
-            logger.info(f"Searching IMDb for: {title} ({year if year else 'no year'})")
+        else:
+            year = None
+        logger.debug(f"Searching IMDb for title: {title}, year: {year}")
+        try:
             movieid = imdb.search_movie(title.lower(), results=10)
-            
-            if not movieid:
-                logger.warning("No IMDb results found")
-                return None
-                
-            logger.debug(f"Found {len(movieid)} potential matches")
-            
-            if year:
-                logger.debug("Filtering results by year")
-                filtered = list(filter(lambda k: str(k.get('year')) == str(year), movieid))
-                if not filtered:
-                    logger.warning("No year matches, using original results")
-                    filtered = movieid
-            else:
+        except Exception as e:
+            logger.error(f"Error searching IMDb: {e}")
+            return None
+        if not movieid:
+            logger.debug("No movies found.")
+            return None
+        if year:
+            logger.debug(f"Filtering movies by year: {year}")
+            filtered = list(filter(lambda k: str(k.get('year')) == str(year), movieid))
+            if not filtered:
+                logger.debug("No movies found for specified year. Using all results.")
                 filtered = movieid
-                
-            logger.debug("Filtering by media type")
-            movieid = list(filter(lambda k: k.get('kind') in ['movie', 'tv series'], filtered))
-            
-            if not movieid:
-                logger.warning("No valid media types found, using raw results")
-                movieid = filtered
-                
-            if bulk:
-                logger.info("Returning bulk results")
-                return movieid
-                
-            movieid = movieid[0].movieID
-            logger.info(f"Selected IMDb ID: {movieid}")
         else:
-            logger.info(f"Using provided IMDb ID: {query}")
-            movieid = query
-
-        logger.debug("Fetching detailed movie information")
-        movie = imdb.get_movie(movieid)
-        
-        logger.debug("Processing movie metadata")
-        date = movie.get("original air date") or movie.get("year") or "N/A"
-        plot = ""
-        
-        if not LONG_IMDB_DESCRIPTION:
-            plot = movie.get('plot')
-            if plot and len(plot) > 0:
-                plot = plot[0]
-                logger.debug("Using short plot description")
-        else:
-            plot = movie.get('plot outline')
-            logger.debug("Using long plot outline")
-            
-        if plot and len(plot) > 800:
-            logger.debug("Trimming plot description")
-            plot = plot[0:800] + "..."
-
-        logger.info("Successfully processed IMDb data")
-        return {
-            'title': movie.get('title'),
-            'votes': movie.get('votes'),
-            "aka": list_to_str(movie.get("akas")),
-            "seasons": movie.get("number of seasons"),
-            "box_office": movie.get('box office'),
-            'localized_title': movie.get('localized title'),
-            'kind': movie.get("kind"),
-            "imdb_id": f"tt{movie.get('imdbID')}",
-            "cast": list_to_str(movie.get("cast")),
-            "runtime": list_to_str(movie.get("runtimes")),
-            "countries": list_to_str(movie.get("countries")),
-            "certificates": list_to_str(movie.get("certificates")),
-            "languages": list_to_str(movie.get("languages")),
-            "director": list_to_str(movie.get("director")),
-            "writer":list_to_str(movie.get("writer")),
-            "producer":list_to_str(movie.get("producer")),
-            "composer":list_to_str(movie.get("composer")) ,
-            "cinematographer":list_to_str(movie.get("cinematographer")),
-            "music_team": list_to_str(movie.get("music department")),
-            "distributors": list_to_str(movie.get("distributors")),
-            'release_date': date,
-            'year': movie.get('year'),
-            'genres': list_to_str(movie.get("genres")),
-            'poster': movie.get('full-size cover url'),
-            'plot': plot,
-            'rating': str(movie.get("rating")),
-            'url':f'https://www.imdb.com/title/tt{movieid}'
-        }
-    except Exception as e:
-        logger.error(f"IMDb processing failed: {str(e)}")
-        return None
+            filtered = movieid
+        movieid = list(filter(lambda k: k.get('kind') in ['movie', 'tv series'], filtered))
+        if not movieid:
+            logger.debug("No movies or TV series found. Using all results.")
+            movieid = filtered
+        if bulk:
+            logger.debug("Returning bulk movie IDs.")
+            return movieid
+        movieid = movieid[0].movieID
+    else:
+        movieid = query
+    logger.debug(f"Fetching movie data for ID: {movieid}")
+    movie = imdb.get_movie(movieid)
+    if movie.get("original air date"):
+        date = movie["original air date"]
+    elif movie.get("year"):
+        date = movie.get("year")
+    else:
+        date = "N/A"
+    plot = ""
+    if not LONG_IMDB_DESCRIPTION:
+        plot = movie.get('plot')
+        if plot and len(plot) > 0:
+            plot = plot[0]
+    else:
+        plot = movie.get('plot outline')
+    if plot and len(plot) > 800:
+        plot = plot[0:800] + "..."
+    logger.debug("Constructing poster dictionary.")
+    return {
+        'title': movie.get('title'),
+        'votes': movie.get('votes'),
+        "aka": list_to_str(movie.get("akas")),
+        "seasons": movie.get("number of seasons"),
+        "box_office": movie.get('box office'),
+        'localized_title': movie.get('localized title'),
+        'kind': movie.get("kind"),
+        "imdb_id": f"tt{movie.get('imdbID')}",
+        "cast": list_to_str(movie.get("cast")),
+        "runtime": list_to_str(movie.get("runtimes")),
+        "countries": list_to_str(movie.get("countries")),
+        "certificates": list_to_str(movie.get("certificates")),
+        "languages": list_to_str(movie.get("languages")),
+        "director": list_to_str(movie.get("director")),
+        "writer": list_to_str(movie.get("writer")),
+        "producer": list_to_str(movie.get("producer")),
+        "composer": list_to_str(movie.get("composer")),
+        "cinematographer": list_to_str(movie.get("cinematographer")),
+        "music_team": list_to_str(movie.get("music department")),
+        "distributors": list_to_str(movie.get("distributors")),
+        'release_date': date,
+        'year': movie.get('year'),
+        'genres': list_to_str(movie.get("genres")),
+        'poster': movie.get('full-size cover url'),
+        'plot': plot,
+        'rating': str(movie.get("rating")),
+        'url': f'https://www.imdb.com/title/tt{movieid}'
+    }
 
 def list_to_str(k):
-    """Convert list to formatted string with logging"""
-    logger.debug("Converting list to string")
-    if not k: 
-        logger.debug("Empty list received")
+    logger.debug(f"Converting list to string: {k}")
+    if not k:
         return "N/A"
-    elif len(k) == 1: 
-        logger.debug("Single-item list converted")
+    elif len(k) == 1:
         return str(k[0])
     elif MAX_LIST_ELM:
-        logger.debug(f"Truncating list to {MAX_LIST_ELM} elements")
         k = k[:int(MAX_LIST_ELM)]
-        return ' '.join(f'{elem}, ' for elem in k)
+        result = ' '.join(f'{elem}, ' for elem in k)
+        logger.debug(f"Trimmed and joined list: {result}")
+        return result
     else:
-        logger.debug("Converting full list")
-        return ' '.join(f'{elem}, ' for elem in k)
+        result = ' '.join(f'{elem}, ' for elem in k)
+        logger.debug(f"Joined list: {result}")
+        return result
 
 __repo__ = "https://github.com/MrMKN/PROFESSOR-BOT"
 __version__ = "PROFESSOR-BOT ᴠ4.5.0"
 __license__ = "GNU GENERAL PUBLIC LICENSE V2"
 __copyright__ = "Copyright (C) 2023-present MrMKN <https://github.com/MrMKN>"
 
+logger.info(f"Repository: {__repo__}")
+logger.info(f"Version: {__version__}")
+logger.info(f"License: {__license__}")
+logger.info(f"Copyright: {__copyright__}")
+
 async def search_gagala(text):
-    """Perform Google search with logging"""
-    logger.info(f"Initializing search for: {text}")
+    logger.debug(f"Performing Google search for: {text}")
     usr_agent = {
-        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) '
-        'Chrome/61.0.3163.100 Safari/537.36'
-        }
+        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/61.0.3163.100 Safari/537.36'
+    }
+    text = text.replace(" ", '+')
+    url = f'https://www.google.com/search?q={text}'
+    logger.debug(f"Sending GET request to: {url}")
     try:
-        text = text.replace(" ", '+')
-        url = f'https://www.google.com/search?q={text}'
-        logger.debug(f"Requesting URL: {url}")
-        
         response = requests.get(url, headers=usr_agent)
         response.raise_for_status()
-        logger.info("Google search successful")
-        
-        soup = BeautifulSoup(response.text, 'html.parser')
-        titles = soup.find_all('h3')
-        logger.debug(f"Found {len(titles)} search results")
-        
-        return [title.getText() for title in titles]
-    except Exception as e:
-        logger.error(f"Search failed: {str(e)}")
+    except requests.RequestException as e:
+        logger.error(f"Error in search_gagala: {e}")
         return []
+    soup = BeautifulSoup(response.text, 'html.parser')
+    titles = soup.find_all('h3')
+    results = [title.getText() for title in titles]
+    logger.debug(f"Found {len(results)} search results.")
+    return results
 
 async def get_settings(group_id):
-    """Retrieve group settings with caching and logging"""
-    logger.debug(f"Fetching settings for group {group_id}")
+    logger.debug(f"Getting settings for group ID: {group_id}")
     settings = temp.SETTINGS.get(group_id)
-    
     if not settings:
-        logger.info("Cache miss - loading from database")
+        logger.debug("Settings not found in cache. Retrieving from database.")
         settings = await db.get_settings(group_id)
         temp.SETTINGS[group_id] = settings
     else:
-        logger.debug("Using cached settings")
-        
+        logger.debug("Settings found in cache.")
     return settings
-    
+
 async def save_group_settings(group_id, key, value):
-    """Update group settings with transaction logging"""
-    logger.info(f"Updating setting {key} for group {group_id}")
+    logger.debug(f"Saving group settings for group ID: {group_id}, key: {key}, value: {value}")
     current = await get_settings(group_id)
     current[key] = value
     temp.SETTINGS[group_id] = current
-    
-    try:
-        await db.update_settings(group_id, current)
-        logger.debug("Database update successful")
-    except Exception as e:
-        logger.error(f"Settings update failed: {str(e)}")
-        raise
+    await db.update_settings(group_id, current)
+    logger.debug("Settings updated successfully.")
 
 def get_size(size):
-    """Convert bytes to human-readable format with logging"""
-    logger.debug(f"Converting size: {size} bytes")
+    logger.debug(f"Converting size: {size}")
     units = ["Bytes", "KB", "MB", "GB", "TB", "PB", "EB"]
     size = float(size)
     i = 0
-    
     while size >= 1024.0 and i < len(units):
         i += 1
         size /= 1024.0
-        
     result = "%.2f %s" % (size, units[i])
     logger.debug(f"Converted size: {result}")
     return result
 
 def get_file_id(msg: Message):
-    """Extract file ID from message with media type detection"""
-    logger.debug("Extracting file ID from message")
     if not msg.media:
-        logger.warning("No media found in message")
+        logger.debug("Message has no media.")
         return None
-        
     for message_type in ("photo", "animation", "audio", "document", "video", "video_note", "voice", "sticker"):
         obj = getattr(msg, message_type)
         if obj:
-            logger.info(f"Extracted media type: {message_type}")
+            logger.debug(f"Found media type: {message_type}")
             setattr(obj, "message_type", message_type)
             return obj
+    logger.debug("No supported media type found.")
+    return None
 
 def extract_user(message: Message) -> Union[int, str]:
-    """Extract user ID and name from message with logging"""
-    logger.debug("Extracting user information from message")
+    logger.debug("Extracting user information.")
     user_id = None
     user_first_name = None
-    
     if message.reply_to_message:
+        logger.debug("Extracting user from replied message.")
         user_id = message.reply_to_message.from_user.id
         user_first_name = message.reply_to_message.from_user.first_name
-        logger.info(f"User extracted from reply: {user_id} - {user_first_name}")
     elif len(message.command) > 1:
+        logger.debug("Extracting user from command arguments.")
         if (len(message.entities) > 1 and message.entities[1].type == enums.MessageEntityType.TEXT_MENTION):
             required_entity = message.entities[1]
             user_id = required_entity.user.id
             user_first_name = required_entity.user.first_name
-            logger.info(f"User extracted from mention: {user_id} - {user_first_name}")
         else:
             user_id = message.command[1]
             user_first_name = user_id
-            try:
-                user_id = int(user_id)
-                logger.info(f"User ID converted to int: {user_id}")
-            except ValueError:
-                logger.warning("Failed to convert user ID to int")
+        try:
+            user_id = int(user_id)
+        except ValueError:
+            logger.warning("User ID is not an integer.")
+            pass
     else:
+        logger.debug("Extracting user from message sender.")
         user_id = message.from_user.id
         user_first_name = message.from_user.first_name
-        logger.info(f"User extracted from message sender: {user_id} - {user_first_name}")
-        
+    logger.debug(f"Extracted user ID: {user_id}, first name: {user_first_name}")
     return (user_id, user_first_name)
 
 def split_quotes(text: str) -> List:
-    """Split quoted text into key and value with logging"""
-    logger.debug("Splitting quotes from text")
+    logger.debug(f"Splitting quotes in text: {text}")
     if not any(text.startswith(char) for char in START_CHAR):
-        logger.debug("No starting quote found, splitting by space")
-        return text.split(None, 1)
-    
+        logger.debug("No starting quote found. Splitting by first space.")
+        parts = text.split(None, 1)
+        logger.debug(f"Split parts: {parts}")
+        return parts
     counter = 1  # ignore first char -> is some kind of quote
     while counter < len(text):
         if text[counter] == "\\":
+            logger.debug("Escaped character found.")
             counter += 1
         elif text[counter] == text[0] or (text[0] == SMART_OPEN and text[counter] == SMART_CLOSE):
+            logger.debug("Ending quote found.")
             break
         counter += 1
     else:
-        logger.debug("No ending quote found, returning split")
-        return text.split(None, 1)
+        logger.debug("No ending quote found. Splitting by first space.")
+        parts = text.split(None, 1)
+        logger.debug(f"Split parts: {parts}")
+        return parts
 
+    # 1 to avoid starting quote, and counter is exclusive so avoids ending
     key = remove_escapes(text[1:counter].strip())
+    # index will be in range, or `else` would have been executed and returned
     rest = text[counter + 1:].strip()
     if not key:
         key = text[0] + text[0]
-        
-    logger.debug(f"Split result: key='{key}', rest='{rest}'")
-    return list(filter(None, [key, rest]))
+    result = list(filter(None, [key, rest]))
+    logger.debug(f"Split parts: {result}")
+    return result
 
 def parser(text, keyword, cb_data):
-    """Parse buttons and alerts from text with logging"""
-    logger.debug("Parsing buttons and alerts from text")
-    if "buttonalert" in text: 
+    logger.debug(f"Parsing text: {text}, keyword: {keyword}, cb_data: {cb_data}")
+    if "buttonalert" in text:
+        logger.debug("Found 'buttonalert' in text. Replacing newlines and tabs.")
         text = (text.replace("\n", "\\n").replace("\t", "\\t"))
-        
     buttons = []
     note_data = ""
     prev = 0
     i = 0
     alerts = []
-    
     for match in BTN_URL_REGEX.finditer(text):
         n_escapes = 0
         to_check = match.start(1) - 1
         while to_check > 0 and text[to_check] == "\\":
             n_escapes += 1
             to_check -= 1
-            
+        # if even, not escaped -> create button
         if n_escapes % 2 == 0:
             note_data += text[prev:match.start(1)]
             prev = match.end(1)
             if match.group(3) == "buttonalert":
+                logger.debug(f"Found buttonalert: {match.group(2)}, {match.group(4)}, same_line: {bool(match.group(5))}")
                 if bool(match.group(5)) and buttons:
                     buttons[-1].append(InlineKeyboardButton(match.group(2), callback_data=f"{cb_data}:{i}:{keyword}"))
                 else:
                     buttons.append([InlineKeyboardButton(match.group(2), callback_data=f"{cb_data}:{i}:{keyword}")])
                 i += 1
                 alerts.append(match.group(4))
-                logger.debug(f"Button alert added: {match.group(2)}")
             elif bool(match.group(5)) and buttons:
+                logger.debug(f"Found URL button: {match.group(2)}, {match.group(4)}, same_line: {bool(match.group(5))}")
                 buttons[-1].append(InlineKeyboardButton(match.group(2), url=match.group(4).replace(" ", "")))
-                logger.debug(f"Button URL added: {match.group(2)}")
             else:
+                logger.debug(f"Found URL button: {match.group(2)}, {match.group(4)}, new line.")
                 buttons.append([InlineKeyboardButton(match.group(2), url=match.group(4).replace(" ", ""))])
-                logger.debug(f"Button added: {match.group(2)}")
         else:
             note_data += text[prev:to_check]
             prev = match.start(1) - 1
-            
-    else: 
+    else:
         note_data += text[prev:]
-        
-    try: 
-        logger.info("Parsing completed successfully")
+    try:
+        logger.debug(f"Parsed note_data: {note_data}, buttons: {buttons}, alerts: {alerts}")
         return note_data, buttons, alerts
     except Exception as e:
-        logger.error(f"Parsing error: {str(e)}")
+        logger.error(f"Error in parser: {e}")
         return note_data, buttons, None
 
 def remove_escapes(text: str) -> str:
-    """Remove escape characters from text with logging"""
-    logger.debug("Removing escape characters from text")
+    logger.debug(f"Removing escapes from text: {text}")
     res = ""
     is_escaped = False
-    
     for counter in range(len(text)):
         if is_escaped:
             res += text[counter]
@@ -394,76 +357,65 @@ def remove_escapes(text: str) -> str:
             is_escaped = True
         else:
             res += text[counter]
-    
-    logger.debug("Escape characters removed successfully")
+    logger.debug(f"Text after removing escapes: {res}")
     return res
 
 def humanbytes(size):
-    """Convert bytes to human-readable format with logging"""
-    logger.debug(f"Converting size to human-readable format: {size}")
+    logger.debug(f"Converting size to human-readable: {size}")
     if not size:
-        logger.warning("No size provided for conversion")
+        logger.debug("Size is zero or empty.")
         return ""
-    
     power = 2**10
     n = 0
     Dic_powerN = {0: ' ', 1: 'Ki', 2: 'Mi', 3: 'Gi', 4: 'Ti'}
-    
     while size > power:
         size /= power
         n += 1
-        
     result = str(round(size, 2)) + " " + Dic_powerN[n] + 'B'
-    logger.debug(f"Converted size: {result}")
+    logger.debug(f"Human-readable size: {result}")
     return result
 
 def get_time(seconds):
-    """Convert seconds to human-readable time format with logging"""
-    logger.debug(f"Converting seconds to time format: {seconds}")
+    logger.debug(f"Formatting time: {seconds} seconds")
     periods = [('ᴅ', 86400), ('ʜ', 3600), ('ᴍ', 60), ('ꜱ', 1)]
     result = ''
-    
     for period_name, period_seconds in periods:
         if seconds >= period_seconds:
             period_value, seconds = divmod(seconds, period_seconds)
             result += f'{int(period_value)}{period_name}'
-    
-    logger.debug(f"Converted time: {result}")
+    logger.debug(f"Formatted time: {result}")
     return result
 
 async def get_shortlink(link):
-    """Get shortened link using API with logging"""
-    logger.info(f"Requesting short link for: {link}")
+    logger.debug(f"Generating shortlink for: {link}")
     url = f'{SHORT_URL}/api'
     params = {'api': SHORT_API, 'url': link}
-    
     try:
         async with aiohttp.ClientSession() as session:
             async with session.get(url, params=params, raise_for_status=True, ssl=False) as response:
                 data = await response.json()
                 if data["status"] == "success":
-                    logger.info("Short link retrieved successfully")
-                    return data['shortenedUrl']
+                    shortened_url = data['shortenedUrl']
+                    logger.debug(f"Shortlink generated: {shortened_url}")
+                    return shortened_url
                 else:
-                    logger.error(f"Error from short link API: {data['message']}")
+                    logger.error(f"Error generating shortlink: {data['message']}")
                     return link
     except Exception as e:
-        logger.error(f"Short link request failed: {str(e)}")
+        logger.error(f"Exception in get_shortlink: {e}")
         return link
 
 def extract_time(time_val):
-    """Extract time from string with logging"""
-    logger.debug(f"Extracting time from value: {time_val}")
+    logger.debug(f"Extracting time from: {time_val}")
     if any(time_val.endswith(unit) for unit in ("s", "m", "h", "d")):
         unit = time_val[-1]
         time_num = time_val[:-1]  # type: str
-        
         if not time_num.isdigit():
-            logger.warning("Invalid time number provided")
+            logger.debug("Time number is not a digit.")
             return None
 
         if unit == "s":
-            bantime = datetime.now() + timedelta(seconds=int(time_num)) 
+            bantime = datetime.now() + timedelta(seconds=int(time_num))
         elif unit == "m":
             bantime = datetime.now() + timedelta(minutes=int(time_num))
         elif unit == "h":
@@ -471,51 +423,43 @@ def extract_time(time_val):
         elif unit == "d":
             bantime = datetime.now() + timedelta(days=int(time_num))
         else:
-            logger.error("Unknown time unit provided")
+            logger.debug("Invalid unit.")
             return None
-            
-        logger.info(f"Extracted ban time: {bantime}")
+        logger.debug(f"Calculated bantime: {bantime}")
         return bantime
     else:
-        logger.warning("No valid time unit found")
+        logger.debug("No valid unit found in time_val.")
         return None
 
 async def admin_check(message: Message) -> bool:
-    """Check if user is an admin with logging"""
-    logger.debug("Checking admin status for user")
-    if not message.from_user: 
-        logger.warning("Message has no user information")
+    logger.debug(f"Checking if user {message.from_user.id} is admin in chat {message.chat.id}")
+    if not message.from_user:
+        logger.debug("Message does not have a from_user.")
         return False
-    
-    if message.chat.type not in [enums.ChatType.GROUP, enums.ChatType.SUPERGROUP]: 
-        logger.warning("Message is not from a group or supergroup")
+    if message.chat.type not in [enums.ChatType.GROUP, enums.ChatType.SUPERGROUP]:
+        logger.debug("Chat is not a group or supergroup.")
         return False
-    
-    if message.from_user.id in [777000, 1087968824]: 
-        logger.info("User  is a bot admin")
+    if message.from_user.id in [777000, 1087968824]:
+        logger.debug("User is a special bot ID.")
         return True
-    
     client = message._client
     chat_id = message.chat.id
     user_id = message.from_user.id
-    
     try:
         check_status = await client.get_chat_member(chat_id=chat_id, user_id=user_id)
-        admin_strings = [enums.ChatMemberStatus.OWNER, enums.ChatMemberStatus.ADMINISTRATOR]
-        
-        if check_status.status not in admin_strings: 
-            logger.info(f"User  {user_id} is not an admin")
-            return False
-        else: 
-            logger.info(f"User  {user_id} is an admin")
-            return True
     except Exception as e:
-        logger.error(f"Admin check failed for user {user_id}: {str(e)}")
+        logger.error(f"Error checking chat member: {e}")
+        return False
+    admin_strings = [enums.ChatMemberStatus.OWNER, enums.ChatMemberStatus.ADMINISTRATOR]
+    if check_status.status not in admin_strings:
+        logger.debug("User is not an admin or owner.")
         return False
+    else:
+        logger.debug("User is an admin or owner.")
+        return True
 
 async def admin_filter(filt, client, message):
-    """Filter for admin messages with logging"""
-    logger.debug("Applying admin filter")
-    is_admin = await admin_check(message)
-    logger.info(f"Admin filter result: {is_admin}")
-    return is_admin
+    logger.debug(f"Admin filter checking for message: {message.id}")
+    result = await admin_check(message)
+    logger.debug(f"Admin filter result: {result}")
+    return result