text: from __future__ import unicode_literals
  import os
  import requests
  import aiohttp
  import youtube_dl
  import wget
  import math
  from pyrogram import filters, Client
  from youtube_search import YoutubeSearch
  from urllib.parse import urlparse
  import aiofiles
  import os
  from random import randint
  from youtubesearchpython import SearchVideos
  from pyrogram.errors import FloodWait, MessageNotModified
  from pyrogram.types import Chat, Message, User
  import asyncio
  from typing import Callable, Coroutine, Dict, List, Tuple, Union
  import sys
  import time
  from helpers.errors import DurationLimitError
  
  @Client.on_message(filters.command('dsfgbgfgfdgdfgsdfsaf') & ~filters.channel)
  def song(client, message):
  
      user_id = message.from_user.id 
      user_name = message.from_user.first_name 
      rpk = "["+user_name+"](tg://user?id="+str(user_id)+")"
  
      query = ''
      for i in message.command[1:]:
          query += ' ' + str(i)
      print(query)
      m = message.reply('🔎 Finding the song...')
      ydl_opts = {"format": "bestaudio/best"}
      try:
          results = YoutubeSearch(query, max_results=1).to_dict()
          link = f"https://youtube.com{results[0]['url_suffix']}"
          #print(results)
          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)
  
  
          duration = results[0]["duration"]
          url_suffix = results[0]["url_suffix"]
          views = results[0]["views"]
  
      except Exception as e:
          m.edit(
              "❌ Found Nothing.\n\nTry another keywork or maybe spell it properly."
          )
          print(str(e))
          return
      m.edit("Downloading the song ")
      try:
          with youtube_dl.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)
          rep = '**🎵 Uploaded by @GroupMusicPlayBot **'
          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
          message.reply_audio(audio_file, caption=rep, thumb=thumb_name, parse_mode='md', title=title, duration=dur)
          m.delete()
      except Exception as e:
          m.edit('❌ Error')
          print(e)
  
      try:
          os.remove(audio_file)
          os.remove(thumb_name)
      except Exception as e:
          print(e)
          
  
  def get_text(message: Message) -> [None, str]:
      text_to_return = message.text
      if message.text is None:
          return None
      if " " in text_to_return:
          try:
              return message.text.split(None, 1)[1]
          except IndexError:
              return None
      else:
          return None
      
  
  def humanbytes(size):
      if not size:
          return ""
      power = 2 ** 10
      raised_to_pow = 0
      dict_power_n = {0: "", 1: "Ki", 2: "Mi", 3: "Gi", 4: "Ti"}
      while size > power:
          size /= power
          raised_to_pow += 1
      return str(round(size, 2)) + " " + dict_power_n[raised_to_pow] + "B"
  
  
  async def progress(current, total, message, start, type_of_ps, file_name=None):
      now = time.time()
      diff = now - start
      if round(diff % 10.00) == 0 or current == total:
          percentage = current * 100 / total
          speed = current / diff
          elapsed_time = round(diff) * 1000
          if elapsed_time == 0:
              return
          time_to_completion = round((total - current) / speed) * 1000
          estimated_total_time = elapsed_time + time_to_completion
          progress_str = "{0}{1} {2}%\n".format(
              "".join(["█" for i in range(math.floor(percentage / 10))]),
              "".join(["░" for i in range(10 - math.floor(percentage / 10))]),
              round(percentage, 2),
          )
          tmp = progress_str + "{0} of {1}\nETA: {2}".format(
              humanbytes(current), humanbytes(total), time_formatter(estimated_total_time)
          )
          if file_name:
              try:
                  await message.edit(
                      "{}\n**File Name:** `{}`\n{}".format(type_of_ps, file_name, tmp)
                  )
              except FloodWait as e:
                  await asyncio.sleep(e.x)
              except MessageNotModified:
                  pass
          else:
              try:
                  await message.edit("{}\n{}".format(type_of_ps, tmp))
              except FloodWait as e:
                  await asyncio.sleep(e.x)
              except MessageNotModified:
                  pass
  
  
  def get_user(message: Message, text: str) -> [int, str, None]:
      if text is None:
          asplit = None
      else:
          asplit = text.split(" ", 1)
      user_s = None
      reason_ = None
      if message.reply_to_message:
          user_s = message.reply_to_message.from_user.id
          reason_ = text if text else None
      elif asplit is None:
          return None, None
      elif len(asplit[0]) > 0:
          user_s = int(asplit[0]) if asplit[0].isdigit() else asplit[0]
          if len(asplit) == 2:
              reason_ = asplit[1]
      return user_s, reason_
  
  
  def get_readable_time(seconds: int) -> int:
      count = 0
      ping_time = ""
      time_list = []
      time_suffix_list = ["s", "m", "h", "days"]
  
      while count < 4:
          count += 1
          if count < 3:
              remainder, result = divmod(seconds, 60)
          else:
              remainder, result = divmod(seconds, 24)
          if seconds == 0 and remainder == 0:
              break
          time_list.append(int(result))
          seconds = int(remainder)
  
      for x in range(len(time_list)):
          time_list[x] = str(time_list[x]) + time_suffix_list[x]
      if len(time_list) == 4:
          ping_time += time_list.pop() + ", "
  
      time_list.reverse()
      ping_time += ":".join(time_list)
  
      return ping_time
  
  
  def time_formatter(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) + " day(s), ") if days else "")
          + ((str(hours) + " hour(s), ") if hours else "")
          + ((str(minutes) + " minute(s), ") if minutes else "")
          + ((str(seconds) + " second(s), ") if seconds else "")
          + ((str(milliseconds) + " millisecond(s), ") if milliseconds else "")
      )
      return tmp[:-2]
  
  
  ydl_opts = {
      'format': 'bestaudio/best',
      'writethumbnail': True,
      'postprocessors': [{
          'key': 'FFmpegExtractAudio',
          'preferredcodec': 'mp3',
          'preferredquality': '192'
      }]
  }
  
  
  def get_file_extension_from_url(url):
      url_path = urlparse(url).path
      basename = os.path.basename(url_path)
      return basename.split(".")[-1]
  
  
  # Funtion To Download Song
  async def download_song(url):
      song_name = f"{randint(6969, 6999)}.mp3"
      async with aiohttp.ClientSession() as session:
          async with session.get(url) as resp:
              if resp.status == 200:
                  f = await aiofiles.open(song_name, mode='wb')
                  await f.write(await resp.read())
                  await f.close()
      return song_name
  
  is_downloading = False
  
  
  def time_to_seconds(time):
      stringt = str(time)
      return sum(int(x) * 60 ** i for i, x in enumerate(reversed(stringt.split(':'))))
  
  
  @Client.on_message(filters.command(["vsong", "vid"]))
  async def ytmusic(client,message: Message):
      global is_downloading
      if is_downloading:
          await message.reply_text("Another download is in progress, try again after sometime.")
          return
  
      urlissed = get_text(message)
  
      pablo =  await client.send_message(
              message.chat.id,
              f"`Getting {urlissed} From Youtube Servers. Please Wait.`")
      if not urlissed:
          await pablo.edit("Invalid Command Syntax, Please Check Help Menu To Know More!")
          return
      
      search = SearchVideos(f"{urlissed}", 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"]
      thums = mio[0]["channel"]
      kekme = f"https://img.youtube.com/vi/{fridayz}/hqdefault.jpg"
      await asyncio.sleep(0.6)
      url = mo
      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,
          }
      try:
          is_downloading = True
          with youtube_dl.YoutubeDL(opts) as ytdl:
              infoo = ytdl.extract_info(url, False)
              duration = round(infoo["duration"] / 60)
  
              if duration > 8:
                  await pablo.edit(
                      f"❌ Videos longer than 8 minute(s) aren't allowed, the provided video is {duration} minute(s)"
                  )
                  is_downloading = False
                  return
              ytdl_data = ytdl.extract_info(url, download=True)
              
      
      except Exception as e:
          #await pablo.edit(event, f"**Failed To Download** \n**Error :** `{str(e)}`")
          is_downloading = False
          return
      
      c_time = time.time()
      file_stark = f"{ytdl_data['id']}.mp4"
      capy = f"**Video Name ➠** `{thum}` \n**Requested For :** `{urlissed}` \n**Channel :** `{thums}` \n**Link :** `{mo}`"
      await client.send_video(message.chat.id, video = open(file_stark, "rb"), duration = int(ytdl_data["duration"]), file_name = str(ytdl_data["title"]), thumb = sedlyf, caption = capy, supports_streaming = True , progress=progress, progress_args=(pablo, c_time, f'`Uploading {urlissed} Song From YouTube Music!`', file_stark))
      await pablo.delete()
      is_downloading = False
      for files in (sedlyf, file_stark):
          if files and os.path.exists(files):
              os.remove(files)
  