Merge pull request #10 from UrloMythus/main

Add support for extracting clean links from IP-Locked / Cloudfare-Blocked Players

mediaflow_proxy/extractors/doodstream.py

@@ -0,0 +1,25 @@
+import httpx
+import time
+import re
+from mediaflow_proxy.configs import settings
+
+
+async def doodstream_url(d: str, use_request_proxy: bool):
+    async with httpx.AsyncClient(proxy=settings.proxy_url if use_request_proxy else None) as client:
+        headers = {
+            "Range": "bytes=0-",
+            "Referer": "https://d000d.com/",
+        }
+
+        response = await client.get(d, follow_redirects=True)
+        if response.status_code == 200:
+            # Get unique timestamp for the request
+            real_time = str(int(time.time()))
+            pattern = r"(\/pass_md5\/.*?)'.*(\?token=.*?expiry=)"
+            match = re.search(pattern, response.text, re.DOTALL)
+            if match:
+                url = f"https://d000d.com{match[1]}"
+                rebobo = await client.get(url, headers=headers, follow_redirects=True)
+                final_url = f"{rebobo.text}123456789{match[2]}{real_time}"
+                doodstream_dict = {"Referer": "https://d000d.com/"}
+                return final_url, doodstream_dict

mediaflow_proxy/extractors/mixdrop.py

@@ -0,0 +1,27 @@
+import httpx
+import re
+import string
+from mediaflow_proxy.configs import settings
+
+
+async def mixdrop_url(d: str, use_request_proxy: bool):
+    headers = {
+        "User-Agent": "Mozilla/5.0 (Windows NT 10.10; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.3",
+        "Accept-Language": "en-US,en;q=0.5",
+    }
+    async with httpx.AsyncClient(proxy=settings.proxy_url if use_request_proxy else None) as client:
+        response = await client.get(d, headers=headers, follow_redirects=True, timeout=30)
+        [s1, s2] = re.search(r"\}\('(.+)',.+,'(.+)'\.split", response.text).group(1, 2)
+        schema = s1.split(";")[2][5:-1]
+        terms = s2.split("|")
+        charset = string.digits + string.ascii_letters
+        d = dict()
+        for i in range(len(terms)):
+            d[charset[i]] = terms[i] or charset[i]
+        final_url = "https:"
+        for c in schema:
+            final_url += d[c] if c in d else c
+        headers_dict = {
+            "User-Agent": "Mozilla/5.0 (Windows NT 10.10; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.3"
+        }
+    return final_url, headers_dict

mediaflow_proxy/extractors/uqload.py

@@ -0,0 +1,14 @@
+import httpx
+import re
+from mediaflow_proxy.configs import settings
+
+
+async def uqload_url(d: str, use_request_proxy: bool):
+    async with httpx.AsyncClient(proxy=settings.proxy_url if use_request_proxy else None) as client:
+
+        response = await client.get(d, follow_redirects=True)
+        video_url_match = re.search(r'sources: \["(.*?)"\]', response.text)
+        if video_url_match:
+            final_url = video_url_match.group(1)
+        uqload_dict = {"Referer": "https://uqload.to/"}
+        return final_url, uqload_dict

mediaflow_proxy/extractors_routes.py

@@ -0,0 +1,55 @@
+from fastapi import APIRouter, Query
+from fastapi.responses import JSONResponse, RedirectResponse
+from .extractors.doodstream import doodstream_url
+from .extractors.uqload import uqload_url
+from .extractors.mixdrop import mixdrop_url
+from mediaflow_proxy.configs import settings
+
+extractor_router = APIRouter()
+host_map = {"Doodstream": doodstream_url, "Mixdrop": mixdrop_url, "Uqload": uqload_url}
+
+
+@extractor_router.get("/extractor")
+async def doodstream_extractor(
+    d: str = Query(..., description="Extract Clean Link from various Hosts"),
+    use_request_proxy: bool = Query(False, description="Whether to use the MediaFlow proxy configuration."),
+    host: str = Query(
+        ..., description='From which Host the URL comes from, here avaiable ones: "Doodstream","Mixdrop","Uqload"'
+    ),
+    redirect_stream: bool = Query(
+        False,
+        description="If enabled the response will be redirected to stream endpoint automatically and the stream will be proxied",
+    ),
+):
+    """
+    Extract a clean link from DoodStream,Mixdrop,Uqload
+
+    Args: request (Request): The incoming HTTP request
+
+    Returns: The clean link (url) and the headers needed to access the url
+
+    N.B. You can't use a rotating proxy if type is set to "Doodstream"
+    """
+    try:
+        final_url, headers_dict = await host_map[host](d, use_request_proxy)
+    except Exception as e:
+        return JSONResponse(content={"error": str(e)})
+    if redirect_stream == True:
+        formatted_headers = format_headers(headers_dict)
+        redirected_stream = f"/proxy/stream?api_password={settings.api_password}&d={final_url}&{formatted_headers}"
+        return RedirectResponse(url=redirected_stream)
+    elif redirect_stream == False:
+        return JSONResponse(content={"url": final_url, "headers": headers_dict})
+
+
+def format_headers(headers):
+    """
+    Format the headers dictionary into a query string format with 'h_' prefix.
+
+    Args:
+    - headers: A dictionary of headers.
+
+    Returns:
+    - A query string formatted string of headers.
+    """
+    return "&".join(f"h_{key}={value}" for key, value in headers.items())

mediaflow_proxy/main.py

@@ -10,6 +10,7 @@ from starlette.staticfiles import StaticFiles
 
 from mediaflow_proxy.configs import settings
 from mediaflow_proxy.routes import proxy_router
+from mediaflow_proxy.extractors_routes import extractor_router
 from mediaflow_proxy.schemas import GenerateUrlRequest
 from mediaflow_proxy.utils.crypto_utils import EncryptionHandler, EncryptionMiddleware
 from mediaflow_proxy.utils.rd_speedtest import run_speedtest, prune_task, results
@@ -96,6 +97,8 @@ async def generate_encrypted_or_encoded_url(request: GenerateUrlRequest):
 
 
 app.include_router(proxy_router, prefix="/proxy", tags=["proxy"], dependencies=[Depends(verify_api_key)])
+app.include_router(extractor_router, tags=["extractors"], dependencies=[Depends(verify_api_key)])
+
 
 static_path = resources.files("mediaflow_proxy").joinpath("static")
 app.mount("/", StaticFiles(directory=str(static_path), html=True), name="static")