Powers/plugins/web_con.py

import asyncio

from pyrogram import filters
from pyrogram.types import CallbackQuery
from pyrogram.types import InlineKeyboardButton as IKB
from pyrogram.types import InputMediaPhoto, InputMediaVideo, Message

from Powers import RMBG, genius_lyrics, is_rmbg
from Powers.utils.custom_filters import command
from Powers.utils.http_helper import *
from Powers.utils.sticker_help import toimage
from Powers.utils.web_helpers import *
from Powers.utils.web_scrapper import INSTAGRAM

# @Gojo.on_message(command(["songname","insong","songinfo","whichsong","rsong","reversesong"]))
# • /whichsong (/songname, /songinfo, /insong, /rsong, /reversesong) : Reply to file to get the song playing in it.
# async def get_song_info(c: Gojo, m: Message):
#     if not is_audd:
#         await m.reply_text("Audd api is missing add it to use this command")
#         return
#     reply = m.reply_to_message
#     if not reply:
#         await m.reply_text("Reply to a video or audio file")
#         return
#     elif reply.text:
#         await m.reply_text("Reply to a video or audio file")
#         return
#     elif not (reply.video or reply.audio or reply.video_note or reply.document and (reply.document.mime_type.split("/")[0] in ["video","audio"])):
#         await m.reply_text("Reply to a video or audio file")
#         return
#     try:
#         to_edit = await m.reply_text("⏳")
#         URL = "https://api.audd.io/"
#         sizee = (await get_file_size(reply)).split()
#         if (int(sizee[0]) <= 30 and sizee[1] == "mb") or sizee[1] == "kb":
#             fpath = await reply.download()
#             files = {
#                 "file" : open(fpath,"rb")
#             }
#             BASE_AUDD = {
#                 "api_token":Audd,
#                 "return": "spotify"
#             }
#             result = resp_post(URL,data=BASE_AUDD, files=files)
#         # elif int(sizee[0]) > 15 or int(sizee[0]) <= 30 and sizee[1] == "mb":
#         #     BASE_AUDD = {
#         #         "api_token":Audd,
#         #         "url": f'{reply.link}',
#         #         "return": "spotify"
#         #     }
#         #    result = resp_post(URL,data=BASE_AUDD)
#         else:
#             await to_edit.edit_text("File size too big\nI can only fetch file of size upto 30 mbs for now")
#             return
#         if result.status_code != 200:
#             await to_edit.edit_text(f"{result.status_code}:{result.text}")
#             return
#         result = result.json()
#         data = result["result"]
#         Artist = data["artist"]
#         Title = data["title"]
#         Release_date = data["release_date"]
#         web_slink = data["song_link"]
#         SPOTIFY = data["spotify"]
#         spotify_url = SPOTIFY["external_urls"]
#         album_url = SPOTIFY["album"]["external_urls"]
#         Album = SPOTIFY["album"]["name"]
#         photo = SPOTIFY["images"][0]["url"]
#         artist_url = SPOTIFY["artists"]["external_urls"]
#         cap = f"""
#     Song name: {Title} 
#     Artist: {Artist}
#     Album: {Album}
#     Release data: {Release_date}
#     """
#         youtube_link = (await song_search(Title))[1]["link"]
#         kb = [
#             [
#                 IKB("🗂 Album", url=album_url),
#                 IKB("🎨 Artist",url=artist_url)
#             ],
#             [
#                 IKB("🎵 Spotify song link",url=spotify_url),
#                 IKB("▶️ Youtube",url=youtube_link)
#             ],
#             [IKB("♾ More links", url=web_slink)]
#         ]
#         if is_genius_lyrics:
#             g_k = [IKB("📝 Lyrics",f"lyrics_{Title}:{Artist}")]
#             kb.append(g_k)
#         await to_edit.delete()
#         os.remove(fpath)
#         await m.reply_photo(photo,caption=cap,reply_markup=IKM(kb))
#     except Exception as e:
#         await to_edit.delete()
#         await m.reply_text(f"Error\n{e}")
#         try:
#             os.remove(fpath)
#         except Exception:
#             pass
#     return

songs = {}


@Gojo.on_callback_query(filters.regex("^lyrics_"))
async def lyrics_for_song(c: Gojo, q: CallbackQuery):
    data = q.data.split("_")[1].split(":")
    song = songe = data[0]
    try:
        artist = data[1]
    except IndexError:
        artist = None
    if artist:
        song = genius_lyrics.search_song(song, artist)
    else:
        song = genius_lyrics.search_song(song)
        artist = song.artist
    if not song.lyrics:
        await q.answer("‼️ No lyrics found ‼️", True)
        return
    header = f"{songe.capitalize()} by {artist}"
    if song.lyrics:
        await q.answer("Fetching lyrics")
        reply = song.lyrics.split("\n", 1)[1]
    if len(reply) >= 4096:
        cap = f"{header}\n{reply[:4080]}..."
        if artist:
            songs[f"{songe}"][f"{artist}"] = reply
            art = f'_{artist}'
        else:
            songs[f"{songe}"] = reply
            art = ''
        new_kb = [
            [
                IKB("Next", f"lyrics_next_{songe}{art}")
            ]
            [
                IKB("Close", "f_close")
            ]
        ]
    else:
        cap = f"{header}\n{reply}"
        new_kb = [
            [
                IKB("Close", "f_close")
            ]
        ]
    await q.message.reply_to_message.reply_text(cap, reply_markup=new_kb)
    await q.message.delete()
    return


@Gojo.on_callback_query(filters.regex("^lyrics_next_") | filters.regex("^lyrics_prev_"))
async def lyrics_for_song_next(c: Gojo, q: CallbackQuery):
    split = q.data.split("_")
    song = split[2]
    todo = split[1]
    try:
        artist = split[3]
        header = f"{song.capitalize()} by {artist}"
        art = f'_{artist}'
    except IndexError:
        artist = False
        header = f"{song.capitalize()}"
        art = ''
    try:
        songe = songs[song][artist] if artist else songs[song]
    except KeyError:
        if artist:
            songe = genius_lyrics.search_song(song, artist)
        else:
            songe = genius_lyrics.search_song(song)
        next_part = songe[4080:] if todo == "next" else songe[:4080]
    next_part = f"{header}\n{next_part}"
    new_kb = [
        [
            IKB("Next", f"lyrics_prev_{song}{art}")
        ]
        [
            IKB("Close", "f_close")
        ]
    ]
    await q.edit_message_text(next_part, reply_markup=new_kb)


@Gojo.on_message(command(["removebackground", "removebg", "rmbg"]))
async def remove_background(c: Gojo, m: Message):
    if not is_rmbg:
        await m.reply_text("Add rmbg api to use this command")
        return

    reply = m.reply_to_message
    if not reply:
        await m.reply_text("Reply to image/sticker to remove it's background")
        return
    elif not (reply.photo or (reply.document and reply.document.mime_type.split("/")[0] == "image") or reply.sticker):
        await m.reply_text("Reply to image/sticker to remove it's background")
        return
    elif reply.sticker and (reply.sticker.is_video or reply.sticker.is_animated):
        await m.reply_text("Reply to normal sticker to remove it's background")
        return
    to_edit = await m.reply_text("⏳")
    URL = "https://api.remove.bg/v1.0/removebg"
    if reply.sticker:
        filee = await reply.download()
        file = toimage(filee)
    else:
        file = await reply.download()
    finfo = {'image_file': open(file, 'rb')}
    Data = {'size': 'auto'}
    Headers = {'X-Api-Key': RMBG}
    result = resp_post(URL, files=finfo, data=Data, headers=Headers)
    await to_edit.delete()
    contentType = result.headers.get("content-type")
    if result.status_code != 200:
        await m.reply_text(f"{result.status_code}:{result.text}")
        os.remove(file)
        return
    elif "image" not in contentType:
        await m.reply_text(f"Error\n{result.content.decode('UTF-8')}")
        os.remove(file)
        return
    to_path = "./downloads"
    to_path = f'{to_path}/no-bg.webp' if reply.sticker else f'{to_path}/no-bg.png'
    with open(to_path, 'wb') as out:
        out.write(result.content)
    if reply.sticker:
        await m.reply_sticker(to_path)
    else:
        await m.reply_photo(to_path)
    try:
        os.remove(file)
        os.remove(to_path)
    except PermissionError:
        await asyncio.sleep(5)
    return


@Gojo.on_message(command(["song", "yta"]))
async def song_down_up(c: Gojo, m: Message):
    try:
        splited = m.text.split(None, 1)[1].strip()
    except IndexError:
        await m.reply_text("**USAGE**\n /song [song name | link]")
        return
    _id = get_video_id(splited)
    query = _id or splited
    to_edit = await m.reply_text("⏳")
    try:
        await youtube_downloader(c, m, query, "a")
        await to_edit.delete()
        return
    except KeyError:
        await to_edit.edit_text("Failed to find any result")
        return
    except Exception as e:
        await to_edit.edit_text(f"Got an error\n{e}")
        LOGGER.error(e)
        LOGGER.error(format_exc())
        return


@Gojo.on_message(command(["vsong", "ytv"]))
async def video_down_up(c: Gojo, m: Message):
    try:
        splited = m.text.split(None, 1)[1].strip()
    except IndexError:
        await m.reply_text("**USAGE**\n /vsong [song name | link]")
        return
    _id = get_video_id(splited)
    query = _id or splited
    to_edit = await m.reply_text("⏳")
    try:
        await youtube_downloader(c, m, query, "v")
        await to_edit.delete()
        return
    except KeyError:
        await to_edit.edit_text("Failed to find any result")
        return
    except Exception as e:
        await to_edit.edit_text(f"Got an error\n{e}")
        LOGGER.error(e)
        LOGGER.error(format_exc())
        return


@Gojo.on_message(command(["ig", "instagram", "insta"]))
async def download_instareels(c: Gojo, m: Message):
    try:
        reel_ = m.command[1]
    except IndexError:
        await m.reply_text("Give me an instagram link to download it...")
        return

    insta = INSTAGRAM(reel_)

    if not insta.is_correct_url():
        await m.reply_text("The link you have provided is not of instagram")
        return

    to_edit = await m.reply_text("Trying to fetch data from the link")

    content = insta.get_media()

    if content["code"] == 69 or content["message"] != "success":
        await to_edit.delete()
        return await m.reply_text(content["message"])

    try:
        medias = content["content"]["mediaUrls"]

        to_delete = await to_edit.edit_text("Found media in the link trying to download and upload them please wait")

        to_send = []
        for media in medias:
            if media["type"] == "image":
                to_send.append(InputMediaPhoto(media["url"]))
            else:
                to_send.append(InputMediaVideo(media["url"]))

        await m.reply_media_group(to_send)
        await to_delete.delete()
        # shutil.rmtree("./scrapped/")

    except KeyError:
        await to_edit.delete()
        await m.reply_text("Failed to fetch any media from given url")
        return


__PLUGIN__ = "web support"

__HELP__ = """
**Available commands**
• /rmbg (/removebg, /removebackground) : Reply to image file or sticker of which you want to remove background
• /song (/yta) <songname or youtube link> : Download audio only from provided youtube url
• /vsong (/ytv) <songname or youtube link> : Download video from provided youtube url
• /ig (/instagram , /insta) <reel's url> : Download reel from it's url

**Bot will not download any song or video having duration greater than 10 minutes (to reduce the load on bot's server)**
"""