Repository: bipinkrish/Link-Bypasser-Bot
Branch: main
Commit: 926cab96e8a9
Files: 17
Total size: 148.7 KB

Directory structure:
gitextract_80omcl63/

├── .github/
│   └── FUNDING.yml
├── .gitignore
├── Dockerfile
├── Procfile
├── README.md
├── app.json
├── app.py
├── bypasser.py
├── config.json
├── db.py
├── ddl.py
├── freewall.py
├── main.py
├── requirements.txt
├── runtime.txt
├── templates/
│   └── index.html
└── texts.py

================================================
FILE CONTENTS
================================================

================================================
FILE: .github/FUNDING.yml
================================================
github: [bipinkrish]


================================================
FILE: .gitignore
================================================
__pycache__
my_bot.session
my_bot.session-journal


================================================
FILE: Dockerfile
================================================
FROM python:3.9

WORKDIR /app

COPY requirements.txt /app/
RUN pip3 install -r requirements.txt
COPY . /app

CMD gunicorn app:app & python3 main.py

================================================
FILE: Procfile
================================================
worker: python3 main.py
web: python3 app.py

================================================
FILE: README.md
================================================
# Link-Bypasser-Bot

a Telegram Bot (with Site) that can Bypass Ad Links, Generate Direct Links and Jump Paywalls. see the Bot at
~~[@BypassLinkBot](https://t.me/BypassLinkBot)~~ [@BypassUrlsBot](https://t.me/BypassUrlsBot) or try it on [Replit](https://replit.com/@bipinkrish/Link-Bypasser#app.py)

---

## Special Feature - Public Database

Results of the bypass is hosted on public database on [DBHub.io](https://dbhub.io/bipinkrish/link_bypass.db) so if the bot finds link alredy in database it uses the result from the same, time saved and so many problems will be solved.

Table is creted with the below command, if anyone wants to use it for thier own.

```sql
CREATE TABLE results (link TEXT PRIMARY KEY, result TEXT)
```

---

## Required Variables

- `TOKEN` Bot Token from @BotFather
- `HASH` API Hash from my.telegram.org
- `ID` API ID from my.telegram.org

## Optional Variables
you can also set these in `config.json` file

- `CRYPT` GDTot Crypt If you don't know how to get Crypt then [Learn Here](https://www.youtube.com/watch?v=EfZ29CotRSU)
- `XSRF_TOKEN` and `Laravel_Session` XSRF Token and Laravel Session cookies! If you don't know how to get then then watch [this Video](https://www.youtube.com/watch?v=EfZ29CotRSU) (for GDTOT) and do the same for sharer.pw
- `DRIVEFIRE_CRYPT` Drivefire Crypt
- `KOLOP_CRYPT`  Kolop Crypt!
- `HUBDRIVE_CRYPT` Hubdrive Crypt
- `KATDRIVE_CRYPT` Katdrive Crypt
- `UPTOBOX_TOKEN` Uptobox Token
- `TERA_COOKIE` Terabox Cookie (only `ndus` value) (see [Help](#help))
- `CLOUDFLARE` Use `cf_clearance` cookie from and Cloudflare protected sites
- `PORT` Port to run the Bot Site on (defaults to 5000)

## Optinal Database Feature
You need set all three to work

- `DB_API` API KEY from [DBHub](https://dbhub.io/pref), make sure it has Read/Write permission
- `DB_OWNER` (defaults to `bipinkrish`)
- `DB_NAME` (defaults to `link_bypass.db`)

---

## Deploy on Heroku

*BEFORE YOU DEPLOY ON HEROKU, YOU SHOULD FORK THE REPO AND CHANGE ITS NAME TO ANYTHING ELSE*<br>

[![Deploy](https://www.herokucdn.com/deploy/button.svg)](https://heroku.com/deploy?template=https://github.com/bipinkrish/Link-Bypasser-Bot)</br>

---

## Commands

Everything is set programtically, nothing to work

```
/start - Welcome Message
/help - List of All Supported Sites
```

---

## Supported Sites

To see the list of supported sites see [texts.py](https://github.com/bipinkrish/Link-Bypasser-Bot/blob/main/texts.py) file

---

## Help

* If you are deploying on VPS, watch videos on how to set/export Environment Variables. OR you can set these in `config.json` file
* Terabox Cookie

    1. Open any Browser
    2. Make sure you are logged in with a Terbox account
    3. Press `f12` to open DEV tools and click Network tab
    4. Open any Terbox video link and open Cookies tab
    5. Copy value of `ndus`
   
   <br>

   ![](https://i.ibb.co/hHBZM5m/Screenshot-113.png)


================================================
FILE: app.json
================================================
{
  "name": "Link-Bypasser-Bot",
  "description": "A Telegram Bot (with Site) that can Bypass Ad Links, Generate Direct Links and Jump Paywalls",
  "keywords": [
    "telegram",
    "Link bypass",
    "bypass bot", 
    "telegram bot" 
  ],
  "repository": "https://github.com/bipinkrish/Link-Bypasser-Bot",
  "logo": "https://ibb.co/kMVxrCj",
  "env": {
    "HASH": {
      "description": "Your API HASH from my.telegram.org",
      "required": true
    },
    "ID": {
      "description": "Your API ID from my.telegram.org",
      "required": true
    },
    "TOKEN":{
      "description": "Your bot token from @BotFather",
      "required": true
    },
    "TERA_COOKIE": {
      "description": "Terabox Cookie (only ndus value)",
      "required": false
    },
    "CRYPT": {
      "description": "GDTot Crypt",
      "required": false
    },
    "XSRF_TOKEN": {
      "description": "XSRF Token cookies! Check readme file in repo",
      "required": false
    },
    "Laravel_Session": {
      "description": "Laravel Session cookies! Check readme file in repo",
      "required": false
    },
    "DRIVEFIRE_CRYPT": {
      "description": "Drivefire Crypt",
      "required": false
    },
    "KOLOP_CRYPT": {
      "description": "Kolop Crypt",
      "required": false
    },
    "HUBDRIVE_CRYPT": {
      "description": "Hubdrive Crypt",
      "required": false
    },
    "KATDRIVE_CRYPT": {
      "description": "Katdrive Crypt",
      "required": false
    },
    "UPTOBOX_TOKEN": {
      "description": "Uptobox Token",
      "required": false
    },
    "CLOUDFLARE": {
      "description": "Use cf_clearance cookie from and Cloudflare protected sites",
      "required": false
    },
    "PORT": {
      "description": "Port to run the Bot Site on (default is 5000)",
      "required": false
    }
  },
  "buildpacks": [
    {
      "url": "heroku/python"
    }
  ],
  "formation": {
    "web": {
      "quantity": 1,
      "size": "standard-1x"
    }
  }
}


================================================
FILE: app.py
================================================
from flask import Flask, request, render_template, make_response, send_file
import bypasser
import re
import os
import freewall


app = Flask(__name__)


def handle_index(ele):
    return bypasser.scrapeIndex(ele)


def store_shortened_links(link):
    with open("shortened_links.txt", "a") as file:
        file.write(link + "\n")


def loop_thread(url):
    urls = []
    urls.append(url)

    if not url:
        return None

    link = ""
    temp = None
    for ele in urls:
        if re.search(r"https?:\/\/(?:[\w.-]+)?\.\w+\/\d+:", ele):
            handle_index(ele)
        elif bypasser.ispresent(bypasser.ddl.ddllist, ele):
            try:
                temp = bypasser.ddl.direct_link_generator(ele)
            except Exception as e:
                temp = "**Error**: " + str(e)
        elif freewall.pass_paywall(ele, check=True):
            freefile = freewall.pass_paywall(ele)
            if freefile:
                try:
                    return send_file(freefile)
                except:
                    pass
        else:
            try:
                temp = bypasser.shortners(ele)
            except Exception as e:
                temp = "**Error**: " + str(e)
        print("bypassed:", temp)
        if temp:
            link = link + temp + "\n\n"

    return link


@app.route("/", methods=["GET", "POST"])
def index():
    if request.method == "POST":
        url = request.form.get("url")
        result = loop_thread(url)
        if freewall.pass_paywall(url, check=True):
            return result

        shortened_links = request.cookies.get("shortened_links")
        if shortened_links:
            prev_links = shortened_links.split(",")
        else:
            prev_links = []

        if result:
            prev_links.append(result)

            if len(prev_links) > 10:
                prev_links = prev_links[-10:]

        shortened_links_str = ",".join(prev_links)
        resp = make_response(
            render_template("index.html", result=result, prev_links=prev_links)
        )
        resp.set_cookie("shortened_links", shortened_links_str)

        return resp

    shortened_links = request.cookies.get("shortened_links")
    return render_template(
        "index.html",
        result=None,
        prev_links=shortened_links.split(",") if shortened_links else None,
    )


if __name__ == "__main__":
    port = int(os.environ.get("PORT", 5000))
    app.run(host="0.0.0.0", port=port)


================================================
FILE: bypasser.py
================================================
import re
import requests
from curl_cffi import requests as Nreq
import base64
from urllib.parse import unquote, urlparse, quote
import time
import cloudscraper
from bs4 import BeautifulSoup, NavigableString, Tag
from lxml import etree
import hashlib
import json
from asyncio import sleep as asleep
import ddl
from cfscrape import create_scraper
from json import load
from os import environ

with open("config.json", "r") as f:
    DATA = load(f)


def getenv(var):
    return environ.get(var) or DATA.get(var, None)


##########################################################
# ENVs

GDTot_Crypt = getenv("CRYPT")
Laravel_Session = getenv("Laravel_Session")
XSRF_TOKEN = getenv("XSRF_TOKEN")
DCRYPT = getenv("DRIVEFIRE_CRYPT")
KCRYPT = getenv("KOLOP_CRYPT")
HCRYPT = getenv("HUBDRIVE_CRYPT")
KATCRYPT = getenv("KATDRIVE_CRYPT")
CF = getenv("CLOUDFLARE")

############################################################
# Lists

otherslist = [
    "exe.io",
    "exey.io",
    "sub2unlock.net",
    "sub2unlock.com",
    "rekonise.com",
    "letsboost.net",
    "ph.apps2app.com",
    "mboost.me",
    "sub4unlock.com",
    "ytsubme.com",
    "social-unlock.com",
    "boost.ink",
    "goo.gl",
    "shrto.ml",
    "t.co",
]

gdlist = [
    "appdrive",
    "driveapp",
    "drivehub",
    "gdflix",
    "drivesharer",
    "drivebit",
    "drivelinks",
    "driveace",
    "drivepro",
    "driveseed",
]


###############################################################
# pdisk


def pdisk(url):
    r = requests.get(url).text
    try:
        return r.split("<!-- ")[-1].split(" -->")[0]
    except:
        try:
            return (
                BeautifulSoup(r, "html.parser").find("video").find("source").get("src")
            )
        except:
            return None


###############################################################
# index scrapper


def scrapeIndex(url, username="none", password="none"):

    def authorization_token(username, password):
        user_pass = f"{username}:{password}"
        return f"Basic {base64.b64encode(user_pass.encode()).decode()}"

    def decrypt(string):
        return base64.b64decode(string[::-1][24:-20]).decode("utf-8")

    def func(payload_input, url, username, password):
        next_page = False
        next_page_token = ""

        url = f"{url}/" if url[-1] != "/" else url

        try:
            headers = {"authorization": authorization_token(username, password)}
        except:
            return "username/password combination is wrong", None, None

        encrypted_response = requests.post(url, data=payload_input, headers=headers)
        if encrypted_response.status_code == 401:
            return "username/password combination is wrong", None, None

        try:
            decrypted_response = json.loads(decrypt(encrypted_response.text))
        except:
            return (
                "something went wrong. check index link/username/password field again",
                None,
                None,
            )

        page_token = decrypted_response["nextPageToken"]
        if page_token is None:
            next_page = False
        else:
            next_page = True
            next_page_token = page_token

        if list(decrypted_response.get("data").keys())[0] != "error":
            file_length = len(decrypted_response["data"]["files"])
            result = ""

            for i, _ in enumerate(range(file_length)):
                files_type = decrypted_response["data"]["files"][i]["mimeType"]
                if files_type != "application/vnd.google-apps.folder":
                    files_name = decrypted_response["data"]["files"][i]["name"]

                    direct_download_link = url + quote(files_name)
                    result += f"• {files_name} :\n{direct_download_link}\n\n"
            return result, next_page, next_page_token

    def format(result):
        long_string = "".join(result)
        new_list = []

        while len(long_string) > 0:
            if len(long_string) > 4000:
                split_index = long_string.rfind("\n\n", 0, 4000)
                if split_index == -1:
                    split_index = 4000
            else:
                split_index = len(long_string)

            new_list.append(long_string[:split_index])
            long_string = long_string[split_index:].lstrip("\n\n")

        return new_list

    # main
    x = 0
    next_page = False
    next_page_token = ""
    result = []

    payload = {"page_token": next_page_token, "page_index": x}
    print(f"Index Link: {url}\n")
    temp, next_page, next_page_token = func(payload, url, username, password)
    if temp is not None:
        result.append(temp)

    while next_page == True:
        payload = {"page_token": next_page_token, "page_index": x}
        temp, next_page, next_page_token = func(payload, url, username, password)
        if temp is not None:
            result.append(temp)
        x += 1

    if len(result) == 0:
        return None
    return format(result)


################################################################
# Shortner Full Page API


def shortner_fpage_api(link):
    link_pattern = r"https?://[\w.-]+/full\?api=([^&]+)&url=([^&]+)(?:&type=(\d+))?"
    match = re.match(link_pattern, link)
    if match:
        try:
            url_enc_value = match.group(2)
            url_value = base64.b64decode(url_enc_value).decode("utf-8")
            return url_value
        except BaseException:
            return None
    else:
        return None


# Shortner Quick Link API


def shortner_quick_api(link):
    link_pattern = r"https?://[\w.-]+/st\?api=([^&]+)&url=([^&]+)"
    match = re.match(link_pattern, link)
    if match:
        try:
            url_value = match.group(2)
            return url_value
        except BaseException:
            return None
    else:
        return None


##############################################################
# tnlink


def tnlink(url):
    client = requests.session()
    DOMAIN = "https://page.tnlink.in/"
    url = url[:-1] if url[-1] == "/" else url
    code = url.split("/")[-1]
    final_url = f"{DOMAIN}/{code}"
    ref = "https://usanewstoday.club/"
    h = {"referer": ref}
    while len(client.cookies) == 0:
        resp = client.get(final_url, headers=h)
        time.sleep(2)
    soup = BeautifulSoup(resp.content, "html.parser")
    inputs = soup.find_all("input")
    data = {input.get("name"): input.get("value") for input in inputs}
    h = {"x-requested-with": "XMLHttpRequest"}
    time.sleep(8)
    r = client.post(f"{DOMAIN}/links/go", data=data, headers=h)
    try:
        return r.json()["url"]
    except:
        return "Something went wrong :("


###############################################################
# psa


def try2link_bypass(url):
    client = cloudscraper.create_scraper(allow_brotli=False)

    url = url[:-1] if url[-1] == "/" else url

    params = (("d", int(time.time()) + (60 * 4)),)
    r = client.get(url, params=params, headers={"Referer": "https://newforex.online/"})

    soup = BeautifulSoup(r.text, "html.parser")
    inputs = soup.find(id="go-link").find_all(name="input")
    data = {input.get("name"): input.get("value") for input in inputs}
    time.sleep(7)

    headers = {
        "Host": "try2link.com",
        "X-Requested-With": "XMLHttpRequest",
        "Origin": "https://try2link.com",
        "Referer": url,
    }

    bypassed_url = client.post(
        "https://try2link.com/links/go", headers=headers, data=data
    )
    return bypassed_url.json()["url"]


def try2link_scrape(url):
    client = cloudscraper.create_scraper(allow_brotli=False)
    h = {
        "upgrade-insecure-requests": "1",
        "user-agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/105.0.0.0 Safari/537.36",
    }
    res = client.get(url, cookies={}, headers=h)
    url = "https://try2link.com/" + re.findall("try2link\.com\/(.*?) ", res.text)[0]
    return try2link_bypass(url)


def psa_bypasser(psa_url):
    cookies = {"cf_clearance": CF}
    headers = {
        "authority": "psa.wf",
        "accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7",
        "accept-language": "en-US,en;q=0.9",
        "referer": "https://psa.wf/",
        "user-agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/113.0.0.0 Safari/537.36",
    }

    r = requests.get(psa_url, headers=headers, cookies=cookies)
    soup = BeautifulSoup(r.text, "html.parser").find_all(
        class_="dropshadowboxes-drop-shadow dropshadowboxes-rounded-corners dropshadowboxes-inside-and-outside-shadow dropshadowboxes-lifted-both dropshadowboxes-effect-default"
    )
    links = []
    for link in soup:
        try:
            exit_gate = link.a.get("href")
            if "/exit" in exit_gate:
                print("scraping :", exit_gate)
                links.append(try2link_scrape(exit_gate))
        except:
            pass

    finals = ""
    for li in links:
        try:
            res = requests.get(li, headers=headers, cookies=cookies)
            soup = BeautifulSoup(res.text, "html.parser")
            name = soup.find("h1", class_="entry-title", itemprop="headline").getText()
            finals += "**" + name + "**\n\n"
            soup = soup.find("div", class_="entry-content", itemprop="text").findAll(
                "a"
            )
            for ele in soup:
                finals += "○ " + ele.get("href") + "\n"
            finals += "\n\n"
        except:
            finals += li + "\n\n"
    return finals


##################################################################################################################
# rocklinks


def rocklinks(url):
    client = cloudscraper.create_scraper(allow_brotli=False)
    if "rocklinks.net" in url:
        DOMAIN = "https://blog.disheye.com"
    else:
        DOMAIN = "https://rocklinks.net"

    url = url[:-1] if url[-1] == "/" else url

    code = url.split("/")[-1]
    if "rocklinks.net" in url:
        final_url = f"{DOMAIN}/{code}?quelle="
    else:
        final_url = f"{DOMAIN}/{code}"

    resp = client.get(final_url)
    soup = BeautifulSoup(resp.content, "html.parser")

    try:
        inputs = soup.find(id="go-link").find_all(name="input")
    except:
        return "Incorrect Link"

    data = {input.get("name"): input.get("value") for input in inputs}

    h = {"x-requested-with": "XMLHttpRequest"}

    time.sleep(10)
    r = client.post(f"{DOMAIN}/links/go", data=data, headers=h)
    try:
        return r.json()["url"]
    except:
        return "Something went wrong :("


################################################
# igg games


def decodeKey(encoded):
    key = ""

    i = len(encoded) // 2 - 5
    while i >= 0:
        key += encoded[i]
        i = i - 2

    i = len(encoded) // 2 + 4
    while i < len(encoded):
        key += encoded[i]
        i = i + 2

    return key


def bypassBluemediafiles(url, torrent=False):
    headers = {
        "User-Agent": "Mozilla/5.0 (X11; Linux x86_64; rv:103.0) Gecko/20100101 Firefox/103.0",
        "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8",
        "Accept-Language": "en-US,en;q=0.5",
        "Alt-Used": "bluemediafiles.com",
        "Connection": "keep-alive",
        "Upgrade-Insecure-Requests": "1",
        "Sec-Fetch-Dest": "document",
        "Sec-Fetch-Mode": "navigate",
        "Sec-Fetch-Site": "none",
        "Sec-Fetch-User": "?1",
    }

    res = requests.get(url, headers=headers)
    soup = BeautifulSoup(res.text, "html.parser")
    script = str(soup.findAll("script")[3])
    encodedKey = script.split('Create_Button("')[1].split('");')[0]

    headers = {
        "User-Agent": "Mozilla/5.0 (X11; Linux x86_64; rv:103.0) Gecko/20100101 Firefox/103.0",
        "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8",
        "Accept-Language": "en-US,en;q=0.5",
        "Referer": url,
        "Alt-Used": "bluemediafiles.com",
        "Connection": "keep-alive",
        "Upgrade-Insecure-Requests": "1",
        "Sec-Fetch-Dest": "document",
        "Sec-Fetch-Mode": "navigate",
        "Sec-Fetch-Site": "same-origin",
        "Sec-Fetch-User": "?1",
    }

    params = {"url": decodeKey(encodedKey)}

    if torrent:
        res = requests.get(
            "https://dl.pcgamestorrents.org/get-url.php", params=params, headers=headers
        )
        soup = BeautifulSoup(res.text, "html.parser")
        furl = soup.find("a", class_="button").get("href")

    else:
        res = requests.get(
            "https://bluemediafiles.com/get-url.php", params=params, headers=headers
        )
        furl = res.url
        if "mega.nz" in furl:
            furl = furl.replace("mega.nz/%23!", "mega.nz/file/").replace("!", "#")

    return furl


def igggames(url):
    res = requests.get(url)
    soup = BeautifulSoup(res.text, "html.parser")
    soup = soup.find("div", class_="uk-margin-medium-top").findAll("a")

    bluelist = []
    for ele in soup:
        bluelist.append(ele.get("href"))
    bluelist = bluelist[3:-1]

    links = ""
    last = None
    fix = True
    for ele in bluelist:
        if ele == "https://igg-games.com/how-to-install-a-pc-game-and-update.html":
            fix = False
            links += "\n"
        if "bluemediafile" in ele:
            tmp = bypassBluemediafiles(ele)
            if fix:
                tt = tmp.split("/")[2]
                if last is not None and tt != last:
                    links += "\n"
                last = tt
            links = links + "○ " + tmp + "\n"
        elif "pcgamestorrents.com" in ele:
            res = requests.get(ele)
            soup = BeautifulSoup(res.text, "html.parser")
            turl = (
                soup.find(
                    "p", class_="uk-card uk-card-body uk-card-default uk-card-hover"
                )
                .find("a")
                .get("href")
            )
            links = links + "🧲 `" + bypassBluemediafiles(turl, True) + "`\n\n"
        elif ele != "https://igg-games.com/how-to-install-a-pc-game-and-update.html":
            if fix:
                tt = ele.split("/")[2]
                if last is not None and tt != last:
                    links += "\n"
                last = tt
            links = links + "○ " + ele + "\n"

    return links[:-1]


###############################################################
# htpmovies cinevood sharespark atishmkv


def htpmovies(link):
    client = cloudscraper.create_scraper(allow_brotli=False)
    r = client.get(link, allow_redirects=True).text
    j = r.split('("')[-1]
    url = j.split('")')[0]
    param = url.split("/")[-1]
    DOMAIN = "https://go.theforyou.in"
    final_url = f"{DOMAIN}/{param}"
    resp = client.get(final_url)
    soup = BeautifulSoup(resp.content, "html.parser")
    try:
        inputs = soup.find(id="go-link").find_all(name="input")
    except:
        return "Incorrect Link"
    data = {input.get("name"): input.get("value") for input in inputs}
    h = {"x-requested-with": "XMLHttpRequest"}
    time.sleep(10)
    r = client.post(f"{DOMAIN}/links/go", data=data, headers=h)
    try:
        return r.json()["url"]
    except:
        return "Something went Wrong !!"


def scrappers(link):

    try:
        link = re.match(
            r"((http|https)\:\/\/)?[a-zA-Z0-9\.\/\?\:@\-_=#]+\.([a-zA-Z]){2,6}([a-zA-Z0-9\.\&\/\?\:@\-_=#])*",
            link,
        )[0]
    except TypeError:
        return "Not a Valid Link."
    links = []

    if "sharespark" in link:
        gd_txt = ""
        res = requests.get("?action=printpage;".join(link.split("?")))
        soup = BeautifulSoup(res.text, "html.parser")
        for br in soup.findAll("br"):
            next_s = br.nextSibling
            if not (next_s and isinstance(next_s, NavigableString)):
                continue
            next2_s = next_s.nextSibling
            if next2_s and isinstance(next2_s, Tag) and next2_s.name == "br":
                text = str(next_s).strip()
                if text:
                    result = re.sub(r"(?m)^\(https://i.*", "", next_s)
                    star = re.sub(r"(?m)^\*.*", " ", result)
                    extra = re.sub(r"(?m)^\(https://e.*", " ", star)
                    gd_txt += (
                        ", ".join(
                            re.findall(
                                r"(?m)^.*https://new1.gdtot.cfd/file/[0-9][^.]*", next_s
                            )
                        )
                        + "\n\n"
                    )
        return gd_txt

    elif "htpmovies" in link and "/exit.php" in link:
        return htpmovies(link)

    elif "htpmovies" in link:
        prsd = ""
        links = []
        res = requests.get(link)
        soup = BeautifulSoup(res.text, "html.parser")
        x = soup.select('a[href^="/exit.php?url="]')
        y = soup.select("h5")
        z = (
            unquote(link.split("/")[-2]).split("-")[0]
            if link.endswith("/")
            else unquote(link.split("/")[-1]).split("-")[0]
        )

        for a in x:
            links.append(a["href"])
            prsd = f"Total Links Found : {len(links)}\n\n"

        msdcnt = -1
        for b in y:
            if str(b.string).lower().startswith(z.lower()):
                msdcnt += 1
                url = f"https://htpmovies.lol" + links[msdcnt]
                prsd += f"{msdcnt+1}. <b>{b.string}</b>\n{htpmovies(url)}\n\n"
                asleep(5)
        return prsd

    elif "cinevood" in link:
        prsd = ""
        links = []
        res = requests.get(link)
        soup = BeautifulSoup(res.text, "html.parser")
        x = soup.select('a[href^="https://kolop.icu/file"]')
        for a in x:
            links.append(a["href"])
        for o in links:
            res = requests.get(o)
            soup = BeautifulSoup(res.content, "html.parser")
            title = soup.title.string
            reftxt = re.sub(r"Kolop \| ", "", title)
            prsd += f"{reftxt}\n{o}\n\n"
        return prsd

    elif "atishmkv" in link:
        prsd = ""
        links = []
        res = requests.get(link)
        soup = BeautifulSoup(res.text, "html.parser")
        x = soup.select('a[href^="https://gdflix.top/file"]')
        for a in x:
            links.append(a["href"])
        for o in links:
            prsd += o + "\n\n"
        return prsd

    elif "teluguflix" in link:
        gd_txt = ""
        r = requests.get(link)
        soup = BeautifulSoup(r.text, "html.parser")
        links = soup.select('a[href*="gdtot"]')
        gd_txt = f"Total Links Found : {len(links)}\n\n"
        for no, link in enumerate(links, start=1):
            gdlk = link["href"]
            t = requests.get(gdlk)
            soupt = BeautifulSoup(t.text, "html.parser")
            title = soupt.select('meta[property^="og:description"]')
            gd_txt += f"{no}. <code>{(title[0]['content']).replace('Download ' , '')}</code>\n{gdlk}\n\n"
            asleep(1.5)
        return gd_txt

    elif "taemovies" in link:
        gd_txt, no = "", 0
        r = requests.get(link)
        soup = BeautifulSoup(r.text, "html.parser")
        links = soup.select('a[href*="shortingly"]')
        gd_txt = f"Total Links Found : {len(links)}\n\n"
        for a in links:
            glink = rocklinks(a["href"])
            t = requests.get(glink)
            soupt = BeautifulSoup(t.text, "html.parser")
            title = soupt.select('meta[property^="og:description"]')
            no += 1
            gd_txt += (
                f"{no}. {(title[0]['content']).replace('Download ' , '')}\n{glink}\n\n"
            )
        return gd_txt

    elif "toonworld4all" in link:
        gd_txt, no = "", 0
        r = requests.get(link)
        soup = BeautifulSoup(r.text, "html.parser")
        links = soup.select('a[href*="redirect/main.php?"]')
        for a in links:
            down = requests.get(a["href"], stream=True, allow_redirects=False)
            link = down.headers["location"]
            glink = rocklinks(link)
            if glink and "gdtot" in glink:
                t = requests.get(glink)
                soupt = BeautifulSoup(t.text, "html.parser")
                title = soupt.select('meta[property^="og:description"]')
                no += 1
                gd_txt += f"{no}. {(title[0]['content']).replace('Download ' , '')}\n{glink}\n\n"
        return gd_txt

    elif "animeremux" in link:
        gd_txt, no = "", 0
        r = requests.get(link)
        soup = BeautifulSoup(r.text, "html.parser")
        links = soup.select('a[href*="urlshortx.com"]')
        gd_txt = f"Total Links Found : {len(links)}\n\n"
        for a in links:
            link = a["href"]
            x = link.split("url=")[-1]
            t = requests.get(x)
            soupt = BeautifulSoup(t.text, "html.parser")
            title = soupt.title
            no += 1
            gd_txt += f"{no}. {title.text}\n{x}\n\n"
            asleep(1.5)
        return gd_txt

    else:
        res = requests.get(link)
        soup = BeautifulSoup(res.text, "html.parser")
        mystx = soup.select(r'a[href^="magnet:?xt=urn:btih:"]')
        for hy in mystx:
            links.append(hy["href"])
        return links


###################################################
# script links


def getfinal(domain, url, sess):

    # sess = requests.session()
    res = sess.get(url)
    soup = BeautifulSoup(res.text, "html.parser")
    soup = soup.find("form").findAll("input")
    datalist = []
    for ele in soup:
        datalist.append(ele.get("value"))

    data = {
        "_method": datalist[0],
        "_csrfToken": datalist[1],
        "ad_form_data": datalist[2],
        "_Token[fields]": datalist[3],
        "_Token[unlocked]": datalist[4],
    }

    sess.headers = {
        "User-Agent": "Mozilla/5.0 (X11; Linux x86_64; rv:103.0) Gecko/20100101 Firefox/103.0",
        "Accept": "application/json, text/javascript, */*; q=0.01",
        "Accept-Language": "en-US,en;q=0.5",
        "Content-Type": "application/x-www-form-urlencoded; charset=UTF-8",
        "X-Requested-With": "XMLHttpRequest",
        "Origin": domain,
        "Connection": "keep-alive",
        "Referer": url,
        "Sec-Fetch-Dest": "empty",
        "Sec-Fetch-Mode": "cors",
        "Sec-Fetch-Site": "same-origin",
    }

    # print("waiting 10 secs")
    time.sleep(10)  # important
    response = sess.post(domain + "/links/go", data=data).json()
    furl = response["url"]
    return furl


def getfirst(url):

    sess = requests.session()
    res = sess.get(url)

    soup = BeautifulSoup(res.text, "html.parser")
    soup = soup.find("form")
    action = soup.get("action")
    soup = soup.findAll("input")
    datalist = []
    for ele in soup:
        datalist.append(ele.get("value"))
    sess.headers = {
        "User-Agent": "Mozilla/5.0 (X11; Linux x86_64; rv:103.0) Gecko/20100101 Firefox/103.0",
        "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8",
        "Accept-Language": "en-US,en;q=0.5",
        "Origin": action,
        "Connection": "keep-alive",
        "Referer": action,
        "Upgrade-Insecure-Requests": "1",
        "Sec-Fetch-Dest": "document",
        "Sec-Fetch-Mode": "navigate",
        "Sec-Fetch-Site": "same-origin",
        "Sec-Fetch-User": "?1",
    }

    data = {"newwpsafelink": datalist[1], "g-recaptcha-response": RecaptchaV3()}
    response = sess.post(action, data=data)
    soup = BeautifulSoup(response.text, "html.parser")
    soup = soup.findAll("div", class_="wpsafe-bottom text-center")
    for ele in soup:
        rurl = ele.find("a").get("onclick")[13:-12]

    res = sess.get(rurl)
    furl = res.url
    # print(furl)
    return getfinal(f'https://{furl.split("/")[-2]}/', furl, sess)


####################################################################################################
# ez4short


def ez4(url):
    client = cloudscraper.create_scraper(allow_brotli=False)
    DOMAIN = "https://ez4short.com"
    ref = "https://techmody.io/"
    h = {"referer": ref}
    resp = client.get(url, headers=h)
    soup = BeautifulSoup(resp.content, "html.parser")
    inputs = soup.find_all("input")
    data = {input.get("name"): input.get("value") for input in inputs}
    h = {"x-requested-with": "XMLHttpRequest"}
    time.sleep(8)
    r = client.post(f"{DOMAIN}/links/go", data=data, headers=h)
    try:
        return r.json()["url"]
    except:
        return "Something went wrong :("


################################################
# ola movies


def olamovies(url):

    print("this takes time, you might want to take a break.")
    headers = {
        "User-Agent": "Mozilla/5.0 (X11; Linux x86_64; rv:103.0) Gecko/20100101 Firefox/103.0",
        "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8",
        "Accept-Language": "en-US,en;q=0.5",
        "Referer": url,
        "Alt-Used": "olamovies.ink",
        "Connection": "keep-alive",
        "Upgrade-Insecure-Requests": "1",
        "Sec-Fetch-Dest": "document",
        "Sec-Fetch-Mode": "navigate",
        "Sec-Fetch-Site": "same-origin",
        "Sec-Fetch-User": "?1",
    }

    client = cloudscraper.create_scraper(allow_brotli=False)
    res = client.get(url)
    soup = BeautifulSoup(res.text, "html.parser")
    soup = soup.findAll("div", class_="wp-block-button")

    outlist = []
    for ele in soup:
        outlist.append(ele.find("a").get("href"))

    slist = []
    for ele in outlist:
        try:
            key = (
                ele.split("?key=")[1]
                .split("&id=")[0]
                .replace("%2B", "+")
                .replace("%3D", "=")
                .replace("%2F", "/")
            )
            id = ele.split("&id=")[1]
        except:
            continue

        count = 3
        params = {"key": key, "id": id}
        soup = "None"

        while (
            "rocklinks.net" not in soup
            and "try2link.com" not in soup
            and "ez4short.com" not in soup
        ):
            res = client.get(
                "https://olamovies.ink/download/", params=params, headers=headers
            )
            soup = BeautifulSoup(res.text, "html.parser")
            soup = soup.findAll("a")[0].get("href")
            if soup != "":
                if (
                    "try2link.com" in soup
                    or "rocklinks.net" in soup
                    or "ez4short.com" in soup
                ):
                    slist.append(soup)
                else:
                    pass
            else:
                if count == 0:
                    break
                else:
                    count -= 1

            time.sleep(10)

    final = []
    for ele in slist:
        if "rocklinks.net" in ele:
            final.append(rocklinks(ele))
        elif "try2link.com" in ele:
            final.append(try2link_bypass(ele))
        elif "ez4short.com" in ele:
            final.append(ez4(ele))
        else:
            pass

    links = ""
    for ele in final:
        links = links + ele + "\n"
    return links[:-1]


###############################################
# katdrive


def parse_info_katdrive(res):
    info_parsed = {}
    title = re.findall(">(.*?)<\/h4>", res.text)[0]
    info_chunks = re.findall(">(.*?)<\/td>", res.text)
    info_parsed["title"] = title
    for i in range(0, len(info_chunks), 2):
        info_parsed[info_chunks[i]] = info_chunks[i + 1]
    return info_parsed


def katdrive_dl(url, katcrypt):
    client = requests.Session()
    client.cookies.update({"crypt": katcrypt})

    res = client.get(url)
    info_parsed = parse_info_katdrive(res)
    info_parsed["error"] = False

    up = urlparse(url)
    req_url = f"{up.scheme}://{up.netloc}/ajax.php?ajax=download"

    file_id = url.split("/")[-1]
    data = {"id": file_id}
    headers = {"x-requested-with": "XMLHttpRequest"}

    try:
        res = client.post(req_url, headers=headers, data=data).json()["file"]
    except:
        return "Error"  # {'error': True, 'src_url': url}

    gd_id = re.findall("gd=(.*)", res, re.DOTALL)[0]
    info_parsed["gdrive_url"] = f"https://drive.google.com/open?id={gd_id}"
    info_parsed["src_url"] = url
    return info_parsed["gdrive_url"]


###############################################
# hubdrive


def parse_info_hubdrive(res):
    info_parsed = {}
    title = re.findall(">(.*?)<\/h4>", res.text)[0]
    info_chunks = re.findall(">(.*?)<\/td>", res.text)
    info_parsed["title"] = title
    for i in range(0, len(info_chunks), 2):
        info_parsed[info_chunks[i]] = info_chunks[i + 1]
    return info_parsed


def hubdrive_dl(url, hcrypt):
    client = requests.Session()
    client.cookies.update({"crypt": hcrypt})

    res = client.get(url)
    info_parsed = parse_info_hubdrive(res)
    info_parsed["error"] = False

    up = urlparse(url)
    req_url = f"{up.scheme}://{up.netloc}/ajax.php?ajax=download"

    file_id = url.split("/")[-1]
    data = {"id": file_id}
    headers = {"x-requested-with": "XMLHttpRequest"}

    try:
        res = client.post(req_url, headers=headers, data=data).json()["file"]
    except:
        return "Error"  # {'error': True, 'src_url': url}

    gd_id = re.findall("gd=(.*)", res, re.DOTALL)[0]
    info_parsed["gdrive_url"] = f"https://drive.google.com/open?id={gd_id}"
    info_parsed["src_url"] = url
    return info_parsed["gdrive_url"]


#################################################
# drivefire


def parse_info_drivefire(res):
    info_parsed = {}
    title = re.findall(">(.*?)<\/h4>", res.text)[0]
    info_chunks = re.findall(">(.*?)<\/td>", res.text)
    info_parsed["title"] = title
    for i in range(0, len(info_chunks), 2):
        info_parsed[info_chunks[i]] = info_chunks[i + 1]
    return info_parsed


def drivefire_dl(url, dcrypt):
    client = requests.Session()
    client.cookies.update({"crypt": dcrypt})

    res = client.get(url)
    info_parsed = parse_info_drivefire(res)
    info_parsed["error"] = False

    up = urlparse(url)
    req_url = f"{up.scheme}://{up.netloc}/ajax.php?ajax=download"

    file_id = url.split("/")[-1]
    data = {"id": file_id}
    headers = {"x-requested-with": "XMLHttpRequest"}

    try:
        res = client.post(req_url, headers=headers, data=data).json()["file"]
    except:
        return "Error"  # {'error': True, 'src_url': url}

    decoded_id = res.rsplit("/", 1)[-1]
    info_parsed = f"https://drive.google.com/file/d/{decoded_id}"
    return info_parsed


##################################################
# kolop


def parse_info_kolop(res):
    info_parsed = {}
    title = re.findall(">(.*?)<\/h4>", res.text)[0]
    info_chunks = re.findall(">(.*?)<\/td>", res.text)
    info_parsed["title"] = title
    for i in range(0, len(info_chunks), 2):
        info_parsed[info_chunks[i]] = info_chunks[i + 1]
    return info_parsed


def kolop_dl(url, kcrypt):
    client = requests.Session()
    client.cookies.update({"crypt": kcrypt})

    res = client.get(url)
    info_parsed = parse_info_kolop(res)
    info_parsed["error"] = False

    up = urlparse(url)
    req_url = f"{up.scheme}://{up.netloc}/ajax.php?ajax=download"

    file_id = url.split("/")[-1]
    data = {"id": file_id}
    headers = {"x-requested-with": "XMLHttpRequest"}

    try:
        res = client.post(req_url, headers=headers, data=data).json()["file"]
    except:
        return "Error"  # {'error': True, 'src_url': url}

    gd_id = re.findall("gd=(.*)", res, re.DOTALL)[0]
    info_parsed["gdrive_url"] = f"https://drive.google.com/open?id={gd_id}"
    info_parsed["src_url"] = url

    return info_parsed["gdrive_url"]


##################################################
# mediafire


def mediafire(url):

    res = requests.get(url, stream=True)
    contents = res.text

    for line in contents.splitlines():
        m = re.search(r'href="((http|https)://download[^"]+)', line)
        if m:
            return m.groups()[0]


####################################################
# zippyshare


def zippyshare(url):
    resp = requests.get(url).text
    surl = resp.split("document.getElementById('dlbutton').href = ")[1].split(";")[0]
    parts = surl.split("(")[1].split(")")[0].split(" ")
    val = str(int(parts[0]) % int(parts[2]) + int(parts[4]) % int(parts[6]))
    surl = surl.split('"')
    burl = url.split("zippyshare.com")[0]
    furl = burl + "zippyshare.com" + surl[1] + val + surl[-2]
    return furl


####################################################
# filercrypt


def getlinks(dlc):
    headers = {
        "User-Agent": "Mozilla/5.0 (X11; Linux x86_64; rv:103.0) Gecko/20100101 Firefox/103.0",
        "Accept": "application/json, text/javascript, */*",
        "Accept-Language": "en-US,en;q=0.5",
        "X-Requested-With": "XMLHttpRequest",
        "Origin": "http://dcrypt.it",
        "Connection": "keep-alive",
        "Referer": "http://dcrypt.it/",
    }

    data = {
        "content": dlc,
    }

    response = requests.post(
        "http://dcrypt.it/decrypt/paste", headers=headers, data=data
    ).json()["success"]["links"]
    links = ""
    for link in response:
        links = links + link + "\n\n"
    return links[:-1]


def filecrypt(url):

    client = cloudscraper.create_scraper(allow_brotli=False)
    headers = {
        "authority": "filecrypt.co",
        "accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9",
        "accept-language": "en-US,en;q=0.9",
        "cache-control": "max-age=0",
        "content-type": "application/x-www-form-urlencoded",
        "origin": "https://filecrypt.co",
        "referer": url,
        "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/105.0.0.0 Safari/537.36",
    }

    resp = client.get(url, headers=headers)
    soup = BeautifulSoup(resp.content, "html.parser")

    buttons = soup.find_all("button")
    for ele in buttons:
        line = ele.get("onclick")
        if line != None and "DownloadDLC" in line:
            dlclink = (
                "https://filecrypt.co/DLC/"
                + line.split("DownloadDLC('")[1].split("'")[0]
                + ".html"
            )
            break

    resp = client.get(dlclink, headers=headers)
    return getlinks(resp.text)


#####################################################
# dropbox


def dropbox(url):
    return (
        url.replace("www.", "")
        .replace("dropbox.com", "dl.dropboxusercontent.com")
        .replace("?dl=0", "")
    )


######################################################
# shareus


def shareus(url):
    headers = {
        "user-agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/115.0.0.0 Safari/537.36",
    }
    DOMAIN = "https://us-central1-my-apps-server.cloudfunctions.net"
    sess = requests.session()

    code = url.split("/")[-1]
    params = {
        "shortid": code,
        "initial": "true",
        "referrer": "https://shareus.io/",
    }
    response = requests.get(f"{DOMAIN}/v", params=params, headers=headers)

    for i in range(1, 4):
        json_data = {
            "current_page": i,
        }
        response = sess.post(f"{DOMAIN}/v", headers=headers, json=json_data)

    response = sess.get(f"{DOMAIN}/get_link", headers=headers).json()
    return response["link_info"]["destination"]


#######################################################
# shortingly


def shortingly(url):
    client = cloudscraper.create_scraper(allow_brotli=False)
    DOMAIN = "https://shortingly.in"
    url = url[:-1] if url[-1] == "/" else url
    code = url.split("/")[-1]
    final_url = f"{DOMAIN}/{code}"
    ref = "https://tech.gyanitheme.com/"
    h = {"referer": ref}
    resp = client.get(final_url, headers=h)
    soup = BeautifulSoup(resp.content, "html.parser")
    inputs = soup.find_all("input")
    data = {input.get("name"): input.get("value") for input in inputs}
    h = {"x-requested-with": "XMLHttpRequest"}
    time.sleep(5)
    r = client.post(f"{DOMAIN}/links/go", data=data, headers=h)
    try:
        return r.json()["url"]
    except:
        return "Something went wrong :("


#######################################################
# Gyanilinks - gtlinks.me


def gyanilinks(url):
    DOMAIN = "https://go.hipsonyc.com/"
    client = cloudscraper.create_scraper(allow_brotli=False)
    url = url[:-1] if url[-1] == "/" else url
    code = url.split("/")[-1]
    final_url = f"{DOMAIN}/{code}"
    resp = client.get(final_url)
    soup = BeautifulSoup(resp.content, "html.parser")
    try:
        inputs = soup.find(id="go-link").find_all(name="input")
    except:
        return "Incorrect Link"
    data = {input.get("name"): input.get("value") for input in inputs}
    h = {"x-requested-with": "XMLHttpRequest"}
    time.sleep(5)
    r = client.post(f"{DOMAIN}/links/go", data=data, headers=h)
    try:
        return r.json()["url"]
    except:
        return "Something went wrong :("


#######################################################
# Flashlink


def flashl(url):
    client = cloudscraper.create_scraper(allow_brotli=False)
    DOMAIN = "https://files.earnash.com/"
    url = url[:-1] if url[-1] == "/" else url
    code = url.split("/")[-1]
    final_url = f"{DOMAIN}/{code}"
    ref = "https://flash1.cordtpoint.co.in"
    h = {"referer": ref}
    resp = client.get(final_url, headers=h)
    soup = BeautifulSoup(resp.content, "html.parser")
    inputs = soup.find_all("input")
    data = {input.get("name"): input.get("value") for input in inputs}
    h = {"x-requested-with": "XMLHttpRequest"}
    time.sleep(15)
    r = client.post(f"{DOMAIN}/links/go", data=data, headers=h)
    try:
        return r.json()["url"]
    except:
        return "Something went wrong :("


#######################################################
# short2url


def short2url(url):
    client = cloudscraper.create_scraper(allow_brotli=False)
    DOMAIN = "https://techyuth.xyz/blog"
    url = url[:-1] if url[-1] == "/" else url
    code = url.split("/")[-1]
    final_url = f"{DOMAIN}/{code}"
    ref = "https://blog.coin2pay.xyz/"
    h = {"referer": ref}
    resp = client.get(final_url, headers=h)
    soup = BeautifulSoup(resp.content, "html.parser")
    inputs = soup.find_all("input")
    data = {input.get("name"): input.get("value") for input in inputs}
    h = {"x-requested-with": "XMLHttpRequest"}
    time.sleep(10)
    r = client.post(f"{DOMAIN}/links/go", data=data, headers=h)
    try:
        return r.json()["url"]
    except:
        return "Something went wrong :("


#######################################################
# anonfiles


def anonfile(url):

    headersList = {"Accept": "*/*"}
    payload = ""

    response = requests.request(
        "GET", url, data=payload, headers=headersList
    ).text.split("\n")
    for ele in response:
        if (
            "https://cdn" in ele
            and "anonfiles.com" in ele
            and url.split("/")[-2] in ele
        ):
            break

    return ele.split('href="')[1].split('"')[0]


##########################################################
# pixl


def pixl(url):
    count = 1
    dl_msg = ""
    currentpage = 1
    settotalimgs = True
    totalimages = ""
    client = cloudscraper.create_scraper(allow_brotli=False)
    resp = client.get(url)
    if resp.status_code == 404:
        return "File not found/The link you entered is wrong!"
    soup = BeautifulSoup(resp.content, "html.parser")
    if "album" in url and settotalimgs:
        totalimages = soup.find("span", {"data-text": "image-count"}).text
        settotalimgs = False
    thmbnailanch = soup.findAll(attrs={"class": "--media"})
    links = soup.findAll(attrs={"data-pagination": "next"})
    try:
        url = links[0].attrs["href"]
    except BaseException:
        url = None
    for ref in thmbnailanch:
        imgdata = client.get(ref.attrs["href"])
        if not imgdata.status_code == 200:
            time.sleep(5)
            continue
        imghtml = BeautifulSoup(imgdata.text, "html.parser")
        downloadanch = imghtml.find(attrs={"class": "btn-download"})
        currentimg = downloadanch.attrs["href"]
        currentimg = currentimg.replace(" ", "%20")
        dl_msg += f"{count}. {currentimg}\n"
        count += 1
    currentpage += 1
    fld_msg = f"Your provided Pixl.is link is of Folder and I've Found {count - 1} files in the folder.\n"
    fld_link = f"\nFolder Link: {url}\n"
    final_msg = fld_link + "\n" + fld_msg + "\n" + dl_msg
    return final_msg


############################################################
# sirigan  ( unused )


def siriganbypass(url):
    client = requests.Session()
    res = client.get(url)
    url = res.url.split("=", maxsplit=1)[-1]

    while True:
        try:
            url = base64.b64decode(url).decode("utf-8")
        except:
            break

    return url.split("url=")[-1]


############################################################
# shorte


def sh_st_bypass(url):
    client = requests.Session()
    client.headers.update({"referer": url})
    p = urlparse(url)

    res = client.get(url)

    sess_id = re.findall("""sessionId(?:\s+)?:(?:\s+)?['|"](.*?)['|"]""", res.text)[0]

    final_url = f"{p.scheme}://{p.netloc}/shortest-url/end-adsession"
    params = {"adSessionId": sess_id, "callback": "_"}
    time.sleep(5)  # !important

    res = client.get(final_url, params=params)
    dest_url = re.findall('"(.*?)"', res.text)[1].replace("\/", "/")

    return {"src": url, "dst": dest_url}["dst"]


#############################################################
# gofile


def gofile_dl(url, password=""):
    api_uri = "https://api.gofile.io"
    client = requests.Session()
    res = client.get(api_uri + "/createAccount").json()

    data = {
        "contentId": url.split("/")[-1],
        "token": res["data"]["token"],
        "websiteToken": "12345",
        "cache": "true",
        "password": hashlib.sha256(password.encode("utf-8")).hexdigest(),
    }
    res = client.get(api_uri + "/getContent", params=data).json()

    content = []
    for item in res["data"]["contents"].values():
        content.append(item)

    return {"accountToken": data["token"], "files": content}["files"][0]["link"]


################################################################
# sharer pw


def parse_info_sharer(res):
    f = re.findall(">(.*?)<\/td>", res.text)
    info_parsed = {}
    for i in range(0, len(f), 3):
        info_parsed[f[i].lower().replace(" ", "_")] = f[i + 2]
    return info_parsed


def sharer_pw(url, Laravel_Session, XSRF_TOKEN, forced_login=False):
    client = cloudscraper.create_scraper(allow_brotli=False)
    client.cookies.update(
        {"XSRF-TOKEN": XSRF_TOKEN, "laravel_session": Laravel_Session}
    )
    res = client.get(url)
    token = re.findall("_token\s=\s'(.*?)'", res.text, re.DOTALL)[0]
    ddl_btn = etree.HTML(res.content).xpath("//button[@id='btndirect']")
    info_parsed = parse_info_sharer(res)
    info_parsed["error"] = True
    info_parsed["src_url"] = url
    info_parsed["link_type"] = "login"
    info_parsed["forced_login"] = forced_login
    headers = {
        "content-type": "application/x-www-form-urlencoded; charset=UTF-8",
        "x-requested-with": "XMLHttpRequest",
    }
    data = {"_token": token}
    if len(ddl_btn):
        info_parsed["link_type"] = "direct"
    if not forced_login:
        data["nl"] = 1
    try:
        res = client.post(url + "/dl", headers=headers, data=data).json()
    except:
        return info_parsed
    if "url" in res and res["url"]:
        info_parsed["error"] = False
        info_parsed["gdrive_link"] = res["url"]
    if len(ddl_btn) and not forced_login and not "url" in info_parsed:
        # retry download via login
        return sharer_pw(url, Laravel_Session, XSRF_TOKEN, forced_login=True)
    return info_parsed["gdrive_link"]


#################################################################
# gdtot


def gdtot(url):
    cget = create_scraper().request
    try:
        res = cget("GET", f'https://gdbot.xyz/file/{url.split("/")[-1]}')
    except Exception as e:
        return f"ERROR: {e.__class__.__name__}"
    token_url = etree.HTML(res.content).xpath(
        "//a[contains(@class,'inline-flex items-center justify-center')]/@href"
    )
    if not token_url:
        try:
            url = cget("GET", url).url
            p_url = urlparse(url)
            res = cget(
                "GET", f"{p_url.scheme}://{p_url.hostname}/ddl/{url.split('/')[-1]}"
            )
        except Exception as e:
            return f"ERROR: {e.__class__.__name__}"
        if (
            drive_link := re.findall(r"myDl\('(.*?)'\)", res.text)
        ) and "drive.google.com" in drive_link[0]:
            return drive_link[0]
        else:
            return "ERROR: Drive Link not found, Try in your broswer"
    token_url = token_url[0]
    try:
        token_page = cget("GET", token_url)
    except Exception as e:
        return f"ERROR: {e.__class__.__name__} with {token_url}"
    path = re.findall('\("(.*?)"\)', token_page.text)
    if not path:
        return "ERROR: Cannot bypass this"
    path = path[0]
    raw = urlparse(token_url)
    final_url = f"{raw.scheme}://{raw.hostname}{path}"
    return ddl.sharer_scraper(final_url)


##################################################################
# adfly


def decrypt_url(code):
    a, b = "", ""
    for i in range(0, len(code)):
        if i % 2 == 0:
            a += code[i]
        else:
            b = code[i] + b
    key = list(a + b)
    i = 0
    while i < len(key):
        if key[i].isdigit():
            for j in range(i + 1, len(key)):
                if key[j].isdigit():
                    u = int(key[i]) ^ int(key[j])
                    if u < 10:
                        key[i] = str(u)
                    i = j
                    break
        i += 1
    key = "".join(key)
    decrypted = base64.b64decode(key)[16:-16]
    return decrypted.decode("utf-8")


def adfly(url):
    client = cloudscraper.create_scraper(allow_brotli=False)
    res = client.get(url).text
    out = {"error": False, "src_url": url}
    try:
        ysmm = re.findall("ysmm\s+=\s+['|\"](.*?)['|\"]", res)[0]
    except:
        out["error"] = True
        return out
    url = decrypt_url(ysmm)
    if re.search(r"go\.php\?u\=", url):
        url = base64.b64decode(re.sub(r"(.*?)u=", "", url)).decode()
    elif "&dest=" in url:
        url = unquote(re.sub(r"(.*?)dest=", "", url))
    out["bypassed_url"] = url
    return out


##############################################################################################
# gplinks


def gplinks(url: str):
    client = cloudscraper.create_scraper(allow_brotli=False)
    token = url.split("/")[-1]
    domain = "https://gplinks.co/"
    referer = "https://mynewsmedia.co/"
    vid = client.get(url, allow_redirects=False).headers["Location"].split("=")[-1]
    url = f"{url}/?{vid}"
    response = client.get(url, allow_redirects=False)
    soup = BeautifulSoup(response.content, "html.parser")
    inputs = soup.find(id="go-link").find_all(name="input")
    data = {input.get("name"): input.get("value") for input in inputs}
    time.sleep(10)
    headers = {"x-requested-with": "XMLHttpRequest"}
    bypassed_url = client.post(domain + "links/go", data=data, headers=headers).json()[
        "url"
    ]
    try:
        return bypassed_url
    except:
        return "Something went wrong :("


######################################################################################################
# droplink


def droplink(url):
    client = cloudscraper.create_scraper(allow_brotli=False)
    res = client.get(url, timeout=5)

    ref = re.findall("action[ ]{0,}=[ ]{0,}['|\"](.*?)['|\"]", res.text)[0]
    h = {"referer": ref}
    res = client.get(url, headers=h)

    bs4 = BeautifulSoup(res.content, "html.parser")
    inputs = bs4.find_all("input")
    data = {input.get("name"): input.get("value") for input in inputs}
    h = {
        "content-type": "application/x-www-form-urlencoded",
        "x-requested-with": "XMLHttpRequest",
    }

    p = urlparse(url)
    final_url = f"{p.scheme}://{p.netloc}/links/go"
    time.sleep(3.1)
    res = client.post(final_url, data=data, headers=h).json()

    if res["status"] == "success":
        return res["url"]
    return "Something went wrong :("


#####################################################################################################################
# link vertise


def linkvertise(url):
    params = {
        "url": url,
    }
    response = requests.get("https://bypass.pm/bypass2", params=params).json()
    if response["success"]:
        return response["destination"]
    else:
        return response["msg"]


###################################################################################################################
# others


def others(url):
    return "API Currently not Available"


#################################################################################################################
# ouo


# RECAPTCHA v3 BYPASS
# code from https://github.com/xcscxr/Recaptcha-v3-bypass
def RecaptchaV3():
    ANCHOR_URL = "https://www.google.com/recaptcha/api2/anchor?ar=1&k=6Lcr1ncUAAAAAH3cghg6cOTPGARa8adOf-y9zv2x&co=aHR0cHM6Ly9vdW8ucHJlc3M6NDQz&hl=en&v=pCoGBhjs9s8EhFOHJFe8cqis&size=invisible&cb=ahgyd1gkfkhe"
    url_base = "https://www.google.com/recaptcha/"
    post_data = "v={}&reason=q&c={}&k={}&co={}"
    client = requests.Session()
    client.headers.update({"content-type": "application/x-www-form-urlencoded"})
    matches = re.findall("([api2|enterprise]+)\/anchor\?(.*)", ANCHOR_URL)[0]
    url_base += matches[0] + "/"
    params = matches[1]
    res = client.get(url_base + "anchor", params=params)
    token = re.findall(r'"recaptcha-token" value="(.*?)"', res.text)[0]
    params = dict(pair.split("=") for pair in params.split("&"))
    post_data = post_data.format(params["v"], token, params["k"], params["co"])
    res = client.post(url_base + "reload", params=f'k={params["k"]}', data=post_data)
    answer = re.findall(r'"rresp","(.*?)"', res.text)[0]
    return answer


# code from https://github.com/xcscxr/ouo-bypass/
def ouo(url):
    tempurl = url.replace("ouo.press", "ouo.io")
    p = urlparse(tempurl)
    id = tempurl.split("/")[-1]
    client = Nreq.Session(
        headers={
            "authority": "ouo.io",
            "accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7",
            "accept-language": "en-GB,en-US;q=0.9,en;q=0.8",
            "cache-control": "max-age=0",
            "referer": "http://www.google.com/ig/adde?moduleurl=",
            "upgrade-insecure-requests": "1",
        }
    )
    res = client.get(tempurl, impersonate="chrome110")
    next_url = f"{p.scheme}://{p.hostname}/go/{id}"

    for _ in range(2):
        if res.headers.get("Location"):
            break
        bs4 = BeautifulSoup(res.content, "lxml")
        inputs = bs4.form.findAll("input", {"name": re.compile(r"token$")})
        data = {input.get("name"): input.get("value") for input in inputs}
        data["x-token"] = RecaptchaV3()
        header = {"content-type": "application/x-www-form-urlencoded"}
        res = client.post(
            next_url,
            data=data,
            headers=header,
            allow_redirects=False,
            impersonate="chrome110",
        )
        next_url = f"{p.scheme}://{p.hostname}/xreallcygo/{id}"

    return res.headers.get("Location")


####################################################################################################################
# mdisk


def mdisk(url):
    header = {
        "Accept": "*/*",
        "Accept-Language": "en-US,en;q=0.5",
        "Accept-Encoding": "gzip, deflate, br",
        "Referer": "https://mdisk.me/",
        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/93.0.4577.82 Safari/537.36",
    }

    inp = url
    fxl = inp.split("/")
    cid = fxl[-1]

    URL = f"https://diskuploader.entertainvideo.com/v1/file/cdnurl?param={cid}"
    res = requests.get(url=URL, headers=header).json()
    return res["download"] + "\n\n" + res["source"]


##################################################################################################################
# AppDrive or DriveApp etc. Look-Alike Link and as well as the Account Details (Required for Login Required Links only)


def unified(url):

    if ddl.is_share_link(url):
        if "https://gdtot" in url:
            return ddl.gdtot(url)
        else:
            return ddl.sharer_scraper(url)

    try:
        Email = "chzeesha4@gmail.com"
        Password = "zeeshi#789"

        account = {"email": Email, "passwd": Password}
        client = cloudscraper.create_scraper(allow_brotli=False)
        client.headers.update(
            {
                "user-agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/97.0.4692.99 Safari/537.36"
            }
        )
        data = {"email": account["email"], "password": account["passwd"]}
        client.post(f"https://{urlparse(url).netloc}/login", data=data)
        res = client.get(url)
        key = re.findall('"key",\s+"(.*?)"', res.text)[0]
        ddl_btn = etree.HTML(res.content).xpath("//button[@id='drc']")
        info = re.findall(">(.*?)<\/li>", res.text)
        info_parsed = {}
        for item in info:
            kv = [s.strip() for s in item.split(": ", maxsplit=1)]
            info_parsed[kv[0].lower()] = kv[1]
        info_parsed = info_parsed
        info_parsed["error"] = False
        info_parsed["link_type"] = "login"
        headers = {
            "Content-Type": f"multipart/form-data; boundary={'-'*4}_",
        }
        data = {"type": 1, "key": key, "action": "original"}
        if len(ddl_btn):
            info_parsed["link_type"] = "direct"
            data["action"] = "direct"
        while data["type"] <= 3:
            boundary = f'{"-"*6}_'
            data_string = ""
            for item in data:
                data_string += f"{boundary}\r\n"
                data_string += f'Content-Disposition: form-data; name="{item}"\r\n\r\n{data[item]}\r\n'
            data_string += f"{boundary}--\r\n"
            gen_payload = data_string
            try:
                response = client.post(url, data=gen_payload, headers=headers).json()
                break
            except BaseException:
                data["type"] += 1
        if "url" in response:
            info_parsed["gdrive_link"] = response["url"]
        elif "error" in response and response["error"]:
            info_parsed["error"] = True
            info_parsed["error_message"] = response["message"]
        else:
            info_parsed["error"] = True
            info_parsed["error_message"] = "Something went wrong :("
        if info_parsed["error"]:
            return info_parsed
        if "driveapp" in urlparse(url).netloc and not info_parsed["error"]:
            res = client.get(info_parsed["gdrive_link"])
            drive_link = etree.HTML(res.content).xpath(
                "//a[contains(@class,'btn')]/@href"
            )[0]
            info_parsed["gdrive_link"] = drive_link
        info_parsed["src_url"] = url
        if "drivehub" in urlparse(url).netloc and not info_parsed["error"]:
            res = client.get(info_parsed["gdrive_link"])
            drive_link = etree.HTML(res.content).xpath(
                "//a[contains(@class,'btn')]/@href"
            )[0]
            info_parsed["gdrive_link"] = drive_link
        if "gdflix" in urlparse(url).netloc and not info_parsed["error"]:
            res = client.get(info_parsed["gdrive_link"])
            drive_link = etree.HTML(res.content).xpath(
                "//a[contains(@class,'btn')]/@href"
            )[0]
            info_parsed["gdrive_link"] = drive_link

        if "drivesharer" in urlparse(url).netloc and not info_parsed["error"]:
            res = client.get(info_parsed["gdrive_link"])
            drive_link = etree.HTML(res.content).xpath(
                "//a[contains(@class,'btn')]/@href"
            )[0]
            info_parsed["gdrive_link"] = drive_link
        if "drivebit" in urlparse(url).netloc and not info_parsed["error"]:
            res = client.get(info_parsed["gdrive_link"])
            drive_link = etree.HTML(res.content).xpath(
                "//a[contains(@class,'btn')]/@href"
            )[0]
            info_parsed["gdrive_link"] = drive_link
        if "drivelinks" in urlparse(url).netloc and not info_parsed["error"]:
            res = client.get(info_parsed["gdrive_link"])
            drive_link = etree.HTML(res.content).xpath(
                "//a[contains(@class,'btn')]/@href"
            )[0]
            info_parsed["gdrive_link"] = drive_link
        if "driveace" in urlparse(url).netloc and not info_parsed["error"]:
            res = client.get(info_parsed["gdrive_link"])
            drive_link = etree.HTML(res.content).xpath(
                "//a[contains(@class,'btn')]/@href"
            )[0]
            info_parsed["gdrive_link"] = drive_link
        if "drivepro" in urlparse(url).netloc and not info_parsed["error"]:
            res = client.get(info_parsed["gdrive_link"])
            drive_link = etree.HTML(res.content).xpath(
                "//a[contains(@class,'btn')]/@href"
            )[0]
            info_parsed["gdrive_link"] = drive_link
        if info_parsed["error"]:
            return "Faced an Unknown Error!"
        return info_parsed["gdrive_link"]
    except BaseException:
        return "Unable to Extract GDrive Link"


#####################################################################################################
# urls open


def urlsopen(url):
    client = cloudscraper.create_scraper(allow_brotli=False)
    DOMAIN = "https://blogpost.viewboonposts.com/e998933f1f665f5e75f2d1ae0009e0063ed66f889000"
    url = url[:-1] if url[-1] == "/" else url
    code = url.split("/")[-1]
    final_url = f"{DOMAIN}/{code}"
    ref = "https://blog.textpage.xyz/"
    h = {"referer": ref}
    resp = client.get(final_url, headers=h)
    soup = BeautifulSoup(resp.content, "html.parser")
    inputs = soup.find_all("input")
    data = {input.get("name"): input.get("value") for input in inputs}
    h = {"x-requested-with": "XMLHttpRequest"}
    time.sleep(2)
    r = client.post(f"{DOMAIN}/links/go", data=data, headers=h)
    try:
        return r.json()["url"]
    except:
        return "Something went wrong :("


####################################################################################################
# URLShortX - xpshort


def xpshort(url):
    client = cloudscraper.create_scraper(allow_brotli=False)
    DOMAIN = "https://xpshort.com"
    url = url[:-1] if url[-1] == "/" else url
    code = url.split("/")[-1]
    final_url = f"{DOMAIN}/{code}"
    ref = "https://www.animalwallpapers.online/"
    h = {"referer": ref}
    resp = client.get(final_url, headers=h)
    soup = BeautifulSoup(resp.content, "html.parser")
    inputs = soup.find_all("input")
    data = {input.get("name"): input.get("value") for input in inputs}
    h = {"x-requested-with": "XMLHttpRequest"}
    time.sleep(8)
    r = client.post(f"{DOMAIN}/links/go", data=data, headers=h)
    try:
        return r.json()["url"]
    except:
        return "Something went wrong :("


####################################################################################################
# Vnshortner-


def vnshortener(url):
    sess = requests.session()
    DOMAIN = "https://vnshortener.com/"
    org = "https://nishankhatri.xyz"
    PhpAcc = DOMAIN + "link/new.php"
    ref = "https://nishankhatri.com.np/"
    go = DOMAIN + "links/go"

    code = url.split("/")[3]
    final_url = f"{DOMAIN}/{code}/"
    headers = {"authority": DOMAIN, "origin": org}

    data = {
        "step_1": code,
    }
    response = sess.post(PhpAcc, headers=headers, data=data).json()
    id = response["inserted_data"]["id"]
    data = {
        "step_2": code,
        "id": id,
    }
    response = sess.post(PhpAcc, headers=headers, data=data).json()

    headers["referer"] = ref
    params = {"sid": str(id)}
    resp = sess.get(final_url, params=params, headers=headers)
    soup = BeautifulSoup(resp.content, "html.parser")
    inputs = soup.find_all("input")
    data = {input.get("name"): input.get("value") for input in inputs}

    time.sleep(1)
    headers["x-requested-with"] = "XMLHttpRequest"
    try:
        r = sess.post(go, data=data, headers=headers).json()
        if r["status"] == "success":
            return r["url"]
        else:
            raise
    except:
        return "Something went wrong :("


#####################################################################################################
# onepagelink


def onepagelink(url):
    client = cloudscraper.create_scraper(allow_brotli=False)
    DOMAIN = "go.onepagelink.in"
    url = url[:-1] if url[-1] == "/" else url
    code = url.split("/")[-1]
    final_url = f"https://{DOMAIN}/{code}"
    ref = "https://gorating.in/"
    h = {"referer": ref}
    response = client.get(final_url, headers=h)
    soup = BeautifulSoup(response.text, "html.parser")
    inputs = soup.find_all("input")
    data = {input.get("name"): input.get("value") for input in inputs}
    h = {"x-requested-with": "XMLHttpRequest"}
    time.sleep(5)
    r = client.post(f"https://{DOMAIN}/links/go", data=data, headers=h)
    try:
        return r.json()["url"]
    except BaseException:
        return "Something went wrong :("


#####################################################################################################
# dulink


def dulink(url):
    client = cloudscraper.create_scraper(allow_brotli=False)
    DOMAIN = "https://du-link.in"
    url = url[:-1] if url[-1] == "/" else url
    ref = "https://profitshort.com/"
    h = {"referer": ref}
    resp = client.get(url, headers=h)
    soup = BeautifulSoup(resp.content, "html.parser")
    inputs = soup.find_all("input")
    data = {input.get("name"): input.get("value") for input in inputs}
    h = {"x-requested-with": "XMLHttpRequest"}
    r = client.post(f"{DOMAIN}/links/go", data=data, headers=h)
    try:
        return r.json()["url"]
    except:
        return "Something went wrong :("


#####################################################################################################
# krownlinks


def krownlinks(url):
    client = cloudscraper.create_scraper(allow_brotli=False)
    DOMAIN = "https://go.bloggerishyt.in/"
    url = url[:-1] if url[-1] == "/" else url
    code = url.split("/")[-1]
    final_url = f"{DOMAIN}/{code}"
    ref = "https://www.techkhulasha.com/"
    h = {"referer": ref}
    resp = client.get(final_url, headers=h)
    soup = BeautifulSoup(resp.content, "html.parser")
    inputs = soup.find_all("input")
    data = {input.get("name"): input.get("value") for input in inputs}
    h = {"x-requested-with": "XMLHttpRequest"}
    time.sleep(8)
    r = client.post(f"{DOMAIN}/links/go", data=data, headers=h)
    try:
        return str(r.json()["url"])
    except BaseException:
        return "Something went wrong :("


####################################################################################################
# adrinolink


def adrinolink(url):
    if "https://adrinolinks.in/" not in url:
        url = "https://adrinolinks.in/" + url.split("/")[-1]
    client = cloudscraper.create_scraper(allow_brotli=False)
    DOMAIN = "https://adrinolinks.in"
    ref = "https://wikitraveltips.com/"
    h = {"referer": ref}
    resp = client.get(url, headers=h)
    soup = BeautifulSoup(resp.content, "html.parser")
    inputs = soup.find_all("input")
    data = {input.get("name"): input.get("value") for input in inputs}
    h = {"x-requested-with": "XMLHttpRequest"}
    time.sleep(8)
    r = client.post(f"{DOMAIN}/links/go", data=data, headers=h)
    try:
        return r.json()["url"]
    except:
        return "Something went wrong :("


#####################################################################################################
# mdiskshortners


def mdiskshortners(url):
    client = cloudscraper.create_scraper(allow_brotli=False)
    DOMAIN = "https://mdiskshortners.in/"
    url = url[:-1] if url[-1] == "/" else url
    code = url.split("/")[-1]
    final_url = f"{DOMAIN}/{code}"
    ref = "https://www.adzz.in/"
    h = {"referer": ref}
    resp = client.get(final_url, headers=h)
    soup = BeautifulSoup(resp.content, "html.parser")
    inputs = soup.find_all("input")
    data = {input.get("name"): input.get("value") for input in inputs}
    h = {"x-requested-with": "XMLHttpRequest"}
    time.sleep(2)
    r = client.post(f"{DOMAIN}/links/go", data=data, headers=h)
    try:
        return r.json()["url"]
    except:
        return "Something went wrong :("


#####################################################################################################
# tinyfy


def tiny(url):
    client = requests.session()
    DOMAIN = "https://tinyfy.in"
    url = url[:-1] if url[-1] == "/" else url
    code = url.split("/")[-1]
    final_url = f"{DOMAIN}/{code}"
    ref = "https://www.yotrickslog.tech/"
    h = {"referer": ref}
    resp = client.get(final_url, headers=h)
    soup = BeautifulSoup(resp.content, "html.parser")
    inputs = soup.find_all("input")
    data = {input.get("name"): input.get("value") for input in inputs}
    h = {"x-requested-with": "XMLHttpRequest"}
    r = client.post(f"{DOMAIN}/links/go", data=data, headers=h)
    try:
        return r.json()["url"]
    except:
        return "Something went wrong :("


#####################################################################################################
# earnl


def earnl(url):
    client = requests.session()
    DOMAIN = "https://v.earnl.xyz"
    url = url[:-1] if url[-1] == "/" else url
    code = url.split("/")[-1]
    final_url = f"{DOMAIN}/{code}"
    ref = "https://link.modmakers.xyz/"
    h = {"referer": ref}
    resp = client.get(final_url, headers=h)
    soup = BeautifulSoup(resp.content, "html.parser")
    inputs = soup.find_all("input")
    data = {input.get("name"): input.get("value") for input in inputs}
    h = {"x-requested-with": "XMLHttpRequest"}
    time.sleep(5)
    r = client.post(f"{DOMAIN}/links/go", data=data, headers=h)
    try:
        return r.json()["url"]
    except:
        return "Something went wrong :("


#####################################################################################################
# moneykamalo


def moneykamalo(url):
    client = requests.session()
    DOMAIN = "https://go.moneykamalo.com"
    url = url[:-1] if url[-1] == "/" else url
    code = url.split("/")[-1]
    final_url = f"{DOMAIN}/{code}"
    ref = "https://bloging.techkeshri.com/"
    h = {"referer": ref}
    resp = client.get(final_url, headers=h)
    soup = BeautifulSoup(resp.content, "html.parser")
    inputs = soup.find_all("input")
    data = {input.get("name"): input.get("value") for input in inputs}
    h = {"x-requested-with": "XMLHttpRequest"}
    time.sleep(5)
    r = client.post(f"{DOMAIN}/links/go", data=data, headers=h)
    try:
        return r.json()["url"]
    except:
        return "Something went wrong :("


#####################################################################################################
# lolshort


def lolshort(url):
    client = requests.session()
    DOMAIN = "https://get.lolshort.tech/"
    url = url[:-1] if url[-1] == "/" else url
    code = url.split("/")[-1]
    final_url = f"{DOMAIN}/{code}"
    ref = "https://tech.animezia.com/"
    h = {"referer": ref}
    resp = client.get(final_url, headers=h)
    soup = BeautifulSoup(resp.content, "html.parser")
    inputs = soup.find_all("input")
    data = {input.get("name"): input.get("value") for input in inputs}
    h = {"x-requested-with": "XMLHttpRequest"}
    time.sleep(5)
    r = client.post(f"{DOMAIN}/links/go", data=data, headers=h)
    try:
        return r.json()["url"]
    except:
        return "Something went wrong :("


#####################################################################################################
# easysky


def easysky(url):
    client = cloudscraper.create_scraper(allow_brotli=False)
    DOMAIN = "https://techy.veganab.co/"
    url = url[:-1] if url[-1] == "/" else url
    code = url.split("/")[-1]
    final_url = f"{DOMAIN}/{code}"
    ref = "https://veganab.co/"
    h = {"referer": ref}
    resp = client.get(final_url, headers=h)
    soup = BeautifulSoup(resp.content, "html.parser")
    inputs = soup.find_all("input")
    data = {input.get("name"): input.get("value") for input in inputs}
    h = {"x-requested-with": "XMLHttpRequest"}
    time.sleep(8)
    r = client.post(f"{DOMAIN}/links/go", data=data, headers=h)
    try:
        return r.json()["url"]
    except:
        return "Something went wrong :("


#####################################################################################################
# indiurl


def indi(url):
    client = requests.session()
    DOMAIN = "https://file.earnash.com/"
    url = url[:-1] if url[-1] == "/" else url
    code = url.split("/")[-1]
    final_url = f"{DOMAIN}/{code}"
    ref = "https://indiurl.cordtpoint.co.in/"
    h = {"referer": ref}
    resp = client.get(final_url, headers=h)
    soup = BeautifulSoup(resp.content, "html.parser")
    inputs = soup.find_all("input")
    data = {input.get("name"): input.get("value") for input in inputs}
    h = {"x-requested-with": "XMLHttpRequest"}
    time.sleep(10)
    r = client.post(f"{DOMAIN}/links/go", data=data, headers=h)
    try:
        return r.json()["url"]
    except:
        return "Something went wrong :("


#####################################################################################################
# linkbnao


def linkbnao(url):
    client = cloudscraper.create_scraper(allow_brotli=False)
    DOMAIN = "https://vip.linkbnao.com"
    url = url[:-1] if url[-1] == "/" else url
    code = url.split("/")[-1]
    final_url = f"{DOMAIN}/{code}"
    ref = "https://ffworld.xyz/"
    h = {"referer": ref}
    resp = client.get(final_url, headers=h)
    soup = BeautifulSoup(resp.content, "html.parser")
    inputs = soup.find_all("input")
    data = {input.get("name"): input.get("value") for input in inputs}
    h = {"x-requested-with": "XMLHttpRequest"}
    time.sleep(2)
    r = client.post(f"{DOMAIN}/links/go", data=data, headers=h)
    try:
        return r.json()["url"]
    except:
        return "Something went wrong :("


#####################################################################################################
# omegalinks


def mdiskpro(url):
    client = cloudscraper.create_scraper(allow_brotli=False)
    DOMAIN = "https://mdisk.pro"
    ref = "https://m.meclipstudy.in/"
    h = {"referer": ref}
    resp = client.get(url, headers=h)
    soup = BeautifulSoup(resp.content, "html.parser")
    inputs = soup.find_all("input")
    data = {input.get("name"): input.get("value") for input in inputs}
    h = {"x-requested-with": "XMLHttpRequest"}
    time.sleep(8)
    r = client.post(f"{DOMAIN}/links/go", data=data, headers=h)
    try:
        return r.json()["url"]
    except:
        return "Something went wrong :("


#####################################################################################################
# tnshort


def tnshort(url):
    client = cloudscraper.create_scraper(allow_brotli=False)
    DOMAIN = "https://news.sagenews.in/"
    url = url[:-1] if url[-1] == "/" else url
    code = url.split("/")[-1]
    final_url = f"{DOMAIN}/{code}"
    ref = "https://movies.djnonstopmusic.in/"
    h = {"referer": ref}
    resp = client.get(final_url, headers=h)
    soup = BeautifulSoup(resp.content, "html.parser")
    inputs = soup.find_all("input")
    data = {input.get("name"): input.get("value") for input in inputs}
    h = {"x-requested-with": "XMLHttpRequest"}
    time.sleep(8)
    r = client.post(f"{DOMAIN}/links/go", data=data, headers=h)
    try:
        return str(r.json()["url"])
    except BaseException:
        return "Something went wrong :("


#####################################################################################################
# tnvalue


def tnvalue(url):
    client = cloudscraper.create_scraper(allow_brotli=False)
    DOMAIN = "https://gadgets.webhostingtips.club/"
    url = url[:-1] if url[-1] == "/" else url
    code = url.split("/")[-1]
    final_url = f"{DOMAIN}/{code}"
    ref = "https://ladkibahin.com/"
    h = {"referer": ref}
    resp = client.get(final_url, headers=h)
    soup = BeautifulSoup(resp.content, "html.parser")
    inputs = soup.find_all("input")
    data = {input.get("name"): input.get("value") for input in inputs}
    h = {"x-requested-with": "XMLHttpRequest"}
    time.sleep(12)
    r = client.post(f"{DOMAIN}/links/go", data=data, headers=h)
    try:
        return str(r.json()["url"])
    except BaseException:
        return "Something went wrong :("


#####################################################################################################
# indianshortner


def indshort(url):
    client = cloudscraper.create_scraper(allow_brotli=False)
    DOMAIN = "https://indianshortner.com/"
    url = url[:-1] if url[-1] == "/" else url
    code = url.split("/")[-1]
    final_url = f"{DOMAIN}/{code}"
    ref = "https://moddingzone.in/"
    h = {"referer": ref}
    resp = client.get(final_url, headers=h)
    soup = BeautifulSoup(resp.content, "html.parser")
    inputs = soup.find_all("input")
    data = {input.get("name"): input.get("value") for input in inputs}
    h = {"x-requested-with": "XMLHttpRequest"}
    time.sleep(5)
    r = client.post(f"{DOMAIN}/links/go", data=data, headers=h)
    try:
        return r.json()["url"]
    except:
        return "Something went wrong :("


#####################################################################################################
# mdisklink


def mdisklink(url):
    client = cloudscraper.create_scraper(allow_brotli=False)
    DOMAIN = "https://mdisklink.link/"
    url = url[:-1] if url[-1] == "/" else url
    code = url.split("/")[-1]
    final_url = f"{DOMAIN}/{code}"
    ref = "https://m.proappapk.com/"
    h = {"referer": ref}
    resp = client.get(final_url, headers=h)
    soup = BeautifulSoup(resp.content, "html.parser")
    inputs = soup.find_all("input")
    data = {input.get("name"): input.get("value") for input in inputs}
    h = {"x-requested-with": "XMLHttpRequest"}
    time.sleep(2)
    r = client.post(f"{DOMAIN}/links/go", data=data, headers=h)
    try:
        return r.json()["url"]
    except:
        return "Something went wrong :("


#####################################################################################################
# rslinks


def rslinks(url):
    client = requests.session()
    download = requests.get(url, stream=True, allow_redirects=False)
    v = download.headers["location"]
    code = v.split("ms9")[-1]
    final = f"http://techyproio.blogspot.com/p/short.html?{code}=="
    try:
        return final
    except:
        return "Something went wrong :("


#########################
# vipurl
def vipurl(url):
    client = cloudscraper.create_scraper(allow_brotli=False)
    DOMAIN = "https://count.vipurl.in/"
    url = url[:-1] if url[-1] == "/" else url
    code = url.split("/")[-1]
    final_url = f"{DOMAIN}/{code}"
    ref = "https://ezeviral.com/"
    h = {"referer": ref}
    response = client.get(final_url, headers=h)
    soup = BeautifulSoup(response.text, "html.parser")
    inputs = soup.find_all("input")
    data = {input.get("name"): input.get("value") for input in inputs}
    h = {"x-requested-with": "XMLHttpRequest"}
    time.sleep(9)
    r = client.post(f"{DOMAIN}/links/go", data=data, headers=h)
    try:
        return r.json()["url"]
    except BaseException:
        return "Something went wrong :("


#####################################################################################################
# mdisky.link
def mdisky(url):
    client = cloudscraper.create_scraper(allow_brotli=False)
    DOMAIN = "https://go.bloggingaro.com/"
    url = url[:-1] if url[-1] == "/" else url
    code = url.split("/")[-1]
    final_url = f"{DOMAIN}/{code}"
    ref = "https://www.bloggingaro.com/"
    h = {"referer": ref}
    resp = client.get(final_url, headers=h)
    soup = BeautifulSoup(resp.content, "html.parser")
    inputs = soup.find_all("input")
    data = {input.get("name"): input.get("value") for input in inputs}
    h = {"x-requested-with": "XMLHttpRequest"}
    time.sleep(6)
    r = client.post(f"{DOMAIN}/links/go", data=data, headers=h)
    try:
        return str(r.json()["url"])
    except BaseException:
        return "Something went wrong :("


#####################################################################################################
# bitly + tinyurl


def bitly_tinyurl(url: str) -> str:
    response = requests.get(url).url
    try:
        return response
    except:
        return "Something went wrong :("


#####################################################################################################
# thinfi


def thinfi(url: str) -> str:
    response = requests.get(url)
    soup = BeautifulSoup(response.content, "html.parser").p.a.get("href")
    try:
        return soup
    except:
        return "Something went wrong :("


#####################################################################################################
# kingurl


def kingurl1(url):
    client = cloudscraper.create_scraper(allow_brotli=False)
    DOMAIN = "https://go.kingurl.in/"
    url = url[:-1] if url[-1] == "/" else url
    code = url.split("/")[-1]
    final_url = f"{DOMAIN}/{code}"
    ref = "https://earnbox.bankshiksha.in/"
    h = {"referer": ref}
    resp = client.get(final_url, headers=h)
    soup = BeautifulSoup(resp.content, "html.parser")
    inputs = soup.find_all("input")
    data = {input.get("name"): input.get("value") for input in inputs}
    h = {"x-requested-with": "XMLHttpRequest"}
    time.sleep(7)
    r = client.post(f"{DOMAIN}/links/go", data=data, headers=h)
    try:
        return str(r.json()["url"])
    except BaseException:
        return "Something went wrong :("


def kingurl(url):
    DOMAIN = "https://earn.bankshiksha.in/click.php?LinkShortUrlID"
    url = url[:-1] if url[-1] == "/" else url
    code = url.split("/")[-1]
    final_url = f"{DOMAIN}={code}"
    return final_url
#####################################################################################################
# helpers


# check if present in list
def ispresent(inlist, url):
    for ele in inlist:
        if ele in url:
            return True
    return False


# shortners
def shortners(url):
    # Shortner Full Page API
    if val := shortner_fpage_api(url):
        return val

    # Shortner Quick Link API
    elif val := shortner_quick_api(url):
        return val

    # igg games
    elif "https://igg-games.com/" in url:
        print("entered igg: ", url)
        return igggames(url)

    # ola movies
    elif "https://olamovies." in url:
        print("entered ola movies: ", url)
        return olamovies(url)

    # katdrive
    elif "https://katdrive." in url:
        if KATCRYPT == "":
            return "🚫 __You can't use this because__ **KATDRIVE_CRYPT** __ENV is not set__"

        print("entered katdrive: ", url)
        return katdrive_dl(url, KATCRYPT)

    # kolop
    elif "https://kolop." in url:
        if KCRYPT == "":
            return (
                "🚫 __You can't use this because__ **KOLOP_CRYPT** __ENV is not set__"
            )

        print("entered kolop: ", url)
        return kolop_dl(url, KCRYPT)

    # hubdrive
    elif "https://hubdrive." in url:
        if HCRYPT == "":
            return "🚫 __You can't use this because__ **HUBDRIVE_CRYPT** __ENV is not set__"

        print("entered hubdrive: ", url)
        return hubdrive_dl(url, HCRYPT)

    # drivefire
    elif "https://drivefire." in url:
        if DCRYPT == "":
            return "🚫 __You can't use this because__ **DRIVEFIRE_CRYPT** __ENV is not set__"

        print("entered drivefire: ", url)
        return drivefire_dl(url, DCRYPT)

    # filecrypt
    elif ("https://filecrypt.co/") in url or ("https://filecrypt.cc/" in url):
        print("entered filecrypt: ", url)
        return filecrypt(url)

    # shareus
    elif "https://shareus." in url or "https://shrs.link/" in url:
        print("entered shareus: ", url)
        return shareus(url)

    # shortingly
    elif "https://shortingly.in/" in url:
        print("entered shortingly: ", url)
        return shortingly(url)

    # vnshortner
    elif "https://vnshortener.com/" in url:
        print("entered vnshortener: ", url)
        return vnshortener(url)

    # onepagelink
    elif "https://onepagelink.in/" in url:
        print("entered onepagelink: ", url)
        return onepagelink(url)

    # gyanilinks
    elif "https://gyanilinks.com/" in url or "https://gtlinks.me/" in url:
        print("entered gyanilinks: ", url)
        return gyanilinks(url)

    # flashlink
    elif "https://go.flashlink.in" in url:
        print("entered flashlink: ", url)
        return flashl(url)

    # short2url
    elif "https://short2url.in/" in url:
        print("entered short2url: ", url)
        return short2url(url)

    # shorte
    elif "https://shorte.st/" in url:
        print("entered shorte: ", url)
        return sh_st_bypass(url)

    # psa
    elif "https://psa.wf/" in url:
        print("entered psa: ", url)
        return psa_bypasser(url)

    # sharer pw
    elif "https://sharer.pw/" in url:
        if XSRF_TOKEN == "" or Laravel_Session == "":
            return "🚫 __You can't use this because__ **XSRF_TOKEN** __and__ **Laravel_Session** __ENV is not set__"

        print("entered sharer: ", url)
        return sharer_pw(url, Laravel_Session, XSRF_TOKEN)

    # gdtot url
    elif "gdtot.cfd" in url:
        print("entered gdtot: ", url)
        return gdtot(url)

    # adfly
    elif "https://adf.ly/" in url:
        print("entered adfly: ", url)
        out = adfly(url)
        return out["bypassed_url"]

    # gplinks
    elif "https://gplinks.co/" in url:
        print("entered gplink: ", url)
        return gplinks(url)

    # droplink
    elif "https://droplink.co/" in url:
        print("entered droplink: ", url)
        return droplink(url)

    # linkvertise
    elif "https://linkvertise.com/" in url:
        print("entered linkvertise: ", url)
        return linkvertise(url)

    # rocklinks
    elif "https://rocklinks.net/" in url:
        print("entered rocklinks: ", url)
        return rocklinks(url)

    # ouo
    elif "https://ouo.press/" in url or "https://ouo.io/" in url:
        print("entered ouo: ", url)
        return ouo(url)

    # try2link
    elif "https://try2link.com/" in url:
        print("entered try2links: ", url)
        return try2link_bypass(url)

    # urlsopen
    elif "https://urlsopen." in url:
        print("entered urlsopen: ", url)
        return urlsopen(url)

    # xpshort
    elif (
        "https://xpshort.com/" in url
        or "https://push.bdnewsx.com/" in url
        or "https://techymozo.com/" in url
    ):
        print("entered xpshort: ", url)
        return xpshort(url)

    # dulink
    elif "https://du-link.in/" in url:
        print("entered dulink: ", url)
        return dulink(url)

    # ez4short
    elif "https://ez4short.com/" in url:
        print("entered ez4short: ", url)
        return ez4(url)

    # krownlinks
    elif "https://krownlinks.me/" in url:
        print("entered krownlinks: ", url)
        return krownlinks(url)

    # adrinolink
    elif "https://adrinolinks." in url:
        print("entered adrinolink: ", url)
        return adrinolink(url)

    # tnlink
    elif "https://link.tnlink.in/" in url:
        print("entered tnlink: ", url)
        return tnlink(url)

    # mdiskshortners
    elif "https://mdiskshortners.in/" in url:
        print("entered mdiskshortners: ", url)
        return mdiskshortners(url)

    # tinyfy
    elif "tinyfy.in" in url:
        print("entered tinyfy: ", url)
        return tiny(url)

    # earnl
    elif "go.earnl.xyz" in url:
        print("entered earnl: ", url)
        return earnl(url)

    # moneykamalo
    elif "earn.moneykamalo.com" in url:
        print("entered moneykamalo: ", url)
        return moneykamalo(url)

    # lolshort
    elif "http://go.lolshort.tech/" in url or "https://go.lolshort.tech/" in url:
        print("entered lolshort: ", url)
        return lolshort(url)

    # easysky
    elif "m.easysky.in" in url:
        print("entered easysky: ", url)
        return easysky(url)

    # indiurl
    elif "go.indiurl.in.net" in url:
        print("entered indiurl: ", url)
        return indi(url)

    # linkbnao
    elif "linkbnao.com" in url:
        print("entered linkbnao: ", url)
        return linkbnao(url)

    # omegalinks
    elif "mdisk.pro" in url:
        print("entered mdiskpro: ", url)
        return mdiskpro(url)

    # tnshort
    elif "https://link.tnshort.net/" in url or "https://tnseries.com/" in url or "https://link.tnseries.com/" in url:
        print("entered tnshort:", url)
        return tnshort(url)

    # tnvalue
    elif (
        "https://link.tnvalue.in/" in url
        or "https://short.tnvalue.in/" in url
        or "https://page.finclub.in/" in url
    ):
        print("entered tnvalue:", url)
        return tnvalue(url)

    # indianshortner
    elif "indianshortner.in" in url:
        print("entered indianshortner: ", url)
        return indshort(url)

    # mdisklink
    elif "mdisklink.link" in url:
        print("entered mdisklink: ", url)
        return mdisklink(url)

    # rslinks
    elif "rslinks.net" in url:
        print("entered rslinks: ", url)
        return rslinks(url)

    # bitly + tinyurl
    elif "bit.ly" in url or "tinyurl.com" in url:
        print("entered bitly_tinyurl: ", url)
        return bitly_tinyurl(url)

    # pdisk
    elif "pdisk.pro" in url:
        print("entered pdisk: ", url)
        return pdisk(url)

    # thinfi
    elif "thinfi.com" in url:
        print("entered thinfi: ", url)
        return thinfi(url)

    # vipurl
    elif "link.vipurl.in" in url or "count.vipurl.in" in url or "vipurl.in" in url:
        print("entered vipurl:", url)
        return vipurl(url)

    # mdisky
    elif "mdisky.link" in url:
        print("entered mdisky:", url)
        return mdisky(url)

    # kingurl
    elif "https://kingurl.in/" in url:
        print("entered kingurl:", url)
        return kingurl(url)

    # htpmovies sharespark cinevood
    elif (
        "https://htpmovies." in url
        or "https://sharespark.me/" in url
        or "https://cinevood." in url
        or "https://atishmkv." in url
        or "https://teluguflix" in url
        or "https://taemovies" in url
        or "https://toonworld4all" in url
        or "https://animeremux" in url
    ):
        print("entered htpmovies sharespark cinevood atishmkv: ", url)
        return scrappers(url)

    # gdrive look alike
    elif ispresent(gdlist, url):
        print("entered gdrive look alike: ", url)
        return unified(url)

    # others
    elif ispresent(otherslist, url):
        print("entered others: ", url)
        return others(url)

    # else
    else:
        print("entered: ", url)
        return "Not in Supported Sites"


################################################################################################################################


================================================
FILE: config.json
================================================
{
    "TOKEN": "",
    "ID": "",
    "HASH": "",
    "Laravel_Session": "",
    "XSRF_TOKEN": "",
    "GDTot_Crypt": "",
    "DCRYPT": "",
    "KCRYPT": "",
    "HCRYPT": "",
    "KATCRYPT": "",
    "UPTOBOX_TOKEN": "",
    "TERA_COOKIE": "",
    "CLOUDFLARE": "",
    "PORT": 5000,
    "DB_API": "",
    "DB_OWNER": "bipinkrish",
    "DB_NAME": "link_bypass.db"
}

================================================
FILE: db.py
================================================
import requests
import base64

class DB:
    def __init__(self, api_key, db_owner, db_name) -> None:
        self.api_key = api_key
        self.db_owner = db_owner
        self.db_name = db_name
        self.url = "https://api.dbhub.io/v1/tables"
        self.data = {
            "apikey": self.api_key,
            "dbowner": self.db_owner,
            "dbname": self.db_name
        }

        response = requests.post(self.url, data=self.data)
        if response.status_code == 200:
            if "results" not in response.json():
                raise Exception("Error, Table not found")
        else:
            raise Exception("Error in Auth")

    def insert(self, link: str, result: str):
        url = "https://api.dbhub.io/v1/execute"
        sql_insert = f"INSERT INTO results (link, result) VALUES ('{link}', '{result}')"
        encoded_sql = base64.b64encode(sql_insert.encode()).decode()
        self.data["sql"] = encoded_sql
        response = requests.post(url, data=self.data)
        if response.status_code == 200:
            if response.json()["status"] != "OK":
                raise Exception("Error while inserting")
            return True
        else:
            print(response.json())
            return None
    
    def find(self, link: str):
        url = "https://api.dbhub.io/v1/query"
        sql_select = f"SELECT result FROM results WHERE link = '{link}'"
        encoded_sql = base64.b64encode(sql_select.encode()).decode()
        self.data["sql"] = encoded_sql
        response = requests.post(url, data=self.data)
        if response.status_code == 200:
            try: return response.json()[0][0]["Value"]
            except: return None
        else:
            print(response.json())
            return None


================================================
FILE: ddl.py
================================================
from base64 import standard_b64encode
from json import loads
from math import floor, pow
from re import findall, match, search, sub
from time import sleep
from urllib.parse import quote, unquote, urlparse
from uuid import uuid4

from bs4 import BeautifulSoup
from cfscrape import create_scraper
from lxml import etree
from requests import get, session

from json import load
from os import environ

with open("config.json", "r") as f:
    DATA = load(f)


def getenv(var):
    return environ.get(var) or DATA.get(var, None)


UPTOBOX_TOKEN = getenv("UPTOBOX_TOKEN")
ndus = getenv("TERA_COOKIE")
if ndus is None:
    TERA_COOKIE = None
else:
    TERA_COOKIE = {"ndus": ndus}


ddllist = [
    "1drv.ms",
    "1fichier.com",
    "4funbox",
    "akmfiles",
    "anonfiles.com",
    "antfiles.com",
    "bayfiles.com",
    "disk.yandex.com",
    "fcdn.stream",
    "femax20.com",
    "fembed.com",
    "fembed.net",
    "feurl.com",
    "filechan.org",
    "filepress",
    "github.com",
    "hotfile.io",
    "hxfile.co",
    "krakenfiles.com",
    "layarkacaxxi.icu",
    "letsupload.cc",
    "letsupload.io",
    "linkbox",
    "lolabits.se",
    "mdisk.me",
    "mediafire.com",
    "megaupload.nz",
    "mirrobox",
    "mm9842.com",
    "momerybox",
    "myfile.is",
    "naniplay.com",
    "naniplay.nanime.biz",
    "naniplay.nanime.in",
    "nephobox",
    "openload.cc",
    "osdn.net",
    "pixeldrain.com",
    "racaty",
    "rapidshare.nu",
    "sbembed.com",
    "sbplay.org",
    "share-online.is",
    "shrdsk",
    "solidfiles.com",
    "streamsb.net",
    "streamtape",
    "terabox",
    "teraboxapp",
    "upload.ee",
    "uptobox.com",
    "upvid.cc",
    "vshare.is",
    "watchsb.com",
    "we.tl",
    "wetransfer.com",
    "yadi.sk",
    "zippyshare.com",
]


def is_share_link(url):
    return bool(
        match(
            r"https?:\/\/.+\.gdtot\.\S+|https?:\/\/(filepress|filebee|appdrive|gdflix|driveseed)\.\S+",
            url,
        )
    )


def get_readable_time(seconds):
    result = ""
    (days, remainder) = divmod(seconds, 86400)
    days = int(days)
    if days != 0:
        result += f"{days}d"
    (hours, remainder) = divmod(remainder, 3600)
    hours = int(hours)
    if hours != 0:
        result += f"{hours}h"
    (minutes, seconds) = divmod(remainder, 60)
    minutes = int(minutes)
    if minutes != 0:
        result += f"{minutes}m"
    seconds = int(seconds)
    result += f"{seconds}s"
    return result


fmed_list = [
    "fembed.net",
    "fembed.com",
    "femax20.com",
    "fcdn.stream",
    "feurl.com",
    "layarkacaxxi.icu",
    "naniplay.nanime.in",
    "naniplay.nanime.biz",
    "naniplay.com",
    "mm9842.com",
]

anonfilesBaseSites = [
    "anonfiles.com",
    "hotfile.io",
    "bayfiles.com",
    "megaupload.nz",
    "letsupload.cc",
    "filechan.org",
    "myfile.is",
    "vshare.is",
    "rapidshare.nu",
    "lolabits.se",
    "openload.cc",
    "share-online.is",
    "upvid.cc",
]


def direct_link_generator(link: str):
    """direct links generator"""
    domain = urlparse(link).hostname
    if "yadi.sk" in domain or "disk.yandex.com" in domain:
        return yandex_disk(link)
    elif "mediafire.com" in domain:
        return mediafire(link)
    elif "uptobox.com" in domain:
        return uptobox(link)
    elif "osdn.net" in domain:
        return osdn(link)
    elif "github.com" in domain:
        return github(link)
    elif "hxfile.co" in domain:
        return hxfile(link)
    elif "1drv.ms" in domain:
        return onedrive(link)
    elif "pixeldrain.com" in domain:
        return pixeldrain(link)
    elif "antfiles.com" in domain:
        return antfiles(link)
    elif "streamtape" in domain:
        return streamtape(link)
    elif "racaty" in domain:
        return racaty(link)
    elif "1fichier.com" in domain:
        return fichier(link)
    elif "solidfiles.com" in domain:
        return solidfiles(link)
    elif "krakenfiles.com" in domain:
        return krakenfiles(link)
    elif "upload.ee" in domain:
        return uploadee(link)
    elif "akmfiles" in domain:
        return akmfiles(link)
    elif "linkbox" in domain:
        return linkbox(link)
    elif "shrdsk" in domain:
        return shrdsk(link)
    elif "letsupload.io" in domain:
        return letsupload(link)
    elif "zippyshare.com" in domain:
        return zippyshare(link)
    elif "mdisk.me" in domain:
        return mdisk(link)
    elif any(x in domain for x in ["wetransfer.com", "we.tl"]):
        return wetransfer(link)
    elif any(x in domain for x in anonfilesBaseSites):
        return anonfilesBased(link)
    elif any(
        x in domain
        for x in [
            "terabox",
            "nephobox",
            "4funbox",
            "mirrobox",
            "momerybox",
            "teraboxapp",
        ]
    ):
        return terabox(link)
    elif any(x in domain for x in fmed_list):
        return fembed(link)
    elif any(
        x in domain
        for x in ["sbembed.com", "watchsb.com", "streamsb.net", "sbplay.org"]
    ):
        return sbembed(link)
    elif is_share_link(link):
        if "gdtot" in domain:
            return gdtot(link)
        elif "filepress" in domain:
            return filepress(link)
        else:
            return sharer_scraper(link)
    else:
        return f"No Direct link function found for\n\n{link}\n\nuse /ddllist"


def mdisk(url):
    header = {
        "Accept": "*/*",
        "Accept-Language": "en-US,en;q=0.5",
        "Accept-Encoding": "gzip, deflate, br",
        "Referer": "https://mdisk.me/",
        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/93.0.4577.82 Safari/537.36",
    }
    id = url.split("/")[-1]
    URL = f"https://diskuploader.entertainvideo.com/v1/file/cdnurl?param={id}"
    return get(url=URL, headers=header).json()["source"]


def yandex_disk(url: str) -> str:
    """Yandex.Disk direct link generator
    Based on https://github.com/wldhx/yadisk-direct"""
    try:
        link = findall(r"\b(https?://(yadi.sk|disk.yandex.com)\S+)", url)[0][0]
    except IndexError:
        return "No Yandex.Disk links found\n"
    api = "https://cloud-api.yandex.net/v1/disk/public/resources/download?public_key={}"
    cget = create_scraper().request
    try:
        return cget("get", api.format(link)).json()["href"]
    except KeyError:
        return "ERROR: File not found/Download limit reached"


def uptobox(url: str) -> str:
    """Uptobox direct link generator
    based on https://github.com/jovanzers/WinTenCermin and https://github.com/sinoobie/noobie-mirror
    """
    try:
        link = findall(r"\bhttps?://.*uptobox\.com\S+", url)[0]
    except IndexError:
        return "No Uptobox links found"
    link = findall(r"\bhttps?://.*\.uptobox\.com/dl\S+", url)
    if link:
        return link[0]
    cget = create_scraper().request
    try:
        file_id = findall(r"\bhttps?://.*uptobox\.com/(\w+)", url)[0]
        if UPTOBOX_TOKEN:
            file_link = f"https://uptobox.com/api/link?token={UPTOBOX_TOKEN}&file_code={file_id}"
        else:
            file_link = f"https://uptobox.com/api/link?file_code={file_id}"
        res = cget("get", file_link).json()
    except Exception as e:
        return f"ERROR: {e.__class__.__name__}"
    if res["statusCode"] == 0:
        return res["data"]["dlLink"]
    elif res["statusCode"] == 16:
        sleep(1)
        waiting_token = res["data"]["waitingToken"]
        sleep(res["data"]["waiting"])
    elif res["statusCode"] == 39:
        return f"ERROR: Uptobox is being limited please wait {get_readable_time(res['data']['waiting'])}"
    else:
        return f"ERROR: {res['message']}"
    try:
        res = cget("get", f"{file_link}&waitingToken={waiting_token}").json()
        return res["data"]["dlLink"]
    except Exception as e:
        return f"ERROR: {e.__class__.__name__}"


def mediafire(url: str) -> str:
    final_link = findall(r"https?:\/\/download\d+\.mediafire\.com\/\S+\/\S+\/\S+", url)
    if final_link:
        return final_link[0]
    cget = create_scraper().request
    try:
        url = cget("get", url).url
        page = cget("get", url).text
    except Exception as e:
        return f"ERROR: {e.__class__.__name__}"
    final_link = findall(
        r"\'(https?:\/\/download\d+\.mediafire\.com\/\S+\/\S+\/\S+)\'", page
    )
    if not final_link:
        return "ERROR: No links found in this page"
    return final_link[0]


def osdn(url: str) -> str:
    """OSDN direct link generator"""
    osdn_link = "https://osdn.net"
    try:
        link = findall(r"\bhttps?://.*osdn\.net\S+", url)[0]
    except IndexError:
        return "No OSDN links found"
    cget = create_scraper().request
    try:
        page = BeautifulSoup(cget("get", link, allow_redirects=True).content, "lxml")
    except Exception as e:
        return f"ERROR: {e.__class__.__name__}"
    info = page.find("a", {"class": "mirror_link"})
    link = unquote(osdn_link + info["href"])
    mirrors = page.find("form", {"id": "mirror-select-form"}).findAll("tr")
    urls = []
    for data in mirrors[1:]:
        mirror = data.find("input")["value"]
        urls.append(sub(r"m=(.*)&f", f"m={mirror}&f", link))
    return urls[0]


def github(url: str) -> str:
    """GitHub direct links generator"""
    try:
        findall(r"\bhttps?://.*github\.com.*releases\S+", url)[0]
    except IndexError:
        return "No GitHub Releases links found"
    cget = create_scraper().request
    download = cget("get", url, stream=True, allow_redirects=False)
    try:
        return download.headers["location"]
    except KeyError:
        return "ERROR: Can't extract the link"


def hxfile(url: str) -> str:
    sess = session()
    try:
        headers = {
            "content-type": "application/x-www-form-urlencoded",
            "user-agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/88.0.4324.152 Safari/537.36",
        }

        data = {
            "op": "download2",
            "id": urlparse(url).path.strip("/")(url),
            "rand": "",
            "referer": "",
            "method_free": "",
            "method_premium": "",
        }

        response = sess.post(url, headers=headers, data=data)
        soup = BeautifulSoup(response, "html.parser")

        if btn := soup.find(class_="btn btn-dow"):
            return btn["href"]
        if unique := soup.find(id="uniqueExpirylink"):
            return unique["href"]

    except Exception as e:
        return f"ERROR: {e.__class__.__name__}"


def letsupload(url: str) -> str:
    cget = create_scraper().request
    try:
        res = cget("POST", url)
    except Exception as e:
        return f"ERROR: {e.__class__.__name__}"
    direct_link = findall(r"(https?://letsupload\.io\/.+?)\'", res.text)
    if direct_link:
        return direct_link[0]
    else:
        return "ERROR: Direct Link not found"


def anonfilesBased(url: str) -> str:
    cget = create_scraper().request
    try:
        soup = BeautifulSoup(cget("get", url).content, "lxml")
    except Exception as e:
        return f"ERROR: {e.__class__.__name__}"
    sa = soup.find(id="download-url")
    if sa:
        return sa["href"]
    return "ERROR: File not found!"


def fembed(link: str) -> str:
    sess = session()
    try:
        url = url.replace("/v/", "/f/")
        raw = session.get(url)
        api = search(r"(/api/source/[^\"']+)", raw.text)
        if api is not None:
            result = {}
            raw = sess.post("https://layarkacaxxi.icu" + api.group(1)).json()
            for d in raw["data"]:
                f = d["file"]
                head = sess.head(f)
                direct = head.headers.get("Location", url)
                result[f"{d['label']}/{d['type']}"] = direct
            dl_url = result

        count = len(dl_url)
        lst_link = [dl_url[i] for i in dl_url]
        return lst_link[count - 1]
    except Exception as e:
        return f"ERROR: {e.__class__.__name__}"


def sbembed(link: str) -> str:
    sess = session()
    try:
        raw = sess.get(link)
        soup = BeautifulSoup(raw, "html.parser")

        result = {}
        for a in soup.findAll("a", onclick=compile(r"^download_video[^>]+")):
            data = dict(
                zip(
                    ["id", "mode", "hash"],
                    findall(r"[\"']([^\"']+)[\"']", a["onclick"]),
                )
            )
            data["op"] = "download_orig"

            raw = sess.get("https://sbembed.com/dl", params=data)
            soup = BeautifulSoup(raw, "html.parser")

            if direct := soup.find("a", text=compile("(?i)^direct")):
                result[a.text] = direct["href"]
        dl_url = result

        count = len(dl_url)
        lst_link = [dl_url[i] for i in dl_url]
        return lst_link[count - 1]

    except Exception as e:
        return f"ERROR: {e.__class__.__name__}"


def onedrive(link: str) -> str:
    """Onedrive direct link generator
    Based on https://github.com/UsergeTeam/Userge"""
    link_without_query = urlparse(link)._replace(query=None).geturl()
    direct_link_encoded = str(
        standard_b64encode(bytes(link_without_query, "utf-8")), "utf-8"
    )
    direct_link1 = (
        f"https://api.onedrive.com/v1.0/shares/u!{direct_link_encoded}/root/content"
    )
    cget = create_scraper().request
    try:
        resp = cget("head", direct_link1)
    except Exception as e:
        return f"ERROR: {e.__class__.__name__}"
    if resp.status_code != 302:
        return "ERROR: Unauthorized link, the link may be private"
    return resp.next.url


def pixeldrain(url: str) -> str:
    """Based on https://github.com/yash-dk/TorToolkit-Telegram"""
    url = url.strip("/ ")
    file_id = url.split("/")[-1]
    if url.split("/")[-2] == "l":
        info_link = f"https://pixeldrain.com/api/list/{file_id}"
        dl_link = f"https://pixeldrain.com/api/list/{file_id}/zip?download"
    else:
        info_link = f"https://pixeldrain.com/api/file/{file_id}/info"
        dl_link = f"https://pixeldrain.com/api/file/{file_id}?download"
    cget = create_scraper().request
    try:
        resp = cget("get", info_link).json()
    except Exception as e:
        return f"ERROR: {e.__class__.__name__}"
    if resp["success"]:
        return dl_link
    else:
        return f"ERROR: Cant't download due {resp['message']}."


def antfiles(url: str) -> str:
    sess = session()
    try:
        raw = sess.get(url)
        soup = BeautifulSoup(raw, "html.parser")

        if a := soup.find(class_="main-btn", href=True):
            return "{0.scheme}://{0.netloc}/{1}".format(urlparse(url), a["href"])

    except Exception as e:
        return f"ERROR: {e.__class__.__name__}"


def streamtape(url: str) -> str:
    response = get(url)

    if videolink := findall(r"document.*((?=id\=)[^\"']+)", response.text):
        nexturl = "https://streamtape.com/get_video?" + videolink[-1]
        try:
            return nexturl
        except Exception as e:
            return f"ERROR: {e.__class__.__name__}"


def racaty(url: str) -> str:
    """Racaty direct link generator
    By https://github.com/junedkh"""
    cget = create_scraper().request
    try:
        url = cget("GET", url).url
        json_data = {"op": "download2", "id": url.split("/")[-1]}
        res = cget("POST", url, data=json_data)
    except Exception as e:
        return f"ERROR: {e.__class__.__name__}"
    html_tree = etree.HTML(res.text)
    direct_link = html_tree.xpath("//a[contains(@id,'uniqueExpirylink')]/@href")
    if direct_link:
        return direct_link[0]
    else:
        return "ERROR: Direct link not found"


def fichier(link: str) -> str:
    """1Fichier direct link generator
    Based on https://github.com/Maujar
    """
    regex = r"^([http:\/\/|https:\/\/]+)?.*1fichier\.com\/\?.+"
    gan = match(regex, link)
    if not gan:
        return "ERROR: The link you entered is wrong!"
    if "::" in link:
        pswd = link.split("::")[-1]
        url = link.split("::")[-2]
    else:
        pswd = None
        url = link
    cget = create_scraper().request
    try:
        if pswd is None:
            req = cget("post", url)
        else:
            pw = {"pass": pswd}
            req = cget("post", url, data=pw)
    except Exception as e:
        return f"ERROR: {e.__class__.__name__}"
    if req.status_code == 404:
        return "ERROR: File not found/The link you entered is wrong!"
    soup = BeautifulSoup(req.content, "lxml")
    if soup.find("a", {"class": "ok btn-general btn-orange"}):
        dl_url = soup.find("a", {"class": "ok btn-general btn-orange"})["href"]
        if dl_url:
            return dl_url
        return "ERROR: Unable to generate Direct Link 1fichier!"
    elif len(soup.find_all("div", {"class": "ct_warn"})) == 3:
        str_2 = soup.find_all("div", {"class": "ct_warn"})[-1]
        if "you must wait" in str(str_2).lower():
            numbers = [int(word) for word in str(str_2).split() if word.isdigit()]
            if numbers:
                return (
                    f"ERROR: 1fichier is on a limit. Please wait {numbers[0]} minute."
                )
            else:
                return "ERROR: 1fichier is on a limit. Please wait a few minutes/hour."
        elif "protect access" in str(str_2).lower():
            return "ERROR: This link requires a password!\n\n<b>This link requires a password!</b>\n- Insert sign <b>::</b> after the link and write the password after the sign.\n\n<b>Example:</b> https://1fichier.com/?smmtd8twfpm66awbqz04::love you\n\n* No spaces between the signs <b>::</b>\n* For the password, you can use a space!"
        else:
            return "ERROR: Failed to generate Direct Link from 1fichier!"
    elif len(soup.find_all("div", {"class": "ct_warn"})) == 4:
        str_1 = soup.find_all("div", {"class": "ct_warn"})[-2]
        str_3 = soup.find_all("div", {"class": "ct_warn"})[-1]
        if "you must wait" in str(str_1).lower():
            numbers = [int(word) for word in str(str_1).split() if word.isdigit()]
            if numbers:
                return (
                    f"ERROR: 1fichier is on a limit. Please wait {numbers[0]} minute."
                )
            else:
                return "ERROR: 1fichier is on a limit. Please wait a few minutes/hour."
        elif "bad password" in str(str_3).lower():
            return "ERROR: The password you entered is wrong!"
        else:
            return "ERROR: Error trying to generate Direct Link from 1fichier!"
    else:
        return "ERROR: Error trying to generate Direct Link from 1fichier!"


def solidfiles(url: str) -> str:
    """Solidfiles direct link generator
    Based on https://github.com/Xonshiz/SolidFiles-Downloader
    By https://github.com/Jusidama18"""
    cget = create_scraper().request
    try:
        headers = {
            "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_9_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/36.0.1985.125 Safari/537.36"
        }
        pageSource = cget("get", url, headers=headers).text
        mainOptions = str(search(r"viewerOptions\'\,\ (.*?)\)\;", pageSource).group(1))
        return loads(mainOptions)["downloadUrl"]
    except Exception as e:
        return f"ERROR: {e.__class__.__name__}"


def krakenfiles(url: str) -> str:
    sess = session()
    try:
        res = sess.get(url)
        html = etree.HTML(res.text)
        if post_url := html.xpath('//form[@id="dl-form"]/@action'):
            post_url = f"https:{post_url[0]}"
        else:
            sess.close()
            return "ERROR: Unable to find post link."
        if token := html.xpath('//input[@id="dl-token"]/@value'):
            data = {"token": token[0]}
        else:
            sess.close()
            return "ERROR: Unable to find token for post."
    except Exception as e:
        sess.close()
        return f"ERROR: {e.__class__.__name__} Something went wrong"
    try:
        dl_link = sess.post(post_url, data=data).json()
        return dl_link["url"]
    except Exception as e:
        sess.close()
        return f"ERROR: {e.__class__.__name__} While send post request"


def uploadee(url: str) -> str:
    """uploadee direct link generator
    By https://github.com/iron-heart-x"""
    cget = create_scraper().request
    try:
        soup = BeautifulSoup(cget("get", url).content, "lxml")
        sa = soup.find("a", attrs={"id": "d_l"})
        return sa["href"]
    except:
        return f"ERROR: Failed to acquire download URL from upload.ee for : {url}"


def terabox(url) -> str:
    sess = session()
    while True:
        try:
            res = sess.get(url)
            print("connected")
            break
        except:
            print("retrying")
    url = res.url

    key = url.split("?surl=")[-1]
    url = f"http://www.terabox.com/wap/share/filelist?surl={key}"
    sess.cookies.update(TERA_COOKIE)

    while True:
        try:
            res = sess.get(url)
            print("connected")
            break
        except Exception as e:
            print("retrying")

    key = res.url.split("?surl=")[-1]
    soup = BeautifulSoup(res.content, "lxml")
    jsToken = None

    for fs in soup.find_all("script"):
        fstring = fs.string
        if fstring and fstring.startswith("try {eval(decodeURIComponent"):
            jsToken = fstring.split("%22")[1]

    while True:
        try:
            res = sess.get(
                f"https://www.terabox.com/share/list?app_id=250528&jsToken={jsToken}&shorturl={key}&root=1"
            )
            print("connected")
            break
        except:
            print("retrying")
    result = res.json()

    if result["errno"] != 0:
        return f"ERROR: '{result['errmsg']}' Check cookies"
    result = result["list"]
    if len(result) > 1:
        return "ERROR: Can't download mutiple files"
    result = result[0]

    if result["isdir"] != "0":
        return "ERROR: Can't download folder"
    return result.get("dlink", "Error")


def filepress(url):
    cget = create_scraper().request
    try:
        url = cget("GET", url).url
        raw = urlparse(url)

        gd_data = {
            "id": raw.path.split("/")[-1],
            "method": "publicDownlaod",
        }
        tg_data = {
            "id": raw.path.split("/")[-1],
            "method": "telegramDownload",
        }

        api = f"{raw.scheme}://{raw.hostname}/api/file/downlaod/"

        gd_res = cget(
            "POST",
            api,
            headers={"Referer": f"{raw.scheme}://{raw.hostname}"},
            json=gd_data,
        ).json()
        tg_res = cget(
            "POST",
            api,
            headers={"Referer": f"{raw.scheme}://{raw.hostname}"},
            json=tg_data,
        ).json()

    except Exception as e:
        return f"Google Drive: ERROR: {e.__class__.__name__} \nTelegram: ERROR: {e.__class__.__name__}"

    gd_result = (
        f'https://drive.google.com/uc?id={gd_res["data"]}'
        if "data" in gd_res
        else f'ERROR: {gd_res["statusText"]}'
    )
    tg_result = (
        f'https://tghub.xyz/?start={tg_res["data"]}'
        if "data" in tg_res
        else "No Telegram file available "
    )

    return f"Google Drive: {gd_result} \nTelegram: {tg_result}"


def gdtot(url):
    cget = create_scraper().request
    try:
        res = cget("GET", f'https://gdbot.xyz/file/{url.split("/")[-1]}')
    except Exception as e:
        return f"ERROR: {e.__class__.__name__}"
    token_url = etree.HTML(res.content).xpath(
        "//a[contains(@class,'inline-flex items-center justify-center')]/@href"
    )
    if not token_url:
        try:
            url = cget("GET", url).url
            p_url = urlparse(url)
            res = cget(
                "GET", f"{p_url.scheme}://{p_url.hostname}/ddl/{url.split('/')[-1]}"
            )
        except Exception as e:
            return f"ERROR: {e.__class__.__name__}"
        drive_link = findall(r"myDl\('(.*?)'\)", res.text)
        if drive_link and "drive.google.com" in drive_link[0]:
            return drive_link[0]
        else:
            return "ERROR: Drive Link not found, Try in your broswer"
    token_url = token_url[0]
    try:
        token_page = cget("GET", token_url)
    except Exception as e:
        return f"ERROR: {e.__class__.__name__} with {token_url}"
    path = findall('\("(.*?)"\)', token_page.text)
    if not path:
        return "ERROR: Cannot bypass this"
    path = path[0]
    raw = urlparse(token_url)
    final_url = f"{raw.scheme}://{raw.hostname}{path}"
    return sharer_scraper(final_url)


def sharer_scraper(url):
    cget = create_scraper().request
    try:
        url = cget("GET", url).url
        raw = urlparse(url)
        header = {
            "useragent": "Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US) AppleWebKit/534.10 (KHTML, like Gecko) Chrome/7.0.548.0 Safari/534.10"
        }
        res = cget("GET", url, headers=header)
    except Exception as e:
        return f"ERROR: {e.__class__.__name__}"
    key = findall('"key",\s+"(.*?)"', res.text)
    if not key:
        return "ERROR: Key not found!"
    key = key[0]
    if not etree.HTML(res.content).xpath("//button[@id='drc']"):
        return "ERROR: This link don't have direct download button"
    boundary = uuid4()
    headers = {
        "Content-Type": f"multipart/form-data; boundary=----WebKitFormBoundary{boundary}",
        "x-token": raw.hostname,
        "useragent": "Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US) AppleWebKit/534.10 (KHTML, like Gecko) Chrome/7.0.548.0 Safari/534.10",
    }

    data = (
        f'------WebKitFormBoundary{boundary}\r\nContent-Disposition: form-data; name="action"\r\n\r\ndirect\r\n'
        f'------WebKitFormBoundary{boundary}\r\nContent-Disposition: form-data; name="key"\r\n\r\n{key}\r\n'
        f'------WebKitFormBoundary{boundary}\r\nContent-Disposition: form-data; name="action_token"\r\n\r\n\r\n'
        f"------WebKitFormBoundary{boundary}--\r\n"
    )
    try:
        res = cget("POST", url, cookies=res.cookies, headers=headers, data=data).json()
    except Exception as e:
        return f"ERROR: {e.__class__.__name__}"
    if "url" not in res:
        return "ERROR: Drive Link not found, Try in your broswer"
    if "drive.google.com" in res["url"]:
        return res["url"]
    try:
        res = cget("GET", res["url"])
    except Exception as e:
        return f"ERROR: {e.__class__.__name__}"
    html_tree = etree.HTML(res.content)
    drive_link = html_tree.xpath("//a[contains(@class,'btn')]/@href")
    if drive_link and "drive.google.com" in drive_link[0]:
        return drive_link[0]
    else:
        return "ERROR: Drive Link not found, Try in your broswer"


def wetransfer(url):
    cget = create_scraper().request
    try:
        url = cget("GET", url).url
        json_data = {"security_hash": url.split("/")[-1], "intent": "entire_transfer"}
        res = cget(
            "POST",
            f'https://wetransfer.com/api/v4/transfers/{url.split("/")[-2]}/download',
            json=json_data,
        ).json()
    except Exception as e:
        return f"ERROR: {e.__class__.__name__}"
    if "direct_link" in res:
        return res["direct_link"]
    elif "message" in res:
        return f"ERROR: {res['message']}"
    elif "error" in res:
        return f"ERROR: {res['error']}"
    else:
        return "ERROR: cannot find direct link"


def akmfiles(url):
    cget = create_scraper().request
    try:
        url = cget("GET", url).url
        json_data = {"op": "download2", "id": url.split("/")[-1]}
        res = cget("POST", url, data=json_data)
    except Exception as e:
        return f"ERROR: {e.__class__.__name__}"
    html_tree = etree.HTML(res.content)
    direct_link = html_tree.xpath("//a[contains(@class,'btn btn-dow')]/@href")
    if direct_link:
        return direct_link[0]
    else:
        return "ERROR: Direct link not found"


def shrdsk(url):
    cget = create_scraper().request
    try:
        url = cget("GET", url).url
        res = cget(
            "GET",
            f'https://us-central1-affiliate2apk.cloudfunctions.net/get_data?shortid={url.split("/")[-1]}',
        )
    except Exception as e:
        return f"ERROR: {e.__class__.__name__}"
    if res.status_code != 200:
        return f"ERROR: Status Code {res.status_code}"
    res = res.json()
    if "type" in res and res["type"].lower() == "upload" and "video_url" in res:
        return res["video_url"]
    return "ERROR: cannot find direct link"


def linkbox(url):
    cget = create_scraper().request
    try:
        url = cget("GET", url).url
        res = cget(
            "GET", f'https://www.linkbox.to/api/file/detail?itemId={url.split("/")[-1]}'
        ).json()
    except Exception as e:
        return f"ERROR: {e.__class__.__name__}"
    if "data" not in res:
        return "ERROR: Data not found!!"
    data = res["data"]
    if not data:
        return "ERROR: Data is None!!"
    if "itemInfo" not in data:
        return "ERROR: itemInfo not found!!"
    itemInfo = data["itemInfo"]
    if "url" not in itemInfo:
        return "ERROR: url not found in itemInfo!!"
    if "name" not in itemInfo:
        return "ERROR: Name not found in itemInfo!!"
    name = quote(itemInfo["name"])
    raw = itemInfo["url"].split("/", 3)[-1]
    return f"https://wdl.nuplink.net/{raw}&filename={name}"


def zippyshare(url):
    cget = create_scraper().request
    try:
        url = cget("GET", url).url
        resp = cget("GET", url)
    except Exception as e:
        return f"ERROR: {e.__class__.__name__}"
    if not resp.ok:
        return "ERROR: Something went wrong!!, Try in your browser"
    if findall(r">File does not exist on this server<", resp.text):
        return "ERROR: File does not exist on server!!, Try in your browser"
    pages = etree.HTML(resp.text).xpath(
        "//script[contains(text(),'dlbutton')][3]/text()"
    )
    if not pages:
        return "ERROR: Page not found!!"
    js_script = pages[0]
    uri1 = None
    uri2 = None
    method = ""
    omg = findall(r"\.omg.=.(.*?);", js_script)
    var_a = findall(r"var.a.=.(\d+)", js_script)
    var_ab = findall(r"var.[ab].=.(\d+)", js_script)
    unknown = findall(r"\+\((.*?).\+", js_script)
    unknown1 = findall(r"\+.\((.*?)\).\+", js_script)
    if omg:
        omg = omg[0]
        method = f"omg = {omg}"
        mtk = (eval(omg) * (int(omg.split("%")[0]) % 3)) + 18
        uri1 = findall(r'"/(d/\S+)/"', js_script)
        uri2 = findall(r'\/d.*?\+"/(\S+)";', js_script)
    elif var_a:
        var_a = var_a[0]
        method = f"var_a = {var_a}"
        mtk = int(pow(int(var_a), 3) + 3)
        uri1 = findall(r"\.href.=.\"/(.*?)/\"", js_script)
        uri2 = findall(r"\+\"/(.*?)\"", js_script)
    elif var_ab:
        a = var_ab[0]
        b = var_ab[1]
        method = f"a = {a}, b = {b}"
        mtk = eval(f"{floor(int(a)/3) + int(a) % int(b)}")
        uri1 = findall(r"\.href.=.\"/(.*?)/\"", js_script)
        uri2 = findall(r"\)\+\"/(.*?)\"", js_script)
    elif unknown:
        method = f"unknown = {unknown[0]}"
        mtk = eval(f"{unknown[0]}+ 11")
        uri1 = findall(r"\.href.=.\"/(.*?)/\"", js_script)
        uri2 = findall(r"\)\+\"/(.*?)\"", js_script)
    elif unknown1:
        method = f"unknown1 = {unknown1[0]}"
        mtk = eval(unknown1[0])
        uri1 = findall(r"\.href.=.\"/(.*?)/\"", js_script)
        uri2 = findall(r"\+.\"/(.*?)\"", js_script)
    else:
        return "ERROR: Direct link not found"
    if not any([uri1, uri2]):
        return f"ERROR: uri1 or uri2 not found with method {method}"
    domain = urlparse(url).hostname
    return f"https://{domain}/{uri1[0]}/{mtk}/{uri2[0]}"


================================================
FILE: freewall.py
================================================
import requests
import base64
import re
from bs4 import BeautifulSoup
from bypasser import RecaptchaV3

RTOKEN = RecaptchaV3()

#######################################################################


def getSoup(res):
    return BeautifulSoup(res.text, "html.parser")


def downloaderla(url, site):
    params = {
        "url": url,
        "token": RTOKEN,
    }
    return requests.get(site, params=params).json()


def getImg(url):
    return requests.get(url).content


def decrypt(res, key):
    if res["success"]:
        return base64.b64decode(res["result"].split(key)[-1]).decode("utf-8")


#######################################################################


def shutterstock(url):
    res = downloaderla(url, "https://ttthreads.net/shutterstock.php")
    if res["success"]:
        return res["result"]


def adobestock(url):
    res = downloaderla(url, "https://new.downloader.la/adobe.php")
    return decrypt(res, "#")


def alamy(url):
    res = downloaderla(url, "https://new.downloader.la/alamy.php")
    return decrypt(res, "#")


def getty(url):
    res = downloaderla(url, "https://getpaidstock.com/api.php")
    return decrypt(res, "#")


def picfair(url):
    res = downloaderla(url, "https://downloader.la/picf.php")
    return decrypt(res, "?newURL=")


def slideshare(url, type="pptx"):
    # enum = {"pdf","pptx","img"}
    # if type not in enum: type = "pdf"
    return requests.get(
        f"https://downloader.at/convert2{type}.php", params={"url": url}
    ).content


def medium(url):
    return requests.post(
        "https://downloader.la/read.php",
        data={
            "mediumlink": url,
        },
    ).content


#######################################################################


def pass_paywall(url, check=False, link=False):
    patterns = [
        (r"https?://(?:www\.)?shutterstock\.com/", shutterstock, True, "png", -1),
        (r"https?://stock\.adobe\.com/", adobestock, True, "png", -2),
        (r"https?://(?:www\.)?alamy\.com/", alamy, True, "png", -1),
        (r"https?://(?:www\.)?gettyimages\.", getty, True, "png", -2),
        (r"https?://(?:www\.)?istockphoto\.com", getty, True, "png", -1),
        (r"https?://(?:www\.)?picfair\.com/", picfair, True, "png", -1),
        (r"https?://(?:www\.)?slideshare\.net/", slideshare, False, "pptx", -1),
        (r"https?://medium\.com/", medium, False, "html", -1),
    ]

    img_link = None
    name = "no-name"
    for pattern, downloader_func, img, ftype, idx in patterns:
        if re.search(pattern, url):
            if check:
                return True
            img_link = downloader_func(url)

            try:
                name = url.split("/")[idx]
            except:
                pass
            if (not img) and img_link:
                fullname = name + "." + ftype
                with open(fullname, "wb") as f:
                    f.write(img_link)
                return fullname
            break

    if check:
        return False
    if link or (not img_link):
        return img_link
    fullname = name + "." + "png"
    with open(fullname, "wb") as f:
        f.write(getImg(img_link))
    return fullname


#######################################################################


================================================
FILE: main.py
================================================
from pyrogram import Client, filters
from pyrogram.types import (
    InlineKeyboardMarkup,
    InlineKeyboardButton,
    BotCommand,
    Message,
)
from os import environ, remove
from threading import Thread
from json import load
from re import search
import re
from urlextract import URLExtract
from texts import HELP_TEXT
import bypasser
import freewall
from time import time
from db import DB

# Initialize URL extractor
extractor = URLExtract()

# Bot configuration
with open("config.json", "r") as f:
    DATA: dict = load(f)

def getenv(var):
    return environ.get(var) or DATA.get(var, None)

bot_token = getenv("TOKEN")
api_hash = getenv("HASH")
api_id = getenv("ID")
app = Client("my_bot", api_id=api_id, api_hash=api_hash, bot_token=bot_token)
with app:
    app.set_bot_commands(
        [
            BotCommand("start", "Welcome Message"),
            BotCommand("help", "List of All Supported Sites"),
        ]
    )

# Database setup
db_api = getenv("DB_API")
db_owner = getenv("DB_OWNER")
db_name = getenv("DB_NAME")
try:
    database = DB(api_key=db_api, db_owner=db_owner, db_name=db_name)
except:
    print("Database is Not Set")
    database = None

# Handle index
def handleIndex(ele: str, message: Message, msg: Message):
    result = bypasser.scrapeIndex(ele)
    try:
        app.delete_messages(message.chat.id, msg.id)
    except:
        pass
    if database and result:
        database.insert(ele, result)
    for page in result:
        app.send_message(
            message.chat.id,
            page,
            reply_to_message_id=message.id,
            disable_web_page_preview=True,
        )

# URL regex pattern
URL_REGEX = r'(?:(?:https?|ftp):\/\/)?[\w/\-?=%.]+\.[\w/\-?=%.]+'

# Updated loopthread function
def loopthread(message: Message, otherss=False):
    urls = []
    # Use message.caption for media (otherss=True), message.text for text messages (otherss=False)
    if otherss:
        texts = message.caption or ""
    else:
        texts = message.text or ""

    # Check entities based on message type
    entities = []
    if otherss and hasattr(message, 'caption_entities') and message.caption_entities:
        entities = message.caption_entities
    elif message.entities:
        entities = message.entities

    # Step 1: Extract URLs from entities
    if entities:
        for entity in entities:
            entity_type = str(entity.type)
            normalized_type = entity_type.split('.')[-1].lower() if '.' in entity_type else entity_type.lower()
            
            if normalized_type == "url":
                url = texts[entity.offset:entity.offset + entity.length]
                urls.append(url)
            elif normalized_type == "text_link":
                if hasattr(entity, 'url') and entity.url:
                    urls.append(entity.url)

    # Step 2: Fallback to text-based URL extraction
    extracted_urls = extractor.find_urls(texts)
    urls.extend(extracted_urls)
    regex_urls = re.findall(URL_REGEX, texts)
    urls.extend(regex_urls)

    # Step 3: Clean and deduplicate URLs
    cleaned_urls = []
    for url in urls:
        cleaned_url = url.strip(".,").rstrip("/")
        if cleaned_url:
            cleaned_urls.append(cleaned_url)
    urls = list(dict.fromkeys(cleaned_urls))  # Preserve order, remove duplicates
    if not urls:
        app.send_message(
            message.chat.id,
            "No valid URLs found in the message.",
            reply_to_message_id=message.id
        )
        return

    # Step 4: Normalize URLs (add protocol if missing)
    normalized_urls = []
    for url in urls:
        if not url.startswith(('http://', 'https://')):
            url = 'https://' + url
        normalized_urls.append(url)
    urls = normalized_urls

    # Bypassing logic
    if bypasser.ispresent(bypasser.ddl.ddllist, urls[0]):
        msg: Message = app.send_message(
            message.chat.id, "⚡ __generating...__", reply_to_message_id=message.id
        )
    elif freewall.pass_paywall(urls[0], check=True):
        msg: Message = app.send_message(
            message.chat.id, "🕴️ __jumping the wall...__", reply_to_message_id=message.id
        )
    else:
        if "https://olamovies" in urls[0] or "https://psa.wf/" in urls[0]:
            msg: Message = app.send_message(
                message.chat.id,
                "⏳ __this might take some time...__",
                reply_to_message_id=message.id,
            )
        else:
            msg: Message = app.send_message(
                message.chat.id, "🔎 __bypassing...__", reply_to_message_id=message.id
            )

    strt = time()
    links = ""
    temp = None

    for ele in urls:
        if database:
            df_find = database.find(ele)
        else:
            df_find = None
        if df_find:
            print("Found in DB")
            temp = df_find
        elif search(r"https?:\/\/(?:[\w.-]+)?\.\w+\/\d+:", ele):
            handleIndex(ele, message, msg)
            return
        elif bypasser.ispresent(bypasser.ddl.ddllist, ele):
            try:
                temp = bypasser.ddl.direct_link_generator(ele)
            except Exception as e:
                temp = "**Error**: " + str(e)
        elif freewall.pass_paywall(ele, check=True):
            freefile = freewall.pass_paywall(ele)
            if freefile:
                try:
                    app.send_document(
                        message.chat.id, freefile, reply_to_message_id=message.id
                    )
                    remove(freefile)
                    app.delete_messages(message.chat.id, [msg.id])
                    return
                except:
                    pass
            else:
                app.send_message(
                    message.chat.id, "__Failed to Jump", reply_to_message_id=message.id
                )
        else:
            try:
                temp = bypasser.shortners(ele)
            except Exception as e:
                temp = "**Error**: " + str(e)

        print("bypassed:", temp)
        if temp is not None:
            if (not df_find) and ("http://" in temp or "https://" in temp) and database:
                print("Adding to DB")
                database.insert(ele, temp)
            links = links + temp + "\n"

    end = time()
    print("Took " + "{:.2f}".format(end - strt) + "sec")

    # Send bypassed links
    try:
        final = []
        tmp = ""
        for ele in links.split("\n"):
            tmp += ele + "\n"
            if len(tmp) > 4000:
                final.append(tmp)
                tmp = ""
        final.append(tmp)
        app.delete_messages(message.chat.id, msg.id)
        tmsgid = message.id
        for ele in final:
            tmsg = app.send_message(
                message.chat.id,
                f"__{ele}__",
                reply_to_message_id=tmsgid,
                disable_web_page_preview=True,
            )
            tmsgid = tmsg.id
    except Exception as e:
        app.send_message(
            message.chat.id,
            f"__Failed to Bypass : {e}__",
            reply_to_message_id=message.id,
        )

# Start command
@app.on_message(filters.command(["start"]))
def send_start(client: Client, message: Message):
    app.send_message(
        message.chat.id,
        f"__👋 Hi **{message.from_user.mention}**, I am Link Bypasser Bot, just send me any supported links and I will get you results.\nCheckout /help to Read More__",
        reply_markup=InlineKeyboardMarkup(
            [
                [
                    InlineKeyboardButton(
                        "🌐 Source Code",
                        url="https://github.com/bipinkrish/Link-Bypasser-Bot",
                    )
                ],
                [
                    InlineKeyboardButton(
                        "Replit",
                        url="https://replit.com/@bipinkrish/Link-Bypasser#app.py",
                    )
                ],
            ]
        ),
        reply_to_message_id=message.id,
    )

# Help command
@app.on_message(filters.command(["help"]))
def send_help(client: Client, message: Message):
    app.send_message(
        message.chat.id,
        HELP_TEXT,
        reply_to_message_id=message.id,
        disable_web_page_preview=True,
    )

# Text message handler
@app.on_message(filters.text)
def receive(client: Client, message: Message):
    bypass = Thread(target=lambda: loopthread(message), daemon=True)
    bypass.start()

# Document thread for DLC files
def docthread(message: Message):
    msg: Message = app.send_message(
        message.chat.id, "🔎 __bypassing...__", reply_to_message_id=message.id
    )
    print("sent DLC file")
    file = app.download_media(message)
    dlccont = open(file, "r").read()
    links = bypasser.getlinks(dlccont)
    app.edit_message_text(
        message.chat.id, msg.id, f"__{links}__", disable_web_page_preview=True
    )
    remove(file)

# Media file handler
@app.on_message([filters.document, filters.photo, filters.video])
def docfile(client: Client, message: Message):
    try:
        if message.document and message.document.file_name.endswith("dlc"):
            bypass = Thread(target=lambda: docthread(message), daemon=True)
            bypass.start()
            return
    except:
        pass
    bypass = Thread(target=lambda: loopthread(message, True), daemon=True)
    bypass.start()

# Start the bot
print("Bot Starting")
app.run()


================================================
FILE: requirements.txt
================================================
requests
cloudscraper
bs4 
python-dotenv
kurigram==2.2.0
PyroTgCrypto==1.2.7
lxml
cfscrape
urllib3==1.26
flask
gunicorn
curl-cffi
urlextract


================================================
FILE: runtime.txt
================================================
python-3.9.14


================================================
FILE: templates/index.html
================================================
<!DOCTYPE html>
<html lang="en">
  <head>
    <title>Web Link Bypasser</title>
    <meta
      name="description"
      content="A site that can Bypass the Ad Links and Generate Direct Links"
    />
    
    <meta charset="utf-8" />
    <meta http-equiv="X-UA-Compatible" content="IE=edge" />
    <meta name="viewport" content="width=device-width, initial-scale=1" />
    <link rel="stylesheet" href="https://bootswatch.com/5/vapor/bootstrap.css" />
  </head>
  <body>
    <style>
    ul.no-bullets {
      list-style-type: none;
      padding-left: 0;
    }

    .no-underline {
      text-decoration: none;
    }
  </style>
    <nav class="navbar navbar-expand-md navbar-dark bg-dark justify-content-center" id="navbarHeader">
      <div class="navbar-brand text-white text-center">
        Quick, Simple and Easy to use Link-Bypasser 
      </div>
    </nav>
    <main>
      <section class="py-5 text-center" id="topHeaderSection">
        <div class="container mt-10">
          <h1 class="mb-4 text-center">Link Bypasser Web</h1>
          <div class="center-content">
            <form method="post">
              <div class="row justify-content-center">
                <div class="col-12 col-md-8 col-lg-6">
                  <div class="input-group mb-3">
                    <input type="text" class="form-control" name="url" placeholder="Enter URL here">
                    <div class="input-group-append">
                      <button class="btn btn-primary" type="submit">Submit</button>
                    </div>
                  </div>
                </div>
              </div>
            </form>
            <div class="mt-4">
            {% if result %}
            <div class="mb-2">
              <a href="{{ result }}" class="d-block" target="_blank">{{ result }}</a>
            </div>
            {% endif %}
          </div>
          {% if prev_links %}
          <div class="mt-4">
            <strong>Previously Shortened Links:</strong>
            <ul class="no-bullets">
              {% for prev_link in prev_links[::-1] %}
              {% if prev_link.strip() %}
              <li>
                <a href="{{ prev_link }}" class="d-block mb-2 no-underline" target="_blank">{{ prev_link }}</a>
              </li>
              {% endif %}
              {% endfor %}
            </ul>
          </div>
          {% endif %}
            </div>
            <p class="mt-3 text-warning">If you encounter any problems, <a href="https://github.com/bipinkrish/Link-Bypasser-Bot/issues"> click here to report</a>.</p>
            <div class="mt-5">
              <p>Designed and made by <a href="https://patelsujal.in">Sujal Patel with Bipinkrish</a></p>
            </div>
          </div>
        </div>
      </section>
    </main>
    <script src="https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/js/bootstrap.bundle.min.js"></script>
    <script src="https://code.jquery.com/jquery-3.6.0.min.js"></script>
  </body> 
</html>


================================================
FILE: texts.py
================================================
gdrivetext = """__- appdrive \n\
- driveapp \n\
- drivehub \n\
- gdflix \n\
- drivesharer \n\
- drivebit \n\
- drivelinks \n\
- driveace \n\
- drivepro \n\
- driveseed \n\
    __"""


otherstext = """__- exe, exey \n\
- sub2unlock, sub2unlock \n\
- rekonise \n\
- letsboost \n\
- phapps2app \n\
- mboost	\n\
- sub4unlock \n\
- ytsubme \n\
- bitly \n\
- social-unlock	\n\
- boost	\n\
- gooly \n\
- shrto \n\
- tinyurl
    __"""


ddltext = """__- yandex \n\
- mediafire \n\
- uptobox \n\
- osdn \n\
- github \n\
- hxfile \n\
- 1drv (onedrive) \n\
- pixeldrain \n\
- antfiles \n\
- streamtape \n\
- racaty \n\
- 1fichier \n\
- solidfiles \n\
- krakenfiles \n\
- upload \n\
- akmfiles \n\
- linkbox \n\
- shrdsk \n\
- letsupload \n\
- zippyshare \n\
- wetransfer \n\
- terabox, teraboxapp, 4funbox, mirrobox, nephobox, momerybox \n\
- filepress \n\
- anonfiles, hotfile, bayfiles, megaupload, letsupload, filechan, myfile, vshare, rapidshare, lolabits, openload, share-online, upvid \n\
- fembed, fembed, femax20, fcdn, feurl, layarkacaxxi, naniplay, nanime, naniplay, mm9842 \n\
- sbembed, watchsb, streamsb, sbplay.
    __"""


shortnertext = """__- igg-games \n\
- olamovies\n\
- katdrive \n\
- drivefire\n\
- kolop \n\
- hubdrive \n\
- filecrypt \n\
- shareus \n\
- shortingly \n\
- gyanilinks \n\
- shorte \n\
- psa \n\
- sharer \n\
- new1.gdtot \n\
- adfly\n\
- gplinks\n\
- droplink \n\
- linkvertise \n\
- rocklinks \n\
- ouo \n\
- try2link \n\
- htpmovies \n\
- sharespark \n\
- cinevood\n\
- atishmkv \n\
- urlsopen \n\
- xpshort, techymozo \n\
- dulink \n\
- ez4short \n\
- krownlinks \n\
- teluguflix \n\
- taemovies \n\
- toonworld4all \n\
- animeremux \n\
- adrinolinks \n\
- tnlink \n\
- flashlink \n\
- short2url \n\
- tinyfy \n\
- mdiskshortners \n\
- earnl \n\
- moneykamalo \n\
- easysky \n\
- indiurl \n\
- linkbnao \n\
- mdiskpro \n\
- tnshort \n\
- indianshortner \n\
- rslinks \n\
- bitly, tinyurl \n\
- thinfi \n\
- pdisk \n\
- vnshortener \n\
- onepagelink \n\
- lolshort \n\
- tnvalue \n\
- vipurl \n\
__"""


freewalltext = """__- shutterstock \n\
- adobe stock \n\
- drivehub \n\
- alamy \n\
- gettyimages \n\
- istockphoto \n\
- picfair \n\
- slideshare \n\
- medium \n\
    __"""


HELP_TEXT = f"**--Just Send me any Supported Links From Below Mentioned Sites--** \n\n\
**List of Sites for DDL : ** \n\n{ddltext} \n\
**List of Sites for Shortners : ** \n\n{shortnertext} \n\
**List of Sites for GDrive Look-ALike : ** \n\n{gdrivetext} \n\
**List of Sites for Jumping Paywall : ** \n\n{freewalltext} \n\
**Other Supported Sites : ** \n\n{otherstext}"