Create fastapi_app.py

fastapi_app.py

@@ -0,0 +1,823 @@
+from fastapi import FastAPI, HTTPException, Depends
+from pydantic import BaseModel, Field
+from bot import Bot, temp
+from database.users_chats_db import db
+from database.ia_filterdb import Media, get_file_details, get_search_results
+from database.connections_mdb import add_connection, active_connection, all_connections, if_active, make_active, make_inactive, delete_connection
+from database.filters_mdb import add_filter, find_filter, get_filters, delete_filter, del_all, count_filters, filter_stats
+from database.gfilters_mdb import add_gfilter, find_gfilter, get_gfilters, delete_gfilter, del_allg, count_gfilters, gfilter_stats
+from utils import get_settings, save_group_settings, humanbytes, get_size, extract_user, get_file_id, get_poster, parser, get_shortlink, extract_time, admin_check
+from info import API_ID, API_HASH, BOT_TOKEN, LOG_CHANNEL, UPTIME, WEB_SUPPORT, LOG_MSG, ADMINS, CHANNELS
+from pyrogram import Client, filters, enums, types
+from pyrogram.errors import ChatAdminRequired, UserIsBlocked, MessageNotModified, PeerIdInvalid, FloodWait
+from pyrogram.types import InlineKeyboardMarkup, InlineKeyboardButton, Message, CallbackQuery
+from telegraph import upload_file
+from io import BytesIO
+import aiohttp
+import asyncio
+import requests
+import os
+import logging
+import re
+import traceback
+import json
+from googletrans import Translator
+from gtts import gTTS
+from youtube_search import YoutubeSearch
+from youtubesearchpython import SearchVideos
+from yt_dlp import YoutubeDL
+import shutil
+import psutil
+import wget
+from datetime import datetime, timedelta
+from telegraph import upload_file
+from PIL import Image, ImageDraw, ImageFont
+import textwrap
+
+app = FastAPI()
+
+# Shared instance of the Bot class
+bot_instance = Bot()
+
+# Initialize Pyrogram client
+@app.on_event("startup")
+async def startup_event():
+    asyncio.create_task(bot_instance.start())
+
+@app.on_event("shutdown")
+async def shutdown_event():
+    await bot_instance.stop()
+
+# Utility functions
+async def get_chat_member(client, chat_id, user_id):
+    try:
+        return await client.get_chat_member(chat_id, user_id)
+    except Exception as e:
+        logger.error(f"Error getting chat member: {e}")
+        return None
+
+async def send_message(client, chat_id, text, reply_markup=None, disable_web_page_preview=False):
+    try:
+        return await client.send_message(chat_id, text, reply_markup=reply_markup, disable_web_page_preview=disable_web_page_preview)
+    except Exception as e:
+        logger.error(f"Error sending message: {e}")
+        return None
+
+async def edit_message(client, message, text, reply_markup=None):
+    try:
+        return await message.edit_text(text, reply_markup=reply_markup)
+    except Exception as e:
+        logger.error(f"Error editing message: {e}")
+        return None
+
+async def delete_message(client, message):
+    try:
+        return await message.delete()
+    except Exception as e:
+        logger.error(f"Error deleting message: {e}")
+        return None
+
+# Models
+class User(BaseModel):
+    user_id: int
+
+class Group(BaseModel):
+    group_id: int
+
+class Filter(BaseModel):
+    group_id: int
+    text: str
+    reply_text: str
+    btn: str = Field(default=None)
+    file: str = Field(default=None)
+    alert: str = Field(default=None)
+
+class GlobalFilter(BaseModel):
+    text: str
+    reply_text: str
+    btn: str = Field(default=None)
+    file: str = Field(default=None)
+    alert: str = Field(default=None)
+
+class BroadcastMessage(BaseModel):
+    message_id: int
+
+class ShortenURL(BaseModel):
+    url: str
+
+class SettingsUpdate(BaseModel):
+    group_id: int
+    setting_key: str
+    setting_value: bool
+
+class SearchQuery(BaseModel):
+    query: str
+    file_type: str = Field(default=None)
+    offset: int = Field(default=0)
+    max_results: int = Field(default=10)
+
+class ConnectionRequest(BaseModel):
+    user_id: int
+    group_id: int
+
+class TextToSpeechRequest(BaseModel):
+    text: str
+
+class YouTubeDownloadRequest(BaseModel):
+    url: str
+
+class TelegraphUploadRequest(BaseModel):
+    file_path: str
+
+class CarbonRequest(BaseModel):
+    text: str
+
+class FontRequest(BaseModel):
+    text: str
+    style: str
+
+class PasteRequest(BaseModel):
+    text: str
+
+class ShareTextRequest(BaseModel):
+    text: str
+
+class GroupManagerAction(BaseModel):
+    action: str
+    user_id: int = Field(default=None)
+    time: str = Field(default=None)
+
+# Endpoints
+@app.get("/uptime")
+async def get_uptime():
+    uptime = datetime.now() - datetime.fromtimestamp(temp.UPTIME)
+    return {"uptime": str(uptime)}
+
+@app.get("/stats")
+async def get_stats():
+    total_users = await db.total_users_count()
+    total_chats = await db.total_chat_count()
+    return {"total_users": total_users, "total_chats": total_chats}
+
+@app.post("/ban_user")
+async def ban_user_endpoint(user: User):
+    await db.ban_user(user.user_id, "No Reason")
+    temp.BANNED_USERS.append(user.user_id)
+    return {"status": "User banned successfully"}
+
+@app.post("/unban_user")
+async def unban_user_endpoint(user: User):
+    await db.remove_ban(user.user_id)
+    temp.BANNED_USERS.remove(user.user_id)
+    return {"status": "User unbanned successfully"}
+
+@app.post("/add_filter")
+async def add_filter_endpoint(filter_data: Filter):
+    await add_filter(filter_data.group_id, filter_data.text, filter_data.reply_text, filter_data.btn, filter_data.file, filter_data.alert)
+    return {"status": "Filter added successfully"}
+
+@app.post("/find_filter")
+async def find_filter_endpoint(filter_data: Filter):
+    reply_text, btn, alert, fileid = await find_filter(filter_data.group_id, filter_data.text)
+    return {"reply_text": reply_text, "btn": btn, "alert": alert, "fileid": fileid}
+
+@app.post("/get_filters")
+async def get_filters_endpoint(group_id: int):
+    texts = await get_filters(group_id)
+    return {"filters": texts}
+
+@app.post("/delete_filter")
+async def delete_filter_endpoint(filter_data: Filter):
+    await delete_filter(None, filter_data.text, filter_data.group_id)
+    return {"status": "Filter deleted successfully"}
+
+@app.post("/del_all_filters")
+async def del_all_filters_endpoint(group_id: int):
+    await del_all(None, group_id, "Group")
+    return {"status": "All filters deleted successfully"}
+
+@app.post("/add_gfilter")
+async def add_gfilter_endpoint(gfilter_data: GlobalFilter):
+    await add_gfilter('gfilters', gfilter_data.text, gfilter_data.reply_text, gfilter_data.btn, gfilter_data.file, gfilter_data.alert)
+    return {"status": "Global filter added successfully"}
+
+@app.post("/find_gfilter")
+async def find_gfilter_endpoint(gfilter_data: GlobalFilter):
+    reply_text, btn, alert, fileid = await find_gfilter('gfilters', gfilter_data.text)
+    return {"reply_text": reply_text, "btn": btn, "alert": alert, "fileid": fileid}
+
+@app.post("/get_gfilters")
+async def get_gfilters_endpoint():
+    texts = await get_gfilters('gfilters')
+    return {"global_filters": texts}
+
+@app.post("/delete_gfilter")
+async def delete_gfilter_endpoint(gfilter_data: GlobalFilter):
+    await delete_gfilter(None, gfilter_data.text, 'gfilters')
+    return {"status": "Global filter deleted successfully"}
+
+@app.post("/del_all_gfilters")
+async def del_all_gfilters_endpoint():
+    await del_allg(None, 'gfilters')
+    return {"status": "All global filters deleted successfully"}
+
+@app.post("/broadcast")
+async def broadcast_endpoint(broadcast_data: BroadcastMessage):
+    users = await db.get_all_users()
+    b_msg = await bot_instance.get_messages(broadcast_data.message_id)
+    sts = await send_message(bot_instance, broadcast_data.message_id, "Broadcasting your messages...")
+    start_time = time.time()
+    total_users = await db.total_users_count()
+    done = 0
+    blocked = 0
+    deleted = 0
+    failed = 0
+    success = 0
+    async for user in users:
+        pti, sh = await broadcast_messages(int(user['id']), b_msg)
+        if pti:
+            success += 1
+        elif pti == False:
+            if sh == "Blocked":
+                blocked += 1
+            elif sh == "Deleted":
+                deleted += 1
+            elif sh == "Error":
+                failed += 1
+        done += 1
+        if not done % 20:
+            await edit_message(bot_instance, sts, f"Broadcast in progress:\n\nTotal Users {total_users}\nCompleted: {done} / {total_users}\nSuccess: {success}\nBlocked: {blocked}\nDeleted: {deleted}")
+    time_taken = datetime.timedelta(seconds=int(time.time() - start_time))
+    await delete_message(bot_instance, sts)
+    await send_message(bot_instance, broadcast_data.message_id, f"Broadcast completed:\nTime taken: {time_taken}\n\nTotal Users: {total_users}\nCompleted: {done} / {total_users}\nSuccess: {success}\nBlocked: {blocked}\nDeleted: {deleted}")
+    return {"status": "Broadcast completed"}
+
+@app.post("/clear_junk")
+async def clear_junk_endpoint():
+    users = await db.get_all_users()
+    sts = await send_message(bot_instance, broadcast_data.message_id, "Clearing junk users...")
+    start_time = time.time()
+    total_users = await db.total_users_count()
+    blocked = 0
+    deleted = 0
+    failed = 0
+    done = 0
+    async for user in users:
+        pti, sh = await clear_junk(int(user['id']), None)
+        if pti == False:
+            if sh == "Blocked":
+                blocked += 1
+            elif sh == "Deleted":
+                deleted += 1
+            elif sh == "Error":
+                failed += 1
+        done += 1
+        if not done % 20:
+            await edit_message(bot_instance, sts, f"Clearing junk in progress:\n\nTotal Users {total_users}\nCompleted: {done} / {total_users}\nBlocked: {blocked}\nDeleted: {deleted}")
+    time_taken = datetime.timedelta(seconds=int(time.time() - start_time))
+    await delete_message(bot_instance, sts)
+    await send_message(bot_instance, broadcast_data.message_id, f"Clearing junk completed:\nTime taken: {time_taken}\n\nTotal Users: {total_users}\nCompleted: {done} / {total_users}\nBlocked: {blocked}\nDeleted: {deleted}")
+    return {"status": "Junk clearing completed"}
+
+@app.post("/group_broadcast")
+async def group_broadcast_endpoint(broadcast_data: BroadcastMessage):
+    groups = await db.get_all_chats()
+    b_msg = await bot_instance.get_messages(broadcast_data.message_id)
+    sts = await send_message(bot_instance, broadcast_data.message_id, "Broadcasting to groups...")
+    start_time = time.time()
+    total_groups = await db.total_chat_count()
+    done = 0
+    failed = ""
+    success = 0
+    deleted = 0
+    async for group in groups:
+        pti, sh, ex = await broadcast_messages_group(int(group['id']), b_msg)
+        if pti == True:
+            if sh == "Success":
+                success += 1
+        elif pti == False:
+            if sh == "deleted":
+                deleted += 1
+                failed += ex
+                try:
+                    await bot_instance.leave_chat(int(group['id']))
+                except Exception as e:
+                    logger.error(f"{e} > {group['id']}")
+        done += 1
+        if not done % 20:
+            await edit_message(bot_instance, sts, f"Broadcast in progress:\n\nTotal Groups {total_groups}\nCompleted: {done} / {total_groups}\nSuccess: {success}\nDeleted: {deleted}")
+    time_taken = datetime.timedelta(seconds=int(time.time() - start_time))
+    await delete_message(bot_instance, sts)
+    await send_message(bot_instance, broadcast_data.message_id, f"Broadcast completed:\nTime taken: {time_taken}\n\nTotal Groups: {total_groups}\nCompleted: {done} / {total_groups}\nSuccess: {success}\nDeleted: {deleted}\n\nFailed reasons: {failed}")
+    return {"status": "Group broadcast completed"}
+
+@app.post("/junk_group")
+async def junk_group_endpoint():
+    groups = await db.get_all_chats()
+    sts = await send_message(bot_instance, broadcast_data.message_id, "Clearing junk groups...")
+    start_time = time.time()
+    total_groups = await db.total_chat_count()
+    done = 0
+    failed = ""
+    deleted = 0
+    async for group in groups:
+        pti, sh, ex = await junk_group(int(group['id']), None)
+        if pti == False:
+            if sh == "deleted":
+                deleted += 1
+                failed += ex
+                try:
+                    await bot_instance.leave_chat(int(group['id']))
+                except Exception as e:
+                    logger.error(f"{e} > {group['id']}")
+        done += 1
+        if not done % 20:
+            await edit_message(bot_instance, sts, f"Clearing junk in progress:\n\nTotal Groups {total_groups}\nCompleted: {done} / {total_groups}\nDeleted: {deleted}")
+    time_taken = datetime.timedelta(seconds=int(time.time() - start_time))
+    await delete_message(bot_instance, sts)
+    await send_message(bot_instance, broadcast_data.message_id, f"Clearing junk completed:\nTime taken: {time_taken}\n\nTotal Groups: {total_groups}\nCompleted: {done} / {total_groups}\nDeleted: {deleted}\n\nFailed reasons: {failed}")
+    return {"status": "Junk group clearing completed"}
+
+@app.post("/add_connection")
+async def add_connection_endpoint(connection_request: ConnectionRequest):
+    result = await add_connection(connection_request.group_id, connection_request.user_id)
+    return {"status": "Connection added successfully" if result else "Connection already exists"}
+
+@app.post("/active_connection")
+async def active_connection_endpoint(user_id: int):
+    group_id = await active_connection(user_id)
+    return {"active_group_id": group_id}
+
+@app.post("/all_connections")
+async def all_connections_endpoint(user_id: int):
+    group_ids = await all_connections(user_id)
+    return {"group_ids": group_ids}
+
+@app.post("/if_active")
+async def if_active_endpoint(connection_request: ConnectionRequest):
+    result = await if_active(connection_request.user_id, connection_request.group_id)
+    return {"is_active": result}
+
+@app.post("/make_active")
+async def make_active_endpoint(connection_request: ConnectionRequest):
+    result = await make_active(connection_request.user_id, connection_request.group_id)
+    return {"status": "Made active successfully" if result else "Failed to make active"}
+
+@app.post("/make_inactive")
+async def make_inactive_endpoint(user_id: int):
+    result = await make_inactive(user_id)
+    return {"status": "Made inactive successfully" if result else "Failed to make inactive"}
+
+@app.post("/delete_connection")
+async def delete_connection_endpoint(connection_request: ConnectionRequest):
+    result = await delete_connection(connection_request.user_id, connection_request.group_id)
+    return {"status": "Connection deleted successfully" if result else "Failed to delete connection"}
+
+@app.post("/search")
+async def search_endpoint(search_query: SearchQuery):
+    files, next_offset, total_results = await get_search_results(search_query.query, file_type=search_query.file_type, offset=search_query.offset, max_results=search_query.max_results)
+    return {"files": files, "next_offset": next_offset, "total_results": total_results}
+
+@app.post("/get_file_details")
+async def get_file_details_endpoint(file_id: str):
+    file_details = await get_file_details(file_id)
+    return {"file_details": file_details}
+
+@app.post("/get_settings")
+async def get_settings_endpoint(group_id: int):
+    settings = await get_settings(group_id)
+    return {"settings": settings}
+
+@app.post("/save_group_settings")
+async def save_group_settings_endpoint(settings_update: SettingsUpdate):
+    await save_group_settings(settings_update.group_id, settings_update.setting_key, settings_update.setting_value)
+    return {"status": "Settings updated successfully"}
+
+@app.post("/send_cached_media")
+async def send_cached_media_endpoint(user_id: int, file_id: str, caption: str = None, protect_content: bool = False):
+    await bot_instance.send_cached_media(chat_id=user_id, file_id=file_id, caption=caption, protect_content=protect_content)
+    return {"status": "Media sent successfully"}
+
+@app.post("/get_poster")
+async def get_poster_endpoint(query: str, id: bool = False, file: str = None):
+    poster = await get_poster(query, bulk=False, id=id, file=file)
+    return {"poster": poster}
+
+@app.post("/parse_text")
+async def parse_text_endpoint(text: str, keyword: str, cb_data: str):
+    note_data, buttons, alerts = parser(text, keyword, cb_data)
+    return {"note_data": note_data, "buttons": buttons, "alerts": alerts}
+
+@app.post("/get_shortlink")
+async def get_shortlink_endpoint(shorten_url: ShortenURL):
+    short_url = await get_shortlink(shorten_url.url)
+    return {"short_url": short_url}
+
+@app.post("/extract_time")
+async def extract_time_endpoint(time_val: str):
+    extracted_time = extract_time(time_val)
+    return {"extracted_time": extracted_time}
+
+@app.post("/admin_check")
+async def admin_check_endpoint(chat_id: int, user_id: int):
+    is_admin = await admin_check(Message(chat_id=chat_id, from_user=types.User(id=user_id)))
+    return {"is_admin": is_admin}
+
+@app.post("/auto_filter")
+async def auto_filter_endpoint(query: str, chat_id: int, user_id: int, offset: int = 0, max_results: int = 10):
+    files, next_offset, total_results = await get_search_results(query, offset=offset, max_results=max_results)
+    if not files:
+        return {"status": "No files found"}
+    pre = 'filep' if await get_settings(chat_id)['file_secure'] else 'file'
+    btn = []
+    for file in files:
+        btn.append([
+            InlineKeyboardButton(text=f"[{humanbytes(file.file_size)}] {file.file_name}", callback_data=f'{pre}#{user_id}#{file.file_id}')
+        ])
+    btn.append([InlineKeyboardButton(text="🔗 How to download 🔗", callback_data="howdl")])
+    reply_markup = InlineKeyboardMarkup(btn)
+    return {"files": files, "next_offset": next_offset, "total_results": total_results, "reply_markup": reply_markup}
+
+@app.post("/send_telegram_message")
+async def send_telegram_message_endpoint(chat_id: int, text: str):
+    message = await send_message(bot_instance, chat_id, text)
+    return {"message_id": message.id}
+
+@app.post("/edit_telegram_message")
+async def edit_telegram_message_endpoint(message_id: int, chat_id: int, text: str):
+    message = await bot_instance.get_messages(chat_id, message_id)
+    edited_message = await edit_message(bot_instance, message, text)
+    return {"edited_message_id": edited_message.id}
+
+@app.post("/delete_telegram_message")
+async def delete_telegram_message_endpoint(message_id: int, chat_id: int):
+    message = await bot_instance.get_messages(chat_id, message_id)
+    await delete_message(bot_instance, message)
+    return {"status": "Message deleted successfully"}
+
+@app.post("/carbon")
+async def carbon_endpoint(carbon_request: CarbonRequest):
+    carbon_image = await make_carbon(carbon_request.text, True)
+    return {"carbon_url": carbon_image}
+
+async def make_carbon(text, tele=False):
+    url = "https://carbonara.solopov.dev/api/cook"
+    async with aiohttp.ClientSession() as session:
+        async with session.post(url, json={"code": text}) as resp:
+            image = BytesIO(await resp.read())
+    image.name = "carbon.png"
+    if tele:
+        uf = upload_file(image)
+        image.close()
+        return f"https://graph.org{uf[0]}"
+    return image
+
+@app.post("/font")
+async def font_endpoint(font_request: FontRequest):
+    fonts = {
+        "typewriter": Fonts.typewriter,
+        "outline": Fonts.outline,
+        "serif": Fonts.serief,
+        "bold_cool": Fonts.bold_cool,
+        "cool": Fonts.cool,
+        "small_cap": Fonts.smallcap,
+        "script": Fonts.script,
+        "bold_script": Fonts.bold_script,
+        "tiny": Fonts.tiny,
+        "comic": Fonts.comic,
+        "san": Fonts.san,
+        "slant_san": Fonts.slant_san,
+        "slant": Fonts.slant,
+        "sim": Fonts.sim,
+        "circles": Fonts.circles,
+        "dark_circle": Fonts.dark_circle,
+        "gothic": Fonts.gothic,
+        "bold_gothic": Fonts.bold_gothic,
+        "cloud": Fonts.cloud,
+        "happy": Fonts.happy,
+        "sad": Fonts.sad,
+        "special": Fonts.special,
+        "square": Fonts.square,
+        "dark_square": Fonts.dark_square,
+        "andalucia": Fonts.andalucia,
+        "manga": Fonts.manga,
+        "stinky": Fonts.stinky,
+        "bubbles": Fonts.bubbles,
+        "underline": Fonts.underline,
+        "ladybug": Fonts.ladybug,
+        "rays": Fonts.rays,
+        "birds": Fonts.birds,
+        "slash": Fonts.slash,
+        "stop": Fonts.stop,
+        "skyline": Fonts.skyline,
+        "arrows": Fonts.arrows,
+        "rvnes": Fonts.rvnes,
+        "strike": Fonts.strike,
+        "frozen": Fonts.frozen
+    }
+    cls = fonts.get(font_request.style)
+    if not cls:
+        return {"error": "Invalid style"}
+    new_text = cls(font_request.text)
+    return {"new_text": new_text}
+
+@app.post("/paste")
+async def paste_endpoint(paste_request: PasteRequest):
+    paste_response = await p_paste(paste_request.text)
+    return paste_response
+
+async def p_paste(code, extension=None):
+    siteurl = "https://pasty.lus.pm/api/v1/pastes"
+    data = {"content": code}
+    try:
+        response = requests.post(url=siteurl, data=json.dumps(data), headers={"User-Agent": "Mozilla/5.0", "content-type": "application/json"})
+    except Exception as e:
+        return {"error": str(e)}
+    if response.ok:
+        response = response.json()
+        purl = (
+            f"https://pasty.lus.pm/{response['id']}.{extension}"
+            if extension
+            else f"https://pasty.lus.pm/{response['id']}.txt"
+        )
+        return {
+            "url": purl,
+            "raw": f"https://pasty.lus.pm/{response['id']}/raw",
+            "bin": "Pasty",
+        }
+    return {"error": "Unable to reach pasty.lus.pm"}
+
+@app.post("/share_text")
+async def share_text_endpoint(share_request: ShareTextRequest):
+    share_url = f"https://t.me/share/url?url={quote(share_request.text)}"
+    return {"share_url": share_url}
+
+@app.post("/telegraph_upload")
+async def telegraph_upload_endpoint(upload_request: TelegraphUploadRequest):
+    try:
+        response = upload_file(upload_request.file_path)
+    except Exception as e:
+        logger.error(f"Error uploading to Telegraph: {e}")
+        return {"error": str(e)}
+    telegraph_url = f"https://graph.org{response[0]}"
+    return {"telegraph_url": telegraph_url}
+
+@app.post("/text_to_speech")
+async def text_to_speech_endpoint(tts_request: TextToSpeechRequest):
+    audio = await convert(tts_request.text)
+    return {"audio_url": audio.name}
+
+async def convert(text):
+    audio = BytesIO()
+    i = Translator().translate(text, dest="en")
+    lang = i.src
+    tts = gTTS(text, lang=lang)
+    audio.name = lang + ".mp3"
+    tts.write_to_fp(audio)
+    return audio
+
+@app.post("/download_youtube_song")
+async def download_youtube_song_endpoint(yt_request: YouTubeDownloadRequest):
+    try:
+        results = YoutubeSearch(yt_request.url, max_results=1).to_dict()
+        link = f"https://youtube.com{results[0]['url_suffix']}"
+        title = results[0]["title"][:40]
+        thumbnail = results[0]["thumbnails"][0]
+        thumb_name = f'thumb{title}.jpg'
+        thumb = requests.get(thumbnail, allow_redirects=True)
+        open(thumb_name, 'wb').write(thumb.content)
+        performer = f"[Mᴋɴ Bᴏᴛᴢ™]"
+        duration = results[0]["duration"]
+        url_suffix = results[0]["url_suffix"]
+        views = results[0]["views"]
+    except Exception as e:
+        logger.error(f"Error downloading YouTube song: {e}")
+        return {"error": str(e)}
+
+    ydl_opts = {"format": "bestaudio[ext=m4a]"}
+    try:
+        with YoutubeDL(ydl_opts) as ydl:
+            info_dict = ydl.extract_info(link, download=False)
+            audio_file = ydl.prepare_filename(info_dict)
+            ydl.process_info(info_dict)
+    except Exception as e:
+        logger.error(f"Error processing YouTube song: {e}")
+        return {"error": str(e)}
+
+    cap = "**BY›› [Mᴋɴ Bᴏᴛᴢ™](https://t.me/mkn_bots_updates)**"
+    secmul, dur, dur_arr = 1, 0, duration.split(':')
+    for i in range(len(dur_arr) - 1, -1, -1):
+        dur += (int(dur_arr[i]) * secmul)
+        secmul *= 60
+
+    return {"audio_file": audio_file, "caption": cap, "title": title, "duration": dur, "performer": performer, "thumb": thumb_name}
+
+@app.post("/download_youtube_video")
+async def download_youtube_video_endpoint(yt_request: YouTubeDownloadRequest):
+    url = yt_request.url
+    try:
+        search = SearchVideos(f"{url}", offset=1, mode="dict", max_results=1)
+        mi = search.result()
+        mio = mi["search_result"]
+        mo = mio[0]["link"]
+        thum = mio[0]["title"]
+        fridayz = mio[0]["id"]
+        mio[0]["channel"]
+        kekme = f"https://img.youtube.com/vi/{fridayz}/hqdefault.jpg"
+        await asyncio.sleep(0.6)
+        sedlyf = wget.download(kekme)
+        opts = {
+            "format": "best",
+            "addmetadata": True,
+            "key": "FFmpegMetadata",
+            "prefer_ffmpeg": True,
+            "geo_bypass": True,
+            "nocheckcertificate": True,
+            "postprocessors": [{"key": "FFmpegVideoConvertor", "preferedformat": "mp4"}],
+            "outtmpl": "%(id)s.mp4",
+            "logtostderr": False,
+            "quiet": True,
+        }
+        with YoutubeDL(opts) as ytdl:
+            ytdl_data = ytdl.extract_info(url, download=True)
+    except Exception as e:
+        logger.error(f"Error downloading YouTube video: {e}")
+        return {"error": str(e)}
+
+    file_stark = f"{ytdl_data['id']}.mp4"
+    capy = f"""**𝚃𝙸𝚃𝙻𝙴 :** [{thum}]({mo})\n**𝚁𝙴𝚀𝚄𝙴𝚂𝚃𝙴𝙳 𝙱𝚈 :** {await bot_instance.get_me().mention}"""
+
+    return {"video_file": file_stark, "caption": capy, "title": ytdl_data["title"], "duration": int(ytdl_data["duration"]), "thumb": sedlyf}
+
+@app.post("/group_manager_action")
+async def group_manager_action_endpoint(action_request: GroupManagerAction):
+    chat_id = action_request.group_id
+    action = action_request.action
+    user_id = action_request.user_id
+    time_val = action_request.time
+
+    if action == "ban":
+        await bot_instance.ban_chat_member(chat_id, user_id)
+        return {"status": "User banned successfully"}
+    elif action == "unban":
+        await bot_instance.unban_chat_member(chat_id, user_id)
+        return {"status": "User unbanned successfully"}
+    elif action == "tban":
+        until_date_val = extract_time(time_val)
+        if until_date_val is None:
+            return {"error": "Invalid time type specified. Expected m, h, or d, Got it: {time_val[-1]}"}
+        await bot_instance.ban_chat_member(chat_id, user_id, until_date=until_date_val)
+        return {"status": "User temporarily banned successfully"}
+    elif action == "mute":
+        await bot_instance.restrict_chat_member(chat_id, user_id, permissions=enums.ChatPermissions())
+        return {"status": "User muted successfully"}
+    elif action == "unmute":
+        await bot_instance.restrict_chat_member(chat_id, user_id, permissions=enums.ChatPermissions(can_send_messages=True))
+        return {"status": "User unmuted successfully"}
+    elif action == "tmute":
+        until_date_val = extract_time(time_val)
+        if until_date_val is None:
+            return {"error": "Invalid time type specified. Expected m, h, or d, Got it: {time_val[-1]}"}
+        await bot_instance.restrict_chat_member(chat_id, user_id, permissions=enums.ChatPermissions(), until_date=until_date_val)
+        return {"status": "User temporarily muted successfully"}
+    elif action == "pin":
+        await bot_instance.pin_chat_message(chat_id, action_request.message_id)
+        return {"status": "Message pinned successfully"}
+    elif action == "unpin":
+        await bot_instance.unpin_chat_message(chat_id, action_request.message_id)
+        return {"status": "Message unpinned successfully"}
+    elif action == "purge":
+        if action_request.message_id:
+            await purge_messages(bot_instance, chat_id, action_request.message_id)
+            return {"status": "Messages purged successfully"}
+        else:
+            return {"error": "Message ID is required for purge action"}
+    else:
+        return {"error": "Invalid action"}
+
+async def purge_messages(client, chat_id, message_id):
+    try:
+        message_ids = []
+        count_del_etion_s = 0
+        if message_id:
+            for a_s_message_id in range(message_id, message_id + 100):
+                message_ids.append(a_s_message_id)
+                if len(message_ids) == 100:
+                    await client.delete_messages(chat_id=chat_id, message_ids=message_ids, revoke=True)
+                    count_del_etion_s += len(message_ids)
+                    message_ids = []
+            if len(message_ids) > 0:
+                await client.delete_messages(chat_id=chat_id, message_ids=message_ids, revoke=True)
+                count_del_etion_s += len(message_ids)
+    except Exception as e:
+        logger.error(f"Error purging messages: {e}")
+        return {"error": str(e)}
+
+@app.post("/group_leave")
+async def group_leave_endpoint(group_id: int):
+    await bot_instance.leave_chat(group_id)
+    return {"status": "Left the group successfully"}
+
+@app.post("/group_disable")
+async def group_disable_endpoint(group_id: int, reason: str = "No Reason"):
+    await db.disable_chat(group_id, reason)
+    temp.BANNED_CHATS.append(group_id)
+    return {"status": "Group disabled successfully"}
+
+@app.post("/group_enable")
+async def group_enable_endpoint(group_id: int):
+    await db.re_enable_chat(group_id)
+    temp.BANNED_CHATS.remove(group_id)
+    return {"status": "Group enabled successfully"}
+
+@app.post("/get_user_info")
+async def get_user_info_endpoint(user_id: int):
+    user_info = await bot_instance.get_users(user_id)
+    return {"user_info": user_info}
+
+@app.post("/get_chat_info")
+async def get_chat_info_endpoint(chat_id: int):
+    chat_info = await bot_instance.get_chat(chat_id)
+    return {"chat_info": chat_info}
+
+@app.post("/send_photo")
+async def send_photo_endpoint(chat_id: int, photo_url: str, caption: str = None):
+    response = requests.get(photo_url)
+    photo = BytesIO(response.content)
+    photo.name = "photo.jpg"
+    message = await bot_instance.send_photo(chat_id, photo, caption=caption)
+    return {"message_id": message.id}
+
+@app.post("/send_document")
+async def send_document_endpoint(chat_id: int, document_url: str, caption: str = None):
+    response = requests.get(document_url)
+    document = BytesIO(response.content)
+    document.name = "document.pdf"
+    message = await bot_instance.send_document(chat_id, document, caption=caption)
+    return {"message_id": message.id}
+
+@app.post("/send_video")
+async def send_video_endpoint(chat_id: int, video_url: str, caption: str = None):
+    response = requests.get(video_url)
+    video = BytesIO(response.content)
+    video.name = "video.mp4"
+    message = await bot_instance.send_video(chat_id, video, caption=caption)
+    return {"message_id": message.id}
+
+@app.post("/send_audio")
+async def send_audio_endpoint(chat_id: int, audio_url: str, caption: str = None):
+    response = requests.get(audio_url)
+    audio = BytesIO(response.content)
+    audio.name = "audio.mp3"
+    message = await bot_instance.send_audio(chat_id, audio, caption=caption)
+    return {"message_id": message.id}
+
+@app.post("/send_voice")
+async def send_voice_endpoint(chat_id: int, voice_url: str, caption: str = None):
+    response = requests.get(voice_url)
+    voice = BytesIO(response.content)
+    voice.name = "voice.ogg"
+    message = await bot_instance.send_voice(chat_id, voice, caption=caption)
+    return {"message_id": message.id}
+
+@app.post("/send_sticker")
+async def send_sticker_endpoint(chat_id: int, sticker_url: str):
+    response = requests.get(sticker_url)
+    sticker = BytesIO(response.content)
+    sticker.name = "sticker.webp"
+    message = await bot_instance.send_sticker(chat_id, sticker)
+    return {"message_id": message.id}
+
+@app.post("/send_animation")
+async def send_animation_endpoint(chat_id: int, animation_url: str, caption: str = None):
+    response = requests.get(animation_url)
+    animation = BytesIO(response.content)
+    animation.name = "animation.gif"
+    message = await bot_instance.send_animation(chat_id, animation, caption=caption)
+    return {"message_id": message.id}
+
+@app.post("/send_video_note")
+async def send_video_note_endpoint(chat_id: int, video_note_url: str):
+    response = requests.get(video_note_url)
+    video_note = BytesIO(response.content)
+    video_note.name = "video_note.mp4"
+    message = await bot_instance.send_video_note(chat_id, video_note)
+    return {"message_id": message.id}
+
+@app.post("/send_location")
+async def send_location_endpoint(chat_id: int, latitude: float, longitude: float):
+    message = await bot_instance.send_location(chat_id, latitude, longitude)
+    return {"message_id": message.id}
+
+@app.post("/send_contact")
+async def send_contact_endpoint(chat_id: int, phone_number: str, first_name: str, last_name: str = None):
+    message = await bot_instance.send_contact(chat_id, phone_number, first_name, last_name=last_name)
+    return {"message_id": message.id}
+
+@app.post("/send_dice")
+async def send_dice_endpoint(chat_id: int):
+    message = await bot_instance.send_dice(chat_id)
+    return {"message_id": message.id}
+
+@app.post("/send_poll")
+async def send_poll_endpoint(chat_id: int, question: str, options: list, is_anonymous: bool = False, type: str = "regular", allows_multiple_answers: bool = False, correct_option_id: int = None, explanation: str =