Upload app.py

app.py

@@ -0,0 +1,352 @@
+import re
+import httpx
+from urllib.parse import urljoin, quote, unquote, urlparse
+from fastapi import FastAPI, Request, Response
+from fastapi.responses import StreamingResponse
+from fastapi.middleware.cors import CORSMiddleware
+
+app = FastAPI()
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+CDN_HOST = "https://plapi.cdnvideohub.com"
+CDN_HEADERS = {
+    "referer": "https://hdkino.pub/",
+    "origin": "https://hdkino.pub",
+    "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 Chrome/124.0.0.0 Safari/537.36",
+}
+VK_HEADERS = {
+    "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 Chrome/124.0.0.0 Safari/537.36",
+    "referer": "https://vkvideo.ru/",
+    "origin": "https://vkvideo.ru",
+}
+
+
+def parse_proxy_params(request: Request):
+    """
+    Парсим raw query string вручную чтобы не потерять & внутри url=
+    Формат: /proxy?url=ENCODED_URL  или  /proxy?url=ENCODED_URL&base=ENCODED_BASE
+    """
+    raw = str(request.url.query)
+    url = None
+    base = None
+
+    if raw.startswith("url="):
+        if "&base=" in raw:
+            idx = raw.index("&base=")
+            url = unquote(raw[4:idx])
+            base = unquote(raw[idx + 6:])
+        else:
+            url = unquote(raw[4:])
+
+    return url, base
+
+
+def rewrite_m3u8(text: str, orig_url: str, hf_base: str) -> str:
+    """Переписывает все URL в m3u8 через /proxy?url="""
+    base = orig_url.rsplit("/", 1)[0] + "/"
+
+    def to_proxy(seg: str) -> str:
+        seg = seg.strip()
+        if not seg:
+            return seg
+        if seg.startswith("http://") or seg.startswith("https://"):
+            abs_url = seg
+        elif seg.startswith("//"):
+            abs_url = "https:" + seg
+        else:
+            abs_url = urljoin(base, seg)
+
+        sub_base = abs_url.rsplit("/", 1)[0] + "/"
+        # Всегда передаём base для правильного разрешения .ts сегментов
+        return f"{hf_base}/proxy?url={quote(abs_url, safe='')}&base={quote(sub_base, safe='')}"
+
+    lines = text.splitlines()
+    out = []
+    for line in lines:
+        stripped = line.strip()
+        if not stripped:
+            out.append(line)
+        elif stripped.startswith("#"):
+            rewritten = re.sub(r'URI="([^"]+)"', lambda m: f'URI="{to_proxy(m.group(1))}"', line)
+            out.append(rewritten)
+        else:
+            out.append(to_proxy(stripped))
+    return "\n".join(out)
+
+
+@app.get("/")
+async def root():
+    return {"status": "ok"}
+
+
+@app.get("/mp4")
+async def mp4_proxy(vkId: str, quality: str = "720p", request: Request = None):
+    """Стримит MP4 через проксі с поддержкой Range запросов"""
+    async with httpx.AsyncClient(timeout=15) as client:
+        r = await client.get(
+            f"{CDN_HOST}/api/v1/player/sv/video/{vkId}",
+            headers=CDN_HEADERS
+        )
+        data = r.json()
+        sources = data.get("sources") or {}
+
+    quality_map = {
+        "1080p": sources.get("mpegFullHdUrl"),
+        "720p":  sources.get("mpegHighUrl"),
+        "480p":  sources.get("mpegMediumUrl"),
+        "360p":  sources.get("mpegLowUrl"),
+        "240p":  sources.get("mpegLowestUrl"),
+        "144p":  sources.get("mpegTinyUrl"),
+    }
+    url = quality_map.get(quality) or sources.get("mpegHighUrl") or sources.get("mpegFullHdUrl")
+    if not url:
+        return Response(content="not found", status_code=404)
+
+    # Передаём Range заголовок если есть (для перемотки)
+    req_headers = dict(VK_HEADERS)
+    if request and request.headers.get("range"):
+        req_headers["range"] = request.headers["range"]
+
+    from fastapi.responses import StreamingResponse as SR
+    import asyncio
+
+    async def stream_mp4():
+        async with httpx.AsyncClient(timeout=300) as client:
+            async with client.stream("GET", url, headers=req_headers) as r2:
+                async for chunk in r2.aiter_bytes(chunk_size=65536):
+                    yield chunk
+
+    # Получаем заголовки без тела
+    async with httpx.AsyncClient(timeout=15) as client:
+        head = await client.head(url, headers=req_headers)
+
+    resp_headers = {
+        "Access-Control-Allow-Origin": "*",
+        "Accept-Ranges": "bytes",
+        "Content-Type": head.headers.get("content-type", "video/mp4"),
+    }
+    if "content-length" in head.headers:
+        resp_headers["Content-Length"] = head.headers["content-length"]
+    if "content-range" in head.headers:
+        resp_headers["Content-Range"] = head.headers["content-range"]
+
+    status = 206 if request and request.headers.get("range") else 200
+
+    return StreamingResponse(stream_mp4(), status_code=status, headers=resp_headers, media_type="video/mp4")
+
+
+@app.get("/fresh_hls")
+async def fresh_hls(vkId: str, request: Request, quality: str = ""):
+    """Получает свежий HLS URL для vkId — решает проблему протухших expires= URL"""
+    async with httpx.AsyncClient(timeout=15) as client:
+        r = await client.get(
+            f"{CDN_HOST}/api/v1/player/sv/video/{vkId}",
+            headers=CDN_HEADERS
+        )
+        data = r.json()
+        hls_url = (data.get("sources") or {}).get("hlsUrl", "")
+        if not hls_url:
+            return Response(content="#EXTM3U\n#EXT-X-ENDLIST", media_type="application/vnd.apple.mpegurl")
+
+    hf = str(request.base_url).rstrip("/").replace("http://", "https://")
+    base = hls_url.rsplit("/", 1)[0] + "/"
+
+    # Получаем master m3u8 и ищем нужное качество
+    async with httpx.AsyncClient(timeout=15) as client:
+        r2 = await client.get(hls_url, headers=VK_HEADERS)
+        master = r2.text
+
+    if not master.strip().startswith("#EXTM3U"):
+        proxy_url = f"{hf}/proxy?url={quote(hls_url, safe='')}"
+        return Response(content=f"#EXTM3U\n#EXT-X-STREAM-INF:PROGRAM-ID=1\n{proxy_url}\n",
+                       media_type="application/vnd.apple.mpegurl",
+                       headers={"Access-Control-Allow-Origin": "*"})
+
+    # Маппинг качеств
+    quality_map = {
+        'ultra': '2160p', '4k': '2160p', 'quad': '1440p', '2k': '1440p',
+        'full': '1080p', 'hd': '720p', 'sd': '480p', 'low': '360p',
+        'lowest': '240p', 'mobile': '144p'
+    }
+    quality_order = ['2160p','1440p','1080p','720p','480p','360p','240p','144p']
+
+    # Парсим master и находим нужный sub-playlist
+    lines = master.splitlines()
+    streams = []
+    for i, line in enumerate(lines):
+        if line.startswith('#EXT-X-STREAM-INF') and i + 1 < len(lines):
+            next_line = lines[i + 1].strip()
+            if not next_line or next_line.startswith('#'):
+                continue
+            q_match = re.search(r'QUALITY=([^,\s]+)', line, re.I)
+            r_match = re.search(r'RESOLUTION=(\d+x\d+)', line, re.I)
+            label = None
+            if q_match:
+                label = quality_map.get(q_match.group(1).lower())
+                if not label:
+                    n = re.match(r'\d+', q_match.group(1))
+                    label = n.group() + 'p' if n else q_match.group(1)
+            elif r_match:
+                h = int(r_match.group(1).split('x')[1])
+                if h >= 2160: label = '2160p'
+                elif h >= 1440: label = '1440p'
+                elif h >= 1080: label = '1080p'
+                elif h >= 720: label = '720p'
+                elif h >= 480: label = '480p'
+                elif h >= 360: label = '360p'
+                else: label = f'{h}p'
+            if label:
+                abs_url = next_line if next_line.startswith('http') else urljoin(base, next_line)
+                streams.append((label, abs_url))
+
+    # Выбираем нужное качество или лучшее
+    target_url = None
+    if quality and streams:
+        for label, url in streams:
+            if label == quality:
+                target_url = url
+                break
+    if not target_url and streams:
+        # Сортируем и берём лучшее
+        def q_rank(item):
+            try: return quality_order.index(item[0])
+            except: return 99
+        streams.sort(key=q_rank)
+        target_url = streams[0][1]
+
+    if not target_url:
+        target_url = hls_url
+
+    # Проксируем выбранный sub-playlist
+    sub_base = target_url.rsplit("/", 1)[0] + "/"
+    proxy_url = f"{hf}/proxy?url={quote(target_url, safe='')}&base={quote(sub_base, safe='')}"
+
+    return Response(
+        content=f"#EXTM3U\n#EXT-X-STREAM-INF:PROGRAM-ID=1\n{proxy_url}\n",
+        media_type="application/vnd.apple.mpegurl",
+        headers={"Access-Control-Allow-Origin": "*"}
+    )
+async def kp_by_imdb(imdb: str = "", title: str = "", year: str = ""):
+    """Ищет Кинопоиск ID по IMDB ID или названию"""
+    KP_API_KEY = "0319695d-7be3-4b6b-9d55-58baa6527f39"
+    async with httpx.AsyncClient(timeout=10, follow_redirects=True) as client:
+        # Поиск по imdb_id
+        if imdb:
+            try:
+                r = await client.get(
+                    f"https://kinopoiskapiunofficial.tech/api/v2.2/films?imdbId={imdb}",
+                    headers={"X-API-KEY": KP_API_KEY}
+                )
+                if r.status_code == 200:
+                    data = r.json()
+                    items = data.get("items", [])
+                    if items and items[0].get("kinopoiskId"):
+                        return {"kp_id": items[0]["kinopoiskId"]}
+            except Exception:
+                pass
+
+        # П��иск по названию (fallback)
+        if title:
+            try:
+                r2 = await client.get(
+                    f"https://kinopoiskapiunofficial.tech/api/v2.1/films/search-by-keyword?keyword={title}",
+                    headers={"X-API-KEY": KP_API_KEY}
+                )
+                if r2.status_code == 200:
+                    data2 = r2.json()
+                    films = data2.get("films", [])
+                    for film in films:
+                        film_year = str(film.get("year", ""))
+                        if not year or film_year == year or abs(int(film_year or 0) - int(year or 0)) <= 1:
+                            kp = film.get("filmId")
+                            if kp:
+                                return {"kp_id": kp}
+            except Exception:
+                pass
+
+    return {"kp_id": None}
+
+
+@app.get("/cdnvideohub/playlist")
+async def playlist(kp: int):
+    async with httpx.AsyncClient(timeout=15) as client:
+        r = await client.get(
+            f"{CDN_HOST}/api/v1/player/sv/playlist?pub=12&aggr=kp&id={kp}",
+            headers=CDN_HEADERS
+        )
+    return Response(content=r.content, status_code=r.status_code, media_type="application/json")
+
+
+@app.get("/cdnvideohub/video")
+async def video(vkId: str):
+    async with httpx.AsyncClient(timeout=15) as client:
+        r = await client.get(
+            f"{CDN_HOST}/api/v1/player/sv/video/{vkId}",
+            headers=CDN_HEADERS
+        )
+    return Response(content=r.content, status_code=r.status_code, media_type="application/json")
+
+
+@app.get("/proxy")
+async def proxy(request: Request):
+    url, base_override = parse_proxy_params(request)
+
+    if not url:
+        return Response(content="no url", status_code=400)
+
+    # base для разрешения относительных путей
+    base = base_override if base_override else url.rsplit("/", 1)[0] + "/"
+
+    async with httpx.AsyncClient(timeout=30, follow_redirects=True) as client:
+        r = await client.get(url, headers=VK_HEADERS)
+
+    content_type = r.headers.get("content-type", "application/octet-stream")
+    text = r.text
+    is_m3u8 = "mpegurl" in content_type or ".m3u8" in url.split("?")[0] or text.strip().startswith("#EXTM3U")
+
+    if not is_m3u8:
+        return Response(
+            content=r.content,
+            status_code=r.status_code,
+            media_type=content_type,
+            headers={"Access-Control-Allow-Origin": "*"}
+        )
+
+    hf = str(request.base_url).rstrip("/").replace("http://", "https://")
+
+    def to_proxy(seg: str) -> str:
+        seg = seg.strip()
+        if not seg:
+            return seg
+        if seg.startswith("http://") or seg.startswith("https://"):
+            abs_url = seg
+        elif seg.startswith("//"):
+            abs_url = "https:" + seg
+        else:
+            abs_url = urljoin(base, seg)
+        sub_base = abs_url.rsplit("/", 1)[0] + "/"
+        return f"{hf}/proxy?url={quote(abs_url, safe='')}&base={quote(sub_base, safe='')}"
+
+    lines = text.splitlines()
+    out = []
+    for line in lines:
+        stripped = line.strip()
+        if not stripped:
+            out.append(line)
+        elif stripped.startswith("#"):
+            rewritten = re.sub(r'URI="([^"]+)"', lambda m: f'URI="{to_proxy(m.group(1))}"', line)
+            out.append(rewritten)
+        else:
+            out.append(to_proxy(stripped))
+
+    return Response(
+        content="\n".join(out),
+        media_type="application/vnd.apple.mpegurl",
+        headers={"Access-Control-Allow-Origin": "*"}
+    )