Delete app.py

app.py

@@ -1,352 +0,0 @@
-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": "*"}
-    )