d4rktg 0.0.1__py3-none-any.whl → 0.0.2__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
+        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,2 @@
+from ._bot import BotManager
+from ._scheduler import scheduler

d4rk/Handlers/_bot.py

@@ -0,0 +1,239 @@
+import os
+import sys
+import asyncio
+import traceback
+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
+
+logger = setup_logger(__name__)
+
+class BotManager(Client):
+    _bot: Client = None
+    _web = True
+    _bot_info = None
+    _is_connected = False
+    _flood_data = {}
+    TOKEN_INDEX = 0
+    _loop = None
+    _scheduler_thread = None
+
+    def create_client(self,token_index):
+        super().__init__(
+            name=self.app_name,
+            api_id=self.api_id,
+            api_hash=self.api_hash,
+            bot_token=self.tokens[token_index],
+            plugins=self.plugins,
+            in_memory=True
+            )
+
+    def load_flood_data(self):
+        if not os.path.exists('flood.txt'):
+            return self._flood_data
+
+        with open('flood.txt', "r") as f:
+            for line in f:
+                if ":" not in line:
+                    continue
+                try:
+                    token_index, until = map(int, line.strip().split(":"))
+                    if token_index not in self._flood_data or until > self._flood_data[token_index]:
+                        self._flood_data[token_index] = until
+                except:
+                    continue
+
+    async def handle_flood_wait(self, wait_time: int):
+        logger.info(f"FloodWait: Sleeping for {wait_time} seconds.")
+
+        await asyncio.sleep(wait_time)
+        try:await super().start()
+        except AccessTokenExpired: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")
+
+    def get_token_index_from_flood_file(self):
+        if not os.path.exists("flood.txt"):
+            return 0
+        now = int(datetime.now(self.TZ).timestamp())
+        available = []
+        non_flooded = []
+        for i in range(len(self.tokens)):
+            until = self._flood_data.get(i, 0)
+            if until <= now:
+                logger.info(f"Token {i} is not in flood.")
+                self._flood_data.pop(i, None)
+                self.save_flood_data()
+                non_flooded.append((i))
+            else:
+                available.append((i, until))
+            if non_flooded != []:
+                return non_flooded[0]
+        logger.warning("All tokens are in flood. Picking the one with the soonest expiry.")
+        available.sort(key=lambda x: x[1])
+        return available[0][0]
+    def save_flood_data(self):
+        with open('flood.txt', "w") as f:
+            for token_index, until in self._flood_data.items():
+                f.write(f"{token_index}:{until}\n")
+
+    async def change_token(self, token_index,wait_time):
+        flood_until = datetime.now(self.TZ) + timedelta(seconds=wait_time)
+        self._flood_data[token_index] = int(flood_until.timestamp())
+        self.save_flood_data()
+        try:
+            self.TOKEN_INDEX = token_index + 1
+            self.create_client(self.TOKEN_INDEX)
+            await asyncio.sleep(2)
+        except:
+            self.TOKEN_INDEX = 0
+            self.create_client(self.TOKEN_INDEX)
+            await self.handle_flood_wait(wait_time)
+
+    async def setup_webserver(self):
+        self._web_runner = await self.web_server.setup_web_server(8443)
+
+    async def powerup(self):
+        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.load_flood_data()
+        self.TOKEN_INDEX= self.get_token_index_from_flood_file()
+        self.create_client(self.TOKEN_INDEX)
+        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.start_scheduler()
+                    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.change_token(self.TOKEN_INDEX,e.value)
+                
+            except AccessTokenExpired:
+                logger.error(f"Access token expired (attempt {attempt + 1})")
+                await self.change_token(self.TOKEN_INDEX, 60)
+            except Exception as e:
+                logger.error(f"Error starting Client (attempt {attempt + 1}): {e}")
+                logger.error(traceback.format_exc())
+                if attempt < max_retries - 1:
+                    logger.info("Retrying in 10 seconds...")
+                    await asyncio.sleep(10)
+        else:
+            logger.error("Failed to start bot after all retry attempts")
+
+        await self.setup_webserver()
+
+    async def powerdown(self, *args):
+        logger.info("Initiating APP to stop...")
+        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:
+            logger.info("Stopping bot client...")
+            try:
+                if self.LOGS:
+                    await self.send_message(chat_id=self.LOGS, text=f"{self._bot_info.mention} stopping...")
+                    await self.send_document(chat_id=self.LOGS, document=f"logs/log-{today}.txt")
+                    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 notification: {e}")
+            logger.info(f"{self._bot_info.first_name} - @{self._bot_info.username} Stoped")
+            await super().stop()
+            sys.exit(0)
+
+    async def reboot(self):
+        try:
+            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:
+                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)
+            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 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/_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,70 @@
+# src/Log/_logger_config.py
+
+import os
+import logging
+from datetime import datetime, timezone, timedelta
+from logging.handlers import TimedRotatingFileHandler
+
+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 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 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)
+    
+    # Create formatter with Sri Lanka timezone
+    formatter = TimeZoneFormatter(
+        '%(asctime)s - %(name)s - %(funcName)s:%(lineno)d - %(levelname)s - %(message)s',
+        datefmt='%Y-%m-%d %H:%M:%S'
+    )
+    
+    file_handler.setFormatter(formatter)
+    console_handler.setFormatter(formatter)
+    logger.addHandler(file_handler)
+    logger.addHandler(console_handler)
+    logger.propagate = False
+    return logger

d4rk/Models/__init__.py

@@ -0,0 +1,2 @@
+from ._commands import command , find_command
+from ._movie_title import movie_finder

d4rk/Models/_commands.py

@@ -0,0 +1,66 @@
+import re
+import requests
+
+from typing import Union
+from functools import wraps
+from pyrogram import Client, filters
+
+from d4rk.Logs import setup_logger
+
+logger = setup_logger(__name__)
+
+command_registry = []
+
+def command(command: Union[str, list], description: str):
+    def decorator(func):
+        command_registry.append({
+            "command": command,
+            "description": description,
+            "handler": func
+        })
+        logger.info(f"Registered command: {command} - {description}")
+        @Client.on_message(filters.command(command))
+        @wraps(func)
+        async def wrapper(client, message):
+            return await func(client, message)
+        
+        return wrapper
+    return decorator
+
+class CommandAI:
+    def __init__(self):
+        self.api_key = "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"
+        self.api_url = "https://api-inference.huggingface.co/models/facebook/bart-large-mnli"
+        self.headers = {"Authorization": "Bearer " + self.api_key}
+
+    def __post(self,payload):   
+        response = requests.post(self.api_url, headers=self.headers, json=payload)
+        if response.status_code != 200:
+            print(f"❌ Error {response.status_code}: {response.text}")
+            return None
+        return response.json()
+    
+    def extract_username(self, query: str):
+        match = re.search(r'@[\w\d_]+', query)
+        return match.group(0) if match else None
+
+    def get_command(self,user_query):
+        labels = [entry["description"] for entry in command_registry]
+        response = self.__post(
+            payload={
+                "inputs": user_query,
+                "parameters": {"candidate_labels": labels},
+            }
+        )
+        print(response)
+        if response is None:return None
+        best_label = response["labels"][0]
+        if best_label is None:
+            logger.error("No matching command found for the user query.")
+            return None
+        for entry in command_registry:
+            if entry["description"] == best_label:
+                return entry["command"] if isinstance(entry["command"], str) else entry["command"][0]
+        return None
+
+find_command = CommandAI()

d4rk/Models/_movie_title.py

@@ -0,0 +1,26 @@
+# src/models/_movie_title.py
+
+from rapidfuzz import process
+
+class FindMovie:
+    def __init__(self):
+        self.movie_titles = []
+        self.movie_docs = []
+    
+    def load_movie_titles(self, titles :list):
+        self.movie_docs = titles
+        self.movie_titles = [doc["title"] for doc in self.movie_docs]
+
+    def get_match_one(self,user_input):
+        match, _, _ = process.extractOne(user_input, self.movie_titles)
+        return match
+
+    def get_match_doc(self,match):
+        return next((doc for doc in self.movie_docs if doc["title"] == match), None)
+    
+    def get_match(self, user_input :str,limit :int=3):
+        matches = process.extract(user_input, self.movie_titles, limit=limit)
+        return matches
+
+movie_finder = FindMovie()
+

d4rk/Utils/__init__.py

@@ -0,0 +1,6 @@
+from ._terminal import clear_terminal
+from ._ip import check_public_ip_reachable , get_public_ip
+from ._decorators import authorize
+from ._delete import delete
+from ._ractions import Reacts
+from ._fonts import FontMessageMixin , get_font

d4rk/Utils/_decorators.py

@@ -0,0 +1,76 @@
+import os
+import asyncio
+import functools
+
+from typing import Union
+from pyrogram import Client 
+from d4rk.Logs import setup_logger
+from pyrogram.types import Message , CallbackQuery , ChatPrivileges
+
+from ._delete import delete
+from ._ractions import Reacts
+
+logger = setup_logger(__name__)
+
+OWNER = os.getenv("OWNER", 7859877609)
+
+def authorize(sudo=True,admin=False,delete_command=True, react=True,react_emoji:Reacts=Reacts.fire,alert=True,permission=None):
+    def decorator(func):
+        @functools.wraps(func)
+        async def wrapper(client: Client, message: Union[Message,CallbackQuery]):
+            try:
+                user = message.from_user
+                if not user:
+                    logger.warning(f"Unauthorized access attempt from non-user message: {message}")
+                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)
+                        if (user_admin:= role.status.name.lower() in ["creator", "administrator","owner"]) and (i_am_admin:=myrole.status.name.lower() in ["creator", "administrator","owner"]):
+                            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:
+                                        msg = ""
+                                        if not has_permission and not has_my_permission:msg = f"❌ Neither you nor I "
+                                        elif not has_permission:msg = f"❌ You don't"
+                                        elif not has_my_permission:msg = f"❌ I don't"
+                                        msg += f" have the required permission: `{permission}`."
+                                        return await client.send_alert(message=message,text=msg)
+                            else:is_admin = True
+                    else:
+                        if alert:
+                            return await client.send_alert(message=message,text="❌ This command can only be used in groups.")
+                        
+                authorized = user.id == OWNER or (sudo and user.id in client.sudo_users) or is_admin
+                if react and isinstance(message, Message):
+                    try:await message.react(react_emoji)
+                    except:pass
+                
+                if not authorized:
+                    logger.warning(f"Unauthorized {func.__name__} request from user {user.id} @{user.username}")
+                    if alert:
+                        m = await client.send_alert(message=message,text="❌ Unauthorized access.")
+                        if react and isinstance(message, Message):
+                            await message.react(Reacts.shit)
+                            if m:await delete(client, message.chat.id, m.id, timeout=5)
+                
+                else:
+                    logger.info(f"Authorized user {user.id} executing {func.__name__}")
+                    await func(client, message)
+                if delete_command:
+                    try:await delete(client, message.chat.id, message.id, timeout=5)
+                    except:pass
+            except Exception as e:
+                logger.error(f"Error in {func.__name__}: {e}")
+            return
+        return wrapper
+    return decorator
+

d4rk/Utils/_delete.py

@@ -0,0 +1,16 @@
+import asyncio
+
+from pyrogram import Client
+from d4rk.Logs import setup_logger
+
+logger = setup_logger(__name__)
+
+async def delete(client: Client, chat_id: int, message_id: int,timeout: int=3):
+    await asyncio.create_task(delete_message_worker(client,chat_id, message_id, timeout))
+
+async def delete_message_worker(client,chat_id, message_id, timeout):
+    await asyncio.sleep(timeout)
+    try:
+        await client.delete_messages(chat_id=chat_id, message_ids=message_id)
+    except Exception as e:
+        logger.error(f"Error deleting message {message_id}: {e}")

d4rk/Utils/_fonts.py

@@ -0,0 +1,82 @@
+# src/Utils/_fonts.py
+
+import re
+
+from typing import Union
+
+from pyrogram import Client
+from pyrogram.enums import ParseMode
+from pyrogram.types import Message, CallbackQuery
+
+__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':'𝟘'}
+
+class FontMessageMixin(Client):
+    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)
+
+    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)
+
+    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)
+
+    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)
+
+    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)
+
+    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)
+
+    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)
+
+    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)
+
+    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)
+    
+    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)
+
+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,92 @@
+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',
+            'imax': 'IMAX', '60fps': '60FPS'
+        }
+        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,5 @@
+from .Database import db
+from .Handlers import BotManager, scheduler
+from .Logs import setup_logger , get_timezone_offset
+from .Models import command, find_command, movie_finder
+from .Utils import *

{d4rktg-0.0.1.dist-info → d4rktg-0.0.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: d4rktg
-Version: 0.0.1
+Version: 0.0.2
 Summary: A module for create with easy and fast
 Author: D4rkShell
 Author-email: premiumqtrst@gmail.com

d4rktg-0.0.2.dist-info/RECORD

@@ -0,0 +1,23 @@
+d4rk/__init__.py,sha256=Xq5qqX-FwosTJBLrSPF53FPD6fEISH750hbImZpSu5k,202
+d4rk/Database/__init__.py,sha256=TQB5D8PBDCq80jPq6rsC2G939yYYKTh_bCcOWsZ-nA8,18
+d4rk/Database/db.py,sha256=MHy3vJRyDMxFbuw8iIw2HZ26cQdT98MBz6LUi1wnpW0,1854
+d4rk/Handlers/__init__.py,sha256=lO1b7Tnu3GWgwcJmX5qepiNqaBBi6qTgjj0SlzVUyEA,63
+d4rk/Handlers/_bot.py,sha256=A4zPQexHScxIajtKMbsjH1ohgVssukeMaL0jKhgpiPI,10502
+d4rk/Handlers/_scheduler.py,sha256=AyqexO4nxZlIzRfU9vWTfJtTWQVQmP4de7GRPg-3JkA,1236
+d4rk/Logs/__init__.py,sha256=mXWD5jXnyH3_AvS7K_ki3iw5BpoEAvrDFbmr-iEFNnY,22
+d4rk/Logs/_logger.py,sha256=C09OA5wUpl5oLp7oAs5P2CrpBKkcHxjUYetCtHJ1Kqk,2379
+d4rk/Models/__init__.py,sha256=84TdTKOHM5fr3T_B77tqgRTnLk5UtaEcGYY0mdLSUNo,85
+d4rk/Models/_commands.py,sha256=YbV6LQgMlTnbtaPRI_yRWWACQVgEBrlPclU-l51yH4Q,2248
+d4rk/Models/_movie_title.py,sha256=s4nUjMTe7th7gNkLy1wDiEZV-OcBvx3ZoV7gVeP9428,788
+d4rk/Utils/__init__.py,sha256=rLJgLDUQqt8e0o1FdXu0RKmkYpV8sd8mfEzYewBXIy4,242
+d4rk/Utils/_decorators.py,sha256=DjrzX3W6nGmrShH2KT4Zm4vfczj3HJv0CGb8Z-9tZ40,4093
+d4rk/Utils/_delete.py,sha256=gSmQAENGmM5XCCJfPuJ4vRMSxtixYG0vYdocU-2TSFg,581
+d4rk/Utils/_fonts.py,sha256=1NxszvAB7kZMMSUBUYFb0vwvqtJFNpFlO04e3jYteGY,6669
+d4rk/Utils/_ip.py,sha256=KJJW2QSngshIVWCO5YPXF1wj4IPQzVN5oFofpfzlU5w,559
+d4rk/Utils/_movie_parser.py,sha256=eiy1YVSu9fgk9pIXnMojJkWhW6SbdewKGF0ATk2qZoA,3440
+d4rk/Utils/_ractions.py,sha256=wOVPyoFnbDuMgoP6NF_gLO1DYcfhERC0trdAK1jWSE8,2170
+d4rk/Utils/_terminal.py,sha256=Anu4OcffY3v6LMOrCskP1cHrJIliomo1Hjownbhh2sQ,125
+d4rktg-0.0.2.dist-info/METADATA,sha256=QJ5UOauEFMY4S2B0pv9EXjhKEjWZP7JjmK_98fq3FNw,923
+d4rktg-0.0.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+d4rktg-0.0.2.dist-info/top_level.txt,sha256=qs1qTnKWImmGi7E0FoJS0OAEOHoVZA9vHRS3Pm6ncAo,5
+d4rktg-0.0.2.dist-info/RECORD,,

d4rktg-0.0.2.dist-info/top_level.txt

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

d4rktg-0.0.1.dist-info/RECORD

@@ -1,4 +0,0 @@
-d4rktg-0.0.1.dist-info/METADATA,sha256=9R-llUIL7azgsymexAccpIGBWYxioHE0ECDJr_91dMs,923
-d4rktg-0.0.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-d4rktg-0.0.1.dist-info/top_level.txt,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-d4rktg-0.0.1.dist-info/RECORD,,

d4rktg-0.0.1.dist-info/top_level.txt

@@ -1 +0,0 @@
-