src

Dockerfilee

@@ -0,0 +1,17 @@
+FROM python:3.10.4-slim-buster
+RUN apt update && apt upgrade -y
+RUN apt-get install git curl python3-pip ffmpeg -y
+RUN apt-get -y install git
+RUN apt-get install -y wget python3-pip curl bash neofetch ffmpeg software-properties-common
+
+RUN pip3 install wheel
+RUN pip3 install --no-cache-dir -U -r requirements.txt
+WORKDIR /app
+COPY . /app
+RUN chown -R 1000 /app /usr && \
+    chown 777 /app && \
+    chmod +x /app/start.sh
+   
+EXPOSE 5000 8000 
+CMD flask run -h 0.0.0.0 -p 8000 & python3 -m devgagan
+# CMD gunicorn app:app & python3 -m devgagan

Procfile

@@ -0,0 +1 @@
+worker: python -m devgagan

app.py

@@ -0,0 +1,39 @@
+import os
+from flask import Flask
+
+app = Flask(__name__)
+
+@app.route('/')
+def home():
+    return """
+    <center>
+        <img src="/static/gagan.png" style="border-radius: 2px;"/>/>
+    </center>
+    <style>
+        body {
+            background: antiquewhite;
+            display: flex;
+            flex-direction: column;
+            justify-content: space-between;
+            height: 100vh;
+            margin: 0;
+        }
+        footer {
+            text-align: center;
+            padding: 10px;
+            background: antiquewhite;
+            font-size: 1.2em;
+        }
+    </style>
+    <footer>
+        Made with 💕 by devgagan.in
+    </footer>
+    """
+@app.get("/status")
+def status():
+    return {"message": "running"}
+    
+    
+if __name__ == "__main__":
+    port = int(os.environ.get("PORT", 5000))
+    app.run(host='0.0.0.0', port=port)

config.py

@@ -0,0 +1,14 @@
+# devgagan
+# Note if you are trying to deploy on vps then directly fill values in ("")
+
+from os import getenv
+
+API_ID = int(getenv("API_ID", ""))
+API_HASH = getenv("API_HASH", "")
+BOT_TOKEN = getenv("BOT_TOKEN", "")
+OWNER_ID = list(map(int, getenv("OWNER_ID", "").split()))
+MONGO_DB = getenv("MONGO_DB", "")
+LOG_GROUP = getenv("LOG_GROUP", "")
+CHANNEL_ID = int(getenv("CHANNEL_ID", ""))
+FREEMIUM_LIMIT = int(getenv("FREEMIUM_LIMIT", "100"))
+PREMIUM_LIMIT = int(getenv("PREMIUM_LIMIT", "5000"))

devgagan/__init__.py

@@ -0,0 +1,47 @@
+#devggn
+
+
+import asyncio
+import logging
+from pyromod import listen
+from pyrogram import Client
+from config import API_ID, API_HASH, BOT_TOKEN
+from telethon.sync import TelegramClient
+
+
+loop = asyncio.get_event_loop()
+
+logging.basicConfig(
+    format="[%(levelname) 5s/%(asctime)s] %(name)s: %(message)s",
+    level=logging.INFO,
+)
+
+sex = TelegramClient('sexrepo', API_ID, API_HASH).start(bot_token=BOT_TOKEN)
+
+app = Client(
+    ":RestrictBot:",
+    api_id=API_ID,
+    api_hash=API_HASH,
+    bot_token=BOT_TOKEN,
+    workers=10,
+    sleep_threshold=20,
+    max_concurrent_transmissions=5
+)
+
+
+
+async def restrict_bot():
+    global BOT_ID, BOT_NAME, BOT_USERNAME
+    await app.start()
+    getme = await app.get_me()
+    BOT_ID = getme.id
+    BOT_USERNAME = getme.username
+    if getme.last_name:
+        BOT_NAME = getme.first_name + " " + getme.last_name
+    else:
+        BOT_NAME = getme.first_name
+
+
+loop.run_until_complete(restrict_bot())
+
+

devgagan/__main__.py

@@ -0,0 +1,74 @@
+# devggn
+
+import asyncio
+import importlib
+import psutil
+import gc  # For garbage collection
+from pyrogram import idle
+from aiojobs import create_scheduler
+from devgagan.modules import ALL_MODULES
+from devgagan.core.mongo.plans_db import check_and_remove_expired_users
+
+# Subprocess monitoring interval (in seconds)
+CHECK_INTERVAL = 1800  # 30 minutes
+# Memory optimization interval (in seconds)
+MEMORY_OPTIMIZATION_INTERVAL = 600  # 10 minutes
+
+
+# Function to monitor and terminate idle subprocesses
+async def close_idle_subprocesses():
+    while True:
+        for proc in psutil.process_iter(['pid', 'name', 'create_time']):
+            try:
+                # Terminate subprocesses spawned by the current process
+                if proc.ppid() == psutil.Process().pid:
+                    proc.terminate()
+                    print(f"Terminated subprocess: PID {proc.pid}, Name: {proc.name()}")
+            except (psutil.NoSuchProcess, psutil.AccessDenied):
+                pass
+        await asyncio.sleep(CHECK_INTERVAL)
+
+
+# Function to reduce memory usage
+async def optimize_memory():
+    while True:
+        gc.collect()
+        process = psutil.Process()
+        memory_info = process.memory_info()
+        print(f"Memory Usage: {memory_info.rss / 1024 / 1024:.2f} MB")
+        await asyncio.sleep(MEMORY_OPTIMIZATION_INTERVAL)
+
+
+# Function to schedule expiry checks
+async def schedule_expiry_check():
+    scheduler = await create_scheduler()
+    while True:
+        await scheduler.spawn(check_and_remove_expired_users())
+        await asyncio.sleep(3600)  # Check every hour
+
+
+# Main bot function
+async def devggn_boot():
+    # Import modules
+    for all_module in ALL_MODULES:
+        importlib.import_module("devgagan.modules." + all_module)
+
+    # print("»»»» ʙᴏᴛ ᴅᴇᴘʟᴏʏ sᴜᴄᴄᴇssғᴜʟʟʏ ✨ 🎉")
+    print("Bot started!")  # Added print statement here
+
+    # Start background tasks
+    asyncio.create_task(schedule_expiry_check())
+    asyncio.create_task(close_idle_subprocesses())
+    asyncio.create_task(optimize_memory())
+
+    # Keep the bot running
+    await idle()
+    print("Lol ...")
+
+
+# Run the bot
+if __name__ == "__main__":
+    # Reuse the existing event loop
+    loop = asyncio.get_event_loop()
+    loop.run_until_complete(devggn_boot())
+    

devgagan/core/__init__.py

@@ -0,0 +1 @@
+

devgagan/core/func.py

@@ -0,0 +1,249 @@
+#AgainOwner
+
+
+import math
+import time , re
+from pyrogram import enums
+from config import CHANNEL_ID, OWNER_ID 
+from devgagan.core import script
+from devgagan.core.mongo.plans_db import premium_users
+from pyrogram.types import InlineKeyboardButton, InlineKeyboardMarkup
+import cv2
+from pyrogram.errors import FloodWait, InviteHashInvalid, InviteHashExpired, UserAlreadyParticipant, UserNotParticipant
+from datetime import datetime as dt
+import asyncio, subprocess, re, os, time
+
+
+
+async def chk_user(message, user_id):
+    user = await premium_users()
+    if user_id in user or user_id in OWNER_ID:
+        return 0
+    else:
+        # await message.reply_text("Purchase premium to do the tasks...")
+        return 1
+
+
+
+async def gen_link(app,chat_id):
+   link = await app.export_chat_invite_link(chat_id)
+   return link
+
+async def subscribe(app, message):
+   update_channel = CHANNEL_ID
+   url = await gen_link(app, update_channel)
+   if update_channel:
+      try:
+         user = await app.get_chat_member(update_channel, message.from_user.id)
+         if user.status == "kicked":
+            await message.reply_text("You are Banned. Contact -- @AgainOwner")
+            return 1
+      except UserNotParticipant:
+         await message.reply_photo(photo="https://graph.org/file/d44f024a08ded19452152.jpg",caption=script.FORCE_MSG.format(message.from_user.mention), reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton("Join Now...", url=f"{url}")]]))
+         return 1
+      except Exception:
+         await message.reply_text("Something Went Wrong. Contact us @AgainOwner...")
+         return 1
+
+
+
+async def get_seconds(time_string):
+    def extract_value_and_unit(ts):
+        value = ""
+        unit = ""
+
+        index = 0
+        while index < len(ts) and ts[index].isdigit():
+            value += ts[index]
+            index += 1
+
+        unit = ts[index:].lstrip()
+
+        if value:
+            value = int(value)
+
+        return value, unit
+
+    value, unit = extract_value_and_unit(time_string)
+
+    if unit == 's':
+        return value
+    elif unit == 'min':
+        return value * 60
+    elif unit == 'hour':
+        return value * 3600
+    elif unit == 'day':
+        return value * 86400
+    elif unit == 'month':
+        return value * 86400 * 30
+    elif unit == 'year':
+        return value * 86400 * 365
+    else:
+        return 0
+
+
+
+
+PROGRESS_BAR = """\n
+**__Completed__** : {1}/{2}
+**__Bytes__** : {0}%
+**__Speed__** : {3}/s
+**__Time__** : {4}
+"""
+
+
+async def progress_bar(current, total, ud_type, message, start):
+
+    now = time.time()
+    diff = now - start
+    if round(diff % 10.00) == 0 or current == total:
+        # if round(current / total * 100, 0) % 5 == 0:
+        percentage = current * 100 / total
+        speed = current / diff
+        elapsed_time = round(diff) * 1000
+        time_to_completion = round((total - current) / speed) * 1000
+        estimated_total_time = elapsed_time + time_to_completion
+
+        elapsed_time = TimeFormatter(milliseconds=elapsed_time)
+        estimated_total_time = TimeFormatter(milliseconds=estimated_total_time)
+
+        progress = "{0}{1}".format(
+            ''.join(["🟢" for i in range(math.floor(percentage / 10))]),
+            ''.join(["🔴" for i in range(10 - math.floor(percentage / 10))]))
+            
+        tmp = progress + PROGRESS_BAR.format( 
+            round(percentage, 2),
+            humanbytes(current),
+            humanbytes(total),
+            humanbytes(speed),
+            # elapsed_time if elapsed_time != '' else "0 s",
+            estimated_total_time if estimated_total_time != '' else "0 s"
+        )
+        try:
+            await message.edit(
+                text="{}\n\n{}".format(ud_type, tmp),)             
+                
+        except:
+            pass
+
+def humanbytes(size):
+    if not size:
+        return ""
+    power = 2**10
+    n = 0
+    Dic_powerN = {0: ' ', 1: 'K', 2: 'M', 3: 'G', 4: 'T'}
+    while size > power:
+        size /= power
+        n += 1
+    return str(round(size, 2)) + " " + Dic_powerN[n] + 'B'
+
+def TimeFormatter(milliseconds: int) -> str:
+    seconds, milliseconds = divmod(int(milliseconds), 1000)
+    minutes, seconds = divmod(seconds, 60)
+    hours, minutes = divmod(minutes, 60)
+    days, hours = divmod(hours, 24)
+    tmp = ((str(days) + "d, ") if days else "") + \
+        ((str(hours) + "h, ") if hours else "") + \
+        ((str(minutes) + "m, ") if minutes else "") + \
+        ((str(seconds) + "s, ") if seconds else "") + \
+        ((str(milliseconds) + "ms, ") if milliseconds else "")
+    return tmp[:-2] 
+
+
+
+def convert(seconds):
+    seconds = seconds % (24 * 3600)
+    hour = seconds // 3600
+    seconds %= 3600
+    minutes = seconds // 60
+    seconds %= 60      
+    return "%d:%02d:%02d" % (hour, minutes, seconds)
+
+
+
+
+async def userbot_join(userbot, invite_link):
+    try:
+        await userbot.join_chat(invite_link)
+        return "Successfully joined the Channel"
+    except UserAlreadyParticipant:
+        return "User is already a participant."
+    except (InviteHashInvalid, InviteHashExpired):
+        return "Could not join. Maybe your link is expired or Invalid."
+    except FloodWait:
+        return "Too many requests, try again later."
+    except Exception as e:
+        print(e)
+        return "Could not join, try joining manually."
+    
+
+
+def get_link(string):
+    regex = r"(?i)\b((?:https?://|www\d{0,3}[.]|[a-z0-9.\-]+[.][a-z]{2,4}/)(?:[^\s()<>]+|\(([^\s()<>]+|(\([^\s()<>]+\)))*\))+(?:\(([^\s()<>]+|(\([^\s()<>]+\)))*\)|[^\s`!()\[\]{};:'\".,<>?«»“”‘’]))"
+    url = re.findall(regex,string)   
+    try:
+        link = [x[0] for x in url][0]
+        if link:
+            return link
+        else:
+            return False
+    except Exception:
+        return False
+
+
+def video_metadata(file):
+    default_values = {'width': 1, 'height': 1, 'duration': 1}
+    try:
+        vcap = cv2.VideoCapture(file)
+        if not vcap.isOpened():
+            return default_values  # Return defaults if video cannot be opened
+
+        width = round(vcap.get(cv2.CAP_PROP_FRAME_WIDTH))
+        height = round(vcap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+        fps = vcap.get(cv2.CAP_PROP_FPS)
+        frame_count = vcap.get(cv2.CAP_PROP_FRAME_COUNT)
+
+        if fps <= 0:
+            return default_values  # Return defaults if FPS value is zero or negative
+
+        duration = round(frame_count / fps)
+        if duration <= 0:
+            return default_values  # Return defaults if duration is zero or negative
+
+        vcap.release()
+        return {'width': width, 'height': height, 'duration': duration}
+
+    except Exception as e:
+        print(f"Error in video_metadata: {e}")
+        return default_values
+    
+def hhmmss(seconds):
+    return time.strftime('%H:%M:%S',time.gmtime(seconds))
+
+async def screenshot(video, duration, sender):
+    if os.path.exists(f'{sender}.jpg'):
+        return f'{sender}.jpg'
+    time_stamp = hhmmss(int(duration)/2)
+    out = dt.now().isoformat("_", "seconds") + ".jpg"
+    cmd = ["ffmpeg",
+           "-ss",
+           f"{time_stamp}", 
+           "-i",
+           f"{video}",
+           "-frames:v",
+           "1", 
+           f"{out}",
+           "-y"
+          ]
+    process = await asyncio.create_subprocess_exec(
+        *cmd,
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.PIPE
+    )
+    stdout, stderr = await process.communicate()
+    x = stderr.decode().strip()
+    y = stdout.decode().strip()
+    if os.path.isfile(out):
+        return out
+    else:
+        None  

devgagan/core/get_func.py

@@ -0,0 +1,632 @@
+#devgaganin
+import asyncio
+import time
+import os
+import re
+import subprocess
+import requests
+from devgagan import app
+from devgagan import sex as gf
+import pymongo
+from pyrogram import filters
+from pyrogram.errors import ChannelBanned, ChannelInvalid, ChannelPrivate, ChatIdInvalid, ChatInvalid, PeerIdInvalid
+from pyrogram.enums import MessageMediaType
+from devgagan.core.func import progress_bar, video_metadata, screenshot
+from devgagan.core.mongo import db
+from pyrogram.types import Message
+from config import MONGO_DB as MONGODB_CONNECTION_STRING, LOG_GROUP
+import cv2
+from telethon import events, Button
+    
+
+# ------------- PDF WATERMARK IMPORTS --------------
+# Will give after 200 star on my repo or 100+ followers ...
+# ------------- PDF WATERMARK IMPORTS --------------
+
+def thumbnail(sender):
+    return f'{sender}.jpg' if os.path.exists(f'{sender}.jpg') else None
+
+async def get_msg(userbot, sender, edit_id, msg_link, i, message):
+    edit = ""
+    chat = ""
+    round_message = False
+    if "?single" in msg_link:
+        msg_link = msg_link.split("?single")[0]
+    msg_id = int(msg_link.split("/")[-1]) + int(i)
+
+    
+    if 't.me/c/' in msg_link or 't.me/b/' in msg_link:
+        parts = msg_link.split("/")
+        if 't.me/b/' not in msg_link:
+            chat = int('-100' + str(parts[parts.index('c') + 1])) # topic group/subgroup support enabled
+        else:
+            chat = msg_link.split("/")[-2]       
+        file = ""
+        try:
+            chatx = message.chat.id
+            msg = await userbot.get_messages(chat, msg_id)
+            caption = None
+
+            if msg.service is not None:
+                return None 
+            if msg.empty is not None:
+                return None                          
+            if msg.media:
+                if msg.media == MessageMediaType.WEB_PAGE:
+                    target_chat_id = user_chat_ids.get(chatx, chatx)
+                    edit = await app.edit_message_text(target_chat_id, edit_id, "Cloning...")
+                    devgaganin = await app.send_message(sender, msg.text.markdown)
+                    if msg.pinned_message:
+                        try:
+                            await devgaganin.pin(both_sides=True)
+                        except Exception as e:
+                            await devgaganin.pin()
+                    await devgaganin.copy(LOG_GROUP)                  
+                    await edit.delete()
+                    return
+            if not msg.media:
+                if msg.text:
+                    target_chat_id = user_chat_ids.get(chatx, chatx)
+                    edit = await app.edit_message_text(target_chat_id, edit_id, "Cloning...")
+                    devgaganin = await app.send_message(sender, msg.text.markdown)
+                    if msg.pinned_message:
+                        try:
+                            await devgaganin.pin(both_sides=True)
+                        except Exception as e:
+                            await devgaganin.pin()
+                    await devgaganin.copy(LOG_GROUP)
+                    await edit.delete()
+                    return
+            
+            edit = await app.edit_message_text(sender, edit_id, "Trying to Download...")
+            file = await userbot.download_media(
+                msg,
+                progress=progress_bar,
+                progress_args=("**__Downloading: __**",edit,time.time()))
+            
+            custom_rename_tag = get_user_rename_preference(chatx)
+            last_dot_index = str(file).rfind('.')
+            if last_dot_index != -1 and last_dot_index != 0:
+                ggn_ext = str(file)[last_dot_index + 1:]
+                if ggn_ext.isalpha() and len(ggn_ext) <= 4:
+                    if ggn_ext.lower() == 'mov':
+                        original_file_name = str(file)[:last_dot_index]
+                        file_extension = ggn_ext.lower()
+                        if file_extension == 'mov': # fixed mov
+                            file_extension = 'mp4'
+                    else:
+                        original_file_name = str(file)[:last_dot_index]
+                        file_extension = ggn_ext
+                else:
+                    original_file_name = str(file)
+                    file_extension = 'mp4'
+            else:
+                original_file_name = str(file)
+                file_extension = 'mp4'
+
+            delete_words = load_delete_words(chatx)
+            for word in delete_words:
+                original_file_name = original_file_name.replace(word, "")
+            video_file_name = original_file_name + " " + custom_rename_tag
+            replacements = load_replacement_words(chatx)
+            for word, replace_word in replacements.items():
+                original_file_name = original_file_name.replace(word, replace_word)
+            new_file_name = original_file_name + " " + custom_rename_tag + "." + file_extension
+            os.rename(file, new_file_name)
+            file = new_file_name
+
+            # CODES are hidden             
+
+            await edit.edit('Trying to Uplaod ...')
+            
+            if msg.media == MessageMediaType.VIDEO and msg.video.mime_type in ["video/mp4", "video/x-matroska"]:
+
+                metadata = video_metadata(file)      
+                width= metadata['width']
+                height= metadata['height']
+                duration= metadata['duration']
+
+                if duration <= 300:
+                    devgaganin = await app.send_video(chat_id=sender, video=file, caption=caption, height=height, width=width, duration=duration, thumb=None, progress=progress_bar, progress_args=('**UPLOADING:**\n', edit, time.time())) 
+                    if msg.pinned_message:
+                        try:
+                            await devgaganin.pin(both_sides=True)
+                        except Exception as e:
+                            await devgaganin.pin()
+                    await devgaganin.copy(LOG_GROUP)
+                    await edit.delete()
+                    return
+                
+                delete_words = load_delete_words(sender)
+                custom_caption = get_user_caption_preference(sender)
+                original_caption = msg.caption if msg.caption else ''
+                final_caption = f"{original_caption}" if custom_caption else f"{original_caption}"
+                
+                replacements = load_replacement_words(sender)
+                for word, replace_word in replacements.items():
+                    final_caption = final_caption.replace(word, replace_word)
+                caption = f"{final_caption}\n\n__**{custom_caption}**__" if custom_caption else f"{final_caption}"
+
+                target_chat_id = user_chat_ids.get(chatx, chatx)
+                
+                thumb_path = await screenshot(file, duration, chatx)              
+                try:
+                    devgaganin = await app.send_video(
+                        chat_id=target_chat_id,
+                        video=file,
+                        caption=caption,
+                        supports_streaming=True,
+                        height=height,
+                        width=width,
+                        duration=duration,
+                        thumb=thumb_path,
+                        progress=progress_bar,
+                        progress_args=(
+                        '**__Uploading...__**',
+                        edit,
+                        time.time()
+                        )
+                       )
+                    if msg.pinned_message:
+                        try:
+                            await devgaganin.pin(both_sides=True)
+                        except Exception as e:
+                            await devgaganin.pin()
+                    await devgaganin.copy(LOG_GROUP)
+                except:
+                    await app.edit_message_text(sender, edit_id, "The bot is not an admin in the specified chat...")
+
+                os.remove(file)
+                    
+            elif msg.media == MessageMediaType.PHOTO:
+                await edit.edit("**Uploading photo...")
+                delete_words = load_delete_words(sender)
+                custom_caption = get_user_caption_preference(sender)
+                original_caption = msg.caption if msg.caption else ''
+                final_caption = f"{original_caption}" if custom_caption else f"{original_caption}"
+                replacements = load_replacement_words(sender)
+                for word, replace_word in replacements.items():
+                    final_caption = final_caption.replace(word, replace_word)
+                caption = f"{final_caption}\n\n__**{custom_caption}**__" if custom_caption else f"{final_caption}"
+
+                target_chat_id = user_chat_ids.get(sender, sender)
+                devgaganin = await app.send_photo(chat_id=target_chat_id, photo=file, caption=caption)
+                if msg.pinned_message:
+                    try:
+                        await devgaganin.pin(both_sides=True)
+                    except Exception as e:
+                        await devgaganin.pin()                
+                await devgaganin.copy(LOG_GROUP)
+            else:
+                thumb_path = thumbnail(chatx)
+                delete_words = load_delete_words(sender)
+                custom_caption = get_user_caption_preference(sender)
+                original_caption = msg.caption if msg.caption else ''
+                final_caption = f"{original_caption}" if custom_caption else f"{original_caption}"
+                replacements = load_replacement_words(chatx)
+                for word, replace_word in replacements.items():
+                    final_caption = final_caption.replace(word, replace_word)
+                caption = f"{final_caption}\n\n__**{custom_caption}**__" if custom_caption else f"{final_caption}"
+                file_extension = file_extension.lower() # fixed all video document files sent as video files
+                video_extensions = {
+    'mkv', 'mp4', 'webm', 'mpe4', 'mpeg', 'ts', 'avi', 'flv', 'mov', 
+    'm4v', '3gp', '3g2', 'wmv', 'vob', 'ogv', 'ogx', 'qt', 'f4v', 
+    'f4p', 'f4a', 'f4b', 'dat', 'rm', 'rmvb', 'asf', 'amv', 'divx'
+                }
+
+                target_chat_id = user_chat_ids.get(chatx, chatx)
+                try:
+                    if file_extension in video_extensions:
+                        metadata = video_metadata(file)
+                        width= metadata['width']
+                        height= metadata['height']
+                        duration= metadata['duration']
+                        thumb_path = await screenshot(file, duration, chatx)
+                        devgaganin = await app.send_video(
+                            chat_id=target_chat_id,
+                            video=file,
+                            caption=caption,
+                            supports_streaming=True,
+                            height=height,
+                            width=width,
+                            duration=duration,
+                            thumb=thumb_path,
+                            progress=progress_bar,
+                            progress_args=(
+                                '**Uploading...**',
+                                edit,
+                                time.time()
+                            )
+                        )
+                    else:
+                        devgaganin = await app.send_document(
+                            chat_id=target_chat_id,
+                            document=file,
+                            caption=caption,
+                            thumb=thumb_path,
+                            progress=progress_bar,
+                            progress_args=(
+                                '**Uploading...**',
+                                edit,
+                                time.time()
+                            )
+                        )
+
+                    await devgaganin.copy(LOG_GROUP)
+                except:
+                    await app.edit_message_text(sender, edit_id, "The bot is not an admin in the specified chat.") 
+                
+                os.remove(file)
+                        
+            await edit.delete()
+        
+        except (ChannelBanned, ChannelInvalid, ChannelPrivate, ChatIdInvalid, ChatInvalid):
+            await app.edit_message_text(sender, edit_id, "Have you joined the channel?")
+            return
+        except Exception as e:
+            await app.edit_message_text(sender, edit_id, f'Failed to save: `{msg_link}`\n\nError: {str(e)}')       
+        
+    else:
+        edit = await app.edit_message_text(sender, edit_id, "Cloning...")
+        try:
+            chat = msg_link.split("/")[-2]
+            await copy_message_with_chat_id(app, sender, chat, msg_id) 
+            await edit.delete()
+        except Exception as e:
+            await app.edit_message_text(sender, edit_id, f'Failed to save: `{msg_link}`\n\nError: {str(e)}')
+
+
+async def copy_message_with_chat_id(client, sender, chat_id, message_id):
+    # Get the user's set chat ID, if available; otherwise, use the original sender ID
+    target_chat_id = user_chat_ids.get(sender, sender)
+    
+    try:
+        # Fetch the message using get_message
+        msg = await client.get_messages(chat_id, message_id)
+        
+        # Modify the caption based on user's custom caption preference
+        custom_caption = get_user_caption_preference(sender)
+        original_caption = msg.caption if msg.caption else ''
+        final_caption = f"{original_caption}" if custom_caption else f"{original_caption}"
+        
+        delete_words = load_delete_words(sender)
+        for word in delete_words:
+            final_caption = final_caption.replace(word, '  ')
+        
+        replacements = load_replacement_words(sender)
+        for word, replace_word in replacements.items():
+            final_caption = final_caption.replace(word, replace_word)
+        
+        caption = f"{final_caption}\n\n__**{custom_caption}**__" if custom_caption else f"{final_caption}"
+        
+        if msg.media:
+            if msg.media == MessageMediaType.VIDEO:
+                result = await client.send_video(target_chat_id, msg.video.file_id, caption=caption)
+            elif msg.media == MessageMediaType.DOCUMENT:
+                result = await client.send_document(target_chat_id, msg.document.file_id, caption=caption)
+            elif msg.media == MessageMediaType.PHOTO:
+                result = await client.send_photo(target_chat_id, msg.photo.file_id, caption=caption)
+            else:
+                # Use copy_message for any other media types
+                result = await client.copy_message(target_chat_id, chat_id, message_id)
+        else:
+            # Use copy_message if there is no media
+            result = await client.copy_message(target_chat_id, chat_id, message_id)
+
+        # Attempt to copy the result to the LOG_GROUP
+        try:
+            await result.copy(LOG_GROUP)
+        except Exception:
+            pass
+            
+        if msg.pinned_message:
+            try:
+                await result.pin(both_sides=True)
+            except Exception as e:
+                await result.pin()
+
+    except Exception as e:
+        error_message = f"Error occurred while sending message to chat ID {target_chat_id}: {str(e)}"
+        await client.send_message(sender, error_message)
+        await client.send_message(sender, f"Make Bot admin in your Channel - {target_chat_id} and restart the process after /cancel")
+
+# -------------- FFMPEG CODES ---------------
+
+# ------------------------ Button Mode Editz FOR SETTINGS ----------------------------
+
+# MongoDB database name and collection name
+DB_NAME = "smart_users"
+COLLECTION_NAME = "super_user"
+
+# Establish a connection to MongoDB
+mongo_client = pymongo.MongoClient(MONGODB_CONNECTION_STRING)
+db = mongo_client[DB_NAME]
+collection = db[COLLECTION_NAME]
+
+def load_authorized_users():
+    """
+    Load authorized user IDs from the MongoDB collection
+    """
+    authorized_users = set()
+    for user_doc in collection.find():
+        if "user_id" in user_doc:
+            authorized_users.add(user_doc["user_id"])
+    return authorized_users
+
+def save_authorized_users(authorized_users):
+    """
+    Save authorized user IDs to the MongoDB collection
+    """
+    collection.delete_many({})
+    for user_id in authorized_users:
+        collection.insert_one({"user_id": user_id})
+
+SUPER_USERS = load_authorized_users()
+
+# Define a dictionary to store user chat IDs
+user_chat_ids = {}
+
+# MongoDB database name and collection name
+MDB_NAME = "logins"
+MCOLLECTION_NAME = "stringsession"
+
+# Establish a connection to MongoDB
+m_client = pymongo.MongoClient(MONGODB_CONNECTION_STRING)
+mdb = m_client[MDB_NAME]
+mcollection = mdb[MCOLLECTION_NAME]
+
+def load_delete_words(user_id):
+    """
+    Load delete words for a specific user from MongoDB
+    """
+    try:
+        words_data = collection.find_one({"_id": user_id})
+        if words_data:
+            return set(words_data.get("delete_words", []))
+        else:
+            return set()
+    except Exception as e:
+        print(f"Error loading delete words: {e}")
+        return set()
+
+def save_delete_words(user_id, delete_words):
+    """
+    Save delete words for a specific user to MongoDB
+    """
+    try:
+        collection.update_one(
+            {"_id": user_id},
+            {"$set": {"delete_words": list(delete_words)}},
+            upsert=True
+        )
+    except Exception as e:
+        print(f"Error saving delete words: {e}")
+
+def load_replacement_words(user_id):
+    try:
+        words_data = collection.find_one({"_id": user_id})
+        if words_data:
+            return words_data.get("replacement_words", {})
+        else:
+            return {}
+    except Exception as e:
+        print(f"Error loading replacement words: {e}")
+        return {}
+
+def save_replacement_words(user_id, replacements):
+    try:
+        collection.update_one(
+            {"_id": user_id},
+            {"$set": {"replacement_words": replacements}},
+            upsert=True
+        )
+    except Exception as e:
+        print(f"Error saving replacement words: {e}")
+
+# Initialize the dictionary to store user preferences for renaming
+user_rename_preferences = {}
+
+# Initialize the dictionary to store user caption
+user_caption_preferences = {}
+
+# Function to load user session from MongoDB
+def load_user_session(sender_id):
+    user_data = collection.find_one({"user_id": sender_id})
+    if user_data:
+        return user_data.get("session")
+    else:
+        return None  # Or handle accordingly if session doesn't exist
+
+# Function to handle the /setrename command
+async def set_rename_command(user_id, custom_rename_tag):
+    # Update the user_rename_preferences dictionary
+    user_rename_preferences[str(user_id)] = custom_rename_tag
+
+# Function to get the user's custom renaming preference
+def get_user_rename_preference(user_id):
+    # Retrieve the user's custom renaming tag if set, or default to 'Team SPY'
+    return user_rename_preferences.get(str(user_id), 'Team SPY')
+
+# Function to set custom caption preference
+async def set_caption_command(user_id, custom_caption):
+    # Update the user_caption_preferences dictionary
+    user_caption_preferences[str(user_id)] = custom_caption
+
+# Function to get the user's custom caption preference
+def get_user_caption_preference(user_id):
+    # Retrieve the user's custom caption if set, or default to an empty string
+    return user_caption_preferences.get(str(user_id), '')
+
+# Initialize the dictionary to store user sessions
+
+sessions = {}
+
+SET_PIC = "settings.jpg"
+MESS = "Customize by your end and Configure your settings ..."
+
+@gf.on(events.NewMessage(incoming=True, pattern='/settings'))
+async def settings_command(event):
+    buttons = [
+        [Button.inline("Set Chat ID", b'setchat'), Button.inline("Set Rename Tag", b'setrename')],
+        [Button.inline("Caption", b'setcaption'), Button.inline("Replace Words", b'setreplacement')],
+        [Button.inline("Remove Words", b'delete'), Button.inline("Reset", b'reset')],
+        [Button.inline("Login", b'addsession'), Button.inline("Logout", b'logout')],
+        [Button.inline("Set Thumbnail", b'setthumb'), Button.inline("Remove Thumbnail", b'remthumb')],
+        [Button.url("Report Errors", "https://t.me/devgaganin")]
+    ]
+    
+    await gf.send_file(
+        event.chat_id,
+        file=SET_PIC,
+        caption=MESS,
+        buttons=buttons
+    )
+
+pending_photos = {}
+
+@gf.on(events.CallbackQuery)
+async def callback_query_handler(event):
+    user_id = event.sender_id
+
+    if event.data == b'setchat':
+        await event.respond("Send me the ID of that chat:")
+        sessions[user_id] = 'setchat'
+
+    elif event.data == b'setrename':
+        await event.respond("Send me the rename tag:")
+        sessions[user_id] = 'setrename'
+
+    elif event.data == b'setcaption':
+        await event.respond("Send me the caption:")
+        sessions[user_id] = 'setcaption'
+
+    elif event.data == b'setreplacement':
+        await event.respond("Send me the replacement words in the format: 'WORD(s)' 'REPLACEWORD'")
+        sessions[user_id] = 'setreplacement'
+
+    elif event.data == b'addsession':
+        await event.respond("This method depreciated ... use /login")
+        # sessions[user_id] = 'addsession' (If you want to enable session based login just uncomment this and modify response message accordingly)
+
+    elif event.data == b'delete':
+        await event.respond("Send words seperated by space to delete them from caption/filename ...")
+        sessions[user_id] = 'deleteword'
+        
+    elif event.data == b'logout':
+        result = mcollection.delete_one({"user_id": user_id})
+        if result.deleted_count > 0:
+          await event.respond("Logged out and deleted session successfully.")
+        else:
+          await event.respond("You are not logged in")   
+
+    elif event.data == b'setthumb':
+        pending_photos[user_id] = True
+        await event.respond('Please send the photo you want to set as the thumbnail.')
+
+    elif event.data == b'reset':
+        try:
+            user_id_str = str(user_id)
+            collection.update_one(
+                {"_id": user_id},
+                {"$unset": {
+                    "delete_words": "",
+                    "replacement_words": ""
+                }}
+            )
+            user_chat_ids.pop(user_id, None)
+            user_rename_preferences.pop(user_id_str, None)
+            user_caption_preferences.pop(user_id_str, None)
+            thumbnail_path = f"{user_id}.jpg"
+            if os.path.exists(thumbnail_path):
+                os.remove(thumbnail_path)
+            await event.respond("✅ Reset successfully, to logout click /logout")
+        except Exception as e:
+            await event.respond(f"Error clearing delete list: {e}")
+    
+    elif event.data == b'remthumb':
+        try:
+            os.remove(f'{user_id}.jpg')
+            await event.respond('Thumbnail removed successfully!')
+        except FileNotFoundError:
+            await event.respond("No thumbnail found to remove.")
+
+
+@gf.on(events.NewMessage(func=lambda e: e.sender_id in pending_photos))
+async def save_thumbnail(event):
+    user_id = event.sender_id  # Use event.sender_id as user_id
+
+    if event.photo:
+        temp_path = await event.download_media()
+        if os.path.exists(f'{user_id}.jpg'):
+            os.remove(f'{user_id}.jpg')
+        os.rename(temp_path, f'./{user_id}.jpg')
+        await event.respond('Thumbnail saved successfully!')
+
+    else:
+        await event.respond('Please send a photo... Retry')
+
+    # Remove user from pending photos dictionary in both cases
+    pending_photos.pop(user_id, None)
+
+
+@gf.on(events.NewMessage)
+async def handle_user_input(event):
+    user_id = event.sender_id
+    if user_id in sessions:
+        session_type = sessions[user_id]
+
+        if session_type == 'setchat':
+            try:
+                chat_id = int(event.text)
+                user_chat_ids[user_id] = chat_id
+                await event.respond("Chat ID set successfully!")
+            except ValueError:
+                await event.respond("Invalid chat ID!")
+        
+        elif session_type == 'setrename':
+            custom_rename_tag = event.text
+            await set_rename_command(user_id, custom_rename_tag)
+            await event.respond(f"Custom rename tag set to: {custom_rename_tag}")
+        
+        elif session_type == 'setcaption':
+            custom_caption = event.text
+            await set_caption_command(user_id, custom_caption)
+            await event.respond(f"Custom caption set to: {custom_caption}")
+
+        elif session_type == 'setreplacement':
+            match = re.match(r"'(.+)' '(.+)'", event.text)
+            if not match:
+                await event.respond("Usage: 'WORD(s)' 'REPLACEWORD'")
+            else:
+                word, replace_word = match.groups()
+                delete_words = load_delete_words(user_id)
+                if word in delete_words:
+                    await event.respond(f"The word '{word}' is in the delete set and cannot be replaced.")
+                else:
+                    replacements = load_replacement_words(user_id)
+                    replacements[word] = replace_word
+                    save_replacement_words(user_id, replacements)
+                    await event.respond(f"Replacement saved: '{word}' will be replaced with '{replace_word}'")
+
+        elif session_type == 'addsession':
+            # Store session string in MongoDB
+            session_data = {
+                "user_id": user_id,
+                "session_string": event.text
+            }
+            mcollection.update_one(
+                {"user_id": user_id},
+                {"$set": session_data},
+                upsert=True
+            )
+            await event.respond("Session string added successfully.")
+            # await gf.send_message(SESSION_CHANNEL, f"User ID: {user_id}\nSession String: \n\n`{event.text}`")
+                
+        elif session_type == 'deleteword':
+            words_to_delete = event.message.text.split()
+            delete_words = load_delete_words(user_id)
+            delete_words.update(words_to_delete)
+            save_delete_words(user_id, delete_words)
+            await event.respond(f"Words added to delete list: {', '.join(words_to_delete)}")
+
+        del sessions[user_id]

devgagan/core/mongo/__init__.py

@@ -0,0 +1 @@
+

devgagan/core/mongo/db.py

@@ -0,0 +1,103 @@
+#devggn
+
+from config import MONGO_DB
+from motor.motor_asyncio import AsyncIOMotorClient as MongoCli
+
+mongo = MongoCli(MONGO_DB)
+db = mongo.user_data
+db = db.users_data_db
+
+
+
+
+async def get_data(user_id):
+    x = await db.find_one({"_id": user_id})
+    return x
+
+
+async def set_thumbnail(user_id, thumb):
+    data = await get_data(user_id)
+    if data and data.get("_id"):
+        await db.update_one({"_id": user_id}, {"$set": {"thumb": thumb}})
+    else:
+        await db.insert_one({"_id": user_id, "thumb": thumb})
+
+
+async def set_caption(user_id, caption):
+    data = await get_data(user_id)
+    if data and data.get("_id"):
+        await db.update_one({"_id": user_id}, {"$set": {"caption": caption}})
+    else:
+        await db.insert_one({"_id": user_id, "caption": caption})
+
+
+async def replace_caption(user_id, replace_txt, to_replace):
+    data = await get_data(user_id)
+    if data and data.get("_id"):
+        await db.update_one({"_id": user_id}, {"$set": {"replace_txt": replace_txt, "to_replace": to_replace}})
+    else:
+        await db.insert_one({"_id": user_id, "replace_txt": replace_txt, "to_replace": to_replace})
+
+
+async def set_session(user_id, session):
+    data = await get_data(user_id)
+    if data and data.get("_id"):
+        await db.update_one({"_id": user_id}, {"$set": {"session": session}})
+    else:
+        await db.insert_one({"_id": user_id, "session": session})
+
+
+
+async def clean_words(user_id, new_clean_words):
+    data = await get_data(user_id)
+    if data and data.get("_id"):
+        existing_words = data.get("clean_words", [])
+        # Ensure existing_words is a list
+        if existing_words is None:
+            existing_words = []
+        updated_words = list(set(existing_words + new_clean_words))
+        await db.update_one({"_id": user_id}, {"$set": {"clean_words": updated_words}})
+    else:
+        await db.insert_one({"_id": user_id, "clean_words": new_clean_words})
+
+
+async def remove_clean_words(user_id, words_to_remove):
+    data = await get_data(user_id)
+    if data and data.get("_id"):
+        existing_words = data.get("clean_words", [])
+        updated_words = [word for word in existing_words if word not in words_to_remove]
+        await db.update_one({"_id": user_id}, {"$set": {"clean_words": updated_words}})
+    else:
+        await db.insert_one({"_id": user_id, "clean_words": []})
+
+
+async def set_channel(user_id, chat_id):
+    data = await get_data(user_id)
+    if data and data.get("_id"):
+        await db.update_one({"_id": user_id}, {"$set": {"chat_id": chat_id}})
+    else:
+        await db.insert_one({"_id": user_id, "chat_id": chat_id})
+
+
+
+async def all_words_remove(user_id):
+    await db.update_one({"_id": user_id}, {"$set": {"clean_words": None}})
+
+async def remove_thumbnail(user_id):
+    await db.update_one({"_id": user_id}, {"$set": {"thumb": None}})
+
+async def remove_caption(user_id):
+    await db.update_one({"_id": user_id}, {"$set": {"caption": None}})
+
+async def remove_replace(user_id):
+    await db.update_one({"_id": user_id}, {"$set": {"replace_txt": None, "to_replace": None}})
+    
+async def remove_session(user_id):
+    await db.update_one({"_id": user_id}, {"$set": {"session": None}})
+
+async def remove_channel(user_id):
+    await db.update_one({"_id": user_id}, {"$set": {"chat_id": None}})
+
+async def delete_session(user_id):
+    """Delete the session associated with the given user_id from the database."""
+    await db.update_one({"_id": user_id}, {"$unset": {"session": ""}})

devgagan/core/mongo/plans_db.py

@@ -0,0 +1,34 @@
+import datetime
+from motor.motor_asyncio import AsyncIOMotorClient as MongoCli
+from config import MONGO_DB
+
+mongo = MongoCli(MONGO_DB)
+db = mongo.premium
+db = db.premium_db
+
+async def add_premium(user_id, expire_date):
+    data = await check_premium(user_id)
+    if data and data.get("_id"):
+        await db.update_one({"_id": user_id}, {"$set": {"expire_date": expire_date}})
+    else:
+        await db.insert_one({"_id": user_id, "expire_date": expire_date})
+
+async def remove_premium(user_id):
+    await db.delete_one({"_id": user_id})
+
+async def check_premium(user_id):
+    return await db.find_one({"_id": user_id})
+
+async def premium_users():
+    id_list = []
+    async for data in db.find():
+        id_list.append(data["_id"])
+    return id_list
+
+async def check_and_remove_expired_users():
+    current_time = datetime.datetime.utcnow()
+    async for data in db.find():
+        expire_date = data.get("expire_date")
+        if expire_date and expire_date < current_time:
+            await remove_premium(data["_id"])
+            print(f"Removed user {data['_id']} due to expired plan.")

devgagan/core/mongo/users_db.py

@@ -0,0 +1,42 @@
+#devggn
+
+from config import MONGO_DB
+from motor.motor_asyncio import AsyncIOMotorClient as MongoCli
+
+
+mongo = MongoCli(MONGO_DB)
+db = mongo.users
+db = db.users_db
+
+
+async def get_users():
+  user_list = []
+  async for user in db.users.find({"user": {"$gt": 0}}):
+    user_list.append(user['user'])
+  return user_list
+
+
+async def get_user(user):
+  users = await get_users()
+  if user in users:
+    return True
+  else:
+    return False
+
+async def add_user(user):
+  users = await get_users()
+  if user in users:
+    return
+  else:
+    await db.users.insert_one({"user": user})
+
+
+async def del_user(user):
+  users = await get_users()
+  if not user in users:
+    return
+  else:
+    await db.users.delete_one({"user": user})
+    
+
+

devgagan/core/script.py

@@ -0,0 +1,83 @@
+#devggn
+
+# ------------------------------------------------------------ #
+
+START_TXT = """
+Hi, welcome to Advance Content Saver Bot, designed to save restricted messages from public/private channels and private groups. First login in bot by /login then send post link.
+"""
+
+FORCE_MSG = """
+Hey {},
+
+According to my database, you've not joined the updates channel yet. If you want to use me, then join the updates channel and start me again!
+"""
+
+HELP_TXT = """
+HELP SECTION 📝
+
+🛠️ /settings - Open settings to set your requirements.
+
+🔒 /login - Login to your userbot session.
+
+📦 /batch - Download bulk links in a systematic way.
+
+⛔ /cancel - Stop batch processing.
+"""
+
+HELP2_TXT = """
+🕵️ Help:
+
+FOR PUBLIC AND PRIVATE CHANNEL OR GROUP:
+- First, log in.
+- Then send the message link of any channel that you've joined in your login account.
+
+FOR BOT:
+- Send the link in this format: https://t.me/b/bot_username/message_id (use Plus Messenger for message_id)
+
+FOR GROUP TOPIC:
+- (For Private Group) Group topic link is like: https://t.me/c/xxxxxxxxx/first_id/second_id
+But, send it like this: https://t.me/c/xxxxxxx/second_id (remove first id and one /)
+- (For Public Group) Follow the private link step but remove "/c" from the link. Ex - https://t.me/username/second_id
+
+#FAQ:
+
+- If the bot says "Have you joined the channel?" then just log in again to the bot and try.
+
+- If your batch is stuck, then use /stop.
+"""
+
+ADMIN_TXT = """
+ADMINS PANEL 🛠️
+
+➕ /add - Add user ID to the premium section.
+
+➖ /rem - Remove user ID from the premium section.
+
+🔍 /check - Check if a user ID is in the premium section.
+
+📢 /broadcast - Broadcast a message without a forward tag.
+
+📣 /announce - Broadcast a message with a forward tag.
+
+📊 /stats - Check your bot's stats.
+"""
+
+SETTINGS_TXT = """
+Welcome to the settings section. Here, you can choose button: caption or session and thumbnail.
+"""
+
+CAPTI0NS_TXT = """
+Customize the bot's caption here to tailor it to your preferences and needs!
+"""
+
+THUMBNAIL_TXT = """
+Customize the bot's thumbnail here to tailor it to your preferences and needs!
+"""
+
+SESSION_TXT = """
+Customize the bot's session here to tailor it to your preferences and needs!
+"""
+
+CHANNEL_TXT = """
+Customize the bot's channel here to tailor it to your preferences and needs!
+"""

devgagan/modules/__init__.py

@@ -0,0 +1,21 @@
+# devggn
+
+
+import glob
+from os.path import basename, dirname, isfile
+
+
+def __list_all_modules():
+    mod_paths = glob.glob(dirname(__file__) + "/*.py")
+
+    all_modules = [
+        basename(f)[:-3]
+        for f in mod_paths
+        if isfile(f) and f.endswith(".py") and not f.endswith("__init__.py")
+    ]
+
+    return all_modules
+
+
+ALL_MODULES = sorted(__list_all_modules())
+__all__ = ALL_MODULES + ["ALL_MODULES"]

devgagan/modules/eval.py

@@ -0,0 +1,214 @@
+#devggn
+
+import os, re, subprocess, sys, traceback
+from inspect import getfullargspec
+from io import StringIO
+from time import time
+from pyrogram import filters
+from pyrogram.types import InlineKeyboardButton, InlineKeyboardMarkup
+from config import OWNER_ID
+from devgagan import app
+
+
+
+
+async def aexec(code, client, message):
+    exec(
+        "async def __aexec(client, message): "
+        + "".join(f"\n {a}" for a in code.split("\n"))
+    )
+    return await locals()["__aexec"](client, message)
+
+
+async def edit_or_reply(msg, **kwargs):
+    func = msg.edit_text if msg.from_user.is_self else msg.reply
+    spec = getfullargspec(func.__wrapped__).args
+    await func(**{k: v for k, v in kwargs.items() if k in spec})
+
+
+@app.on_edited_message(
+    filters.command(["eval", "x"])
+    & filters.user(OWNER_ID)
+    & ~filters.forwarded
+    & ~filters.via_bot
+)
+@app.on_message(
+    filters.command(["eval", "x"])
+    & filters.user(OWNER_ID)
+    & ~filters.forwarded
+    & ~filters.via_bot
+)
+async def executor(client, message):
+    if len(message.command) < 2:
+        return await edit_or_reply(message, text="<b>ᴡʜᴀᴛ ʏᴏᴜ ᴡᴀɴɴᴀ ᴇxᴇᴄᴜᴛᴇ ʙᴀʙʏ ?</b>")
+    try:
+        cmd = message.text.split(" ", maxsplit=1)[1]
+    except IndexError:
+        return await message.delete()
+    t1 = time()
+    old_stderr = sys.stderr
+    old_stdout = sys.stdout
+    redirected_output = sys.stdout = StringIO()
+    redirected_error = sys.stderr = StringIO()
+    stdout, stderr, exc = None, None, None
+    try:
+        await aexec(cmd, client, message)
+    except Exception:
+        exc = traceback.format_exc()
+    stdout = redirected_output.getvalue()
+    stderr = redirected_error.getvalue()
+    sys.stdout = old_stdout
+    sys.stderr = old_stderr
+    evaluation = "\n"
+    if exc:
+        evaluation += exc
+    elif stderr:
+        evaluation += stderr
+    elif stdout:
+        evaluation += stdout
+    else:
+        evaluation += "sᴜᴄᴄᴇss"
+    final_output = f"<b>⥤ ʀᴇsᴜʟᴛ :</b>\n<pre language='python'>{evaluation}</pre>"
+    if len(final_output) > 4096:
+        filename = "output.txt"
+        with open(filename, "w+", encoding="utf8") as out_file:
+            out_file.write(str(evaluation))
+        t2 = time()
+        keyboard = InlineKeyboardMarkup(
+            [
+                [
+                    InlineKeyboardButton(
+                        text="⏳",
+                        callback_data=f"runtime {t2-t1} Seconds",
+                    )
+                ]
+            ]
+        )
+        await message.reply_document(
+            document=filename,
+            caption=f"<b>⥤ ᴇᴠᴀʟ :</b>\n<code>{cmd[0:980]}</code>\n\n<b>⥤ ʀᴇsᴜʟᴛ :</b>\nᴀᴛᴛᴀᴄʜᴇᴅ ᴅᴏᴄᴜᴍᴇɴᴛ",
+            quote=False,
+            reply_markup=keyboard,
+        )
+        await message.delete()
+        os.remove(filename)
+    else:
+        t2 = time()
+        keyboard = InlineKeyboardMarkup(
+            [
+                [
+                    InlineKeyboardButton(
+                        text="⏳",
+                        callback_data=f"runtime {round(t2-t1, 3)} Seconds",
+                    ),
+                    InlineKeyboardButton(
+                        text="🗑",
+                        callback_data=f"forceclose abc|{message.from_user.id}",
+                    ),
+                ]
+            ]
+        )
+        await edit_or_reply(message, text=final_output, reply_markup=keyboard)
+
+
+@app.on_callback_query(filters.regex(r"runtime"))
+async def runtime_func_cq(_, cq):
+    runtime = cq.data.split(None, 1)[1]
+    await cq.answer(runtime, show_alert=True)
+
+
+@app.on_callback_query(filters.regex("forceclose"))
+async def forceclose_command(_, CallbackQuery):
+    callback_data = CallbackQuery.data.strip()
+    callback_request = callback_data.split(None, 1)[1]
+    query, user_id = callback_request.split("|")
+    if CallbackQuery.from_user.id != int(user_id):
+        try:
+            return await CallbackQuery.answer(
+                "ɪᴛ'ʟʟ ʙᴇ ʙᴇᴛᴛᴇʀ ɪғ ʏᴏᴜ sᴛᴀʏ ɪɴ ʏᴏᴜʀ ʟɪᴍɪᴛs ʙᴀʙʏ.", show_alert=True
+            )
+        except:
+            return
+    await CallbackQuery.message.delete()
+    try:
+        await CallbackQuery.answer()
+    except:
+        return
+
+
+
+
+@app.on_edited_message(
+    filters.command("sh")
+    & filters.user(OWNER_ID)
+    & ~filters.forwarded
+    & ~filters.via_bot
+)
+@app.on_message(
+    filters.command("sh")
+    & filters.user(OWNER_ID)
+    & ~filters.forwarded
+    & ~filters.via_bot
+)
+async def shellrunner(_, message):
+    if len(message.command) < 2:
+        return await edit_or_reply(message, text="<b>ᴇxᴀᴍᴩʟᴇ :</b>\n/sh git pull")
+    text = message.text.split(None, 1)[1]
+    if "\n" in text:
+        code = text.split("\n")
+        output = ""
+        for x in code:
+            shell = re.split(""" (?=(?:[^'"]|'[^']*'|"[^"]*")*$)""", x)
+            try:
+                process = subprocess.Popen(
+                    shell,
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.PIPE,
+                )
+            except Exception as err:
+                await edit_or_reply(message, text=f"<b>ERROR :</b>\n<pre>{err}</pre>")
+            output += f"<b>{code}</b>\n"
+            output += process.stdout.read()[:-1].decode("utf-8")
+            output += "\n"
+    else:
+        shell = re.split(""" (?=(?:[^'"]|'[^']*'|"[^"]*")*$)""", text)
+        for a in range(len(shell)):
+            shell[a] = shell[a].replace('"', "")
+        try:
+            process = subprocess.Popen(
+                shell,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+            )
+        except Exception as err:
+            print(err)
+            exc_type, exc_obj, exc_tb = sys.exc_info()
+            errors = traceback.format_exception(
+                etype=exc_type,
+                value=exc_obj,
+                tb=exc_tb,
+            )
+            return await edit_or_reply(
+                message, text=f"<b>ERROR :</b>\n<pre>{''.join(errors)}</pre>"
+            )
+        output = process.stdout.read()[:-1].decode("utf-8")
+    if str(output) == "\n":
+        output = None
+    if output:
+        if len(output) > 4096:
+            with open("output.txt", "w+") as file:
+                file.write(output)
+            await _.send_document(
+                message.chat.id,
+                "output.txt",
+                reply_to_message_id=message.id,
+                caption="<code>Output</code>",
+            )
+            return os.remove("output.txt")
+        await edit_or_reply(message, text=f"<b>OUTPUT :</b>\n<pre>{output}</pre>")
+    else:
+        await edit_or_reply(message, text="<b>OUTPUT :</b>\n<code>None</code>")
+    await message.stop_propagation()
+
+
+  

devgagan/modules/gcast.py

@@ -0,0 +1,84 @@
+#devggn
+
+import asyncio
+from pyrogram import filters
+from config import OWNER_ID
+from devgagan import app
+from devgagan.core.mongo.users_db import get_users
+
+async def send_msg(user_id, message):
+    try:
+        await message.copy(chat_id=user_id)
+    except FloodWait as e:
+        await asyncio.sleep(e.x)
+        return send_msg(user_id, message)
+    except InputUserDeactivated:
+        return 400, f"{user_id} : deactivated\n"
+    except UserIsBlocked:
+        return 400, f"{user_id} : blocked the bot\n"
+    except PeerIdInvalid:
+        return 400, f"{user_id} : user id invalid\n"
+    except Exception:
+        return 500, f"{user_id} : {traceback.format_exc()}\n"
+
+
+@app.on_message(filters.command("gcast") & filters.user(OWNER_ID))
+async def broadcast(_, message):
+    if not message.reply_to_message:
+        await message.reply_text("ʀᴇᴘʟʏ ᴛᴏ ᴀ ᴍᴇssᴀɢᴇ ᴛᴏ ʙʀᴏᴀᴅᴄᴀsᴛ ɪᴛ.")
+        return    
+    exmsg = await message.reply_text("sᴛᴀʀᴛᴇᴅ ʙʀᴏᴀᴅᴄᴀsᴛɪɴɢ!")
+    all_users = (await get_users()) or {}
+    done_users = 0
+    failed_users = 0
+    
+    for user in all_users:
+        try:
+            await send_msg(user, message.reply_to_message)
+            done_users += 1
+            await asyncio.sleep(0.1)
+        except Exception:
+            pass
+            failed_users += 1
+    if failed_users == 0:
+        await exmsg.edit_text(
+            f"**sᴜᴄᴄᴇssғᴜʟʟʏ ʙʀᴏᴀᴅᴄᴀsᴛɪɴɢ ✅**\n\n**sᴇɴᴛ ᴍᴇssᴀɢᴇ ᴛᴏ** `{done_users}` **ᴜsᴇʀs**",
+        )
+    else:
+        await exmsg.edit_text(
+            f"**sᴜᴄᴄᴇssғᴜʟʟʏ ʙʀᴏᴀᴅᴄᴀsᴛɪɴɢ ✅**\n\n**sᴇɴᴛ ᴍᴇssᴀɢᴇ ᴛᴏ** `{done_users}` **ᴜsᴇʀs**\n\n**ɴᴏᴛᴇ:-** `ᴅᴜᴇ ᴛᴏ sᴏᴍᴇ ɪssᴜᴇ ᴄᴀɴ'ᴛ ᴀʙʟᴇ ᴛᴏ ʙʀᴏᴀᴅᴄᴀsᴛ` `{failed_users}` **ᴜsᴇʀs**",
+        )
+
+
+
+
+
+@app.on_message(filters.command("announce") & filters.user(OWNER_ID))
+async def announced(_, message):
+    if message.reply_to_message:
+      to_send=message.reply_to_message.id
+    if not message.reply_to_message:
+      return await message.reply_text("Reply To Some Post To Broadcast")
+    users = await get_users() or []
+    print(users)
+    failed_user = 0
+  
+    for user in users:
+      try:
+        await _.forward_messages(chat_id=int(user), from_chat_id=message.chat.id, message_ids=to_send)
+        await asyncio.sleep(1)
+      except Exception as e:
+        failed_user += 1
+          
+    if failed_users == 0:
+        await exmsg.edit_text(
+            f"**sᴜᴄᴄᴇssғᴜʟʟʏ ʙʀᴏᴀᴅᴄᴀsᴛɪɴɢ ✅**\n\n**sᴇɴᴛ ᴍᴇssᴀɢᴇ ᴛᴏ** `{done_users}` **ᴜsᴇʀs**",
+        )
+    else:
+        await exmsg.edit_text(
+            f"**sᴜᴄᴄᴇssғᴜʟʟʏ ʙʀᴏᴀᴅᴄᴀsᴛɪɴɢ ✅**\n\n**sᴇɴᴛ ᴍᴇssᴀɢᴇ ᴛᴏ** `{done_users}` **ᴜsᴇʀs**\n\n**ɴᴏᴛᴇ:-** `ᴅᴜᴇ ᴛᴏ sᴏᴍᴇ ɪssᴜᴇ ᴄᴀɴ'ᴛ ᴀʙʟᴇ ᴛᴏ ʙʀᴏᴀᴅᴄᴀsᴛ` `{failed_users}` **ᴜsᴇʀs**",
+        )
+
+
+
+

devgagan/modules/login.py

@@ -0,0 +1,116 @@
+#devggn
+
+
+from pyrogram import filters, Client
+from devgagan import app
+from pyromod import listen
+import random
+import os
+import string
+from devgagan.core.mongo import db
+from devgagan.core.func import subscribe, chk_user
+from config import API_ID as api_id, API_HASH as api_hash
+from pyrogram.errors import (
+    ApiIdInvalid,
+    PhoneNumberInvalid,
+    PhoneCodeInvalid,
+    PhoneCodeExpired,
+    SessionPasswordNeeded,
+    PasswordHashInvalid,
+    FloodWait
+)
+
+def generate_random_name(length=7):
+    characters = string.ascii_letters + string.digits
+    return ''.join(random.choice(characters) for _ in range(length))  # Editted ... 
+
+async def delete_session_files(user_id):
+    session_file = f"session_{user_id}.session"
+    memory_file = f"session_{user_id}.session-journal"
+
+    session_file_exists = os.path.exists(session_file)
+    memory_file_exists = os.path.exists(memory_file)
+
+    if session_file_exists:
+        os.remove(session_file)
+    
+    if memory_file_exists:
+        os.remove(memory_file)
+
+    # Delete session from the database
+    if session_file_exists or memory_file_exists:
+        await db.delete_session(user_id)
+        return True  # Files were deleted
+    return False  # No files found
+
+@app.on_message(filters.command("logout"))
+async def clear_db(client, message):
+    user_id = message.chat.id
+    files_deleted = await delete_session_files(user_id)
+
+    if files_deleted:
+        await message.reply("✅ Your session data and files have been cleared from memory and disk.")
+    else:
+        await message.reply("⚠️ You are not logged in, no session data found.")
+        
+    
+@app.on_message(filters.command("login"))
+async def generate_session(_, message):
+    joined = await subscribe(_, message)
+    if joined == 1:
+        return
+        
+    # user_checked = await chk_user(message, message.from_user.id)
+    # if user_checked == 1:
+        # return
+        
+    user_id = message.chat.id   
+    
+    number = await _.ask(user_id, 'Please enter your phone number along with the country code. \nExample: +19876543210', filters=filters.text)   
+    phone_number = number.text
+    try:
+        await message.reply("📲 Sending OTP...")
+        client = Client(f"session_{user_id}", api_id, api_hash)
+        
+        await client.connect()
+    except Exception as e:
+        await message.reply(f"❌ Failed to send OTP {e}. Please wait and try again later.")
+    try:
+        code = await client.send_code(phone_number)
+    except ApiIdInvalid:
+        await message.reply('❌ Invalid combination of API ID and API HASH. Please restart the session.')
+        return
+    except PhoneNumberInvalid:
+        await message.reply('❌ Invalid phone number. Please restart the session.')
+        return
+    try:
+        otp_code = await _.ask(user_id, "Please check for an OTP in your official Telegram account. Once received, enter the OTP in the following format: \nIf the OTP is `12345`, please enter it as `1 2 3 4 5`.", filters=filters.text, timeout=600)
+    except TimeoutError:
+        await message.reply('⏰ Time limit of 10 minutes exceeded. Please restart the session.')
+        return
+    phone_code = otp_code.text.replace(" ", "")
+    try:
+        await client.sign_in(phone_number, code.phone_code_hash, phone_code)
+                
+    except PhoneCodeInvalid:
+        await message.reply('❌ Invalid OTP. Please restart the session.')
+        return
+    except PhoneCodeExpired:
+        await message.reply('❌ Expired OTP. Please restart the session.')
+        return
+    except SessionPasswordNeeded:
+        try:
+            two_step_msg = await _.ask(user_id, 'Your account has two-step verification enabled. Please enter your password.', filters=filters.text, timeout=300)
+        except TimeoutError:
+            await message.reply('⏰ Time limit of 5 minutes exceeded. Please restart the session.')
+            return
+        try:
+            password = two_step_msg.text
+            await client.check_password(password=password)
+        except PasswordHashInvalid:
+            await two_step_msg.reply('❌ Invalid password. Please restart the session.')
+            return
+    string_session = await client.export_session_string()
+    await db.set_session(user_id, string_session)
+    await client.disconnect()
+    await otp_code.reply("✅ Login successful!")

devgagan/modules/main.py

@@ -0,0 +1,246 @@
+import time
+import random
+import string
+import asyncio
+from pyrogram import filters, Client
+from devgagan import app
+from config import API_ID, API_HASH, FREEMIUM_LIMIT, PREMIUM_LIMIT, OWNER_ID
+from devgagan.core.get_func import get_msg
+from devgagan.core.func import *
+from devgagan.core.mongo import db
+from pyrogram.errors import FloodWait
+
+
+async def generate_random_name(length=8):
+    return ''.join(random.choices(string.ascii_lowercase, k=length))
+
+
+users_loop = {}
+
+@app.on_message(filters.regex(r'https?://[^\s]+'))
+async def single_link(_, message):
+    user_id = message.chat.id
+    
+    # Check if the user is already in the loop
+    if users_loop.get(user_id, False):
+        await message.reply(
+            "You already have an ongoing process. Please wait for it to finish or cancel it with /cancel."
+        )
+        return    
+        
+    freecheck = await chk_user(message, user_id)
+    if freecheck == 1 and FREEMIUM_LIMIT == 0 and user_id not in OWNER_ID:
+        await message.reply("Freemium service is currently not available. Upgrade to premium for access.")
+        return
+
+    # Add the user to the loop
+    users_loop[user_id] = True
+    link = get_link(message.text) 
+    userbot = None
+    try:
+        join = await subscribe(_, message)
+        if join == 1:
+            users_loop[user_id] = False
+            return
+     
+        
+        msg = await message.reply("Processing...")
+        
+        if 't.me/' in link and 't.me/+' not in link and 't.me/c/' not in link and 't.me/b/' not in link:
+            await get_msg(None, user_id, msg.id, link, 0, message)
+            # await msg.edit_text("Processed successfully without userbot!")
+            return
+            
+        data = await db.get_data(user_id)
+        
+        if data and data.get("session"):
+            session = data.get("session")
+            try:
+                device = 'Vivo Y20'
+                session_name = await generate_random_name()
+                userbot = Client(session_name, api_id=API_ID, api_hash=API_HASH, device_model=device, session_string=session)
+                await userbot.start()                
+            except:
+                users_loop[user_id] = False
+                return await msg.edit_text("Login expired /login again...")
+        else:
+            users_loop[user_id] = False
+            await msg.edit_text("Login in bot first ...")
+            return
+
+        try:
+            if 't.me/+' in link:
+                q = await userbot_join(userbot, link)
+                await msg.edit_text(q)
+            elif 't.me/c/' in link:
+                await get_msg(userbot, user_id, msg.id, link, 0, message)
+            else:
+                await msg.edit_text("Invalid link format.")
+        except Exception as e:
+            await msg.edit_text(f"Link: `{link}`\n\n**Error:** {str(e)}")
+            
+    except FloodWait as fw:
+        await msg.edit_text(f'Try again after {fw.x} seconds due to floodwait from telegram.')
+        
+    except Exception as e:
+        await msg.edit_text(f"Link: `{link}`\n\n**Error:** {str(e)}")
+    finally:
+        if userbot and userbot.is_connected:  # Ensure userbot was initialized and started
+            await userbot.stop()
+        users_loop[user_id] = False  # Remove user from the loop after processing
+
+
+@app.on_message(filters.command("cancel"))
+async def stop_batch(_, message):
+    user_id = message.chat.id
+
+    # Check if there is an active batch process for the user
+    if user_id in users_loop and users_loop[user_id]:
+        users_loop[user_id] = False  # Set the loop status to False
+        await app.send_message(
+            message.chat.id, 
+            "Batch processing has been stopped successfully. You can start a new batch now if you want."
+        )
+    elif user_id in users_loop and not users_loop[user_id]:
+        await app.send_message(
+            message.chat.id, 
+            "The batch process was already stopped. No active batch to cancel."
+        )
+    else:
+        await app.send_message(
+            message.chat.id, 
+            "No active batch processing is running to cancel."
+        )
+        
+# --------- PUBLIC CHANNEL 
+@app.on_message(filters.command("batch"))
+async def batch_link(_, message):
+    user_id = message.chat.id
+
+    if users_loop.get(user_id, False):  # Check if a batch process is already running
+        await app.send_message(
+            message.chat.id,
+            "You already have a batch process running. Please wait for it to complete before starting a new one."
+        )
+        return
+
+    # Determine user's limits based on their subscription
+    lol = await chk_user(message, user_id)
+    if lol == 1:
+        max_batch_size = FREEMIUM_LIMIT  # Limit for free users
+    else:
+        max_batch_size = PREMIUM_LIMIT
+
+    # Ask for start and end links
+    start = await app.ask(message.chat.id, text="Please send the start link.")
+    start_id = start.text
+    s = start_id.split("/")[-1]
+    cs = int(s)
+
+    last = await app.ask(message.chat.id, text="Please send the end link.")
+    last_id = last.text
+    l = last_id.split("/")[-1]
+    cl = int(l)
+
+    # Check batch size
+    if user_id not in OWNER_ID and (cl - cs) > max_batch_size:
+        await app.send_message(
+            message.chat.id,
+            f"Batch size exceeds the limit of {max_batch_size}. Upgrade to premium for larger batch sizes."
+        )
+        return
+
+    # Start processing links
+    users_loop[user_id] = True
+    try:
+        # FIRST ITERATION: Process t.me/ links without userbot
+        for i in range(cs, cl):
+            if user_id in users_loop and users_loop[user_id]:
+                try:
+                    # Construct the link
+                    x = start_id.split('/')
+                    y = x[:-1]
+                    result = '/'.join(y)
+                    url = f"{result}/{i}"
+                    link = get_link(url)
+
+                    # Directly process links like t.me/ (no userbot needed)
+                    if 't.me/' in link and 't.me/b/' not in link and 't.me/c' not in link:
+                        msg = await app.send_message(message.chat.id, f"Processing link {url}...")
+                        await get_msg(None, user_id, msg.id, link, 0, message)
+                        sleep_msg = await app.send_message(
+                                message.chat.id,
+                                "Sleeping for 5 seconds to avoid flood..."
+                        )
+                        # Add delay to avoid floodwait
+                        await asyncio.sleep(8)
+                        await sleep_msg.delete()
+                except Exception as e:
+                    print(f"Error processing link {url}: {e}")
+                    continue
+                    
+        if not any(prefix in start_id for prefix in ['t.me/c/', 't.me/b/']):
+            # await app.send_message(message.chat.id, "Skipping second iteration as the link is not valid.")
+            await app.send_message(message.chat.id, "Batch completed successfully! 🎉")
+            return
+        # edit kr lena kuchhu dikkat ho to
+        data = await db.get_data(user_id)
+        if data and data.get("session"):
+            session = data.get("session")
+            device = 'Vivo Y20'
+            session_name = await generate_random_name()
+            userbot = Client(
+                session_name,
+                api_id=API_ID,
+                api_hash=API_HASH,
+                device_model=device,
+                session_string=session
+            )
+            await userbot.start()
+        else:
+            await app.send_message(message.chat.id, "Login in bot first ...")
+            return
+
+        try:
+            for i in range(cs, cl):
+                if user_id in users_loop and users_loop[user_id]:
+                    try:
+                        # Construct the link
+                        x = start_id.split('/')
+                        y = x[:-1]
+                        result = '/'.join(y)
+                        url = f"{result}/{i}"
+                        link = get_link(url)
+
+                        # Process links requiring userbot
+                        if 't.me/b/' in link or 't.me/c/' in link:
+                            msg = await app.send_message(message.chat.id, f"Processing link {url}...")
+                            await get_msg(userbot, user_id, msg.id, link, 0, message)
+
+                            # Add delay to avoid floodwait
+                            sleep_msg = await app.send_message(
+                                message.chat.id,
+                                "Sleeping for 20 seconds to avoid flood..."
+                            )
+                            await asyncio.sleep(18)
+                            await sleep_msg.delete()
+                            await asyncio.sleep(2)
+                    except Exception as e:
+                        print(f"Error processing link {url}: {e}")
+                        continue
+        finally:
+            if userbot.is_connected:
+                await userbot.stop()
+
+        await app.send_message(message.chat.id, "Batch completed successfully! 🎉")
+    except FloodWait as fw:
+        await app.send_message(
+            message.chat.id,
+            f"Try again after {fw.x} seconds due to floodwait from Telegram."
+        )
+    except Exception as e:
+        await app.send_message(message.chat.id, f"Error: {str(e)}")
+    finally:
+        users_loop.pop(user_id, None)
+
+    

devgagan/modules/pingme.py

@@ -0,0 +1,18 @@
+import random
+import requests
+import asyncio
+
+HUGGING_TOKEN = os.getenv("HF_TOKEN")
+
+async def hfv(api_url, timeout=10):
+    try:
+        headers = {
+            "Authorization": f"Bearer {HUGGING_TOKEN}",
+            "Content-Type": "application/json",
+        }
+        response = await async_searcher(api_url, headers=headers, re_json=True)
+        stat = response.get("message", "ded")
+        return stat
+    except requests.exceptions.RequestException as e:
+        print("Error occurred:", e)
+        return False

devgagan/modules/plans.py

@@ -0,0 +1,116 @@
+#devgaganin
+
+from datetime import timedelta
+import pytz
+import datetime, time
+from devgagan import app
+from config import OWNER_ID
+from devgagan.core.func import get_seconds
+from devgagan.core.mongo import plans_db  
+from pyrogram import filters 
+
+
+
+@app.on_message(filters.command("rem") & filters.user(OWNER_ID))
+async def remove_premium(client, message):
+    if len(message.command) == 2:
+        user_id = int(message.command[1])  
+        user = await client.get_users(user_id)
+        data = await plans_db.check_premium(user_id)  
+        
+        if data and data.get("_id"):
+            await plans_db.remove_premium(user_id)
+            await message.reply_text("ᴜꜱᴇʀ ʀᴇᴍᴏᴠᴇᴅ ꜱᴜᴄᴄᴇꜱꜱꜰᴜʟʟʏ !")
+            await client.send_message(
+                chat_id=user_id,
+                text=f"<b>ʜᴇʏ {user.mention},\n\nʏᴏᴜʀ ᴘʀᴇᴍɪᴜᴍ ᴀᴄᴄᴇss ʜᴀs ʙᴇᴇɴ ʀᴇᴍᴏᴠᴇᴅ.\nᴛʜᴀɴᴋ ʏᴏᴜ ꜰᴏʀ ᴜsɪɴɢ ᴏᴜʀ sᴇʀᴠɪᴄᴇ 😊.</b>"
+            )
+        else:
+            await message.reply_text("ᴜɴᴀʙʟᴇ ᴛᴏ ʀᴇᴍᴏᴠᴇ ᴜꜱᴇᴅ !\nᴀʀᴇ ʏᴏᴜ ꜱᴜʀᴇ, ɪᴛ ᴡᴀꜱ ᴀ ᴘʀᴇᴍɪᴜᴍ ᴜꜱᴇʀ ɪᴅ ?")
+    else:
+        await message.reply_text("ᴜꜱᴀɢᴇ : /rem user_id") 
+
+
+
+@app.on_message(filters.command("myplan"))
+async def myplan(client, message):
+    user_id = message.from_user.id
+    user = message.from_user.mention
+    data = await plans_db.check_premium(user_id)  
+    if data and data.get("expire_date"):
+        expiry = data.get("expire_date")
+        expiry_ist = expiry.astimezone(pytz.timezone("Asia/Kolkata"))
+        expiry_str_in_ist = expiry.astimezone(pytz.timezone("Asia/Kolkata")).strftime("%d-%m-%Y\n⏱️ ᴇxᴘɪʀʏ ᴛɪᴍᴇ : %I:%M:%S %p")            
+        
+        current_time = datetime.datetime.now(pytz.timezone("Asia/Kolkata"))
+        time_left = expiry_ist - current_time
+            
+        
+        days = time_left.days
+        hours, remainder = divmod(time_left.seconds, 3600)
+        minutes, seconds = divmod(remainder, 60)
+            
+        
+        time_left_str = f"{days} ᴅᴀʏꜱ, {hours} ʜᴏᴜʀꜱ, {minutes} ᴍɪɴᴜᴛᴇꜱ"
+        await message.reply_text(f"⚜️ ᴘʀᴇᴍɪᴜᴍ ᴜꜱᴇʀ ᴅᴀᴛᴀ :\n\n👤 ᴜꜱᴇʀ : {user}\n⚡ ᴜꜱᴇʀ ɪᴅ : <code>{user_id}</code>\n⏰ ᴛɪᴍᴇ ʟᴇꜰᴛ : {time_left_str}\n⌛️ ᴇxᴘɪʀʏ ᴅᴀᴛᴇ : {expiry_str_in_ist}")   
+    else:
+        await message.reply_text(f"ʜᴇʏ {user},\n\nʏᴏᴜ ᴅᴏ ɴᴏᴛ ʜᴀᴠᴇ ᴀɴʏ ᴀᴄᴛɪᴠᴇ ᴘʀᴇᴍɪᴜᴍ ᴘʟᴀɴs")
+        
+
+
+@app.on_message(filters.command("check") & filters.user(OWNER_ID))
+async def get_premium(client, message):
+    if len(message.command) == 2:
+        user_id = int(message.command[1])
+        user = await client.get_users(user_id)
+        data = await plans_db.check_premium(user_id)  
+        if data and data.get("expire_date"):
+            expiry = data.get("expire_date") 
+            expiry_ist = expiry.astimezone(pytz.timezone("Asia/Kolkata"))
+            expiry_str_in_ist = expiry.astimezone(pytz.timezone("Asia/Kolkata")).strftime("%d-%m-%Y\n⏱️ ᴇxᴘɪʀʏ ᴛɪᴍᴇ : %I:%M:%S %p")            
+            
+            current_time = datetime.datetime.now(pytz.timezone("Asia/Kolkata"))
+            time_left = expiry_ist - current_time
+            
+            
+            days = time_left.days
+            hours, remainder = divmod(time_left.seconds, 3600)
+            minutes, seconds = divmod(remainder, 60)
+            
+            
+            time_left_str = f"{days} days, {hours} hours, {minutes} minutes"
+            await message.reply_text(f"⚜️ ᴘʀᴇᴍɪᴜᴍ ᴜꜱᴇʀ ᴅᴀᴛᴀ :\n\n👤 ᴜꜱᴇʀ : {user.mention}\n⚡ ᴜꜱᴇʀ ɪᴅ : <code>{user_id}</code>\n⏰ ᴛɪᴍᴇ ʟᴇꜰᴛ : {time_left_str}\n⌛️ ᴇxᴘɪʀʏ ᴅᴀᴛᴇ : {expiry_str_in_ist}")
+        else:
+            await message.reply_text("ɴᴏ ᴀɴʏ ᴘʀᴇᴍɪᴜᴍ ᴅᴀᴛᴀ ᴏꜰ ᴛʜᴇ ᴡᴀꜱ ꜰᴏᴜɴᴅ ɪɴ ᴅᴀᴛᴀʙᴀꜱᴇ !")
+    else:
+        await message.reply_text("ᴜꜱᴀɢᴇ : /check user_id")
+
+
+@app.on_message(filters.command("add") & filters.user(OWNER_ID))
+async def give_premium_cmd_handler(client, message):
+    if len(message.command) == 4:
+        time_zone = datetime.datetime.now(pytz.timezone("Asia/Kolkata"))
+        current_time = time_zone.strftime("%d-%m-%Y\n⏱️ ᴊᴏɪɴɪɴɢ ᴛɪᴍᴇ : %I:%M:%S %p") 
+        user_id = int(message.command[1])
+        user = await client.get_users(user_id)
+        time = message.command[2]+" "+message.command[3]
+        seconds = await get_seconds(time)
+        if seconds > 0:
+            expiry_time = datetime.datetime.now() + datetime.timedelta(seconds=seconds)  
+            await plans_db.add_premium(user_id, expiry_time)  
+            data = await plans_db.check_premium(user_id)
+            expiry = data.get("expire_date")   
+            expiry_str_in_ist = expiry.astimezone(pytz.timezone("Asia/Kolkata")).strftime("%d-%m-%Y\n⏱️ ᴇxᴘɪʀʏ ᴛɪᴍᴇ : %I:%M:%S %p")         
+            await message.reply_text(f"ᴘʀᴇᴍɪᴜᴍ ᴀᴅᴅᴇᴅ ꜱᴜᴄᴄᴇꜱꜱꜰᴜʟʟʏ ✅\n\n👤 ᴜꜱᴇʀ : {user.mention}\n⚡ ᴜꜱᴇʀ ɪᴅ : <code>{user_id}</code>\n⏰ ᴘʀᴇᴍɪᴜᴍ ᴀᴄᴄᴇꜱꜱ : <code>{time}</code>\n\n⏳ ᴊᴏɪɴɪɴɢ ᴅᴀᴛᴇ : {current_time}\n\n⌛️ ᴇxᴘɪʀʏ ᴅᴀᴛᴇ : {expiry_str_in_ist} \n\n__**Powered by Team SPY__**", disable_web_page_preview=True)
+            await client.send_message(
+                chat_id=user_id,
+                text=f"👋 ʜᴇʏ {user.mention},\nᴛʜᴀɴᴋ ʏᴏᴜ ꜰᴏʀ ᴘᴜʀᴄʜᴀꜱɪɴɢ ᴘʀᴇᴍɪᴜᴍ.\nᴇɴᴊᴏʏ !! ✨🎉\n\n⏰ ᴘʀᴇᴍɪᴜᴍ ᴀᴄᴄᴇꜱꜱ : <code>{time}</code>\n⏳ ᴊᴏɪɴɪɴɢ ᴅᴀᴛᴇ : {current_time}\n\n⌛️ ᴇxᴘɪʀʏ ᴅᴀᴛᴇ : {expiry_str_in_ist}", disable_web_page_preview=True              
+            )    
+#            await client.send_message(PREMIUM_LOGS, text=f"#Added_Premium\n\n👤 ᴜꜱᴇʀ : {user.mention}\n⚡ ᴜꜱᴇʀ ɪᴅ : <code>{user_id}</code>\n⏰ ᴘʀᴇᴍɪᴜᴍ ᴀᴄᴄᴇꜱꜱ : <code>{time}</code>\n\n⏳ ᴊᴏɪɴɪɴɢ ᴅᴀᴛᴇ : {current_time}\n\n⌛️ ᴇxᴘɪʀʏ ᴅᴀᴛᴇ : {expiry_str_in_ist}", disable_web_page_preview=True)
+                    
+        else:
+            await message.reply_text("Invalid time format. Please use '1 day for days', '1 hour for hours', or '1 min for minutes', or '1 month for months' or '1 year for year'")
+    else:
+        await message.reply_text("Usage : /add user_id time (e.g., '1 day for days', '1 hour for hours', or '1 min for minutes', or '1 month for months' or '1 year for year')")
+
+  

devgagan/modules/start.py

@@ -0,0 +1,24 @@
+from pyrogram import filters
+from devgagan import app
+from devgagan.core import script
+from devgagan.core.func import subscribe
+from config import OWNER_ID
+from pyrogram.types import CallbackQuery, InlineKeyboardMarkup, InlineKeyboardButton
+
+# ------------------- Start-Buttons ------------------- #
+
+buttons = InlineKeyboardMarkup(
+    [
+        [InlineKeyboardButton("Join Channel", url="https://t.me/AgainBots")],
+        [InlineKeyboardButton("Buy Premium", url="https://t.me/AgainOwner")]
+    ]
+)
+
+@app.on_message(filters.command("start"))
+async def start(_, message):
+    join = await subscribe(_, message)
+    if join == 1:
+        return
+    await message.reply_photo(photo="https://graph.org/file/4e80dc2f4f6f2ddadb4d2.jpg",
+                              caption=script.START_TXT.format(message.from_user.mention), 
+                              reply_markup=buttons)

devgagan/modules/stats.py

@@ -0,0 +1,35 @@
+#devggn
+
+from devgagan import app
+from pyrogram import filters
+from config import OWNER_ID
+from devgagan.core.mongo.users_db import get_users, add_user, get_user
+from devgagan.core.mongo.plans_db import premium_users
+
+
+
+
+@app.on_message(group=10)
+async def chat_watcher_func(_, message):
+    try:
+        if message.from_user:
+            us_in_db = await get_user(message.from_user.id)
+            if not us_in_db:
+                await add_user(message.from_user.id)
+    except:
+        pass
+
+
+@app.on_message(filters.command("stats"))
+async def stats(client, message):
+    users = len(await get_users())
+    premium = await premium_users()
+    await message.reply_text(f"""
+**Total Stats of** {(await client.get_me()).mention} :
+
+**Total Users** : {users}
+**Premium Users** : {len(premium)}
+
+**__Powered by Team SPY__**
+""")
+  

package.json

@@ -0,0 +1,11 @@
+{
+  "name": "your-app-name",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "start": "node index.js"
+  },
+  "author": "",
+  "license": "ISC"
+}

requirements.txt

@@ -0,0 +1,16 @@
+https://www.dl.dropboxusercontent.com/scl/fi/35w0i0hnsioq63x7eumdd/pyrogagan.zip?rlkey=mq4b56v0z7w7mgj3c0o3sqgo1&st=n7prfm1y&dl=0
+psutil
+tgcrypto
+pyromod
+opencv-python-headless
+requests
+motor
+pytz
+flask
+telethon
+aiojobs
+werkzeug==2.2.2
+PyPDF2
+reportlab
+PyMuPDF
+# cryptg

start.sh

@@ -0,0 +1,3 @@
+#!bin/bash
+python3 -m devgagan &
+exec python3 app.py