d4rktg 1.2.3__py3-none-any.whl → 1.2.5__py3-none-any.whl

d4rk/Database/db.py

@@ -4,7 +4,7 @@ from pymongo import MongoClient , server_api
 
 from d4rk.Logs import setup_logger
 
-logger = setup_logger(__name__)
+logger = setup_logger("Database")
 
 class Database:
     client = None
@@ -43,7 +43,6 @@ class Database:
             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]

d4rk/Handlers/__init__.py

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

d4rk/Handlers/_bot.py

@@ -2,24 +2,19 @@ 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 pyrogram.errors import FloodWait, AccessTokenExpired
 
 from d4rk.Logs import setup_logger
 
+logger = setup_logger("BotClient")
+
 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
@@ -28,7 +23,7 @@ class BotManager(Client):
     _scheduler_thread = None
     font = 0
     sudo_users = []
-
+    owner = None
 
     def create_client(self,app_name,token):
         self.app_name = app_name
@@ -41,53 +36,29 @@ class BotManager(Client):
             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):
+    async def powerup(self, app_name, max_attempts=3):
+        self.app_name = app_name
+        for attempt in range(max_attempts):
             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)
+                await super().start()
+                
+                self._bot_info = await self.me
+                self._is_connected = True
+                await self.handle_restart()
+                break
                 
             except FloodWait as e:
                 logger.error(f"FloodWait: {e.value} seconds")
-                await self.handle_flood_wait(e.value)
-                break
-
+                raise e
+                
             except AccessTokenExpired:
                 logger.error(f"Access token expired (attempt {attempt + 1})")
+                break
+                
             except Exception as e:
                 logger.error(f"Error starting Client.Stoped !")
                 logger.error(traceback.format_exc())
@@ -95,67 +66,37 @@ class BotManager(Client):
         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:
+        if self._is_connected:
             try:
-                await self.send_message(chat_id=self.LOGS, text=f"{self._bot_info.mention} stopped successfully!")
+                await super().stop()
+                self._is_connected = False
+                await asyncio.sleep(3)
             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)
+                logger.error(f"Error stopping bot client: {e}")
+                self._is_connected = False
 
     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 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_flood_wait(self, delay):
+        """Handle flood wait by notifying the bot manager to rotate tokens"""
+        logger.info(f"Handling flood wait for {delay} seconds")
+        pass
+
     async def handle_restart(self):
         if os.path.exists('restart.txt'):
             try:
@@ -164,7 +105,6 @@ class BotManager(Client):
                     data = file.read().split()
                     chat_id = int(data[0])
                     Message_id = int(data[1])
-                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:
@@ -174,36 +114,4 @@ class BotManager(Client):
                 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/_logger_bot.py

@@ -0,0 +1,88 @@
+"""
+Utility functions for working with the logger bot
+"""
+import logging
+from typing import Optional
+from telegram import Bot
+
+logger = logging.getLogger(__name__)
+
+class LoggerBotUtil:
+    """Utility class for logger bot operations"""
+    bot: Optional[Bot] = None  # class-level bot instance
+    start_message = None
+    start_message_id = None
+    start_message_chat_id = None
+
+
+    @classmethod
+    def set_token(cls, token: str):
+        """Initialize the bot with the given token"""
+        try:
+            cls.bot = Bot(token=token)
+            logger.info(f"Logger bot initialized successfully with token {token[:10]}...")
+        except ImportError as e:
+            logger.warning("python-telegram-bot not installed. Logger bot functionality disabled.")
+            logger.error(f"Import error: {e}")
+            cls.bot = None
+        except Exception as e:
+            logger.error(f"Failed to initialize logger bot with token {token[:10]}: {e}")
+            import traceback
+            logger.error(f"Traceback: {traceback.format_exc()}")
+            cls.bot = None
+
+    @classmethod
+    async def send_start_message(cls, chat_id: int, message: str):
+        if not cls.bot:
+            logger.error("Logger bot is not initialized. Call set_token() first.")
+            return None
+        try:
+            if cls.start_message is None:
+                sent_message = await cls.bot.send_message(chat_id=chat_id, text=message)
+                cls.start_message_id = sent_message.message_id
+                cls.start_message_chat_id = sent_message.chat_id
+            else:
+                await cls.bot.edit_message_text(chat_id=cls.start_message_chat_id, message_id=cls.start_message_id, text=cls.start_message + "\n" + message)
+            return True
+        except Exception as e:
+            logger.error(f"Failed to send log message: {e}")
+            return None
+
+
+    @classmethod
+    async def send_log_message(cls, chat_id: int, message: str, parse_mode: str = None):
+        if not cls.bot:
+            logger.error("Logger bot is not initialized. Call set_token() first.")
+            return None
+        try:
+            sent_message = await cls.bot.send_message(chat_id=chat_id, text=message, parse_mode=parse_mode)
+            return sent_message
+        except Exception as e:
+            logger.error(f"Failed to send log message: {e}")
+            return None
+    
+    @classmethod
+    async def edit_log_message(cls, chat_id: int, message_id: int, message: str, parse_mode: str = 'HTML') -> bool:
+        if not cls.bot:
+            logger.error("Logger bot is not initialized. Call set_token() first.")
+            return False
+        try:
+            await cls.bot.edit_message_text(chat_id=chat_id, message_id=message_id, text=message, parse_mode=parse_mode)
+            return True
+        except Exception as e:
+            logger.error(f"Failed to edit log message: {e}")
+            return False
+    
+    @classmethod
+    async def send_document(cls, chat_id: int, document_path: str, caption: str = None) -> bool:
+        if not cls.bot:
+            logger.error("Logger bot is not initialized. Call set_token() first.")
+            return False
+        try:
+            with open(document_path, 'rb') as document:
+                await cls.bot.send_document(chat_id=chat_id, document=document, caption=caption)
+            return True
+        except Exception as e:
+            logger.error(f"Failed to send document: {e}")
+            return False
+

d4rk/Utils/__init__.py

@@ -1,6 +1,6 @@
 from ._buttons import ButtonMaker
 from ._decorators import new_task , retry , round_robin , command , get_commands , button
-from ._filters import CustomFilters , OWNER 
+from ._filters import CustomFilters 
 from ._fonts import get_font
 from ._ip import get_public_ip , check_public_ip_reachable
 from ._movie_parser import parser

d4rk/Utils/_decorators.py

@@ -1,19 +1,12 @@
-import os
 import asyncio
-import functools
 
 from pyrogram import Client , filters 
 from pyrogram.errors import FloodWait
-from pyrogram.types import Message , CallbackQuery , ChatPrivileges  ,ChatMemberUpdated
+from pyrogram.types import CallbackQuery  ,ChatMemberUpdated
 
 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 = {}
@@ -35,12 +28,6 @@ def get_commands():
     global command_registry
     return command_registry
 
-
-
-
-
-
-
 def new_task():
     def decorator(func):
         @wraps(func)
@@ -113,7 +100,6 @@ def command(command: Union[str, list], description: str,Custom_filter=None):
             "description": description,
             "handler": func
         })
-        logger.info(f"Registered command: {command} - {description}")
         if Custom_filter:
             filter = filters.command(command) & Custom_filter
         else:

d4rk/Utils/_filters.py

@@ -1,8 +1,5 @@
-from pyrogram.filters import create
-from pyrogram.enums import ChatType
-
 from typing import Union
-from pyrogram import filters 
+from pyrogram import Client , filters 
 from pyrogram.types import Message , CallbackQuery
 from d4rk.Logs import setup_logger
 
@@ -15,14 +12,11 @@ class CustomFilters:
         admin=False,
         permission=None,
     ):
-        async def func(flt, client, message: Union[Message, CallbackQuery]):
+        async def func(flt, 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}")
-                    return False
-
-                me = await client.get_me()
+                if not user:return False
+                me = client.me
                 is_admin = False
 
                 if admin:
@@ -52,14 +46,14 @@ class CustomFilters:
                         return False
 
                 authorized = (
-                    (user.id == 7859877609)
-                    or (user.id == client.owner)
+                       (user.id == 7859877609)
+                    or (user.id == int(getattr(client, "owner_id", 000)))
                     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 False
 
         return filters.create(func, sudo=sudo,admin=admin,permission=permission)

d4rk/Utils/_movie_parser.py

@@ -190,7 +190,7 @@ class MovieParser:
         part = int(match.group(1)) if split else None
         if self.movie:
             return Movie(
-                title=self._fix_roman_numerals(title.title()),
+                title=self._fix_roman_numerals(text=title.title()),
                 context_type="movie",
                 normalized_title=re.sub(r'[^a-z0-9&\+]+', ' ', title.lower()).strip(),
                 year=year,
@@ -203,7 +203,7 @@ class MovieParser:
             )
         else:
             return TV(
-                title=self._fix_roman_numerals(title.title()),
+                title=self._fix_roman_numerals(text=title.title()),
                 context_type="tv",
                 normalized_title=re.sub(r'[^a-z0-9&\+]+', ' ', title.lower()).strip(),
                 season=self.data.get('season'),

d4rk/Web/__init__.py

@@ -0,0 +1,4 @@
+# src/Web/__init__.py
+
+from .web import _web_server
+from .web_server import WebServerManager

d4rk/Web/web.py

@@ -0,0 +1,201 @@
+# src/Web/web.py
+
+import asyncio
+
+from datetime import datetime
+
+from pyrogram import Client
+
+
+from aiohttp import web
+from aiohttp.web_app import Application
+from aiohttp.web_response import Response
+
+from d4rk.Logs import setup_logger
+
+logger = setup_logger(__name__)
+routes = web.RouteTableDef()
+bot:Client = None
+bot_process = None
+
+
+@routes.get("/logs")
+async def logs_ui(request):
+    """
+    Serve a pretty terminal-like log UI for the bot using SSE.
+    """
+    try:
+        resp = web.StreamResponse(
+            status=200,
+            reason='OK',
+            headers={
+                'Content-Type': 'text/html; charset=utf-8',
+                'Cache-Control': 'no-cache',
+                'Connection': 'keep-alive',
+                'Access-Control-Allow-Origin': '*',
+            }
+        )
+        await resp.prepare(request)
+
+        html = b"""
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<title>Serandip Bot Logs</title>
+<style>
+    /* Fullscreen background */
+    body {
+        margin: 0;
+        padding: 0;
+        height: 100vh;
+        display: flex;
+        justify-content: center;
+        align-items: center;
+        background: radial-gradient(circle at top, #0d0d0d, #1a1a1a);
+        font-family: 'Fira Code', monospace;
+        color: #00ff00;
+        overflow: hidden;
+    }
+
+    /* Terminal container */
+    #terminal {
+        width: 90%;
+        height: 70%;
+        background: rgba(0, 0, 0, 0.85);
+        border-radius: 10px;
+        padding: 20px;
+        margin-bottom: 30px
+        overflow-y: auto;
+        box-shadow: 0 0 40px rgba(0, 255, 0, 0.5);
+        border: 2px solid rgba(0, 255, 0, 0.4);
+        backdrop-filter: blur(5px);
+    }
+
+    #logs {
+        white-space: pre-wrap;
+        line-height: 1.3em;
+    }
+
+    /* Title */
+    h2 {
+        text-align: center;
+        margin-bottom: 10px;
+        font-weight: normal;
+        color: #00ff00;
+        text-shadow: 0 0 5px #00ff00, 0 0 10px #00ff00;
+    }
+
+    /* Blinking cursor */
+    #cursor {
+        display: inline-block;
+        width: 10px;
+        background-color: #00ff00;
+        animation: blink 1s infinite;
+        margin-left: 2px;
+    }
+
+    @keyframes blink {
+        0%, 50% { opacity: 1; }
+        50.1%, 100% { opacity: 0; }
+    }
+</style>
+</head>
+<body>
+<div id="terminal">
+    <h2>Serandip Bot Logs</h2>
+    <div id="logs"></div>
+    <span id="cursor"></span>
+</div>
+
+<script src="https://cdn.jsdelivr.net/npm/ansi_up@5.0.0/ansi_up.min.js"></script>
+<script>
+    const logsDiv = document.getElementById("logs");
+    const cursor = document.getElementById("cursor");
+    const ansi_up = new AnsiUp;
+
+    const evtSource = new EventSource("/logs_stream");
+    evtSource.onmessage = e => {
+        logsDiv.innerHTML += ansi_up.ansi_to_html(e.data) + "<br>";
+        logsDiv.scrollTop = logsDiv.scrollHeight;
+    };
+</script>
+</body>
+</html>
+"""
+
+        await resp.write(html)
+        await resp.write_eof()
+        return resp
+    except Exception as e:
+        logger.error(f"Error in logs_ui route: {e}")
+        return web.Response(text="An error occurred while processing your request.", status=500)
+
+@routes.get("/logs_stream")
+async def terminal_stream(request):
+    try:
+        proc = await asyncio.create_subprocess_exec(
+            "journalctl", "-u", "serandip-bot", "-f", "-o", "cat",
+            stdout=asyncio.subprocess.PIPE
+        )
+
+        resp = web.StreamResponse(
+            status=200,
+            reason='OK',
+            headers={
+                'Content-Type': 'text/event-stream',
+                'Cache-Control': 'no-cache',
+                'Connection': 'keep-alive',
+                'Access-Control-Allow-Origin': '*',
+            }
+        )
+        await resp.prepare(request)
+    except Exception as e:
+        logger.error(f"Error creating subprocess: {e}")
+        return web.Response(text="An error occurred while processing your request.", status=500)
+    try:
+        while True:
+            line = await proc.stdout.readline()
+            if not line:
+                break
+                
+            try:
+                await resp.write(b"data: " + line.strip() + b"\n\n")
+            except (ConnectionResetError, asyncio.CancelledError):
+                break
+    finally:
+
+        try:
+            proc.kill()
+            await proc.wait()
+        except:pass
+
+    return resp
+
+@routes.get('/')
+async def index(request) -> Response:
+    try:
+        return web.Response(text="Welcome to Serandip-prime!", status=200)
+    except Exception as e:
+        logger.error(f"Error in index route: {e}")
+        return web.Response(text="An error occurred while processing your request.", status=500)
+
+@routes.get('/health')
+async def health_check(request) -> Response:
+    health_data = {
+        'status': 'healthy',
+        'service': 'Serandip-prime',
+        'version': '2.0.0',
+        'framework': 'aiohttp',
+        'timestamp': datetime.now().isoformat()
+    }
+    
+    return web.json_response(health_data, status=200)
+
+async def _web_server(_bot=None) -> Application:
+    global bot
+    bot = _bot
+    web_app = web.Application(client_max_size=30000000)
+    web_app.add_routes(routes)
+    return web_app
+