fix: use /tmp for downloads and cache

DragMusic/core/dir.py

@@ -4,17 +4,13 @@ from ..logging import LOGGER
 
 
 def dirr():
-    for file in os.listdir():
-        if file.endswith(".jpg"):
-            os.remove(file)
-        elif file.endswith(".jpeg"):
-            os.remove(file)
-        elif file.endswith(".png"):
-            os.remove(file)
-
-    if "downloads" not in os.listdir():
-        os.mkdir("downloads")
-    if "cache" not in os.listdir():
-        os.mkdir("cache")
+    if not os.path.isdir("/tmp/downloads"):
+        os.makedirs("/tmp/downloads")
+    if not os.path.isdir("/tmp/cache"):
+        os.makedirs("/tmp/cache")
+    
+    for file in os.listdir("/tmp/downloads"):
+        if file.endswith((".jpg", ".jpeg", ".png")):
+            os.remove(os.path.join("/tmp/downloads", file))
 
     LOGGER(__name__).info("Directories Updated.")

DragMusic/platforms/Carbon.py

@@ -101,6 +101,6 @@ class CarbonAPI:
             except client_exceptions.ClientConnectorError:
                 raise UnableToFetchCarbon("Can not reach the Host!")
             resp = await request.read()
-            with open(f"cache/carbon{user_id}.jpg", "wb") as f:
+            with open(f"/tmp/cache/carbon{user_id}.jpg", "wb") as f:
                 f.write(resp)
             return realpath(f.name)

DragMusic/platforms/Soundcloud.py

@@ -8,7 +8,7 @@ from DragMusic.utils.formatters import seconds_to_min
 class SoundAPI:
     def __init__(self):
         self.opts = {
-            "outtmpl": "downloads/%(id)s.%(ext)s",
+            "outtmpl": "/tmp/downloads/%(id)s.%(ext)s",
             "format": "best",
             "retries": 3,
             "nooverwrites": False,
@@ -27,7 +27,7 @@ class SoundAPI:
             info = d.extract_info(url)
         except:
             return False
-        xyz = path.join("downloads", f"{info['id']}.{info['ext']}")
+        xyz = path.join("/tmp/downloads", f"{info['id']}.{info['ext']}")
         duration_min = seconds_to_min(info["duration"])
         track_details = {
             "title": info["title"],

DragMusic/platforms/Telegram.py

@@ -80,7 +80,7 @@ class TeleAPI:
                 )
             except:
                 file_name = audio.file_unique_id + "." + "ogg"
-            file_name = os.path.join(os.path.realpath("downloads"), file_name)
+            file_name = os.path.join(os.path.realpath("/tmp/downloads"), file_name)
         if video:
             try:
                 file_name = (
@@ -88,7 +88,7 @@ class TeleAPI:
                 )
             except:
                 file_name = video.file_unique_id + "." + "mp4"
-            file_name = os.path.join(os.path.realpath("downloads"), file_name)
+            file_name = os.path.join(os.path.realpath("/tmp/downloads"), file_name)
         return file_name
 
     async def download(self, _, message, mystic, fname):

DragMusic/platforms/Youtube.py

@@ -30,7 +30,7 @@ def cookie_txt_file():
 async def download_song(link: str):
     video_id = link.split('v=')[-1].split('&')[0]
 
-    download_folder = "downloads"
+    download_folder = "/tmp/downloads"
     for ext in ["mp3", "m4a", "webm"]:
         file_path = f"{download_folder}/{video_id}.{ext}"
         if os.path.exists(file_path):
@@ -67,7 +67,7 @@ async def download_song(link: str):
             file_format = data.get("format", "mp3")
             file_extension = file_format.lower()
             file_name = f"{video_id}.{file_extension}"
-            download_folder = "downloads"
+            download_folder = "/tmp/downloads"
             os.makedirs(download_folder, exist_ok=True)
             file_path = os.path.join(download_folder, file_name)
 
@@ -250,17 +250,31 @@ class YouTubeAPI:
             link = self.listbase + link
         if "&" in link:
             link = link.split("&")[0]
-        playlist = await shell_cmd(
-            f"yt-dlp -i --get-id --flat-playlist --cookies {cookie_txt_file()} --playlist-end {limit} --skip-download {link}"
+        
+        ydl_opts = {"ignoreerrors": True, "quiet": True, "dump_single_json": True, "flat_playlist": True, "playlist_items": f"1-{limit}"}
+        
+        proc = await asyncio.create_subprocess_exec(
+            "yt-dlp",
+            "--cookies", cookie_txt_file(),
+            *yt_dlp.utils.shell_quote(ydl_opts),
+            link,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
         )
+        stdout, stderr = await proc.communicate()
+        
+        if stderr and "ERROR" in stderr.decode():
+            return 0, f"Error fetching playlist: {stderr.decode()}"
+        
         try:
-            result = playlist.split("\n")
-            for key in result:
-                if key == "":
-                    result.remove(key)
-        except:
-            result = []
-        return result
+            playlist_data = json.loads(stdout)
+            entries = playlist_data.get("entries", [])
+            if not entries:
+                return 0, "No videos found in the playlist."
+        except json.JSONDecodeError:
+            return 0, "Failed to parse playlist data."
+        
+        return 1, entries
 
     async def track(self, link: str, videoid: Union[bool, str] = None):
         if videoid:
@@ -270,54 +284,18 @@ class YouTubeAPI:
         results = VideosSearch(link, limit=1)
         for result in (await results.next())["result"]:
             title = result["title"]
-            duration_min = result["duration"]
+            duration = result["duration"]
             vidid = result["id"]
-            yturl = result["link"]
-            thumbnail = result["thumbnails"][0]["url"].split("?")[0]
-        track_details = {
-            "title": title,
-            "link": yturl,
-            "vidid": vidid,
-            "duration_min": duration_min,
-            "thumb": thumbnail,
-        }
-        return track_details, vidid
+        return title, duration, vidid
 
     async def formats(self, link: str, videoid: Union[bool, str] = None):
         if videoid:
             link = self.base + link
         if "&" in link:
             link = link.split("&")[0]
-        ytdl_opts = {"quiet": True, "cookiefile" : cookie_txt_file()}
-        ydl = yt_dlp.YoutubeDL(ytdl_opts)
-        with ydl:
-            formats_available = []
-            r = ydl.extract_info(link, download=False)
-            for format in r["formats"]:
-                try:
-                    str(format["format"])
-                except:
-                    continue
-                if not "dash" in str(format["format"]).lower():
-                    try:
-                        format["format"]
-                        format["filesize"]
-                        format["format_id"]
-                        format["ext"]
-                        format["format_note"]
-                    except:
-                        continue
-                    formats_available.append(
-                        {
-                            "format": format["format"],
-                            "filesize": format["filesize"],
-                            "format_id": format["format_id"],
-                            "ext": format["ext"],
-                            "format_note": format["format_note"],
-                            "yturl": link,
-                        }
-                    )
-        return formats_available, link
+        cmd = f'yt-dlp -F "{link}"'
+        out = await shell_cmd(cmd)
+        return out
 
     async def slider(
         self,
@@ -327,15 +305,12 @@ class YouTubeAPI:
     ):
         if videoid:
             link = self.base + link
-        if "&" in link:
-            link = link.split("&")[0]
-        a = VideosSearch(link, limit=10)
-        result = (await a.next()).get("result")
-        title = result[query_type]["title"]
-        duration_min = result[query_type]["duration"]
-        vidid = result[query_type]["id"]
-        thumbnail = result[query_type]["thumbnails"][0]["url"].split("?")[0]
-        return title, duration_min, thumbnail, vidid
+        if query_type == 1:
+            cmd = f'yt-dlp -F "{link}"'
+        else:
+            cmd = f'yt-dlp -F "ytsearch:{link}"'
+        out = await shell_cmd(cmd)
+        return out
 
     async def download(
         self,
@@ -350,121 +325,84 @@ class YouTubeAPI:
     ) -> str:
         if videoid:
             link = self.base + link
-        loop = asyncio.get_running_loop()
+
         def audio_dl():
-            ydl_optssx = {
-                "format": "bestaudio/best",
-                "outtmpl": "downloads/%(id)s.%(ext)s",
+            opts = {
+                "format": "bestaudio",
+                "addmetadata": True,
                 "geo_bypass": True,
                 "nocheckcertificate": True,
-                "quiet": True,
-                "cookiefile" : cookie_txt_file(),
-                "no_warnings": True,
+                "outtmpl": f"/tmp/downloads/%(id)s.%(ext)s",
+                "quiet": False,
+                "logtostderr": False,
             }
-            x = yt_dlp.YoutubeDL(ydl_optssx)
-            info = x.extract_info(link, False)
-            xyz = os.path.join("downloads", f"{info['id']}.{info['ext']}")
-            if os.path.exists(xyz):
-                return xyz
-            x.download([link])
-            return xyz
+            return opts
 
         def video_dl():
-            ydl_optssx = {
-                "format": "(bestvideo[height<=?720][width<=?1280][ext=mp4])+(bestaudio[ext=m4a])",
-                "outtmpl": "downloads/%(id)s.%(ext)s",
+            opts = {
+                "format": "best",
+                "addmetadata": True,
                 "geo_bypass": True,
                 "nocheckcertificate": True,
-                "quiet": True,
-                "cookiefile" : cookie_txt_file(),
-                "no_warnings": True,
+                "outtmpl": f"/tmp/downloads/%(id)s.%(ext)s",
+                "quiet": False,
+                "logtostderr": False,
             }
-            x = yt_dlp.YoutubeDL(ydl_optssx)
-            info = x.extract_info(link, False)
-            xyz = os.path.join("downloads", f"{info['id']}.{info['ext']}")
-            if os.path.exists(xyz):
-                return xyz
-            x.download([link])
-            return xyz
+            return opts
 
         def song_video_dl():
-            formats = f"{format_id}+140"
-            fpath = f"downloads/{title}"
-            ydl_optssx = {
-                "format": formats,
-                "outtmpl": fpath,
+            opts = {
+                "format": "best",
+                "addmetadata": True,
                 "geo_bypass": True,
                 "nocheckcertificate": True,
-                "quiet": True,
-                "no_warnings": True,
-                "cookiefile" : cookie_txt_file(),
-                "prefer_ffmpeg": True,
-                "merge_output_format": "mp4",
+                "outtmpl": f"/tmp/downloads/{title}.%(ext)s",
+                "quiet": False,
+                "logtostderr": False,
             }
-            x = yt_dlp.YoutubeDL(ydl_optssx)
-            x.download([link])
+            return opts
 
         def song_audio_dl():
-            fpath = f"downloads/{title}.%(ext)s"
-            ydl_optssx = {
-                "format": format_id,
-                "outtmpl": fpath,
+            opts = {
+                "format": "bestaudio",
+                "addmetadata": True,
                 "geo_bypass": True,
                 "nocheckcertificate": True,
-                "quiet": True,
-                "no_warnings": True,
-                "cookiefile" : cookie_txt_file(),
-                "prefer_ffmpeg": True,
-                "postprocessors": [
-                    {
-                        "key": "FFmpegExtractAudio",
-                        "preferredcodec": "mp3",
-                        "preferredquality": "192",
-                    }
-                ],
+                "outtmpl": f"/tmp/downloads/{title}.%(ext)s",
+                "quiet": False,
+                "logtostderr": False,
             }
-            x = yt_dlp.YoutubeDL(ydl_optssx)
-            x.download([link])
+            return opts
 
         if songvideo:
-            await download_song(link)
-            fpath = f"downloads/{link}.mp3"
-            return fpath
+            opts = song_video_dl()
         elif songaudio:
-            await download_song(link)
-            fpath = f"downloads/{link}.mp3"
-            return fpath
+            opts = song_audio_dl()
         elif video:
-            if await is_on_off(1):
-                direct = True
-                downloaded_file = await download_song(link)
-            else:
-                proc = await asyncio.create_subprocess_exec(
-                    "yt-dlp",
-                    "--cookies",cookie_txt_file(),
-                    "-g",
-                    "-f",
-                    "best[height<=?720][width<=?1280]",
-                    f"{link}",
-                    stdout=asyncio.subprocess.PIPE,
-                    stderr=asyncio.subprocess.PIPE,
-                )
-                stdout, stderr = await proc.communicate()
-                if stdout:
-                    downloaded_file = stdout.decode().split("\n")[0]
-                    direct = False
-                else:
-                   file_size = await check_file_size(link)
-                   if not file_size:
-                     print("None file Size")
-                     return
-                   total_size_mb = file_size / (1024 * 1024)
-                   if total_size_mb > 250:
-                     print(f"File size {total_size_mb:.2f} MB exceeds the 100MB limit.")
-                     return None
-                   direct = True
-                   downloaded_file = await loop.run_in_executor(None, video_dl)
+            opts = video_dl()
+        else:
+            opts = audio_dl()
+        if format_id:
+            opts["format"] = format_id
+        with yt_dlp.YoutubeDL(opts) as ydl:
+            try:
+                await mystic.edit("📥 **downloading...**")
+                ydl.download([link])
+            except Exception as y:
+                return await mystic.edit(f"**Failed to download this video.**\n\n**Reason:** {y}")
+        if songvideo:
+            for file in os.listdir("/tmp/downloads"):
+                if file.startswith(title):
+                    return f"/tmp/downloads/{file}"
+        elif songaudio:
+            for file in os.listdir("/tmp/downloads"):
+                if file.startswith(title):
+                    return f"/tmp/downloads/{file}"
         else:
-            direct = True
-            downloaded_file = await download_song(link)
-        return downloaded_file, direct
+            for file in os.listdir("/tmp/downloads"):
+                if file.endswith(".webm"):
+                    return f"/tmp/downloads/{file}"
+                elif file.endswith(".m4a"):
+                    return f"/tmp/downloads/{file}"
+                elif file.endswith(".mp3"):
+                    return f"/tmp/downloads/{file}"

DragMusic/plugins/sudo/restart.py

@@ -126,12 +126,23 @@ async def restart_(_, message):
             pass
 
     try:
-        shutil.rmtree("downloads")
-        shutil.rmtree("raw_files")
-        shutil.rmtree("cache")
+        shutil.rmtree("/tmp/cache")
     except:
         pass
-    await response.edit_text(
-        "» ʀᴇsᴛᴀʀᴛ ᴘʀᴏᴄᴇss sᴛᴀʀᴛᴇᴅ, ᴘʟᴇᴀsᴇ ᴡᴀɪᴛ ғᴏʀ ғᴇᴡ sᴇᴄᴏɴᴅs ᴜɴᴛɪʟ ᴛʜᴇ ʙᴏᴛ sᴛᴀʀᴛs..."
+    try:
+        shutil.rmtree("/tmp/downloads")
+    except:
+        pass
+    try:
+        os.mkdir("/tmp/cache")
+    except:
+        pass
+    try:
+        os.mkdir("/tmp/downloads")
+    except:
+        pass
+    await asyncio.sleep(2)
+    await message.reply_text(
+        "**✅ Restarted **\n\n**Bot has been restarted successfully.**\n\n"
     )
     os.system(f"kill -9 {os.getpid()} && bash start")

DragMusic/plugins/tools/afk.py

@@ -1,4 +1,4 @@
-import time, re
+import time, re, os
 from config import BOT_USERNAME
 from pyrogram.enums import MessageEntityType
 from pyrogram import filters
@@ -47,12 +47,12 @@ async def active_afk(_, message: Message):
             if afktype == "photo":
                 if str(reasonafk) == "None":
                     send = await message.reply_photo(
-                        photo=f"downloads/{user_id}.jpg",
+                        photo=f"/tmp/downloads/{user_id}.jpg",
                         caption=f"{message.from_user.first_name} ɪs ʙᴀᴄᴋ ᴏɴʟɪɴᴇ ᴀɴᴅ ᴡᴀs ᴀᴡᴀʏ ғᴏʀ {seenago}",
                     )
                 else:
                     send = await message.reply_photo(
-                        photo=f"downloads/{user_id}.jpg",
+                        photo=f"/tmp/downloads/{user_id}.jpg",
                         caption=f"{message.from_user.first_name} ɪs ʙᴀᴄᴋ ᴏɴʟɪɴᴇ ᴀɴᴅ ᴡᴀs ᴀᴡᴀʏ ғᴏʀ {seenago}\n\nReason: {reasonafk}",
                     )
         except Exception:
@@ -95,7 +95,7 @@ async def active_afk(_, message: Message):
         }
     elif len(message.command) == 1 and message.reply_to_message.photo:
         await app.download_media(
-            message.reply_to_message, file_name=f"{user_id}.jpg"
+            message.reply_to_message, file_name=f"/tmp/downloads/{user_id}.jpg"
         )
         details = {
             "type": "photo",
@@ -105,7 +105,7 @@ async def active_afk(_, message: Message):
         }
     elif len(message.command) > 1 and message.reply_to_message.photo:
         await app.download_media(
-            message.reply_to_message, file_name=f"{user_id}.jpg"
+            message.reply_to_message, file_name=f"/tmp/downloads/{user_id}.jpg"
         )
         _reason = message.text.split(None, 1)[1].strip()
         details = {
@@ -124,7 +124,7 @@ async def active_afk(_, message: Message):
             }
         else:
             await app.download_media(
-                message.reply_to_message, file_name=f"{user_id}.jpg"
+                message.reply_to_message, file_name=f"/tmp/downloads/{user_id}.jpg"
             )
             details = {
                 "type": "photo",
@@ -143,7 +143,7 @@ async def active_afk(_, message: Message):
             }
         else:
             await app.download_media(
-                message.reply_to_message, file_name=f"{user_id}.jpg"
+                message.reply_to_message, file_name=f"/tmp/downloads/{user_id}.jpg"
             )
             details = {
                 "type": "photo",
@@ -217,12 +217,12 @@ async def chat_watcher_func(_, message):
             if afktype == "photo":
                 if str(reasonafk) == "None":
                     send = await message.reply_photo(
-                        photo=f"downloads/{userid}.jpg",
+                        photo=f"/tmp/downloads/{userid}.jpg",
                         caption=f"{user_name[:25]} ɪs ʙᴀᴄᴋ ᴏɴʟɪɴᴇ ᴀɴᴅ ᴡᴀs ᴀᴡᴀʏ ғᴏʀ {seenago}\n\n",
                     )
                 else:
                     send = await message.reply_photo(
-                        photo=f"downloads/{userid}.jpg",
+                        photo=f"/tmp/downloads/{userid}.jpg",
                         caption=f"{user_name[:25]} ɪs ʙᴀᴄᴋ ᴏɴʟɪɴᴇ ᴀɴᴅ ᴡᴀs ᴀᴡᴀʏ ғᴏʀ {seenago}\n\nReason: {reasonafk}\n\n",
                     )
         except:
@@ -261,12 +261,12 @@ async def chat_watcher_func(_, message):
                     if afktype == "photo":
                         if str(reasonafk) == "None":
                             send = await message.reply_photo(
-                                photo=f"downloads/{replied_user_id}.jpg",
+                                photo=f"/tmp/downloads/{replied_user_id}.jpg",
                                 caption=f"{replied_first_name[:25]} ɪs ᴀғᴋ sɪɴᴄᴇ {seenago}\n\n",
                             )
                         else:
                             send = await message.reply_photo(
-                                photo=f"downloads/{replied_user_id}.jpg",
+                                photo=f"/tmp/downloads/{replied_user_id}.jpg",
                                 caption=f"{replied_first_name[:25]} ɪs ᴀғᴋ sɪɴᴄᴇ {seenago}\n\nReason: {reasonafk}\n\n",
                             )
                 except Exception:
@@ -317,12 +317,12 @@ async def chat_watcher_func(_, message):
                         if afktype == "photo":
                             if str(reasonafk) == "None":
                                 send = await message.reply_photo(
-                                    photo=f"downloads/{user.id}.jpg",
+                                    photo=f"/tmp/downloads/{user.id}.jpg",
                                     caption=f"{user.first_name[:25]} ɪs ᴀғᴋ sɪɴᴄᴇ {seenago}\n\n",
                                 )
                             else:
                                 send = await message.reply_photo(
-                                    photo=f"downloads/{user.id}.jpg",
+                                    photo=f"/tmp/downloads/{user.id}.jpg",
                                     caption=f"{user.first_name[:25]} ɪs ᴀғᴋ sɪɴᴄᴇ {seenago}\n\nAlasan: {reasonafk}\n\n",
                                 )
                     except:
@@ -363,12 +363,12 @@ async def chat_watcher_func(_, message):
                         if afktype == "photo":
                             if str(reasonafk) == "None":
                                 send = await message.reply_photo(
-                                    photo=f"downloads/{user_id}.jpg",
+                                    photo=f"/tmp/downloads/{user_id}.jpg",
                                     caption=f"{first_name[:25]} ɪs ᴀғᴋ sɪɴᴄᴇ {seenago}\n\n",
                                 )
                             else:
                                 send = await message.reply_photo(
-                                    photo=f"downloads/{user_id}.jpg",
+                                    photo=f"/tmp/downloads/{user_id}.jpg",
                                     caption=f"{first_name[:25]} ɪs ᴀғᴋ sɪɴᴄᴇ {seenago}\n\nAlasan: {reasonafk}\n\n",
                                 )
                     except:

DragMusic/plugins/tools/welcome.py

@@ -4,6 +4,8 @@ from pyrogram import *
 from pyrogram.types import *
 from logging import getLogger
 from DragMusic import app
+from typing import Union
+import textwrap
 
 
 
@@ -19,8 +21,7 @@ class WelDatabase:
         return chat_id in self.data
 
     async def add_wlcm(self, chat_id):
-        self.data[chat_id] = {}  # You can store additional information related to the chat
-        # For example, self.data[chat_id]['some_key'] = 'some_value'
+        self.data[chat_id] = {}
 
     async def rm_wlcm(self, chat_id):
         if chat_id in self.data:
@@ -62,15 +63,15 @@ def welcomepic(pic, user, chatname, id, uname):
     draw.text((2100, 1420), f'ID: {id}', fill=(12000, 12000, 12000), font=font)
     pfp_position = (1990, 435)
     background.paste(pfp, pfp_position, pfp)
-    background.save(f"downloads/welcome#{id}.png")
-    return f"downloads/welcome#{id}.png"
+    background.save(f"/tmp/downloads/welcome#{id}.png")
+    return f"/tmp/downloads/welcome#{id}.png"
 
 # FUCK you bhosadiwale 
 
 
 @app.on_message(filters.command("wel") & ~filters.private)
 async def auto_state(_, message):
-    usage = "**Usage:**\n⦿/wel [on|off]\n➤ᴀᴜʀ ʜᴀᴀɴ ᴋᴀɴɢᴇʀs ᴋᴀʀᴏ ᴀʙ ᴄᴏᴘʏ ʙʜᴏsᴀᴅɪᴡᴀʟᴇ\n➤sᴀʟᴏɴ ᴀᴜʀ ʜᴀᴀɴ sᴛʏʟɪsʜ ғᴏɴᴛ ɴᴏᴛ ᴀʟʟᴏᴡᴇᴅ ɪɴ ᴛʜᴇ ᴛʜᴜᴍʙɴᴀɪʟ.!\ᴀᴜʀ ʜᴀᴀɴ ᴀɢʀ ᴋʜᴜᴅ ᴋɪ ᴋᴀʀɴɪ ʜᴀɪ ᴛᴏ ɢᴀᴀɴᴅ ᴍᴀʀᴀᴏ ʙᴇᴛɪᴄʜᴏᴅ"
+    usage = "**Usage:**\n⦿/wel [on|off]"
     if len(message.command) == 1:
         return await message.reply_text(usage)
     chat_id = message.chat.id
@@ -103,7 +104,7 @@ async def auto_state(_, message):
 @app.on_chat_member_updated(filters.group, group=-3)
 async def greet_group(_, member: ChatMemberUpdated):
     chat_id = member.chat.id
-    A = await wlcm.find_one(chat_id)  # Corrected this line
+    A = await wlcm.find_one(chat_id)
     if not A:
         return
     if (
@@ -115,7 +116,7 @@ async def greet_group(_, member: ChatMemberUpdated):
     user = member.new_chat_member.user if member.new_chat_member else member.from_user
     try:
         pic = await app.download_media(
-            user.photo.big_file_id, file_name=f"pp{user.id}.png"
+            user.photo.big_file_id, file_name=f"/tmp/downloads/pp{user.id}.png"
         )
     except AttributeError:
         pic = "DragMusic/assets/upic.png"
@@ -137,15 +138,14 @@ async def greet_group(_, member: ChatMemberUpdated):
 ๏ ɴᴀᴍᴇ ➛ {user.mention}
 ๏ ɪᴅ ➛ {user.id}
 ๏ ᴜsᴇʀɴᴀᴍᴇ ➛ @{user.username}
-๏ ᴍᴀᴅᴇ ʙʏ ➛ [ʀᴏʏ-ᴇᴅɪᴛx](https://t.me/BTSChinna**
 """,
-            reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton(f"ᴀᴅᴅ ᴍᴇ ʙᴀʙʏ", url=f"https://t.me/alexaprobot?startgroup=true")]])
+            reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton(f"ᴀᴅᴅ ᴍᴇ ʙᴀʙʏ", url=f"https://t.me/{(await app.get_me()).username}?startgroup=true")]])
         )
     except Exception as e:
         LOGGER.error(e)
     try:
-        os.remove(f"downloads/welcome#{user.id}.png")
-        os.remove(f"downloads/pp{user.id}.png")
+        os.remove(f"/tmp/downloads/welcome#{user.id}.png")
+        os.remove(f"/tmp/downloads/pp{user.id}.png")
     except Exception as e:
         pass
 
@@ -155,11 +155,158 @@ async def greet_group(_, member: ChatMemberUpdated):
 async def bot_wel(_, message):
     for u in message.new_chat_members:
         if u.id == app.me.id:
-            await app.send_message(LOG_CHANNEL_ID, f"""
-**NEW GROUP
-➖➖➖➖➖➖➖➖➖➖➖➖
-NAME: {message.chat.title}
-ID: {message.chat.id}
-USERNAME: @{message.chat.username}
-➖➖➖➖➖➖➖➖➖➖➖➖**
-""")
+            await app.send_message(message.chat.id, "Thanks for adding me to your group.")
+
+async def welcome_captcha(
+    _, message: Message, cb_data: dict, failed: bool = False
+) -> Union[int, bool]:
+    if failed:
+        photo = (
+            "https://telegra.ph/file/223695233211590f7ac71.jpg"
+        )
+    else:
+        photo = (
+            "https://telegra.ph/file/223695233211590f7ac71.jpg"
+        )
+    background = Image.open(photo)
+    background = background.resize((1280, 720))
+
+    #
+    image3 = Image.new("RGBA", (1280, 720))
+    image3.paste(background, (0, 0))
+    #
+
+    # Drawing with Impact Font
+    draw = ImageDraw.Draw(image3)
+    font = ImageFont.truetype("DragMusic/assets/font.ttf", 60)
+    font2 = ImageFont.truetype("DragMusic/assets/font2.ttf", 70)
+    arial = ImageFont.truetype("DragMusic/assets/font2.ttf", 40)
+    gfont = ImageFont.truetype("DragMusic/assets/font2.tf", 40)
+    para = textwrap.wrap(title, width=32)
+    j = 0
+    try:
+        if para[0]:
+            draw.text(
+                (5, 5),
+                f"{para[0]}",
+                fill="white",
+                stroke_width=3,
+                stroke_fill="black",
+                font=font,
+            )
+        if para[1]:
+            draw.text(
+                (5, 70),
+                f"{para[1]}",
+                fill="white",
+                stroke_width=3,
+                stroke_fill="black",
+                font=font,
+            )
+    except:
+        pass
+    text_w, text_h = draw.textsize(f"Welcome to {ctitle}", font=gfont)
+    draw.text(
+        ((1280 - text_w) / 2, 615),
+        f"Welcome to {ctitle}",
+        fill="white",
+        font=gfont,
+    )
+    draw.text((740, 480), "NAME:", fill="white", font=arial)
+    draw.text(
+        (915, 480),
+        f"{fullname}",
+        fill="white",
+        font=arial,
+    )
+    draw.text(
+        (740, 530),
+        f"USERNAME : @{uname}",
+        (255, 255, 255),
+        font=arial,
+    )
+
+    background.save(f"/tmp/downloads/welcome#{id}.png")
+    return f"/tmp/downloads/welcome#{id}.png"
+
+
+async def on_new_chat_member(client, message: Message):
+    if not await is_approved(message.chat.id):
+        return await message.reply_text(
+            f"Greetings {message.from_user.mention}, and welcome to {message.chat.title}.\n\n{app.mention} do not have permission to work here. You must request permission from my owner."
+        )
+    if message.from_user.id in BANNED_USERS:
+        return
+    if (await client.get_me()).id in [user.id for user in message.new_chat_members]:
+        return
+    for user in message.new_chat_members:
+        if await is_gbanned_user(user.id):
+            await message.chat.ban_member(user.id)
+            await message.reply_text(
+                f"{user.mention} was globally banned, so I'm kicking them. Sorry for the inconvenience."
+            )
+            return
+        if user.is_bot:
+            return
+        if not await is_welcome_on(message.chat.id):
+            continue
+        # Check if the user is a bot
+        if user.is_bot:
+            return  # Do not send a welcome message to bots
+
+        # Get the welcome message and buttons for the chat
+        welcome, buttons = await get_welcome(str(message.chat.id))
+
+        # Replace placeholders in the welcome message with user and chat information
+        mention = user.mention
+        title = message.chat.title
+        fullname = user.first_name + " " + user.last_name if user.last_name else user.first_name
+        username = f"@{user.username}" if user.username else "NO USERNAME"
+        user_id = user.id
+        # Send the welcome message with the custom buttons
+        await client.send_message(
+            chat_id=message.chat.id,
+            text=welcome.format(
+                mention=mention,
+                title=title,
+                fullname=fullname,
+                username=username,
+                id=user_id,
+            ),
+            reply_markup=InlineKeyboardMarkup(buttons),
+            disable_web_page_preview=True,
+        )
+
+
+async def on_user_left(client, message: Message):
+    if not await is_goodbye_on(message.chat.id):
+        return
+    if await is_gbanned_user(message.left_chat_member.id):
+        return
+
+    left = message.left_chat_member
+    if left.is_bot:
+        return  # Do not send a goodbye message to bots
+
+    # Get the goodbye message and buttons for the chat
+    goodbye, buttons = await get_goodbye(str(message.chat.id))
+
+    # Replace placeholders in the goodbye message with user and chat information
+    mention = left.mention
+    title = message.chat.title
+    fullname = left.first_name + " " + left.last_name if left.last_name else left.first_name
+    username = f"@{left.username}" if left.username else "NO USERNAME"
+    user_id = left.id
+    # Send the goodbye message with the custom buttons
+    await client.send_message(
+        chat_id=message.chat.id,
+        text=goodbye.format(
+            mention=mention,
+            title=title,
+            fullname=fullname,
+            username=username,
+            id=user_id,
+        ),
+        reply_markup=InlineKeyboardMarkup(buttons),
+        disable_web_page_preview=True,
+    )

DragMusic/utils/thumbnails.py

@@ -1,5 +1,6 @@
 import os
 import re
+import textwrap
 
 import aiofiles
 import aiohttp
@@ -8,7 +9,9 @@ from unidecode import unidecode
 from youtubesearchpython.__future__ import VideosSearch
 
 from DragMusic import app
+from DragMusic.core.mongo import db
 from config import YOUTUBE_IMG_URL
+from DragMusic.logging import LOGGER
 
 
 def changeImageSize(maxWidth, maxHeight, image):
@@ -30,8 +33,8 @@ def clear(text):
 
 
 async def get_thumb(videoid):
-    if os.path.isfile(f"cache/{videoid}.png"):
-        return f"cache/{videoid}.png"
+    if os.path.isfile(f"/tmp/cache/{videoid}.png"):
+        return f"/tmp/cache/{videoid}.png"
 
     url = f"https://www.youtube.com/watch?v={videoid}"
     try:
@@ -39,7 +42,7 @@ async def get_thumb(videoid):
         for result in (await results.next())["result"]:
             try:
                 title = result["title"]
-                title = re.sub("\W+", " ", title)
+                title = re.sub("\\W+", " ", title)
                 title = title.title()
             except:
                 title = "Unsupported Title"
@@ -60,11 +63,11 @@ async def get_thumb(videoid):
         async with aiohttp.ClientSession() as session:
             async with session.get(thumbnail) as resp:
                 if resp.status == 200:
-                    f = await aiofiles.open(f"cache/thumb{videoid}.png", mode="wb")
+                    f = await aiofiles.open(f"/tmp/cache/thumb{videoid}.png", mode="wb")
                     await f.write(await resp.read())
                     await f.close()
 
-        youtube = Image.open(f"cache/thumb{videoid}.png")
+        youtube = Image.open(f"/tmp/cache/thumb{videoid}.png")
         image1 = changeImageSize(1280, 720, youtube)
         image2 = image1.convert("RGBA")
         background = image2.filter(filter=ImageFilter.BoxBlur(10))
@@ -111,11 +114,204 @@ async def get_thumb(videoid):
             font=arial,
         )
         try:
-            os.remove(f"cache/thumb{videoid}.png")
+            os.remove(f"/tmp/cache/thumb{videoid}.png")
         except:
             pass
-        background.save(f"cache/{videoid}.png")
-        return f"cache/{videoid}.png"
+        background.save(f"/tmp/cache/{videoid}.png")
+        return f"/tmp/cache/{videoid}.png"
     except Exception as e:
         print(e)
         return YOUTUBE_IMG_URL
+
+
+async def gen_thumb(videoid: str, user_id: int) -> str:
+    if os.path.isfile(f"/tmp/cache/{videoid}.png"):
+        return f"/tmp/cache/{videoid}.png"
+    url = f"https://www.youtube.com/watch?v={videoid}"
+    try:
+        results = VideosSearch(url, limit=1)
+        for result in (await results.next())["result"]:
+            try:
+                title = result["title"]
+                title = re.sub("\\W+", " ", title)
+                title = title.title()
+            except:
+                title = "Unsupported Title"
+            try:
+                duration = result["duration"]
+            except:
+                duration = "Unknown Mins"
+            thumbnail = result["thumbnails"][0]["url"].split("?")[0]
+            try:
+                views = result["viewCount"]["short"]
+            except:
+                views = "Unknown Views"
+            try:
+                channel = result["channel"]["name"]
+            except:
+                channel = "Unknown Channel"
+
+        async with aiohttp.ClientSession() as session:
+            async with session.get(thumbnail) as resp:
+                if resp.status == 200:
+                    ctitle = (await app.get_chat(user_id)).title
+                    ctitle = await crop_title(ctitle)
+                    try:
+                        f = await aiofiles.open(f"/tmp/cache/thumb{videoid}.png", mode="wb")
+                        await f.write(await resp.read())
+                        await f.close()
+                        youtube = Image.open(f"/tmp/cache/thumb{videoid}.png")
+                        image1 = changeImageSize(1280, 720, youtube)
+                        image2 = image1.convert("RGBA")
+                        background = image2.filter(filter=ImageFilter.BoxBlur(30))
+                        enhancer = ImageEnhance.Brightness(background)
+                        background = enhancer.enhance(0.5)
+                        draw = ImageDraw.Draw(background)
+                        arial = ImageFont.truetype("DragMusic/assets/font2.ttf", 40)
+                        font = ImageFont.truetype("DragMusic/assets/font.ttf", 30)
+                        draw.text((1110, 8), unidecode(app.name), fill="white", font=arial)
+                        draw.text(
+                            (55, 560),
+                            f"{channel} | {views[:23]}",
+                            (255, 255, 255),
+                            font=arial,
+                        )
+                        draw.text(
+                            (57, 600),
+                            clear(title),
+                            (255, 255, 255),
+                            font=font,
+                        )
+                        draw.line(
+                            [(55, 660), (1220, 660)],
+                            fill="white",
+                            width=5,
+                            joint="curve",
+                        )
+                        draw.ellipse(
+                            [(918, 648), (942, 672)],
+                            outline="white",
+                            fill="white",
+                            width=15,
+                        )
+                        draw.text(
+                            (36, 685),
+                            "00:00",
+                            (255, 255, 255),
+                            font=arial,
+                        )
+                        draw.text(
+                            (1185, 685),
+                            f"{duration[:23]}",
+                            (255, 255, 255),
+                            font=arial,
+                        )
+                    except Exception:
+                        pass
+                    circle = Image.open("DragMusic/assets/circle.png")
+                    try:
+                        pfp = Image.open(
+                            await app.download_media(
+                                (await app.get_chat(user_id)).photo.big_file_id,
+                                file_name=f"pfp{user_id}.png",
+                            )
+                        )
+                    except Exception:
+                        pfp = Image.open("DragMusic/assets/profile.png")
+                    pfp = pfp.resize((450, 450))
+                    pfp = crop_center(pfp, 450, 450)
+                    pfp = mask_circle_solid(pfp, (0, 0, 0, 0), 225)
+
+                    #
+                    image3 = Image.new("RGBA", (1280, 720))
+                    image3.paste(background, (0, 0))
+                    image3.paste(youtube, (200, 70), mask=youtube)
+                    image3.paste(pfp, (410, 420), mask=pfp)
+                    image3.paste(circle, (410, 420), mask=circle)
+
+                    # Drawing with Impact Font
+                    draw = ImageDraw.Draw(image3)
+                    font = ImageFont.truetype("DragMusic/assets/font.ttf", 60)
+                    font2 = ImageFont.truetype("DragMusic/assets/font2.ttf", 70)
+                    arial = ImageFont.truetype("DragMusic/assets/font2.ttf", 40)
+                    gfont = ImageFont.truetype("DragMusic/assets/font2.ttf", 40)
+                    para = textwrap.wrap(title, width=32)
+                    j = 0
+                    try:
+                        if para[0]:
+                            draw.text(
+                                (5, 5),
+                                f"{para[0]}",
+                                fill="white",
+                                stroke_width=3,
+                                stroke_fill="black",
+                                font=font,
+                            )
+                        if para[1]:
+                            draw.text(
+                                (5, 70),
+                                f"{para[1]}",
+                                fill="white",
+                                stroke_width=3,
+                                stroke_fill="black",
+                                font=font,
+                            )
+                    except:
+                        pass
+                    text_w, text_h = draw.textsize(f"Playing on: {ctitle}", font=gfont)
+                    draw.text(
+                        ((1280 - text_w) / 2, 615),
+                        f"Playing on: {ctitle}",
+                        fill="white",
+                        font=gfont,
+                    )
+                    draw.text((740, 480), "Duration:", fill="white", font=arial)
+                    draw.text(
+                        (915, 480),
+                        f"{duration} Mins",
+                        fill="white",
+                        font=arial,
+                    )
+                    draw.text(
+                        (740, 530),
+                        f"Views : {views}",
+                        (255, 255, 255),
+                        font=arial,
+                    )
+
+                    try:
+                        os.remove(f"/tmp/cache/thumb{videoid}.png")
+                    except:
+                        pass
+                    background.save(f"/tmp/cache/{videoid}.png")
+                    return f"/tmp/cache/{videoid}.png"
+    except Exception as e:
+        LOGGER(__name__).error(e)
+        return ""
+
+
+def crop_center(pil_img, crop_width, crop_height):
+    img_width, img_height = pil_img.size
+    return pil_img.crop(
+        (
+            (img_width - crop_width) // 2,
+            (img_height - crop_height) // 2,
+            (img_width + crop_width) // 2,
+            (img_height + crop_height) // 2,
+        )
+    )
+
+
+def mask_circle_solid(im, a, size):
+    output = Image.new("RGBA", (size, size), (0, 0, 0, 0))
+    draw = ImageDraw.Draw(output)
+    draw.ellipse((0, 0, size, size), fill=a)
+    output.putalpha(220)
+    return output
+
+
+async def crop_title(title):
+    if len(title) > 20:
+        return f"{title[:20]}..."
+    else:
+        return title