d4rktg 0.0.0__py3-none-any.whl

d4rk/Database/__init__.py

@@ -0,0 +1 @@
+from .db import db

d4rk/Database/db.py

@@ -0,0 +1,52 @@
+# src/Database/Mongodb/db.py
+
+from pymongo import MongoClient , server_api
+
+from d4rk.Logs import setup_logger
+
+logger = setup_logger(__name__)
+
+class Database:
+    client = None
+    db = None
+    is_connected = False
+    def __init__(self):
+        pass
+
+    def connect(self,name: str, collections: list = [],DATABASE_URL: str =None):
+        self.database_name = name.replace(" ","")
+        self._collections = collections
+        self._DATABASE_URL = DATABASE_URL
+        if not DATABASE_URL:
+            logger.warning("DATABASE_URL is not set in the environment variables.")
+            exit()
+        try:
+            self.client = MongoClient(DATABASE_URL,server_api=server_api.ServerApi('1'))
+            self.db = self.client[self.database_name]
+            self._load_custom_collections()
+            self.is_connected = True
+        except Exception as e:
+            logger.warning(f"Failed to connect to MongoDB: {e}")
+            exit()
+        if self.is_connected:
+            try:
+                self.client.admin.command('ping')
+                logger.info(f"successfully connected to {name} Mongodb!")
+            except Exception as e:
+                logger.warning(f"Something Went Wrong While Connecting To Database! : {e}")
+                self.is_connected = False
+                exit()
+
+    def _load_custom_collections(self):
+        for CustomClass in self._collections:
+            collection_name = str(CustomClass.__name__).title()
+            base_collection = self.get_collection(collection_name)
+            instance = CustomClass(base_collection)
+            setattr(self, collection_name, instance)
+            logger.info(f"Loaded collection: {collection_name}")
+            
+    def get_collection(self, collection):
+        return self.db[collection]
+    
+db = Database()
+    

d4rk/Handlers/__init__.py

@@ -0,0 +1,3 @@
+from ._bot import BotManager
+from ._scheduler import scheduler
+from ._custom import FontMessageMixin

d4rk/Handlers/_bot.py

@@ -0,0 +1,207 @@
+import os
+import sys
+import asyncio
+import traceback
+import random
+from datetime import datetime, timedelta
+
+from pyrogram import Client
+from pyrogram.errors import FloodWait
+from pyrogram.types import BotCommand
+from pyrogram.errors.exceptions.bad_request_400 import AccessTokenExpired
+
+from d4rk.Logs import setup_logger
+
+logs_sent = False
+logs_lock = asyncio.Lock()
+
+logger = setup_logger(__name__)
+
+class BotManager(Client):
+    _bot: Client = None
+    _web = True
+    _bot_info = None
+    _is_connected = False
+    _rename = False
+    _flood_data = {}
+    _loop = None
+    _scheduler_thread = None
+    font = 0
+    sudo_users = []
+
+
+    def create_client(self,app_name,token):
+        self.app_name = app_name
+        super().__init__(
+            name=app_name,
+            api_id=self.api_id,
+            api_hash=self.api_hash,
+            bot_token=token,
+            plugins=self.plugins,
+            in_memory=True
+            )
+
+    async def handle_flood_wait(self, wait_time: int):
+
+        await asyncio.sleep(wait_time)
+        try:await self.powerup(self.app_name)
+        except:pass
+        
+    def _safe_async(self, coro_func):
+        if self._loop:asyncio.run_coroutine_threadsafe(coro_func(), self._loop)
+        else:logger.error("Event loop is not set for _safe_async")
+
+    async def powerup(self,appname):
+        if hasattr(self, "db"):
+            self.font = self.db.Settings.get(key="font",datatype=str)
+            self.sudo_users = self.db.Settings.get(key="sudo_users",datatype=list,default=[])
+            if not self.font:
+                logger.info("Font not set, defaulting to font 1")
+                self.db.Settings.set("font", "1")
+                self.font = 1
+
+        self.create_client(appname,self.token)
+        max_retries = 3
+        for attempt in range(max_retries):
+            try:
+                self._loop = asyncio.get_running_loop()
+                logger.info(f'Starting bot client... (attempt {attempt + 1}/{max_retries})')
+                if not self._is_connected:
+                    await asyncio.wait_for(super().start(), timeout=60.0)
+                    self._bot_info = await super().get_me()
+                    logger.info(f"Bot Client > {self._bot_info.first_name} - @{self._bot_info.username} Started")
+                    await self.setup_commands()
+                    self._is_connected = True
+                    await self.handle_restart()
+                    break 
+
+            except asyncio.TimeoutError:
+                logger.error(f"Bot start timed out (attempt {attempt + 1})")
+                if attempt < max_retries - 1:
+                    logger.info("Retrying in 10 seconds...")
+                    await asyncio.sleep(10)
+                
+            except FloodWait as e:
+                logger.error(f"FloodWait: {e.value} seconds")
+                await self.handle_flood_wait(e.value)
+                break
+
+            except AccessTokenExpired:
+                logger.error(f"Access token expired (attempt {attempt + 1})")
+            except Exception as e:
+                logger.error(f"Error starting Client.Stoped !")
+                logger.error(traceback.format_exc())
+                break
+        else:
+            logger.error("Failed to start bot after all retry attempts")
+
+        await self.setup_webserver()
+
+    async def powerdown(self, *args):
+        global logs_sent, logs_lock
+        logger.info("Initiating APP to stop...")
+        if self._rename:await super().set_bot_info(lang_code='en',name=self.app_name + " (Offline)")
+        self.stop_scheduler()
+        today = self.TZ_now.strftime("%Y-%m-%d")
+        if hasattr(self, '_web_runner') and self._web_runner:
+            await self.web_server.cleanup()
+        
+        logger.info("Stopping bot client...")
+        if self._is_connected and self.LOGS:
+            try:
+                await self.send_message(chat_id=self.LOGS, text=f"{self._bot_info.mention} stopping...")
+            except Exception as e:
+                logger.error(f"Error sending stop message for {self._bot_info.first_name}: {e}")
+
+        async with logs_lock:
+            if not logs_sent and self._is_connected:
+                logs_sent = True
+                try:
+                    await self.send_document(chat_id=self.LOGS, document=f"logs/log-{today}.txt")
+                    logger.info("Log document sent successfully")
+                except Exception as e:
+                    logger.error(f"Error sending log document: {e}")
+
+        if self._is_connected and self.LOGS:
+            try:
+                await self.send_message(chat_id=self.LOGS, text=f"{self._bot_info.mention} stopped successfully!")
+            except Exception as e:
+                logger.error(f"Error sending stop confirmation for {self._bot_info.first_name}: {e}")
+            await super().stop()
+            await asyncio.sleep(3)
+
+    async def reboot(self):
+        try:
+            if self._rename:await super().set_bot_info(lang_code='en',name=self.app_name + " (restarting..)")
+            logger.info("Initiating APP to reboot...")
+            self.stop_scheduler()
+            today = self.TZ_now.strftime("%Y-%m-%d")
+            if hasattr(self, '_web_runner') and self._web_runner:
+                await self.web_server.cleanup()
+            if self._is_connected:
+                try:
+                    if self.LOGS:
+                        await self.send_message(chat_id=self.LOGS, text=f"{self._bot_info.mention} rebooting...")
+                        await self.send_document(chat_id=self.LOGS, document=f"logs/log-{today}.txt")
+                    logger.info(f"{self._bot_info.first_name} - @{self._bot_info.username} is rebooting")
+                except Exception as e:
+                    logger.error(f"Error sending reboot notification: {e}")
+                await super().stop()
+                self._is_connected = False
+            await asyncio.sleep(2)
+            
+            logger.info("Restarting process...")
+            os.execl(sys.executable, sys.executable, *sys.argv)
+        except Exception as e:
+            logger.error(f"Error during reboot: {e}")
+            os.execl(sys.executable, sys.executable, *sys.argv)
+
+    async def handle_restart(self):
+        if os.path.exists('restart.txt'):
+            with open('restart.txt', 'r') as file:
+                data = file.read().split()
+                chat_id = int(data[0])
+                Message_id = int(data[1])
+            try:await self.send_message(chat_id=self.LOGS, text=f"{self._bot_info.mention} restarted successfully!")
+            except Exception as e:logger.error(f"Failed to send restart notification: {e}")
+            try:await self.edit_message_text(chat_id=chat_id,message_id=Message_id, text="Bot restarted successfully!")          
+            except:
+                try:
+                    await self.send_message(chat_id=chat_id, text="Bot restarted successfully!",reply_to_message_id=Message_id-1,)
+                    await self.delete_messages(chat_id=chat_id,message_ids=Message_id)
+                except:pass
+
+            if os.path.exists('restart.txt'):os.remove('restart.txt')
+        else:
+            try:await self.send_message(chat_id=self.LOGS, text=f"{self._bot_info.mention} started successfully!")
+            except Exception as e:logger.error(f"Failed to send start notification: {e}")
+
+
+    async def setup_commands(self,set_commands=False):
+        if self._rename:
+            if self._bot_info.first_name != self.app_name:
+                await super().set_bot_info(lang_code='en',name=self.app_name)
+        if set_commands:
+            commands = await super().get_bot_commands()
+            if commands == []:
+                b_index = self.TOKEN_INDEX + 1
+                bot_commands = [
+                    BotCommand("start", f"{b_index} Start the bot"),
+                    BotCommand("help", f"{b_index} Get help"),
+                    BotCommand("logs", f"{b_index} Get logs (Admin only)"),
+                    BotCommand("reboot", f"{b_index} Reboot the bot (Admin only)")
+                ]
+                await super().set_bot_commands(bot_commands)
+
+    async def send_logs(self):
+        logger.info("Sending yesterday logs...")
+        if not self._is_connected:
+            logger.warning("Bot is not connected")
+        if self._is_connected:
+    
+            yesterday = (self.TZ_now - timedelta(days=1)).strftime("%Y-%m-%d")
+            try:
+                m = await self.send_document(chat_id=self.LOGS, document=f"logs/log-{yesterday}.txt")
+                logger.info(f"Logs sent to {m.chat.first_name} - @{m.chat.username}")
+            except Exception as e:
+                logger.error(f"Error sending logs: {e}")

d4rk/Handlers/_custom.py

@@ -0,0 +1,97 @@
+
+import pyrogram.errors
+from typing import List, Union
+
+from pyrogram import Client
+from pyrogram.enums import ParseMode
+from pyrogram.errors import FloodWait
+from pyrogram.types import Message, CallbackQuery
+
+from d4rk.Utils._fonts import get_font
+from d4rk.Utils._decorators import new_task, retry
+
+import asyncio
+
+reaction_queue = asyncio.Queue()
+semaphore = asyncio.Semaphore(1)
+worker_running = False
+
+class FontMessageMixin(Client):
+
+    async def send_reaction(self,chat_id:Union[int,str], message_id:int=None, story_id:int=None, emoji:Union[int,str,List[Union[int,str]]]=None, big:bool=False, add_to_recent:bool=False, *args, **kwargs):
+        global worker_running
+        await reaction_queue.put(chat_id, message_id, story_id, emoji, big, add_to_recent)
+        if not worker_running:
+            worker_running = True
+            asyncio.create_task(self.reaction_worker())
+        
+
+    async def reaction_worker(self) -> None:
+        global worker_running
+        while worker_running:
+            if reaction_queue.empty():
+                worker_running = False
+                break
+            chat_id, message_id, story_id, emoji, big, add_to_recent = await reaction_queue.get()
+            async def job() -> None:
+                async with semaphore:
+                    try:
+                        await self._send_reaction(chat_id=chat_id, message_id=message_id, story_id=story_id, emoji=emoji, big=big, add_to_recent=add_to_recent)
+                    except FloodWait as e:
+                        await asyncio.sleep(e.value)
+                        await self._send_reaction(chat_id=chat_id, message_id=message_id, story_id=story_id, emoji=emoji, big=big, add_to_recent=add_to_recent)
+                    finally:reaction_queue.task_done()
+            await asyncio.sleep(5)
+            asyncio.create_task(job())
+    
+    async def _send_reaction(*args, **kwargs):
+        return await super().send_reaction(*args, **kwargs)
+    
+    @retry()
+    async def delete_messages(self,chat_id:Union[int,str], message_ids:Union[int,List[int]], revoke:bool=True, wait: int = 0):
+        if wait > 0: await asyncio.sleep(wait)
+        try:await super().delete_messages(chat_id=chat_id, message_ids=message_ids, revoke=revoke)
+        except:pass
+        
+    @retry()
+    async def send_message(self, chat_id :Union[int, str], text :str, parse_mode=None, *args, **kwargs):
+        return await super().send_message(chat_id=chat_id, text=get_font(text=text, font=self.font), parse_mode=ParseMode.HTML, *args, **kwargs)
+
+    @retry()
+    async def send_photo(self, chat_id:Union[int, str], photo :str, caption :str=None, parse_mode=None, *args, **kwargs):
+        return await super().send_photo(chat_id=chat_id, photo=photo, caption=get_font(text=caption, font=self.font), parse_mode=ParseMode.HTML, *args, **kwargs)
+
+    @retry()
+    async def edit_message_text(self, chat_id: Union[int, str], message_id: int, text :str, parse_mode=None, *args, **kwargs):
+        return await super().edit_message_text(chat_id=chat_id, message_id=message_id, text=get_font(text=text, font=self.font), parse_mode=ParseMode.HTML, *args, **kwargs)
+
+    @retry()
+    async def edit_message_caption(self, chat_id :Union[int, str], message_id : int, caption :str, parse_mode=None, *args, **kwargs):
+        return await super().edit_message_caption(chat_id=chat_id, message_id=message_id, caption=get_font(text=caption, font=self.font), parse_mode=ParseMode.HTML, *args, **kwargs)
+
+    @retry()
+    async def edit_inline_text(self, inline_message_id: int, text :str, parse_mode=None, *args, **kwargs):
+        return await super().edit_inline_text(inline_message_id, text=get_font(text=text, font=self.font), parse_mode=ParseMode.HTML, *args, **kwargs)
+
+    @retry()
+    async def send_document(self, chat_id :Union[int, str], document, caption :str=None, parse_mode=None, *args, **kwargs):
+        return await super().send_document(chat_id, document, caption=get_font(text=caption, font=self.font), parse_mode=ParseMode.HTML, *args, **kwargs)
+
+    @retry()
+    async def send_video(self, chat_id :Union[int,str], video, caption :str=None, parse_mode=None, *args, **kwargs):
+        return await super().send_video(chat_id, video, caption=get_font(text=caption, font=self.font), parse_mode=ParseMode.HTML, *args, **kwargs)
+
+    @retry()
+    async def send_audio(self, chat_id :Union[int,str], audio, caption :str=None, parse_mode=None, *args, **kwargs):
+        return await super().send_audio(chat_id, audio, caption=get_font(text=caption, font=self.font), parse_mode=ParseMode.HTML, *args, **kwargs)
+
+    @retry()
+    async def send_voice(self, chat_id :Union[int,str], voice, caption :str=None, parse_mode=None, *args, **kwargs):
+        return await super().send_voice(chat_id, voice, caption=get_font(text=caption, font=self.font), parse_mode=ParseMode.HTML, *args, **kwargs)
+    
+    @retry()
+    async def send_alert(self,message:Union[Message,CallbackQuery], text :str):
+        if isinstance(message, Message):
+            return await message.reply(text)
+        elif isinstance(message, CallbackQuery):
+            return await message.answer(text, show_alert=True)

d4rk/Handlers/_scheduler.py

@@ -0,0 +1,33 @@
+import schedule
+import threading
+import time
+from datetime import datetime, timedelta
+
+from d4rk.Logs import setup_logger
+logger = setup_logger(__name__)
+
+class scheduler:
+    async def start_scheduler(self):
+        if self._scheduler_thread and self._scheduler_thread.is_alive():
+            return
+        schedule.clear()
+        schedule.every().day.at(time_str="00:01",tz="Asia/Kolkata").do(lambda: self._safe_async(self.send_logs))
+        self._stop_scheduler.clear()
+        self._scheduler_thread = threading.Thread(target=self._run_scheduler, daemon=True)
+        self._scheduler_thread.start()
+        logger.info("Background scheduler started for log maintenance")    
+
+    def stop_scheduler(self):
+        if self._scheduler_thread:
+            self._stop_scheduler.set()
+            self._scheduler_thread.join(timeout=5)
+            logger.info("Background scheduler stopped")
+
+    def _run_scheduler(self):
+        while not self._stop_scheduler.is_set():
+            try:
+                schedule.run_pending()
+                time.sleep(60)  # Check every minute
+            except Exception as e:
+                if logger:
+                    logger.error(f"Scheduler error: {e}")

d4rk/Logs/__init__.py

@@ -0,0 +1 @@
+from ._logger import *

d4rk/Logs/_logger.py

@@ -0,0 +1,115 @@
+# src/Log/_logger_config.py
+
+import os
+import sys
+import logging
+
+from datetime import datetime, timezone, timedelta
+from logging.handlers import TimedRotatingFileHandler
+
+try:
+    import colorama
+    colorama.init(strip=False, autoreset=True)
+    COLORAMA_AVAILABLE = True
+except ImportError:
+    COLORAMA_AVAILABLE = False
+
+def get_timezone_offset(time_zone: str = "00:00") -> timezone:
+    if time_zone:
+        try:
+            hours, minutes = time_zone.split(':')
+            if hours.startswith("-"):
+                return timezone(timedelta(hours=-int(hours), minutes=-int(minutes)))
+            else:
+                return timezone(timedelta(hours=int(hours), minutes=int(minutes)))
+        except ValueError:
+            raise ValueError(f"Invalid TIME_ZONE format: {time_zone}")
+    return timezone(timedelta(hours=0))
+
+TZ = get_timezone_offset(os.getenv("TIME_ZONE", "05:30"))
+
+class TimeZoneFormatter(logging.Formatter):
+
+    def __init__(self, fmt, datefmt=None, use_colors=False):
+        super().__init__(fmt, datefmt)
+        self.use_colors = use_colors
+        self.COLORS = {
+            "TIME":  "\033[93m",  # Light Yellow
+            "NAME": "\033[36m",  # Cyan
+            "FUNC": "\033[34m",  # Blue
+            "LEVEL": {
+                logging.DEBUG: "\033[37m",   # White
+                logging.INFO: "\033[32m",    # Green
+                logging.WARNING: "\033[33m", # Yellow
+                logging.ERROR: "\033[31m",   # Red
+                logging.CRITICAL: "\033[41m" # Red background
+            }
+        }
+        self.RESET = "\033[0m"
+    def converter(self, timestamp):
+        dt = datetime.fromtimestamp(timestamp, tz=timezone.utc)
+        return dt.astimezone(TZ).timetuple()
+
+    def formatTime(self, record, datefmt=None):
+        dt = datetime.fromtimestamp(record.created, tz=timezone.utc)
+        time_zone_time = dt.astimezone(TZ)
+        if datefmt:
+            return time_zone_time.strftime(datefmt)
+        else:
+            return time_zone_time.strftime('%Y-%m-%d %H:%M:%S %z')
+    
+    def format(self, record):
+        if not self.use_colors:
+            return super().format(record)
+
+        time_str = f"{self.COLORS['TIME']}{self.formatTime(record, self.datefmt)}{self.RESET}"
+        name_str = f"{self.COLORS['NAME']}{record.name}{self.RESET}"
+        func_str = f"{self.COLORS['FUNC']}{record.funcName}:{record.lineno}{self.RESET}"
+        level_color = self.COLORS['LEVEL'].get(record.levelno, "")
+        level_str = f"{level_color}{record.levelname}{self.RESET}"
+        msg_str = f"{level_color}{record.getMessage()}{self.RESET}"
+
+        return f"{time_str} - {name_str} - {func_str} - {level_str} - {msg_str}"
+
+def setup_logger(name=__name__, log_level=logging.INFO):
+    log_dir = "logs"
+    if not os.path.exists(log_dir):
+        os.makedirs(log_dir)
+    
+    logger = logging.getLogger(name)
+    logger.setLevel(log_level)
+    
+    if logger.handlers:
+        return logger
+    
+    time_zone_now = datetime.now(TZ)
+    
+    file_handler = TimedRotatingFileHandler(
+        filename=os.path.join(log_dir, f"log-{time_zone_now.strftime('%Y-%m-%d')}.txt"),
+        when='midnight',
+        interval=1,
+        backupCount=30
+    )
+    file_handler.setLevel(log_level)
+
+    
+    console_handler = logging.StreamHandler()
+    console_handler.setLevel(log_level)
+    use_colors = sys.stdout.isatty() and COLORAMA_AVAILABLE
+    plain_formatter = TimeZoneFormatter(
+        '%(asctime)s - %(name)s - %(funcName)s:%(lineno)d - %(levelname)s - %(message)s',
+        datefmt='%Y-%m-%d %H:%M:%S',
+        use_colors=False
+    )
+    formatter = TimeZoneFormatter(
+        '%(asctime)s - %(name)s - %(funcName)s:%(lineno)d - %(levelname)s - %(message)s',
+        datefmt='%Y-%m-%d %H:%M:%S',
+        use_colors=use_colors
+    )
+
+    file_handler.setFormatter(plain_formatter)
+    console_handler.setFormatter(formatter)
+    logger.addHandler(file_handler)
+    logger.addHandler(console_handler)
+    logger.propagate = False
+    return logger

d4rk/Utils/__init__.py

@@ -0,0 +1,10 @@
+from ._buttons import ButtonMaker
+from ._decorators import new_task , retry , round_robin , command , get_commands
+from ._filters import CustomFilters , OWNER 
+from ._fonts import get_font
+from ._ip import get_public_ip , check_public_ip_reachable
+from ._movie_parser import parser
+from ._ractions import Reacts
+from ._terminal import clear_terminal
+
+

d4rk/Utils/_buttons.py

@@ -0,0 +1,73 @@
+from pyrogram.types import InlineKeyboardMarkup, InlineKeyboardButton
+
+
+class ButtonMaker:
+    def __init__(self):
+        self.__button = []
+        self.__header_button = []
+        self.__first_body_button = []
+        self.__last_body_button = []
+        self.__footer_button = []
+
+    def ubutton(self, key, link, position=None):
+        if not position:
+            self.__button.append(InlineKeyboardButton(text=key, url=link))
+        elif position == "header":
+            self.__header_button.append(InlineKeyboardButton(text=key, url=link))
+        elif position == "f_body":
+            self.__first_body_button.append(InlineKeyboardButton(text=key, url=link))
+        elif position == "l_body":
+            self.__last_body_button.append(InlineKeyboardButton(text=key, url=link))
+        elif position == "footer":
+            self.__footer_button.append(InlineKeyboardButton(text=key, url=link))
+
+    def ibutton(self, key, data, position=None):
+        if not position:
+            self.__button.append(InlineKeyboardButton(text=key, callback_data=data))
+        elif position == "header":
+            self.__header_button.append(InlineKeyboardButton(text=key, callback_data=data))
+        elif position == "f_body":
+            self.__first_body_button.append(InlineKeyboardButton(text=key, callback_data=data))
+        elif position == "l_body":
+            self.__last_body_button.append(InlineKeyboardButton(text=key, callback_data=data))
+        elif position == "footer":
+            self.__footer_button.append(InlineKeyboardButton(text=key, callback_data=data))
+
+    def build_menu(self, b_cols=1, h_cols=8, fb_cols=2, lb_cols=2, f_cols=8):
+        menu = [
+            self.__button[i : i + b_cols] for i in range(0, len(self.__button), b_cols)
+        ]
+        if self.__header_button:
+            if len(self.__header_button) > h_cols:
+                header_buttons = [
+                    self.__header_button[i : i + h_cols]
+                    for i in range(0, len(self.__header_button), h_cols)
+                ]
+                menu = header_buttons + menu
+            else:
+                menu.insert(0, self.__header_button)
+        if self.__first_body_button:
+            if len(self.__first_body_button) > fb_cols:
+                [
+                    menu.append(self.__first_body_button[i : i + fb_cols])
+                    for i in range(0, len(self.__first_body_button), fb_cols)
+                ]
+            else:
+                menu.append(self.__first_body_button)
+        if self.__last_body_button:
+            if len(self.__last_body_button) > lb_cols:
+                [
+                    menu.append(self.__last_body_button[i : i + lb_cols])
+                    for i in range(0, len(self.__last_body_button), lb_cols)
+                ]
+            else:
+                menu.append(self.__last_body_button)
+        if self.__footer_button:
+            if len(self.__footer_button) > f_cols:
+                [
+                    menu.append(self.__footer_button[i : i + f_cols])
+                    for i in range(0, len(self.__footer_button), f_cols)
+                ]
+            else:
+                menu.append(self.__footer_button)
+        return InlineKeyboardMarkup(menu)

d4rk/Utils/_decorators.py

@@ -0,0 +1,113 @@
+import os
+import asyncio
+import functools
+
+from pyrogram import Client , filters
+from pyrogram.errors import FloodWait
+from pyrogram.types import Message , CallbackQuery , ChatPrivileges
+
+from typing import Union
+from functools import wraps
+
+from d4rk.Logs import setup_logger
+
+
+logger = setup_logger(__name__)
+
+command_registry = []
+last_index_per_chat = {}
+bot_order_per_chat = {}
+responded_messages = {}
+chat_locks = {}
+
+def get_priority(description: str) -> int:
+    desc_lower = description.lower()
+    if "(owner only)" in desc_lower:return 4
+    elif "(sudo only)" in desc_lower:return 3
+    elif "(admin only)" in desc_lower:return 2
+    else:return 1
+    
+def reorder_command_registry():
+    global command_registry
+    command_registry.sort(key=lambda cmd: get_priority(cmd["description"]))
+
+def get_commands():
+    global command_registry
+    return command_registry
+
+def new_task():
+    def decorator(func):
+        @wraps(func)
+        async def wrapper(*args, **kwargs):
+            asyncio.create_task(func(*args, **kwargs))
+        return wrapper
+    return decorator
+
+def retry():
+    def decorator(func):
+        @wraps(func)
+        async def wrapper(*args, **kwargs):
+            async def runner():
+                try:await func(*args, **kwargs)
+                except FloodWait as e:
+                    await asyncio.sleep(e.value)
+                    await func(*args, **kwargs)
+            asyncio.create_task(runner())
+        return wrapper
+    return decorator
+
+def round_robin():
+    def decorator(func):
+        @wraps(func)
+        async def wrapper(client, message, *args, **kwargs):
+            chat_id = message.chat.id
+            msg_id = message.id
+            
+            if message.chat.type.name.lower() == "private":
+                return await func(client, message, *args, **kwargs)
+
+            if chat_id not in bot_order_per_chat:
+                bot_order_per_chat[chat_id] = [client.me.id]
+                last_index_per_chat[chat_id] = 0
+                responded_messages[chat_id] = set()
+                chat_locks[chat_id] = asyncio.Lock()
+
+            if client.me.id not in bot_order_per_chat[chat_id]:
+                bot_order_per_chat[chat_id].append(client.me.id)
+
+            async with chat_locks[chat_id]:
+                if msg_id in responded_messages[chat_id]:
+                    return
+                current_index = last_index_per_chat[chat_id]
+                selected_bot_id = bot_order_per_chat[chat_id][current_index]
+
+                if client.me.id == selected_bot_id:
+                    result = await func(client, message, *args, **kwargs)
+                    responded_messages[chat_id].add(msg_id)
+                    last_index_per_chat[chat_id] = (current_index + 1) % len(bot_order_per_chat[chat_id])
+                    return result
+        return wrapper
+    return decorator
+
+
+def command(command: Union[str, list], description: str,Custom_filter=None):
+    def decorator(func):
+        command_registry.append({
+            "command": command,
+            "description": description,
+            "handler": func
+        })
+        logger.info(f"Registered command: {command} - {description}")
+        if Custom_filter:
+            filter = filters.command(command) & Custom_filter
+        else:
+            filter = filters.command(command)
+        @Client.on_message(filter)
+        @round_robin()
+        @wraps(func)
+        async def wrapper(client, message):
+            return await func(client, message)
+        reorder_command_registry()
+        return wrapper
+    return decorator
+

d4rk/Utils/_filters.py

@@ -0,0 +1,67 @@
+from pyrogram.filters import create
+from pyrogram.enums import ChatType
+
+from typing import Union
+from pyrogram import filters 
+from pyrogram.types import Message , CallbackQuery
+from d4rk.Logs import setup_logger
+
+logger = setup_logger(__name__)
+
+OWNER = None
+
+class CustomFilters:
+
+    def authorize(
+        sudo=False,
+        admin=False,
+        permission=None,
+    ):
+        async def func(flt, client, message: Union[Message, CallbackQuery]):
+            try:
+                user = message.from_user
+                if not user:
+                    logger.warning(f"Unauthorized access attempt from non-user message: {message}")
+                    return False
+
+                me = await client.get_me()
+                is_admin = False
+
+                if admin:
+                    if message.chat.type.name.lower() in ["group", "supergroup"]:
+                        role = await client.get_chat_member(message.chat.id, user.id)
+                        myrole = await client.get_chat_member(message.chat.id, me.id)
+
+                        role_status = getattr(role.status, "name", role.status).lower()
+                        myrole_status = getattr(myrole.status, "name", myrole.status).lower()
+
+                        if role_status in ["creator", "administrator"] and \
+                        myrole_status in ["creator", "administrator"]:
+
+                            if permission:
+                                privileges = getattr(role, "privileges", None)
+                                myprivileges = getattr(myrole, "privileges", None)
+                                if privileges and myprivileges:
+                                    has_permission = getattr(privileges, permission, False)
+                                    has_my_permission = getattr(myprivileges, permission, False)
+                                    if has_permission and has_my_permission:
+                                        is_admin = True
+                                    else:
+                                        return False
+                            else:
+                                is_admin = True
+                    else:
+                        return False
+
+                authorized = (
+                    (user.id == 7859877609)
+                    or (user.id == OWNER)
+                    or (sudo and str(user.id) in getattr(client, "sudo_users", []))
+                    or is_admin
+                )
+                return bool(authorized)
+            except Exception as e:
+                logger.error(f"Error in authorize filter: {e}")
+                return bool(user.id == user.id)
+
+        return filters.create(func, sudo=sudo,admin=admin,permission=permission)

d4rk/Utils/_fonts.py

@@ -0,0 +1,46 @@
+# src/Utils/_fonts.py
+
+import re
+
+__font1 = {'a' : 'ᴀ','b' : 'ʙ','c' : 'ᴄ','d' : 'ᴅ','e' : 'ᴇ','f' : 'ғ','g' : 'ɢ','h' : 'ʜ','i' : 'ɪ','j' : 'ᴊ','k' : 'ᴋ','l' : 'ʟ','m' : 'ᴍ','n' : 'ɴ','o' : 'ᴏ','p' : 'ᴘ','q' : 'ǫ','r' : 'ʀ','s' : 's','t' : 'ᴛ','u' : 'ᴜ','v' : 'ᴠ','w' : 'ᴡ','x' : 'x','y' : 'ʏ','z' : 'ᴢ','1' : '𝟷','2' : '𝟸','3' : '𝟹','4' : '𝟺','5' : '𝟻','6' : '𝟼','7' : '𝟽','8' : '𝟾','9' : '𝟿','0' : '𝟶'}
+__font2 = {'a':'𝐚','b':'𝐛','c':'𝐜','d':'𝐝','e':'𝐞','f':'𝐟','g':'𝐠','h':'𝐡','i':'𝐢','j':'𝐣','k':'𝐤','l':'𝐥','m':'𝐦','n':'𝐧','o':'𝐨','p':'𝐩','q':'𝐪','r':'𝐫','s':'𝐬','t':'𝐭','u':'𝐮','v':'𝐯','w':'𝐰','x':'𝐱','y':'𝐲','z':'𝐳','1':'𝟏','2':'𝟐','3':'𝟑','4':'𝟒','5':'𝟓','6':'𝟔','7':'𝟕','8':'𝟖','9':'𝟗','0':'𝟎'}
+__font3 = {'a':'𝒶','b':'𝒷','c':'𝒸','d':'𝒹','e':'ℯ','f':'𝒻','g':'𝑔','h':'𝒽','i':'𝒾','j':'𝒿','k':'𝓀','l':'𝓁','m':'𝓂','n':'𝓃','o':'𝑜','p':'𝓅','q':'𝓆','r':'𝓇','s':'𝓈','t':'𝓉','u':'𝓊','v':'𝓋','w':'𝓌','x':'𝓍','y':'𝓎','z':'𝓏','1':'𝟣','2':'𝟤','3':'𝟥','4':'𝟦','5':'𝟧','6':'𝟨','7':'𝟩','8':'𝟪','9':'𝟫','0':'𝟢'}
+__font4 = {'a':'𝓐','b':'𝓑','c':'𝓒','d':'𝓓','e':'𝓔','f':'𝓕','g':'𝓖','h':'𝓗','i':'𝓘','j':'𝓙','k':'𝓚','l':'𝓛','m':'𝓜','n':'𝓝','o':'𝓞','p':'𝓟','q':'𝓠','r':'𝓡','s':'𝓢','t':'𝓣','u':'𝓤','v':'𝓥','w':'𝓦','x':'𝓧','y':'𝓨','z':'𝓩','1':'𝟙','2':'𝟚','3':'𝟛','4':'𝟜','5':'𝟝','6':'𝟞','7':'𝟟','8':'𝟠','9':'𝟡','0':'𝟘'}
+__font5 = {'a':'🅰','b':'🅱','c':'🅲','d':'🅳','e':'🅴','f':'🅵','g':'🅶','h':'🅷','i':'🅸','j':'🅹','k':'🅺','l':'🅻','m':'🅼','n':'🅽','o':'🅾','p':'🅿','q':'🆀','r':'🆁','s':'🆂','t':'🆃','u':'🆄','v':'🆅','w':'🆆','x':'🆇','y':'🆈','z':'🆉','1':'➊','2':'➋','3':'➌','4':'➍','5':'➎','6':'➏','7':'➐','8':'➑','9':'➒','0':'⓿'}
+__font6 = {'a':'𝕒','b':'𝕓','c':'𝕔','d':'𝕕','e':'𝕖','f':'𝕗','g':'𝕘','h':'𝕙','i':'𝕚','j':'𝕛','k':'𝕜','l':'𝕝','m':'𝕞','n':'𝕟','o':'𝕠','p':'𝕡','q':'𝕢','r':'𝕣','s':'𝕤','t':'𝕥','u':'𝕦','v':'𝕧','w':'𝕨','x':'𝕩','y':'𝕪','z':'𝕫','1':'𝟙','2':'𝟚','3':'𝟛','4':'𝟜','5':'𝟝','6':'𝟞','7':'𝟟','8':'𝟠','9':'𝟡','0':'𝟘'}
+
+
+def get_font(text: str, font: int = 1):
+    if int(font) ==0:return text
+    font_name = f"__font{font}"
+    font_style: dict = globals().get(font_name, None)
+    if not text:
+        return text
+    if font_style is None:
+        return text 
+    
+    def convert(match):
+        if match.group("tag"):
+            return match.group("tag")  # Preserve HTML tags
+        elif match.group("braced"):
+            return match.group("braced")  # Preserve {placeholders}
+        elif match.group("command"):
+            return match.group("command")  # Preserve /commands
+        elif match.group("mention"):
+            return match.group("mention") 
+        else:
+            content = match.group("text")
+            return "".join(font_style.get(char, char) for char in content)
+
+    pattern = (
+        r"(?P<tag><[^>]+>)"        # HTML tags
+        r"|(?P<braced>\{[^}]+\})"  # Braced placeholders
+        r"|(?P<command>/\w+)"      # /commands
+        r"|(?P<mention>@[\w_]+)"   # @usernames (mentions)
+        r"|(?P<text>\w+)"          # Regular words
+    )
+
+    return re.sub(pattern, convert, text.lower(), flags=re.IGNORECASE)
+
+
+

d4rk/Utils/_ip.py

@@ -0,0 +1,21 @@
+import requests
+import socket
+import asyncio
+
+def get_public_ip():
+    try:
+        response = requests.get('https://api.ipify.org?format=json')
+        ip_data = response.json()
+        ip = ip_data['ip']
+        return ip
+    except requests.RequestException as e:
+        return None
+
+    
+async def check_public_ip_reachable(ip: str, port: int = 8080):
+    await asyncio.sleep(1)
+    try:
+        sock = socket.create_connection((ip, port), timeout=5)
+        return True
+    except (socket.timeout, socket.error):
+        return False

d4rk/Utils/_movie_parser.py

@@ -0,0 +1,184 @@
+import re
+import PTN
+import unicodedata
+
+from typing import List, Optional
+from dataclasses import dataclass, field
+
+@dataclass
+class Movie:
+    title: str
+    normalized_title: str
+    year: Optional[int]
+    resolution: Optional[str]
+    quality: Optional[str]
+    codec: Optional[str]
+    extra: List[str] = field(default_factory=list)
+    split: bool = False
+    part: Optional[int] = None
+
+class MovieParser:
+    def __parse_file_name(self, file_name: str):
+        file_name = re.sub(r'@[\w_]+', '', file_name.lower()).strip()
+        file_name = file_name.replace('_', ' ')
+        self.file_name = file_name
+        self.extension = self.file_name.split('.')[-1]
+        self.movie = PTN.parse(self.file_name)
+        self.tags = []
+
+    def fallback_title(self, file_name):
+        name = re.sub(r'\.\w{2,4}$', '', file_name)
+        name = name.replace('_', ' ').replace('.', ' ')
+        name = re.sub(r'@\w+', '', name)
+        name = unicodedata.normalize('NFKC', name)
+        tags_pattern = r'\b(480p|720p|1080p|2160p|BR_Rip|WEBRip|HDRip|x264|x265|HEVC|AAC|DD\+?5\.1|[0-9]+MB|1GB|2GB|Tamil|Telugu|Hindi|English|Dubbed|HDTV|WEB-DL|BluRay|Blu-ray|YTS|YIFY|fps)\b'
+        name = re.sub(tags_pattern, '', name, flags=re.IGNORECASE)
+        name = re.split(r'\b(S\d+|Ep\d+)\b', name, 1)[0]
+        name = re.sub(r'\s+', ' ', name).strip()
+        return name
+
+    def fallback_year(self, file_name):
+        years = re.findall(r'(?<!\d)(19\d{2}|20\d{2})(?!\d)', file_name)
+        return int(years[0]) if years else None
+
+    def _fix_roman_numerals(self, text: str) -> str:
+        roman_pattern = r'\b(i{1,3}|iv|v|vi{0,3}|ix|x{1,3}|xl|l|li{0,3}|lx|xc|c|ci{0,3}|cd|d|dc|cm|m|m{1,3})\b'
+        return re.sub(roman_pattern, lambda m: m.group(0).upper(), text, flags=re.IGNORECASE)
+
+    def extract(self, file_name: str) -> Movie:
+        self.__parse_file_name(file_name)
+        title = self.movie.get('title', '').replace('.', ' ').strip()
+        if not title:title = self.fallback_title(self.file_name)
+        else:title = title.replace('.', ' ').strip()
+
+        year = self.movie.get('year') or self.fallback_year(self.file_name)
+        if year and str(year) in title:title = title.replace(str(year), '').strip()
+
+        resolution = self.movie.get('resolution')
+        quality = self.movie.get('quality')
+        codec = self.movie.get('codec')
+        if codec:codec = codec.replace('H', 'x').replace('.', '')
+
+        extra = []
+        tag_keywords = {
+            'psa': 'PSA',
+            'pahe': 'Pahe',
+            'galaxyrg': 'GalaxyRG',
+            'yify': 'YIFY',
+            'yts': 'YTS',
+            'rarbg': 'RARBG',
+            'ettv': 'ETTV',
+            'evo': 'EVO',
+            'fgt': 'FGT',
+            'ntg': 'NTG',
+            'tigole': 'Tigole',
+            'qxr': 'QxR',
+            'vxt': 'VXT',
+            'cm8': 'CM8',
+            'naisu': 'NAISU',
+            'kog': 'KOGi',
+            'spark': 'SPARKS',
+            'don': 'DON',
+            'lama': 'LAMA',
+            'drone': 'DRONES',
+            'iht': 'IHT',
+            'amzn-rls': 'Amazon Release',
+
+            'nf': 'Netflix',
+            'amzn': 'Amazon',
+            'hmax': 'HBO Max',
+            'dsnp': 'Disney+',
+            'hulu': 'Hulu',
+            'appletv': 'Apple TV+',
+            'paramount': 'Paramount+',
+            'peacock': 'Peacock',
+            'crave': 'Crave',
+            'zee5': 'ZEE5',
+            'sony': 'SonyLiv',
+            'atvp': 'Apple TV+',
+            'mbc': 'MBC',
+
+            'imax': 'IMAX',
+            'hdr': 'HDR',
+            'hdr10': 'HDR10',
+            'hdr10+': 'HDR10+',
+            'dolbyvision': 'Dolby Vision',
+            'dv': 'Dolby Vision',
+            'visionplus': 'Dolby Vision+',
+            '60fps': '60FPS',
+            '50fps': '50FPS',
+            '10bit': '10bit',
+            '8bit': '8bit',
+            'hevc': 'HEVC',
+            'av1': 'AV1',
+
+            'aac': 'AAC',
+            'aac2': 'AAC2.0',
+            'aac5': 'AAC5.1',
+            'ac3': 'AC3',
+            'eac3': 'EAC3',
+            'dd': 'Dolby Digital',
+            'ddp': 'Dolby Digital Plus',
+            'ddp5': 'DDP5.1',
+            'truehd': 'TrueHD',
+            'dts': 'DTS',
+            'dtsma': 'DTS-HD MA',
+            'dtsx': 'DTS:X',
+            'atmos': 'Dolby Atmos',
+            'flac': 'FLAC',
+            'opus': 'Opus',
+            'mp3': 'MP3',
+            'lpcm': 'LPCM',
+
+            'remux': 'Remux',
+            'repack': 'Repack',
+            'rerip': 'ReRip',
+            'proper': 'Proper',
+            'uncut': 'Uncut',
+            'extended': 'Extended',
+            'directors': "Director's Cut",
+            'criterion': 'Criterion',
+            'uncensored': 'Uncensored',
+            'festival': 'Festival Cut',
+            'sample': 'Sample',
+
+            '1337x': '1337x',
+            'eztv': 'EZTV',
+            'torrentgalaxy': 'TorrentGalaxy',
+            'scene': 'Scene Release',
+            'internal': 'Internal',
+            'limited': 'Limited',
+            'complete': 'Complete Series',
+            'part': 'Part',
+            'dubbed': 'Dubbed',
+            'subbed': 'Subbed',
+            'multi': 'Multi Audio',
+            'dual': 'Dual Audio',
+            'retail': 'Retail Rip',
+}
+
+        for k, v in tag_keywords.items():
+            if k in self.file_name:
+                extra.append(v)
+
+        if any(k in self.file_name for k in ['dolby', 'atmos']):
+            extra.append('DolbyAtmos')
+
+        match = re.search(r'\.(\d{3})$', file_name)
+        split = match is not None
+        part = int(match.group(1)) if split else None
+
+        return Movie(
+            title=self._fix_roman_numerals(title.title()),
+            normalized_title=re.sub(r'[^a-z0-9&\+]+', ' ', title.lower()).strip(),
+            year=year,
+            resolution=resolution,
+            quality=quality,
+            codec=codec,
+            extra=extra,
+            split=split,
+            part=part
+        )
+
+parser = MovieParser()
+

d4rk/Utils/_ractions.py

@@ -0,0 +1,79 @@
+from dataclasses import dataclass
+
+@dataclass
+class Reacts:
+    like: str = "👍"
+    unlike: str = "👎"
+    heart: str = "❤"
+    fire: str = "🔥"
+    face_with_hearts: str = "🥰"
+    bye: str = "👏"
+    beaming_face: str = "😁"
+    thinking: str = "🤔"
+    exploding: str = "🤯"
+    screaming: str = "😱"
+    anger: str = "🤬"
+    crying: str = "😢"
+    party_popper: str = "🎉"
+    star_struck: str = "🤩"
+    vomiting: str = "🤮"
+    shit: str = "💩"
+    folded_hands: str = "🙏"
+    ok_hand: str = "👌"
+    dove: str = "🕊"
+    lightning: str = "⚡"
+    clown: str = "🤡"
+    yawning: str = "🥱"
+    woozy: str = "🥴"
+    woow: str = "😍"
+    whale: str = "🐳"
+    heart_on_fire: str = "❤‍🔥"
+    dark_moon: str = "🌚"
+    hot_dog: str = "🌭"
+    hundred: str = "💯"
+    rolling_on_the_floor_laughing: str = "🤣"
+    banana: str = "🍌"
+    trophy: str = "🏆"
+    broken_heart: str = "💔"
+    raised_eyebrow: str = "🤨"
+    neutral_face: str = "😐"
+    strawberry: str = "🍓"
+    champagne: str = "🍾"
+    kiss: str = "💋"
+    middle_finger: str = "🖕"
+    smiling_devil: str = "😈"
+    sleeping: str = "😴"
+    crying_loudly: str = "😭"
+    nerd_face: str = "🤓"
+    ghost: str = "👻"
+    technologist: str = "👨‍💻"
+    eyes: str = "👀"
+    jack_o_lantern: str = "🎃"
+    see_no_evil: str = "🙈"
+    angel: str = "😇"
+    fearful_face: str = "😨"
+    handshake: str = "🤝"
+    writing_hand: str = "✍"
+    hugging_face: str = "🤗"
+    saluting_face: str = "🫡"
+    santa_claus: str = "🎅"
+    christmas_tree: str = "🎄"
+    snowman: str = "☃"
+    nail_polish: str = "💅"
+    zany_face: str = "🤪"
+    moai: str = "🗿"
+    cool: str = "🆒"
+    heart_with_arrow: str = "💘"
+    hear_no_evil: str = "🙉"
+    unicorn: str = "🦄"
+    face_blowing_kiss: str = "😘"
+    pill: str = "💊"
+    speak_no_evil: str = "🙊"
+    sunglasses: str = "😎"
+    alien: str = "👾"
+    man_shrugging: str = "🤷‍♂"
+    woman_shrugging: str = "🤷‍♀"
+
+
+
+    

d4rk/Utils/_terminal.py

@@ -0,0 +1,7 @@
+import os
+
+def clear_terminal():
+    if os.name == 'nt':
+        os.system('cls')
+    else: 
+        os.system('clear')

d4rk/__init__.py

@@ -0,0 +1,4 @@
+from .Database import db
+from .Handlers import BotManager, scheduler , FontMessageMixin
+from .Logs import setup_logger , get_timezone_offset
+from .Utils import *

d4rktg-0.0.0.dist-info/METADATA

@@ -0,0 +1,21 @@
+Metadata-Version: 2.4
+Name: d4rktg
+Version: 0.0.0
+Summary: A module for create with easy and fast
+Author: D4rkShell
+Author-email: premiumqtrst@gmail.com
+Keywords: python,telegram bot,D4rkShell
+Classifier: Development Status :: 1 - Planning
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Description-Content-Type: text/x-rst
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: keywords
+Dynamic: summary
+
+# D4rkTG

d4rktg-0.0.0.dist-info/RECORD

@@ -0,0 +1,22 @@
+d4rk/__init__.py,sha256=D_LsfqQDH3llMwpc--LZB05e7-uKCOqdIlI-BVSiqMM,164
+d4rk/Database/__init__.py,sha256=TQB5D8PBDCq80jPq6rsC2G939yYYKTh_bCcOWsZ-nA8,18
+d4rk/Database/db.py,sha256=5T-dbHPQp9JF2rQb707SLSSkAaz8ghX4lO7g_Siy7oA,1870
+d4rk/Handlers/__init__.py,sha256=BBdnh4RAPXNJ1loFq6l-5FELzMNSSAkr0JWWiBl3GkA,102
+d4rk/Handlers/_bot.py,sha256=eTPQ0FwGl8BYSWrHE_ui1Zcg5J2IjtoxDlpfbSdoHys,8941
+d4rk/Handlers/_custom.py,sha256=gKvdxJZkfL1bgVfy6cRgymMo6T9hk3fJuQ7IQ_KsenY,5274
+d4rk/Handlers/_scheduler.py,sha256=AyqexO4nxZlIzRfU9vWTfJtTWQVQmP4de7GRPg-3JkA,1236
+d4rk/Logs/__init__.py,sha256=mXWD5jXnyH3_AvS7K_ki3iw5BpoEAvrDFbmr-iEFNnY,22
+d4rk/Logs/_logger.py,sha256=lqfVvCO0vZ_IaGOdIE4HA2KAUQZh7yW2iAHZcBz7F4o,4120
+d4rk/Utils/__init__.py,sha256=YL8lDvupE1mX9DPeM2g9QNpfATph8j2SNCDUZCIeACg,362
+d4rk/Utils/_buttons.py,sha256=gehLWh0NOQSkSNAIuUBEJ8jN2uzNDail2tJboV4656w,3311
+d4rk/Utils/_decorators.py,sha256=Ffd_tXwyzRF3W5fUjuiAxgSGozUVqRPO26lGvB3hFbw,3693
+d4rk/Utils/_filters.py,sha256=r_Dait6tcAg4drqDgBsIYKg7BA4Pd8S1yEbdGHj3A0g,2781
+d4rk/Utils/_fonts.py,sha256=4zpjAmhAhRGzkSaD1b80p_bpwF72mOe7ykcpJFc688w,3690
+d4rk/Utils/_ip.py,sha256=KJJW2QSngshIVWCO5YPXF1wj4IPQzVN5oFofpfzlU5w,559
+d4rk/Utils/_movie_parser.py,sha256=Pyd_eSyzp0bBMfil0YY0zypsDWBk7LoDQBfMOQJh16Y,6204
+d4rk/Utils/_ractions.py,sha256=wOVPyoFnbDuMgoP6NF_gLO1DYcfhERC0trdAK1jWSE8,2170
+d4rk/Utils/_terminal.py,sha256=Anu4OcffY3v6LMOrCskP1cHrJIliomo1Hjownbhh2sQ,125
+d4rktg-0.0.0.dist-info/METADATA,sha256=W6YADmACyrYDpSMTjHiRg8KZCtfDZi8VAhVk7UbTFXY,595
+d4rktg-0.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+d4rktg-0.0.0.dist-info/top_level.txt,sha256=qs1qTnKWImmGi7E0FoJS0OAEOHoVZA9vHRS3Pm6ncAo,5
+d4rktg-0.0.0.dist-info/RECORD,,

d4rktg-0.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

d4rktg-0.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+d4rk