Laberthread - Autoscript Vavoo auf e2 oder TvHeadend

###############################################################
PORT = 4323

ADDON_SIG_TTL = 600  # 10 Minuten
###############################################################

import json
import gzip
import requests
from io import BytesIO
import uuid
from flask import Flask, request, Response, abort
import time
import socket
import threading

# ---------------- LÄNDER ----------------

REGIONS = [
    {"language": "de", "region": "DE"},
    {"language": "de", "region": "AT"},
    {"language": "de", "region": "CH"},
    {"language": "es", "region": "ES"},
    {"language": "fr", "region": "FR"},
    {"language": "it", "region": "IT"},
    {"language": "nl", "region": "NL"},
    {"language": "nl", "region": "BE"},
    {"language": "en", "region": "UK"},
    {"language": "en", "region": "US"},
    {"language": "en", "region": "CA"},
    {"language": "pl", "region": "PL"},
    {"language": "cs", "region": "CZ"},
    {"language": "hu", "region": "HU"},
    {"language": "tr", "region": "TR"},
    {"language": "pt", "region": "PT"},
    {"language": "ro", "region": "RO"},
    {"language": "sv", "region": "SE"},
    {"language": "no", "region": "NO"},
    {"language": "da", "region": "DK"},
    {"language": "fi", "region": "FI"},
]

GEOIP_URL = "https://www.vavoo.tv/geoip"
PING_URL = "https://www.vavoo.tv/api/app/ping"
CATALOG_URL = "https://vavoo.to/mediahubmx-catalog.json"
RESOLVE_URL = "https://vavoo.to/mediahubmx-resolve.json"

# Default-Werte, werden pro Region überschrieben
LANGUAGE = "de"
REGION = "DE"

HEADERS = {
    "accept": "*/*",
    "user-agent": "electron-fetch/1.0 electron (+https://github.com/arantes555/electron-fetch)",
    "Accept-Language": LANGUAGE,
    "Accept-Encoding": "gzip, deflate",
    "Connection": "close",
}

def decode_response(resp):
    if resp.content[:2] == b'\x1f\x8b':
        return json.loads(gzip.decompress(resp.content))
    return resp.json()

session = requests.Session()
session.headers.update(HEADERS)

# ---------------- GEO + INITIAL PING ----------------

r_geo = session.get(GEOIP_URL)
r_geo.raise_for_status()
geo_data = decode_response(r_geo)

unique_id = str(uuid.uuid4())
current_timestamp = int(time.time() * 1000)

initial_payload = {
    "reason": "app-focus",
    "locale": "de",
    "theme": "dark",
    "metadata": {
        "device": {"type": "desktop", "uniqueId": unique_id},
        "os": {"name": "win32", "version": "Windows 10 Pro", "abis": ["x64"], "host": "Lenovo"},
        "app": {"platform": "electron"},
        "version": {"package": "tv.vavoo.app", "binary": "3.1.8", "js": "3.1.8"},
    },
    "appFocusTime": 0,
    "playerActive": False,
    "playDuration": 0,
    "devMode": False,
    "hasAddon": True,
    "castConnected": False,
    "package": "tv.vavoo.app",
    "version": "3.1.8",
    "process": "app",
    "firstAppStart": current_timestamp,
    "lastAppStart": current_timestamp,
    "ipLocation": None,
    "adblockEnabled": True,
    "proxy": {"supported": ["ss"], "engine": "Mu", "enabled": False, "autoServer": True},
    "iap": {"supported": False},
}

r1 = session.post(PING_URL, json=initial_payload)
r1.raise_for_status()
data1 = decode_response(r1)

# ---------------- ADDON SIG MANAGEMENT ----------------

addon_sig_lock = threading.Lock()
addon_sig_data = {
    "sig": data1.get("addonSig"),
    "ts": time.time()
}

def refresh_addon_sig_if_needed(force=False):
    with addon_sig_lock:
        now = time.time()
        if not force and now - addon_sig_data["ts"] < ADDON_SIG_TTL:
            return addon_sig_data["sig"]

        payload = initial_payload.copy()
        payload["lastAppStart"] = int(time.time() * 1000)

        r = session.post(PING_URL, json=payload)
        r.raise_for_status()
        data = decode_response(r)

        sig = data.get("addonSig")
        if not sig:
            raise RuntimeError("No addonSig received")

        addon_sig_data["sig"] = sig
        addon_sig_data["ts"] = now

        print("[✓] addonSig refreshed")
        return sig

# ---------------- CATALOG LOAD (MULTI-REGION) ----------------

all_filtered_items = []

for entry in REGIONS:
    LANGUAGE = entry["language"]
    REGION = entry["region"]

    print(f"[+] Lade Katalog für {LANGUAGE}-{REGION}")

    catalog_headers = {
        "content-type": "application/json; charset=utf-8",
        "mediahubmx-signature": addon_sig_data["sig"],
        "user-agent": "MediaHubMX/2",
        "accept": "*/*",
        "Accept-Language": LANGUAGE,
        "Accept-Encoding": "gzip, deflate",
        "Connection": "close",
    }

    cursor = None

    while True:
        catalog_payload = {
            "language": LANGUAGE,
            "region": REGION,
            "catalogId": "iptv",
            "id": "iptv",
            "adult": False,
            "search": "",
            "sort": "",
            "filter": {},
            "cursor": cursor,
            "clientVersion": "3.0.2"
        }

        r_catalog = session.post(CATALOG_URL, json=catalog_payload, headers=catalog_headers)
        r_catalog.raise_for_status()
        catalog_data = decode_response(r_catalog)

        for item in catalog_data.get("items", []):
            if item.get("type") == "iptv":
                all_filtered_items.append({
                    "id": item["ids"]["id"],
                    "url": item["url"],
                    "name": item["name"],
                    "group": item["group"],
                    "logo": item["logo"],
                    "language": LANGUAGE,
                    "region": REGION
                })

        cursor = catalog_data.get("nextCursor")
        if not cursor:
            break

print(f"[✓] Gesamtanzahl IPTV-Sender: {len(all_filtered_items)}")

# ---------------- M3U SAVE ----------------

LOCAL_IP = "127.0.0.1"

def get_local_ip():
    return LOCAL_IP

def save_m3u_file():
    local_ip = get_local_ip()
    m3u = "#EXTM3U\n"
    for item in all_filtered_items:
        m3u += (
            f'#EXTINF:-1 tvg-id="{item["id"]}" '
            f'tvg-name="{item["name"]}" '
            f'tvg-logo="{item["logo"]}" '
            f'group-title="{item["group"]} ({item["region"]})",{item["name"]}\n'
        )
        m3u += f"http://{local_ip}:{PORT}/vavoo?channel={item['id']}\n"

    with open("vavoo_playlist.m3u", "w", encoding="utf-8") as f:
        f.write(m3u)

    print("[✓] vavoo_playlist.m3u written")

save_m3u_file()

# ---------------- FLASK APP ----------------

app = Flask(__name__)

@app.route("/vavoo")
def stream_proxy():
    channel_id = request.args.get("channel")
    if not channel_id:
        abort(400)

    channel = next((i for i in all_filtered_items if i["id"] == channel_id), None)
    if not channel:
        abort(404)

    try:
        sig = refresh_addon_sig_if_needed()
    except Exception as e:
        abort(502, str(e))

    resolve_headers = {
        "content-type": "application/json; charset=utf-8",
        "mediahubmx-signature": sig,
        "user-agent": "MediaHubMX/2",
        "accept": "*/*",
        "Accept-Language": channel["language"],
        "Accept-Encoding": "gzip, deflate",
        "Connection": "close",
    }

    resolve_payload = {
        "language": channel["language"],
        "region": channel["region"],
        "url": channel["url"],
        "clientVersion": "3.0.2"
    }

    r_resolve = session.post(RESOLVE_URL, json=resolve_payload, headers=resolve_headers)

    if r_resolve.status_code == 403:
        sig = refresh_addon_sig_if_needed(force=True)
        resolve_headers["mediahubmx-signature"] = sig
        r_resolve = session.post(RESOLVE_URL, json=resolve_payload, headers=resolve_headers)

    r_resolve.raise_for_status()
    result = decode_response(r_resolve)

    if result:
        return Response(status=302, headers={"Location": result[0]["url"]})

    abort(404)

@app.route("/playlist.m3u")
def playlist():
    local_ip = get_local_ip()
    m3u = "#EXTM3U\n"
    for item in all_filtered_items:
        m3u += (
            f'#EXTINF:-1 tvg-id="{item["id"]}" '
            f'tvg-name="{item["name"]}" '
            f'tvg-logo="{item["logo"]}" '
            f'group-title="{item["group"]} ({item["region"]})",{item["name"]}\n'
        )
        m3u += f"http://{local_ip}:{PORT}/vavoo?channel={item['id']}\n"

    return Response(m3u, mimetype="application/x-mpegURL")

if __name__ == "__main__":
    app.run(host="0.0.0.0", port=PORT)

root@bre2ze4k:/home# python3 vavoo.py
[+] Lade Katalog für de-DE
[+] Lade Katalog für de-AT
[+] Lade Katalog für de-CH
[+] Lade Katalog für es-ES
[+] Lade Katalog für fr-FR
[+] Lade Katalog für it-IT
[+] Lade Katalog für nl-NL
[+] Lade Katalog für nl-BE
[+] Lade Katalog für en-UK
[+] Lade Katalog für en-US
[+] Lade Katalog für en-CA
[+] Lade Katalog für pl-PL
[+] Lade Katalog für cs-CZ
[+] Lade Katalog für hu-HU
[+] Lade Katalog für tr-TR
[+] Lade Katalog für pt-PT
[+] Lade Katalog für ro-RO
[+] Lade Katalog für sv-SE
[+] Lade Katalog für no-NO
[+] Lade Katalog für da-DK
[+] Lade Katalog für fi-FI
[✓] Gesamtanzahl IPTV-Sender: 96152
[✓] vavoo_playlist.m3u written
 * Serving Flask app 'vavoo'
 * Debug mode: off
WARNING: This is a development server. Do not use it in a production deployment. Use a production WSGI server instead.
 * Running on all addresses (0.0.0.0)
 * Running on http://127.0.0.1:4323
 * Running on http://192.168.1.39:4323
Press CTRL+C to quit