Upload 5 files

tvproxy-main/Dockerfile

@@ -0,0 +1,30 @@
+# Usa l'immagine base di Python
+FROM python:3.12-slim
+
+# Imposta la directory di lavoro
+WORKDIR /app
+
+# Copia i file necessari
+COPY requirements.txt .
+COPY app.py .
+
+# Installa le dipendenze
+RUN pip install --upgrade pip
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Installa Gunicorn (se non è già in requirements.txt)
+RUN pip install gunicorn
+
+# Espone la porta 7860 per Flask/Gunicorn
+EXPOSE 7860
+
+# Comando per avviare il server Flask con Gunicorn e 4 worker
+CMD ["gunicorn", "app:app", \
+     "-w", "4", \
+     "--worker-class", "gevent", \
+     "--worker-connections", "100", \
+     "-b", "0.0.0.0:7860", \
+     "--timeout", "120", \
+     "--keep-alive", "5", \
+     "--max-requests", "1000", \
+     "--max-requests-jitter", "100"]

tvproxy-main/DockerfileHF

@@ -0,0 +1,33 @@
+# Usa l'immagine base di Python
+FROM python:3.12-slim
+
+# Installa git e certificati SSL
+RUN apt-get update && apt-get install -y \
+    git \
+    ca-certificates \
+    && rm -rf /var/lib/apt/lists/*
+
+# Imposta la directory di lavoro
+WORKDIR /app
+
+# Clona il repository GitHub
+RUN git clone https://github.com/nzo66/tvproxy .
+COPY . .
+
+# Installa le dipendenze
+RUN pip install --upgrade pip
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Espone la porta 7860 per Flask/Gunicorn
+EXPOSE 7860
+
+# Comando ottimizzato per avviare il server
+CMD ["gunicorn", "app:app", \
+     "-w", "4", \
+     "--worker-class", "gevent", \
+     "--worker-connections", "100", \
+     "-b", "0.0.0.0:7860", \
+     "--timeout", "120", \
+     "--keep-alive", "5", \
+     "--max-requests", "1000", \
+     "--max-requests-jitter", "100"]

tvproxy-main/README.md

@@ -0,0 +1,295 @@
+# tvproxy 📺
+
+Un server proxy leggero e dockerizzato basato su **Flask** e **Requests**, progettato per superare restrizioni e accedere a flussi M3U/M3U8 senza interruzioni.
+
+- 📥 **Scarica e modifica** flussi `.m3u` e `.m3u8` al volo.
+- 🔁 **Proxa i segmenti** `.ts` mantenendo header personalizzati.
+- 🚫 **Supera restrizioni** comuni come `Referer`, `User-Agent`, ecc.
+- 🐳 **Facilmente dockerizzabile** su qualsiasi macchina, server o piattaforma cloud.
+
+---
+
+## 📚 Indice
+
+- Piattaforme di Deploy
+  - Render
+  - HuggingFace
+- Setup Locale
+  - Docker
+  - Termux (Android)
+  - Python
+- Utilizzo del Proxy
+- Configurazione Proxy
+- Gestione Docker
+
+---
+
+## ☁️ Piattaforme di Deploy
+
+### ▶️ Deploy su Render
+
+1.  Vai su **Projects → New → Web Service → Public Git Repo**.
+2.  Inserisci l'URL del repository: `https://github.com/nzo66/tvproxy` e clicca **Connect**.
+3.  Scegli un nome a piacere per il servizio.
+4.  Imposta **Instance Type** su `Free` (o un'opzione a pagamento per prestazioni migliori).
+5.  **(Opzionale) Configura le variabili d'ambiente per i proxy:**
+    *   Nella sezione **Environment**, aggiungi una o più variabili.
+    *   **Per proxy SOCKS5:**
+        *   **Key:** `SOCKS5_PROXY`
+        *   **Value:** `socks5://user:pass@host:port`
+    *   **Per proxy HTTP/HTTPS:**
+        *   **Key 1:** `HTTP_PROXY`
+        *   **Value 1:** `http://user:pass@host:port`
+        *   **Key 2:** `HTTPS_PROXY`
+        *   **Value 2:** `http://user:pass@host:port`
+    *   **Nota:** Puoi inserire più proxy (dello stesso tipo) separandoli da una virgola. Lo script ne sceglierà uno a caso per ogni richiesta.
+    *   Per maggiori dettagli, consulta la sezione Configurazione Proxy.
+6.  Clicca su **Create Web Service**.
+
+### 🤗 Deploy su HuggingFace
+
+1.  Crea un nuovo **Space**.
+2.  Scegli un nome, seleziona **Docker** come SDK e lascia la visibilità su **Public**.
+3.  Vai su **Files** → `⋮` → **Upload file** e carica il file `DockerfileHF` dal repository, rinominandolo in **Dockerfile**.
+4.  **Configura le variabili d'ambiente per la porta:**
+    *   Vai su **Settings** del tuo Space.
+    *   Nella sezione **Secrets**, aggiungi un nuovo secret.
+5.  **(Opzionale) Configura un proxy HTTP/HTTPS:**
+    *   HuggingFace Spaces **non supporta proxy SOCKS5**, ma puoi usare proxy HTTP/HTTPS.
+    *   Nella sezione **Secrets**, aggiungi i seguenti secret (devono essere usati entrambi):
+    *   **Secret 1:**
+        *   **Name:** `HTTP_PROXY`
+        *   **Value:** `http://user:pass@host:port,http://user:pass@host:port`
+    *   **Secret 2:**
+        *   **Name:** `HTTPS_PROXY`
+        *   **Value:** `http://user:pass@host:port,http://user:pass@host:port`
+    *   **Nota:** Entrambe le variabili devono puntare allo stesso URL del proxy HTTP.
+6.  Una volta completato il deploy, vai su `⋮` → **Embed this Space** per ottenere il **Direct URL**.
+
+> 🔄 **Nota:** Se aggiorni il valore del proxy o altre variabili, ricorda di fare un "Factory Rebuild" dallo Space per applicare le modifiche.
+
+---
+
+## 💻 Setup Locale
+
+### 🐳 Docker (Locale o Server)
+
+#### Costruzione e Avvio
+
+1.  **Clona il repository e costruisci l'immagine Docker:**
+    ```bash
+    git clone https://github.com/nzo66/tvproxy.git
+    cd tvproxy
+    docker build -t tvproxy .
+    ```
+
+2.  **Avvia il container:**
+
+    *   **Senza proxy:**
+        ```bash
+        docker run -d -p 7860:7860 --name tvproxy tvproxy
+        ```
+
+    *   **Con un proxy SOCKS5:**
+        ```bash
+        docker run -d -p 7860:7860 -e SOCKS5_PROXY="socks5://proxy1,socks5://proxy2" --name tvproxy tvproxy
+        ```
+    *   **Con un proxy HTTP/HTTPS:**
+        ```bash
+        docker run -d -p 7860:7860 -e HTTP_PROXY="http://proxy.example.com:8080,http://user:pass@host:port" -e HTTPS_PROXY="http://proxy.example.com:8080,http://user:pass@host:port" --name tvproxy tvproxy
+        ```
+### 🐧 Termux (Dispositivi Android)
+
+1.  **Installa i pacchetti necessari:**
+    ```bash
+    pkg update && pkg upgrade
+    pkg install git python nano -y
+    ```
+
+2.  **Clona il repository e installa le dipendenze:**
+    ```bash
+    git clone https://github.com/nzo66/tvproxy.git
+    cd tvproxy
+    pip install -r requirements.txt
+    ```
+
+3.  **(Opzionale) Configura un proxy tramite file `.env`:**
+    ```bash
+    # Crea e apri il file .env con l'editor nano
+    nano .env
+    ```
+    Incolla la configurazione nel file. Puoi usare proxy SOCKS5 o HTTP/HTTPS. Salva con `Ctrl+X`, poi `Y` e `Invio`.
+    ```dotenv
+    # Scegli solo un tipo di proxy (SOCKS5 o HTTP/HTTPS).
+    # Rimuovi il commento (#) dalle righe che vuoi usare.
+
+    # --- Proxy SOCKS5 (uno o più, separati da virgola) ---
+    # SOCKS5_PROXY="socks5://user:pass@host1:port,socks5://host2:port"
+
+    # --- Proxy HTTP/HTTPS (devono essere specificati entrambi) ---
+    # HTTP_PROXY="http://user:pass@host:port,http://user:pass@host:port"
+    # HTTPS_PROXY="http://user:pass@host:port,http://user:pass@host:port"
+    ```
+
+4.  **Avvia il server con Gunicorn:**
+    ```bash
+    gunicorn app:app -w 4 --worker-class gevent -b 0.0.0.0:7860
+    ```
+    > 👉 **Consiglio:** Per un avvio più robusto, puoi usare i parametri aggiuntivi:
+    > ```bash
+    > gunicorn app:app -w 4 --worker-class gevent --worker-connections 100 -b 0.0.0.0:7860 --timeout 120 --keep-alive 5 --max-requests 1000 --max-requests-jitter 100
+    > ```
+
+### 🐍 Python (Locale)
+
+1.  **Clona il repository:**
+    ```bash
+    git clone https://github.com/nzo66/tvproxy.git
+    cd tvproxy
+    ```
+
+2.  **Installa le dipendenze:**
+    ```bash
+    pip install -r requirements.txt
+    ```
+
+3.  **(Opzionale) Configura un proxy tramite file `.env`:**
+    Crea un file `.env` nella cartella principale e aggiungi la configurazione del proxy. Lo script lo caricherà automaticamente.
+    ```bash
+    # Esempio: crea e modifica il file con nano
+    nano .env
+    ```
+    **Contenuto del file `.env`:**
+    ```dotenv
+    # Scegli solo un tipo di proxy (SOCKS5 o HTTP/HTTPS).
+    # Rimuovi il commento (#) dalle righe che vuoi usare.
+
+    # --- Proxy SOCKS5 (uno o più, separati da virgola) ---
+    # SOCKS5_PROXY="socks5://user:pass@host1:port,socks5://host2:port"
+
+    # --- Proxy HTTP/HTTPS (devono essere specificati entrambi) ---
+    # HTTP_PROXY="http://user:pass@host:port,http://user:pass@host:port"
+    # HTTPS_PROXY="http://user:pass@host:port,http://user:pass@host:port"
+    ```
+
+4.  **Avvia il server con Gunicorn:**
+    ```bash
+    gunicorn app:app -w 4 --worker-class gevent --worker-connections 100 -b 0.0.0.0:7860 --timeout 120 --keep-alive 5 --max-requests 1000 --max-requests-jitter 100
+    ```
+
+---
+
+## 🛠️ Come Utilizzare
+
+Sostituisci `<server-ip>` con l'IP o l'hostname del tuo server e `<URL_...>` con gli URL che vuoi proxare.
+
+### 📡 Endpoint 1: Proxy per Liste M3U Complete
+
+Ideale per proxare un'intera lista M3U, garantendo compatibilità con vari formati (es. Vavoo, Daddylive).
+
+**Formato URL:**
+```text
+http://<server-ip>:7860/proxy?url=<URL_LISTA_M3U>
+```
+
+### 📺 Endpoint 2: Proxy per Singoli Flussi M3U8 (con Headers)
+
+Specifico per proxare un singolo flusso `.m3u8`, con la possibilità di aggiungere headers HTTP personalizzati per superare protezioni specifiche.
+
+**Formato URL Base:**
+```text
+http://<server-ip>:7860/proxy/m3u?url=<URL_FLUSSO_M3U8>
+```
+
+**Aggiungere Headers Personalizzati (Opzionale):**
+Per aggiungere headers, accodali all'URL usando il prefisso `&h_`.
+
+**Formato:**
+```text
+&h_<NOME_HEADER>=<VALORE_HEADER>
+```
+
+**Esempio completo con Headers:**
+```text
+http://<server-ip>:7860/proxy/m3u?url=https://example.com/stream.m3u8&h_user-agent=VLC/3.0.20&h_referer=https://example.com/
+```
+
+> ⚠️ **Attenzione:** Se i valori degli header contengono caratteri speciali, assicurati che siano correttamente **URL-encoded**.
+
+---
+
+## 🔒 Configurazione Proxy
+
+L'uso dei proxy è **completamente opzionale**. Se non viene specificato alcun proxy, tutte le richieste verranno effettuate direttamente dal server. Configurali solo se hai bisogno di superare blocchi geografici o restrizioni di rete.
+
+Lo script supporta proxy **SOCKS5**, **HTTP** e **HTTPS** tramite variabili d'ambiente o un file `.env`.
+
+### Variabili d'Ambiente
+
+| Variabile            | Descrizione                                                                                              | Esempio                                                    |
+| -------------------- | -------------------------------------------------------------------------------------------------------- | --------------------------------------------------         |
+| `SOCKS5_PROXY`       | Uno o più proxy SOCKS5, separati da virgola.                                                             | `socks5://user:pass@host:port,socks5://host2:port`         |
+| `HTTP_PROXY`         | L'URL del proxy HTTP. Da usare in coppia con `HTTPS_PROXY`.                                              | `http://user:pass@host:port,http://host:port`              |
+| `HTTPS_PROXY`        | L'URL del proxy per le richieste HTTPS. Di solito è lo stesso di `HTTP_PROXY`.                            | `http://user:pass@host:port,http://host:port`             |
+
+### Esempio di file `.env` (per uso locale)
+
+Crea un file `.env` nella directory principale del progetto per configurare facilmente i proxy durante lo sviluppo locale. Lo script caricherà automaticamente le variabili.
+
+```dotenv
+# Scegli solo un tipo di proxy (SOCKS5 o HTTP/HTTPS).
+# Rimuovi il commento (#) dalle righe che vuoi usare.
+
+# --- Proxy SOCKS5 ---
+# Puoi specificare uno o più proxy, separati da virgola.
+# SOCKS5_PROXY="socks5://user:pass@host1:port,socks5://host2:port"
+
+# --- Proxy HTTP/HTTPS ---
+# Devi specificare entrambe le variabili con lo stesso valore.
+# HTTP_PROXY="http://user:pass@host:port,http://host:port"
+# HTTPS_PROXY="http://user:pass@host:port,http://host:port"
+```
+
+---
+
+## 🔐 Proxy Consigliato per Streaming
+
+### 🌍 [proxy-cheap](https://www.proxy-cheap.com/) — HTTP & SOCKS5 Static Datacenter Dedicati
+
+> ⚠️ **Importante:** HuggingFace supporta solo proxy **HTTP**  
+> ✅ Ideale per: Streaming, scraping, AI requests, automazioni
+
+---
+
+🎁 **Usa il codice coupon:** `NZO66`  
+💸 **Ottieni il 10% di sconto prima del pagamento!**
+
+---
+
+🔧 Affidabile, veloce, anonimo — Perfetto per chi cerca stabilità nei proxy dedicati.
+
+---
+
+## 🐳 Gestione Docker
+
+-   **Visualizza i log:** `docker logs -f tvproxy`
+-   **Ferma il container:** `docker stop tvproxy`
+-   **Avvia il container:** `docker start tvproxy`
+-   **Rimuovi il container:** `docker rm -f tvproxy`
+
+---
+
+## ✅ Caratteristiche Principali
+
+-   ✅ Supporto automatico per `.m3u` e `.m3u8`.
+-   ✅ Inoltro di headers HTTP personalizzati (`Authorization`, `Referer`, etc.).
+-   ✅ Superamento di restrizioni geografiche o di accesso.
+-   ✅ Compatibilità con qualsiasi player IPTV.
+-   ✅ Totalmente dockerizzato e pronto per il deploy.
+-   ✅ Avviabile anche direttamente con Python.
+
+---
+
+## 🎉 Enjoy the Stream!
+
+> Ora puoi guardare i tuoi flussi preferiti ovunque, senza restrizioni.

tvproxy-main/app.py

@@ -0,0 +1,1040 @@
+from flask import Flask, request, Response, jsonify
+import requests
+from urllib.parse import urlparse, urljoin, quote, unquote
+import re
+import traceback
+import json
+import base64
+from urllib.parse import quote_plus
+import os
+import random
+import time
+from cachetools import TTLCache, LRUCache
+from dotenv import load_dotenv
+from requests.adapters import HTTPAdapter
+from urllib3.util.retry import Retry
+import psutil
+from threading import Thread, Lock
+import weakref
+
+app = Flask(__name__)
+
+load_dotenv()
+
+# --- Configurazione Generale ---
+VERIFY_SSL = os.environ.get('VERIFY_SSL', 'false').lower() not in ('false', '0', 'no')
+if not VERIFY_SSL:
+    print("ATTENZIONE: La verifica del certificato SSL è DISABILITATA. Questo potrebbe esporre a rischi di sicurezza.")
+    import urllib3
+    urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
+
+# Timeout aumentato per gestire meglio i segmenti TS di grandi dimensioni
+REQUEST_TIMEOUT = int(os.environ.get('REQUEST_TIMEOUT', 30))
+print(f"Timeout per le richieste impostato a {REQUEST_TIMEOUT} secondi.")
+
+# Configurazioni Keep-Alive
+KEEP_ALIVE_TIMEOUT = int(os.environ.get('KEEP_ALIVE_TIMEOUT', 300))  # 5 minuti
+MAX_KEEP_ALIVE_REQUESTS = int(os.environ.get('MAX_KEEP_ALIVE_REQUESTS', 1000))
+POOL_CONNECTIONS = int(os.environ.get('POOL_CONNECTIONS', 20))
+POOL_MAXSIZE = int(os.environ.get('POOL_MAXSIZE', 50))
+
+print(f"Keep-Alive configurato: timeout={KEEP_ALIVE_TIMEOUT}s, max_requests={MAX_KEEP_ALIVE_REQUESTS}")
+
+# --- Variabili globali per monitoraggio sistema ---
+system_stats = {
+    'ram_usage': 0,
+    'ram_used_gb': 0,
+    'ram_total_gb': 0,
+    'network_sent': 0,
+    'network_recv': 0,
+    'bandwidth_usage': 0
+}
+
+# Pool globale di sessioni per connessioni persistenti
+SESSION_POOL = {}
+SESSION_LOCK = Lock()
+
+def get_system_stats():
+    """Ottiene le statistiche di sistema in tempo reale"""
+    global system_stats
+    
+    # Memoria RAM
+    memory = psutil.virtual_memory()
+    system_stats['ram_usage'] = memory.percent
+    system_stats['ram_used_gb'] = memory.used / (1024**3)  # GB
+    system_stats['ram_total_gb'] = memory.total / (1024**3)  # GB
+    
+    # Utilizzo di rete
+    net_io = psutil.net_io_counters()
+    system_stats['network_sent'] = net_io.bytes_sent / (1024**2)  # MB
+    system_stats['network_recv'] = net_io.bytes_recv / (1024**2)  # MB
+    
+    return system_stats
+
+def monitor_bandwidth():
+    """Monitora la banda di rete in background"""
+    global system_stats
+    prev_sent = 0
+    prev_recv = 0
+    
+    while True:
+        try:
+            net_io = psutil.net_io_counters()
+            current_sent = net_io.bytes_sent
+            current_recv = net_io.bytes_recv
+            
+            if prev_sent > 0 and prev_recv > 0:
+                # Calcola la banda utilizzata nell'ultimo secondo (in MB/s)
+                sent_per_sec = (current_sent - prev_sent) / (1024 * 1024)  # Convertito in MB/s
+                recv_per_sec = (current_recv - prev_recv) / (1024 * 1024)  # Convertito in MB/s
+                system_stats['bandwidth_usage'] = sent_per_sec + recv_per_sec
+            
+            prev_sent = current_sent
+            prev_recv = current_recv
+        except Exception as e:
+            print(f"Errore nel monitoraggio banda: {e}")
+        
+        time.sleep(1)
+
+def connection_manager():
+    """Thread per gestire le connessioni persistenti"""
+    while True:
+        try:
+            time.sleep(300)  # Controlla ogni 5 minuti
+            
+            # Statistiche connessioni
+            with SESSION_LOCK:
+                active_sessions = len(SESSION_POOL)
+                print(f"Sessioni attive nel pool: {active_sessions}")
+                
+                # Pulizia periodica delle sessioni inattive
+                if active_sessions > 10:  # Se troppe sessioni, pulisci
+                    cleanup_sessions()
+                    
+        except Exception as e:
+            print(f"Errore nel connection manager: {e}")
+
+def cleanup_sessions():
+    """Pulisce le sessioni inattive dal pool"""
+    global SESSION_POOL, SESSION_LOCK
+    
+    with SESSION_LOCK:
+        for key, session in list(SESSION_POOL.items()):
+            try:
+                session.close()
+            except:
+                pass
+        SESSION_POOL.clear()
+        print("Pool di sessioni pulito")
+
+# Avvia i thread di monitoraggio
+bandwidth_thread = Thread(target=monitor_bandwidth, daemon=True)
+bandwidth_thread.start()
+
+connection_thread = Thread(target=connection_manager, daemon=True)
+connection_thread.start()
+
+# --- Configurazione Proxy ---
+PROXY_LIST = []
+
+def setup_proxies():
+    """Carica la lista di proxy SOCKS5, HTTP e HTTPS dalle variabili d'ambiente."""
+    global PROXY_LIST
+    proxies_found = []
+
+    socks_proxy_list_str = os.environ.get('SOCKS5_PROXY')
+    if socks_proxy_list_str:
+        raw_socks_list = [p.strip() for p in socks_proxy_list_str.split(',') if p.strip()]
+        if raw_socks_list:
+            print(f"Trovati {len(raw_socks_list)} proxy SOCKS5. Verranno usati a rotazione.")
+            for proxy in raw_socks_list:
+                final_proxy_url = proxy
+                if proxy.startswith('socks5://'):
+                    final_proxy_url = 'socks5h' + proxy[len('socks5'):]
+                    print(f"Proxy SOCKS5 convertito per garantire la risoluzione DNS remota")
+                elif not proxy.startswith('socks5h://'):
+                    print(f"ATTENZIONE: L'URL del proxy SOCKS5 non è un formato SOCKS5 valido (es. socks5:// o socks5h://). Potrebbe non funzionare.")
+                proxies_found.append(final_proxy_url)
+            print("Assicurati di aver installato la dipendenza per SOCKS: 'pip install PySocks'")
+
+    http_proxy_list_str = os.environ.get('HTTP_PROXY')
+    if http_proxy_list_str:
+        http_proxies = [p.strip() for p in http_proxy_list_str.split(',') if p.strip()]
+        if http_proxies:
+            print(f"Trovati {len(http_proxies)} proxy HTTP. Verranno usati a rotazione.")
+            proxies_found.extend(http_proxies)
+
+    https_proxy_list_str = os.environ.get('HTTPS_PROXY')
+    if https_proxy_list_str:
+        https_proxies = [p.strip() for p in https_proxy_list_str.split(',') if p.strip()]
+        if https_proxies:
+            print(f"Trovati {len(https_proxies)} proxy HTTPS. Verranno usati a rotazione.")
+            proxies_found.extend(https_proxies)
+
+    PROXY_LIST = proxies_found
+
+    if PROXY_LIST:
+        print(f"Totale di {len(PROXY_LIST)} proxy configurati. Verranno usati a rotazione per ogni richiesta.")
+    else:
+        print("Nessun proxy (SOCKS5, HTTP, HTTPS) configurato.")
+
+def get_proxy_for_url(url):
+    """Seleziona un proxy casuale dalla lista, ma lo salta per i domini GitHub."""
+    if not PROXY_LIST:
+        return None
+
+    try:
+        parsed_url = urlparse(url)
+        if 'github.com' in parsed_url.netloc:
+            return None
+    except Exception:
+        pass
+
+    chosen_proxy = random.choice(PROXY_LIST)
+    return {'http': chosen_proxy, 'https': chosen_proxy}
+
+def create_robust_session():
+    """Crea una sessione con configurazione robusta e keep-alive per connessioni persistenti."""
+    session = requests.Session()
+    
+    # Configurazione Keep-Alive
+    session.headers.update({
+        'Connection': 'keep-alive',
+        'Keep-Alive': f'timeout={KEEP_ALIVE_TIMEOUT}, max={MAX_KEEP_ALIVE_REQUESTS}'
+    })
+    
+    retry_strategy = Retry(
+        total=3,
+        read=2,
+        connect=2,
+        backoff_factor=1,
+        status_forcelist=[429, 500, 502, 503, 504],
+        allowed_methods=["HEAD", "GET", "OPTIONS"]
+    )
+    
+    adapter = HTTPAdapter(
+        max_retries=retry_strategy,
+        pool_connections=POOL_CONNECTIONS,
+        pool_maxsize=POOL_MAXSIZE,
+        pool_block=False
+    )
+    
+    session.mount("http://", adapter)
+    session.mount("https://", adapter)
+    
+    return session
+
+def get_persistent_session(proxy_url=None):
+    """Ottiene una sessione persistente dal pool o ne crea una nuova"""
+    global SESSION_POOL, SESSION_LOCK
+    
+    # Usa proxy_url come chiave, o 'default' se non c'è proxy
+    pool_key = proxy_url if proxy_url else 'default'
+    
+    with SESSION_LOCK:
+        if pool_key not in SESSION_POOL:
+            session = create_robust_session()
+            
+            # Configura proxy se fornito
+            if proxy_url:
+                session.proxies.update({'http': proxy_url, 'https': proxy_url})
+            
+            SESSION_POOL[pool_key] = session
+            print(f"Nuova sessione persistente creata per: {pool_key}")
+        
+        return SESSION_POOL[pool_key]
+
+def make_persistent_request(url, headers=None, timeout=None, proxy_url=None, **kwargs):
+    """Effettua una richiesta usando connessioni persistenti"""
+    session = get_persistent_session(proxy_url)
+    
+    # Headers per keep-alive
+    request_headers = {
+        'Connection': 'keep-alive',
+        'Keep-Alive': f'timeout={KEEP_ALIVE_TIMEOUT}, max={MAX_KEEP_ALIVE_REQUESTS}'
+    }
+    
+    if headers:
+        request_headers.update(headers)
+    
+    try:
+        response = session.get(
+            url, 
+            headers=request_headers, 
+            timeout=timeout or REQUEST_TIMEOUT,
+            verify=VERIFY_SSL,
+            **kwargs
+        )
+        return response
+    except Exception as e:
+        print(f"Errore nella richiesta persistente: {e}")
+        # In caso di errore, rimuovi la sessione dal pool
+        with SESSION_LOCK:
+            if proxy_url in SESSION_POOL:
+                del SESSION_POOL[proxy_url]
+        raise
+
+def get_dynamic_timeout(url, base_timeout=REQUEST_TIMEOUT):
+    """Calcola timeout dinamico basato sul tipo di risorsa."""
+    if '.ts' in url.lower():
+        return base_timeout * 2  # Timeout doppio per segmenti TS
+    elif '.m3u8' in url.lower():
+        return base_timeout * 1.5  # Timeout aumentato per playlist
+    else:
+        return base_timeout
+
+setup_proxies()
+
+# --- Configurazione Cache ---
+M3U8_CACHE = TTLCache(maxsize=200, ttl=5)
+TS_CACHE = TTLCache(maxsize=1000, ttl=300) 
+KEY_CACHE = TTLCache(maxsize=200, ttl=300)
+
+# --- Dynamic DaddyLive URL Fetcher ---
+DADDYLIVE_BASE_URL = None
+LAST_FETCH_TIME = 0
+FETCH_INTERVAL = 3600
+
+def get_daddylive_base_url():
+    """Fetches and caches the dynamic base URL for DaddyLive."""
+    global DADDYLIVE_BASE_URL, LAST_FETCH_TIME
+    current_time = time.time()
+    
+    if DADDYLIVE_BASE_URL and (current_time - LAST_FETCH_TIME < FETCH_INTERVAL):
+        return DADDYLIVE_BASE_URL
+
+    try:
+        print("Fetching dynamic DaddyLive base URL from GitHub...")
+        github_url = 'https://raw.githubusercontent.com/thecrewwh/dl_url/refs/heads/main/dl.xml'
+        response = requests.get(
+            github_url,
+            timeout=REQUEST_TIMEOUT,
+            proxies=get_proxy_for_url(github_url),
+            verify=VERIFY_SSL
+        )
+        response.raise_for_status()
+        content = response.text
+        match = re.search(r'src\s*=\s*"([^"]*)"', content)
+        if match:
+            base_url = match.group(1)
+            if not base_url.endswith('/'):
+                base_url += '/'
+            DADDYLIVE_BASE_URL = base_url
+            LAST_FETCH_TIME = current_time
+            print(f"Dynamic DaddyLive base URL updated to: {DADDYLIVE_BASE_URL}")
+            return DADDYLIVE_BASE_URL
+    except requests.RequestException as e:
+        print(f"Error fetching dynamic DaddyLive URL: {e}. Using fallback.")
+    
+    DADDYLIVE_BASE_URL = "https://daddylive.sx/"
+    print(f"Using fallback DaddyLive URL: {DADDYLIVE_BASE_URL}")
+    return DADDYLIVE_BASE_URL
+
+get_daddylive_base_url()
+
+def detect_m3u_type(content):
+    """Rileva se è un M3U (lista IPTV) o un M3U8 (flusso HLS)"""
+    if "#EXTM3U" in content and "#EXTINF" in content:
+        return "m3u8"
+    return "m3u"
+
+def replace_key_uri(line, headers_query):
+    """Sostituisce l'URI della chiave AES-128 con il proxy"""
+    match = re.search(r'URI="([^"]+)"', line)
+    if match:
+        key_url = match.group(1)
+        proxied_key_url = f"/proxy/key?url={quote(key_url)}&{headers_query}"
+        return line.replace(key_url, proxied_key_url)
+    return line
+
+def extract_channel_id(url):
+    """Estrae l'ID del canale da vari formati URL"""
+    match_premium = re.search(r'/premium(\d+)/mono\.m3u8$', url)
+    if match_premium:
+        return match_premium.group(1)
+
+    match_player = re.search(r'/(?:watch|stream|cast|player)/stream-(\d+)\.php', url)
+    if match_player:
+        return match_player.group(1)
+
+    return None
+
+def process_daddylive_url(url):
+    """Converte URL vecchi in formati compatibili con DaddyLive 2025"""
+    daddy_base_url = get_daddylive_base_url()
+    daddy_domain = urlparse(daddy_base_url).netloc
+
+    match_premium = re.search(r'/premium(\d+)/mono\.m3u8$', url)
+    if match_premium:
+        channel_id = match_premium.group(1)
+        new_url = f"{daddy_base_url}watch/stream-{channel_id}.php"
+        print(f"URL processato da {url} a {new_url}")
+        return new_url
+
+    if daddy_domain in url and any(p in url for p in ['/watch/', '/stream/', '/cast/', '/player/']):
+        return url
+
+    if url.isdigit():
+        return f"{daddy_base_url}watch/stream-{url}.php"
+
+    return url
+
+def resolve_m3u8_link(url, headers=None):
+    """Risolve URL DaddyLive con gestione avanzata degli errori di timeout."""
+    if not url:
+        print("Errore: URL non fornito.")
+        return {"resolved_url": None, "headers": {}}
+
+    current_headers = headers.copy() if headers else {}
+    
+    clean_url = url
+    extracted_headers = {}
+    if '&h_' in url or '%26h_' in url:
+        print("Rilevati parametri header nell'URL - Estrazione in corso...")
+        temp_url = url
+        if 'vavoo.to' in temp_url.lower() and '%26' in temp_url:
+             temp_url = temp_url.replace('%26', '&')
+        
+        if '%26h_' in temp_url:
+            temp_url = unquote(unquote(temp_url))
+
+        url_parts = temp_url.split('&h_', 1)
+        clean_url = url_parts[0]
+        header_params = '&h_' + url_parts[1]
+        
+        for param in header_params.split('&'):
+            if param.startswith('h_'):
+                try:
+                    key_value = param[2:].split('=', 1)
+                    if len(key_value) == 2:
+                        key = unquote(key_value[0]).replace('_', '-')
+                        value = unquote(key_value[1])
+                        extracted_headers[key] = value
+                except Exception as e:
+                    print(f"Errore nell'estrazione dell'header {param}: {e}")
+
+    print(f"Tentativo di risoluzione URL (DaddyLive): {clean_url}")
+
+    daddy_base_url = get_daddylive_base_url()
+    daddy_origin = urlparse(daddy_base_url).scheme + "://" + urlparse(daddy_base_url).netloc
+
+    daddylive_headers = {
+        'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36',
+        'Referer': daddy_base_url,
+        'Origin': daddy_origin
+    }
+    final_headers_for_resolving = {**current_headers, **daddylive_headers}
+
+    try:
+        print("Ottengo URL base dinamico...")
+        github_url = 'https://raw.githubusercontent.com/thecrewwh/dl_url/refs/heads/main/dl.xml'
+        main_url_req = requests.get(
+            github_url,
+            timeout=REQUEST_TIMEOUT,
+            proxies=get_proxy_for_url(github_url),
+            verify=VERIFY_SSL
+        )
+        main_url_req.raise_for_status()
+        main_url = main_url_req.text
+        baseurl = re.findall('(?s)src = "([^"]*)', main_url)[0]
+        print(f"URL base ottenuto: {baseurl}")
+
+        channel_id = extract_channel_id(clean_url)
+        if not channel_id:
+            print(f"Impossibile estrarre ID canale da {clean_url}")
+            return {"resolved_url": clean_url, "headers": current_headers}
+
+        print(f"ID canale estratto: {channel_id}")
+
+        stream_url = f"{baseurl}stream/stream-{channel_id}.php"
+        print(f"URL stream costruito: {stream_url}")
+
+        final_headers_for_resolving['Referer'] = baseurl + '/'
+        final_headers_for_resolving['Origin'] = baseurl
+
+        print(f"Passo 1: Richiesta a {stream_url}")
+        response = requests.get(stream_url, headers=final_headers_for_resolving, timeout=REQUEST_TIMEOUT, proxies=get_proxy_for_url(stream_url), verify=VERIFY_SSL)
+        response.raise_for_status()
+
+        iframes = re.findall(r'<a[^>]*href="([^"]+)"[^>]*>\s*<button[^>]*>\s*Player\s*2\s*<\/button>', response.text)
+        if not iframes:
+            print("Nessun link Player 2 trovato")
+            return {"resolved_url": clean_url, "headers": current_headers}
+
+        print(f"Passo 2: Trovato link Player 2: {iframes[0]}")
+
+        url2 = iframes[0]
+        url2 = baseurl + url2
+        url2 = url2.replace('//cast', '/cast')
+
+        final_headers_for_resolving['Referer'] = url2
+        final_headers_for_resolving['Origin'] = url2
+
+        print(f"Passo 3: Richiesta a Player 2: {url2}")
+        response = requests.get(url2, headers=final_headers_for_resolving, timeout=REQUEST_TIMEOUT, proxies=get_proxy_for_url(url2), verify=VERIFY_SSL)
+        response.raise_for_status()
+
+        iframes = re.findall(r'iframe src="([^"]*)', response.text)
+        if not iframes:
+            print("Nessun iframe trovato nella pagina Player 2")
+            return {"resolved_url": clean_url, "headers": current_headers}
+
+        iframe_url = iframes[0]
+        print(f"Passo 4: Trovato iframe: {iframe_url}")
+
+        print(f"Passo 5: Richiesta iframe: {iframe_url}")
+        response = requests.get(iframe_url, headers=final_headers_for_resolving, timeout=REQUEST_TIMEOUT, proxies=get_proxy_for_url(iframe_url), verify=VERIFY_SSL)
+        response.raise_for_status()
+
+        iframe_content = response.text
+
+        try:
+            channel_key = re.findall(r'(?s) channelKey = \"([^"]*)', iframe_content)[0]
+
+            auth_ts_b64 = re.findall(r'(?s)c = atob\("([^"]*)', iframe_content)[0]
+            auth_ts = base64.b64decode(auth_ts_b64).decode('utf-8')
+
+            auth_rnd_b64 = re.findall(r'(?s)d = atob\("([^"]*)', iframe_content)[0]
+            auth_rnd = base64.b64decode(auth_rnd_b64).decode('utf-8')
+
+            auth_sig_b64 = re.findall(r'(?s)e = atob\("([^"]*)', iframe_content)[0]
+            auth_sig = base64.b64decode(auth_sig_b64).decode('utf-8')
+            auth_sig = quote_plus(auth_sig)
+
+            auth_host_b64 = re.findall(r'(?s)a = atob\("([^"]*)', iframe_content)[0]
+            auth_host = base64.b64decode(auth_host_b64).decode('utf-8')
+
+            auth_php_b64 = re.findall(r'(?s)b = atob\("([^"]*)', iframe_content)[0]
+            auth_php = base64.b64decode(auth_php_b64).decode('utf-8')
+
+            print(f"Parametri estratti: channel_key={channel_key}")
+
+        except (IndexError, Exception) as e:
+            print(f"Errore estrazione parametri: {e}")
+            return {"resolved_url": clean_url, "headers": current_headers}
+
+        auth_url = f'{auth_host}{auth_php}?channel_id={channel_key}&ts={auth_ts}&rnd={auth_rnd}&sig={auth_sig}'
+        print(f"Passo 6: Autenticazione: {auth_url}")
+
+        auth_response = requests.get(auth_url, headers=final_headers_for_resolving, timeout=REQUEST_TIMEOUT, proxies=get_proxy_for_url(auth_url), verify=VERIFY_SSL)
+        auth_response.raise_for_status()
+
+        host = re.findall('(?s)m3u8 =.*?:.*?:.*?".*?".*?"([^"]*)', iframe_content)[0]
+        server_lookup = re.findall(r'n fetchWithRetry\(\s*\'([^\']*)', iframe_content)[0]
+
+        server_lookup_url = f"https://{urlparse(iframe_url).netloc}{server_lookup}{channel_key}"
+        print(f"Passo 7: Server lookup: {server_lookup_url}")
+
+        lookup_response = requests.get(server_lookup_url, headers=final_headers_for_resolving, timeout=REQUEST_TIMEOUT, proxies=get_proxy_for_url(server_lookup_url), verify=VERIFY_SSL)
+        lookup_response.raise_for_status()
+        server_data = lookup_response.json()
+        server_key = server_data['server_key']
+
+        print(f"Server key ottenuto: {server_key}")
+
+        referer_raw = f'https://{urlparse(iframe_url).netloc}'
+
+        clean_m3u8_url = f'https://{server_key}{host}{server_key}/{channel_key}/mono.m3u8'
+
+        print(f"URL M3U8 pulito costruito: {clean_m3u8_url}")
+
+        final_headers_for_fetch = {
+            'User-Agent': final_headers_for_resolving.get('User-Agent'),
+            'Referer': referer_raw,
+            'Origin': referer_raw
+        }
+
+        return {
+            "resolved_url": clean_m3u8_url,
+            "headers": final_headers_for_fetch
+        }
+
+    except (requests.exceptions.ConnectTimeout, requests.exceptions.ProxyError) as e:
+        print(f"ERRORE DI TIMEOUT O PROXY DURANTE LA RISOLUZIONE: {e}")
+        print("Questo problema è spesso legato a un proxy SOCKS5 lento, non funzionante o bloccato.")
+        print("CONSIGLI: Controlla che i tuoi proxy siano attivi. Prova ad aumentare il timeout impostando la variabile d'ambiente 'REQUEST_TIMEOUT' (es. a 20 o 30 secondi).")
+        return {"resolved_url": clean_url, "headers": current_headers}
+    except requests.exceptions.ConnectionError as e:
+        if "Read timed out" in str(e):
+            print(f"Read timeout durante la risoluzione per {clean_url}")
+            return {"resolved_url": clean_url, "headers": current_headers}
+        else:
+            print(f"Errore di connessione durante la risoluzione: {e}")
+            return {"resolved_url": clean_url, "headers": current_headers}
+    except requests.exceptions.ReadTimeout as e:
+        print(f"Read timeout esplicito per {clean_url}")
+        return {"resolved_url": clean_url, "headers": current_headers}
+    except Exception as e:
+        print(f"Errore durante la risoluzione: {e}")
+        import traceback
+        print(f"Traceback: {traceback.format_exc()}")
+        return {"resolved_url": clean_url, "headers": current_headers}
+
+@app.route('/stats')
+def get_stats():
+    """Endpoint per ottenere le statistiche di sistema"""
+    stats = get_system_stats()
+    return jsonify(stats)
+
+@app.route('/dashboard')
+def dashboard():
+    """Dashboard con statistiche di sistema"""
+    stats = get_system_stats()
+    daddy_base_url = get_daddylive_base_url()
+    
+    dashboard_html = f"""
+    <!DOCTYPE html>
+    <html>
+    <head>
+        <title>Proxy Dashboard</title>
+        <meta http-equiv="refresh" content="5">
+        <style>
+            body {{ font-family: Arial, sans-serif; margin: 20px; background-color: #f5f5f5; }}
+            .container {{ max-width: 1200px; margin: 0 auto; }}
+            .stats-grid {{ display: grid; grid-template-columns: repeat(auto-fit, minmax(300px, 1fr)); gap: 20px; margin: 20px 0; }}
+            .stat-card {{ background: white; padding: 20px; border-radius: 8px; box-shadow: 0 2px 4px rgba(0,0,0,0.1); }}
+            .stat-title {{ font-size: 18px; font-weight: bold; color: #333; margin-bottom: 10px; }}
+            .stat-value {{ font-size: 24px; color: #007bff; }}
+            .status {{ padding: 10px; background: #d4edda; border: 1px solid #c3e6cb; border-radius: 4px; margin: 20px 0; }}
+            .progress-bar {{ width: 100%; height: 20px; background-color: #e9ecef; border-radius: 10px; overflow: hidden; }}
+            .progress-fill {{ height: 100%; background-color: #007bff; transition: width 0.3s ease; }}
+            .connection-stats {{ background: #f8f9fa; padding: 15px; border-radius: 5px; margin: 10px 0; }}
+        </style>
+    </head>
+    <body>
+        <div class="container">
+            <h1>🚀 Proxy Monitoring Dashboard</h1>
+            
+            <div class="status">
+                <strong>Status:</strong> Proxy ONLINE - Base URL: {daddy_base_url}
+            </div>
+            
+            <div class="connection-stats">
+                <strong>Connessioni Persistenti:</strong> {len(SESSION_POOL)} sessioni attive nel pool
+            </div>
+            
+            <div class="stats-grid">
+                <div class="stat-card">
+                    <div class="stat-title">💾 Utilizzo RAM</div>
+                    <div class="stat-value">{stats['ram_usage']:.1f}%</div>
+                    <div class="progress-bar">
+                        <div class="progress-fill" style="width: {stats['ram_usage']}%"></div>
+                    </div>
+                    <small>{stats['ram_used_gb']:.2f} GB / {stats['ram_total_gb']:.2f} GB</small>
+                </div>
+                
+                <div class="stat-card">
+                    <div class="stat-title">🌐 Banda di Rete</div>
+                    <div class="stat-value">{stats['bandwidth_usage']:.2f} MB/s</div>
+                    <small>Utilizzo corrente della banda</small>
+                </div>
+                
+                <div class="stat-card">
+                    <div class="stat-title">📤 Dati Inviati</div>
+                    <div class="stat-value">{stats['network_sent']:.1f} MB</div>
+                    <small>Totale dalla partenza</small>
+                </div>
+                
+                <div class="stat-card">
+                    <div class="stat-title">📥 Dati Ricevuti</div>
+                    <div class="stat-value">{stats['network_recv']:.1f} MB</div>
+                    <small>Totale dalla partenza</small>
+                </div>
+            </div>
+            
+            <div style="margin-top: 30px;">
+                <h3>🔗 Endpoints Disponibili:</h3>
+                <ul>
+                    <li><a href="/proxy?url=URL_M3U">/proxy</a> - Proxy per liste M3U</li>
+                    <li><a href="/proxy/m3u?url=URL_M3U8">/proxy/m3u</a> - Proxy per file M3U8</li>
+                    <li><a href="/proxy/resolve?url=URL">/proxy/resolve</a> - Risoluzione URL DaddyLive</li>
+                    <li><a href="/stats">/stats</a> - API JSON delle statistiche</li>
+                </ul>
+            </div>
+        </div>
+    </body>
+    </html>
+    """
+    
+    return dashboard_html
+
+@app.route('/proxy/m3u')
+def proxy_m3u():
+    """Proxy per file M3U e M3U8 con supporto DaddyLive 2025 e caching"""
+    m3u_url = request.args.get('url', '').strip()
+    if not m3u_url:
+        return "Errore: Parametro 'url' mancante", 400
+
+    cache_key_headers = "&".join(sorted([f"{k}={v}" for k, v in request.args.items() if k.lower().startswith("h_")]))
+    cache_key = f"{m3u_url}|{cache_key_headers}"
+
+    if cache_key in M3U8_CACHE:
+        print(f"Cache HIT per M3U8: {m3u_url}")
+        cached_response = M3U8_CACHE[cache_key]
+        return Response(cached_response, content_type="application/vnd.apple.mpegurl")
+    print(f"Cache MISS per M3U8: {m3u_url}")
+
+    daddy_base_url = get_daddylive_base_url()
+    daddy_origin = urlparse(daddy_base_url).scheme + "://" + urlparse(daddy_base_url).netloc
+
+    default_headers = {
+        "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36",
+        "Referer": daddy_base_url,
+        "Origin": daddy_origin
+    }
+
+    request_headers = {
+        unquote(key[2:]).replace("_", "-"): unquote(value).strip()
+        for key, value in request.args.items()
+        if key.lower().startswith("h_")
+    }
+
+    headers = {**default_headers, **request_headers}
+
+    processed_url = process_daddylive_url(m3u_url)
+
+    try:
+        print(f"Chiamata a resolve_m3u8_link per URL processato: {processed_url}")
+        result = resolve_m3u8_link(processed_url, headers)
+        if not result["resolved_url"]:
+            return "Errore: Impossibile risolvere l'URL in un M3U8 valido.", 500
+
+        resolved_url = result["resolved_url"]
+        current_headers_for_proxy = result["headers"]
+
+        print(f"Risoluzione completata. URL M3U8 finale: {resolved_url}")
+
+        if not resolved_url.endswith('.m3u8'):
+            print(f"URL risolto non è un M3U8: {resolved_url}")
+            return "Errore: Impossibile ottenere un M3U8 valido dal canale", 500
+
+        print(f"Fetching M3U8 content from clean URL: {resolved_url}")
+        print(f"Using headers: {current_headers_for_proxy}")
+
+        timeout = get_dynamic_timeout(resolved_url)
+        proxy_config = get_proxy_for_url(resolved_url)
+        proxy_key = proxy_config['http'] if proxy_config else None
+        
+        m3u_response = make_persistent_request(
+            resolved_url,
+            headers=current_headers_for_proxy,
+            timeout=timeout,
+            proxy_url=proxy_key,
+            allow_redirects=True
+        )
+        m3u_response.raise_for_status()
+
+        m3u_content = m3u_response.text
+        final_url = m3u_response.url
+
+        file_type = detect_m3u_type(m3u_content)
+        if file_type == "m3u":
+            return Response(m3u_content, content_type="application/vnd.apple.mpegurl")
+
+        parsed_url = urlparse(final_url)
+        base_url = f"{parsed_url.scheme}://{parsed_url.netloc}{parsed_url.path.rsplit('/', 1)[0]}/"
+
+        headers_query = "&".join([f"h_{quote(k)}={quote(v)}" for k, v in current_headers_for_proxy.items()])
+
+        modified_m3u8 = []
+        for line in m3u_content.splitlines():
+            line = line.strip()
+            if line.startswith("#EXT-X-KEY") and 'URI="' in line:
+                line = replace_key_uri(line, headers_query)
+            elif line and not line.startswith("#"):
+                segment_url = urljoin(base_url, line)
+                line = f"/proxy/ts?url={quote(segment_url)}&{headers_query}"
+            modified_m3u8.append(line)
+
+        modified_m3u8_content = "\n".join(modified_m3u8)
+
+        M3U8_CACHE[cache_key] = modified_m3u8_content
+
+        return Response(modified_m3u8_content, content_type="application/vnd.apple.mpegurl")
+
+    except requests.RequestException as e:
+        print(f"Errore durante il download o la risoluzione del file: {str(e)}")
+        return f"Errore durante il download o la risoluzione del file M3U/M3U8: {str(e)}", 500
+    except Exception as e:
+        print(f"Errore generico nella funzione proxy_m3u: {str(e)}")
+        return f"Errore generico durante l'elaborazione: {str(e)}", 500
+
+@app.route('/proxy/resolve')
+def proxy_resolve():
+    """Proxy per risolvere e restituire un URL M3U8 con metodo DaddyLive 2025"""
+    url = request.args.get('url', '').strip()
+    if not url:
+        return "Errore: Parametro 'url' mancante", 400
+
+    daddy_base_url = get_daddylive_base_url()
+    daddy_origin = urlparse(daddy_base_url).scheme + "://" + urlparse(daddy_base_url).netloc
+
+    default_headers = {
+        "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36",
+        "Referer": daddy_base_url,
+        "Origin": daddy_origin
+    }
+
+    request_headers = {
+        unquote(key[2:]).replace("_", "-"): unquote(value).strip()
+        for key, value in request.args.items()
+        if key.lower().startswith("h_")
+    }
+
+    headers = {**default_headers, **request_headers}
+
+    try:
+        processed_url = process_daddylive_url(url)
+        result = resolve_m3u8_link(processed_url, headers)
+        if not result["resolved_url"]:
+            return "Errore: Impossibile risolvere l'URL", 500
+
+        headers_query = "&".join([f"h_{quote(k)}={quote(v)}" for k, v in result["headers"].items()])
+        return Response(
+            f"#EXTM3U\n"
+            f"#EXTINF:-1,Canale Risolto\n"
+            f"/proxy/m3u?url={quote(result['resolved_url'])}&{headers_query}",
+            content_type="application/vnd.apple.mpegurl"
+        )
+
+    except Exception as e:
+        return f"Errore durante la risoluzione dell'URL: {str(e)}", 500
+
+@app.route('/proxy/ts')
+def proxy_ts():
+    """Proxy per segmenti .TS con connessioni persistenti, headers personalizzati e caching"""
+    ts_url = request.args.get('url', '').strip()
+    if not ts_url:
+        return "Errore: Parametro 'url' mancante", 400
+
+    if ts_url in TS_CACHE:
+        print(f"Cache HIT per TS: {ts_url}")
+        return Response(TS_CACHE[ts_url], content_type="video/mp2t")
+    print(f"Cache MISS per TS: {ts_url}")
+
+    headers = {
+        unquote(key[2:]).replace("_", "-"): unquote(value).strip()
+        for key, value in request.args.items()
+        if key.lower().startswith("h_")
+    }
+
+    proxy_config = get_proxy_for_url(ts_url)
+    proxy_key = proxy_config['http'] if proxy_config else None
+    
+    ts_timeout = get_dynamic_timeout(ts_url)
+    max_retries = 3
+    
+    for attempt in range(max_retries):
+        try:
+            response = make_persistent_request(
+                ts_url,
+                headers=headers,
+                timeout=ts_timeout,
+                proxy_url=proxy_key,
+                stream=True,
+                allow_redirects=True
+            )
+            response.raise_for_status()
+
+            def generate_and_cache():
+                content_parts = []
+                try:
+                    for chunk in response.iter_content(chunk_size=8192):
+                        if chunk:
+                            content_parts.append(chunk)
+                            yield chunk
+                except (requests.exceptions.ConnectionError, requests.exceptions.ReadTimeout) as e:
+                    if "Read timed out" in str(e) or "timed out" in str(e).lower():
+                        print(f"Timeout durante il download del segmento TS (tentativo {attempt + 1}): {ts_url}")
+                        return
+                    raise
+                finally:
+                    ts_content = b"".join(content_parts)
+                    if ts_content and len(ts_content) > 1024:
+                        TS_CACHE[ts_url] = ts_content
+                        print(f"Segmento TS cachato ({len(ts_content)} bytes) per: {ts_url}")
+
+            return Response(generate_and_cache(), content_type="video/mp2t")
+
+        except requests.exceptions.ConnectionError as e:
+            if "Read timed out" in str(e) or "timed out" in str(e).lower():
+                print(f"Timeout del segmento TS (tentativo {attempt + 1}/{max_retries}): {ts_url}")
+                if attempt == max_retries - 1:
+                    return f"Errore: Timeout persistente per il segmento TS dopo {max_retries} tentativi", 504
+                time.sleep(2 ** attempt)
+                continue
+            else:
+                return f"Errore di connessione per il segmento TS: {str(e)}", 500
+        except requests.exceptions.ReadTimeout as e:
+            print(f"Read timeout esplicito per il segmento TS (tentativo {attempt + 1}/{max_retries}): {ts_url}")
+            if attempt == max_retries - 1:
+                return f"Errore: Read timeout persistente per il segmento TS dopo {max_retries} tentativi", 504
+            time.sleep(2 ** attempt)
+            continue
+        except requests.RequestException as e:
+            return f"Errore durante il download del segmento TS: {str(e)}", 500
+        
+@app.route('/proxy')
+def proxy():
+    """Proxy per liste M3U che aggiunge automaticamente /proxy/m3u?url= con IP prima dei link"""
+    m3u_url = request.args.get('url', '').strip()
+    if not m3u_url:
+        return "Errore: Parametro 'url' mancante", 400
+
+    try:
+        server_ip = request.host
+        proxy_config = get_proxy_for_url(m3u_url)
+        proxy_key = proxy_config['http'] if proxy_config else None
+        
+        response = make_persistent_request(
+            m3u_url,
+            timeout=REQUEST_TIMEOUT,
+            proxy_url=proxy_key
+        )
+        response.raise_for_status()
+        m3u_content = response.text
+        
+        modified_lines = []
+        current_stream_headers_params = [] 
+
+        for line in m3u_content.splitlines():
+            line = line.strip()
+            if line.startswith('#EXTHTTP:'):
+                try:
+                    json_str = line.split(':', 1)[1].strip()
+                    headers_dict = json.loads(json_str)
+                    for key, value in headers_dict.items():
+                        encoded_key = quote(quote(key))
+                        encoded_value = quote(quote(str(value)))
+                        current_stream_headers_params.append(f"h_{encoded_key}={encoded_value}")
+                except Exception as e:
+                    print(f"ERROR: Errore nel parsing di #EXTHTTP '{line}': {e}")
+                modified_lines.append(line)
+            
+            elif line.startswith('#EXTVLCOPT:'):
+                try:
+                    options_str = line.split(':', 1)[1].strip()
+                    for opt_pair in options_str.split(','):
+                        opt_pair = opt_pair.strip()
+                        if '=' in opt_pair:
+                            key, value = opt_pair.split('=', 1)
+                            key = key.strip()
+                            value = value.strip().strip('"')
+                            
+                            header_key = None
+                            if key.lower() == 'http-user-agent':
+                                header_key = 'User-Agent'
+                            elif key.lower() == 'http-referer':
+                                header_key = 'Referer'
+                            elif key.lower() == 'http-cookie':
+                                header_key = 'Cookie'
+                            elif key.lower() == 'http-header':
+                                full_header_value = value
+                                if ':' in full_header_value:
+                                    header_name, header_val = full_header_value.split(':', 1)
+                                    header_key = header_name.strip()
+                                    value = header_val.strip()
+                                else:
+                                    print(f"WARNING: Malformed http-header option in EXTVLCOPT: {opt_pair}")
+                                    continue
+                            
+                            if header_key:
+                                encoded_key = quote(quote(header_key))
+                                encoded_value = quote(quote(value))
+                                current_stream_headers_params.append(f"h_{encoded_key}={encoded_value}")
+                            
+                except Exception as e:
+                    print(f"ERROR: Errore nel parsing di #EXTVLCOPT '{line}': {e}")
+                modified_lines.append(line)
+            elif line and not line.startswith('#'):
+                if 'pluto.tv' in line.lower():
+                    modified_lines.append(line)
+                else:
+                    encoded_line = quote(line, safe='')
+                    headers_query_string = ""
+                    if current_stream_headers_params:
+                        headers_query_string = "%26" + "%26".join(current_stream_headers_params)
+                    
+                    modified_line = f"http://{server_ip}/proxy/m3u?url={encoded_line}{headers_query_string}"
+                    modified_lines.append(modified_line)
+                
+                current_stream_headers_params = [] 
+            else:
+                modified_lines.append(line)
+        
+        modified_content = '\n'.join(modified_lines)
+        parsed_m3u_url = urlparse(m3u_url)
+        original_filename = os.path.basename(parsed_m3u_url.path)
+        
+        return Response(modified_content, content_type="application/vnd.apple.mpegurl", headers={'Content-Disposition': f'attachment; filename="{original_filename}"'})
+        
+    except requests.RequestException as e:
+        print(f"ERRORE: Fallito il download di '{m3u_url}'.")
+        return f"Errore durante il download della lista M3U: {str(e)}", 500
+    except Exception as e:
+        return f"Errore generico: {str(e)}", 500
+
+@app.route('/proxy/key')
+def proxy_key():
+    """Proxy per la chiave AES-128 con headers personalizzati e caching"""
+    key_url = request.args.get('url', '').strip()
+    if not key_url:
+        return "Errore: Parametro 'url' mancante per la chiave", 400
+
+    if key_url in KEY_CACHE:
+        print(f"Cache HIT per KEY: {key_url}")
+        return Response(KEY_CACHE[key_url], content_type="application/octet-stream")
+    print(f"Cache MISS per KEY: {key_url}")
+
+    headers = {
+        unquote(key[2:]).replace("_", "-"): unquote(value).strip()
+        for key, value in request.args.items()
+        if key.lower().startswith("h_")
+    }
+
+    try:
+        proxy_config = get_proxy_for_url(key_url)
+        proxy_key = proxy_config['http'] if proxy_config else None
+        
+        response = make_persistent_request(
+            key_url,
+            headers=headers,
+            timeout=REQUEST_TIMEOUT,
+            proxy_url=proxy_key,
+            allow_redirects=True
+        )
+        response.raise_for_status()
+        key_content = response.content
+
+        KEY_CACHE[key_url] = key_content
+        return Response(key_content, content_type="application/octet-stream")
+
+    except requests.RequestException as e:
+        return f"Errore durante il download della chiave AES-128: {str(e)}", 500
+
+@app.route('/')
+def index():
+    """Pagina principale con statistiche di sistema"""
+    stats = get_system_stats()
+    base_url = get_daddylive_base_url()
+    
+    return f"""
+    <h1>🚀 Proxy ONLINE</h1>
+    <p><strong>Base URL DaddyLive:</strong> {base_url}</p>
+    
+    <h2>📊 Statistiche Sistema</h2>
+    <ul>
+        <li><strong>RAM:</strong> {stats['ram_usage']:.1f}% ({stats['ram_used_gb']:.2f} GB / {stats['ram_total_gb']:.2f} GB)</li>
+        <li><strong>Banda:</strong> {stats['bandwidth_usage']:.2f} MB/s</li>
+        <li><strong>Dati Inviati:</strong> {stats['network_sent']:.1f} MB</li>
+        <li><strong>Dati Ricevuti:</strong> {stats['network_recv']:.1f} MB</li>
+        <li><strong>Connessioni Persistenti:</strong> {len(SESSION_POOL)} sessioni attive</li>
+    </ul>
+    
+    <p><a href="/dashboard">📈 Dashboard Completo</a> | <a href="/stats">📊 API JSON</a></p>
+    """
+
+if __name__ == '__main__':
+    port = int(os.environ.get("PORT", 7860))
+    print(f"Proxy ONLINE - In ascolto su porta {port}")
+    app.run(host="0.0.0.0", port=port, debug=False)

tvproxy-main/requirements.txt

@@ -0,0 +1,7 @@
+flask
+requests
+gunicorn[gevent]
+python-dotenv
+cachetools
+PySocks
+psutil