Upload 4 files

Dockerfile

@@ -0,0 +1,32 @@
+# 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 .
+
+# 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"]

README.md

@@ -1,10 +1,165 @@
+# 📺 tvproxy
+
+## 🚀 M3U8 Proxy Dockerizzato
+
+Un server proxy leggero basato su **Flask** e **Requests**, progettato per:
+
+- 📥 Scaricare e modificare flussi **.m3u / .m3u8**
+- 🔁 Proxare i segmenti `.ts`, mantenendo header personalizzati
+- 🚫 Superare restrizioni come **Referer**, **User-Agent**, ecc.
+- 🐳 Essere facilmente **dockerizzabile** su qualsiasi macchina o server
+
+---
+
+## ☁️ Deploy su Render
+
+1. Vai su **Projects → Deploy a Web Service → Public Git Repo**
+2. Inserisci il repo: `https://github.com/nzo66/tvproxy` → **Connect**
+3. Dai un nome a piacere
+4. Imposta **Instance Type** su `Free`
+5. Clicca su **Deploy Web Service**
+
 ---
-title: '123123123'
-emoji: 😻
-colorFrom: indigo
-colorTo: yellow
-sdk: docker
-pinned: false
+
+## 🤗 Deploy su HuggingFace
+
+`ricora di fare factory rebuild per aggiornare il proxy se ci sono aggiornamenti!`
+
+1. Crea un nuovo **Space**
+2. Scegli un nome qualsiasi e imposta **Docker** come tipo
+3. Lascia **Public** e crea lo Space
+4. Vai in alto a destra → `⋮` → **Files** → carica **DockerfileHF** rinominandolo **Dockerfile**
+5. Infine vai su `⋮` → **Embed this Space** per ottenere il **Direct URL**
+
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+## 🐳 Docker (Locale o Server)
+
+### ✅ Costruzione e Avvio
+
+```bash
+git clone https://github.com/nzo66/tvproxy.git
+cd tvproxy
+docker build -t tvproxy .
+docker run -d -p 7860:7860 --name tvproxy tvproxy
+```
+
+---
+
+## 🐧 Termux (Dispositivi Android)
+
+### ✅ Costruzione e Avvio
+
+```bash
+pkg install git python -y
+git clone https://github.com/nzo66/tvproxy.git
+cd tvproxy
+pip install -r requirements.txt'
+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
+```
+
+---
+
+## 🐍 Avvio con Python (Locale)
+
+### ✅ Setup e Avvio
+
+```bash
+# Clona il repository
+git clone https://github.com/nzo66/tvproxy.git
+cd tvproxy
+
+# Installa le dipendenze
+pip install -r requirements.txt
+
+# Avvia il server
+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
+```
+
+---
+
+## 🛠️ Gestione Docker
+
+- 📄 Logs: `docker logs -f tvproxy`
+- ⛔ Stop: `docker stop tvproxy`
+- 🔄 Start: `docker start tvproxy`
+- 🧹 Rimozione: `docker rm -f tvproxy`
+
+---
+
+## 🛠️ Come Utilizzare
+
+Assicurati di sostituire i placeholder come `<server-ip>` con l'indirizzo IP o l'hostname effettivo del tuo server e `<URL_...>` con gli URL specifici.
+
+---
+
+### 1. Proxy per Liste M3U Complete 📡
+
+Questo endpoint è progettato per proxare l'intera lista M3U. È particolarmente utile per garantire compatibilità e stabilità, con supporto menzionato per formati come Vavoo e Daddylive.
+
+**Formato URL:**
+```text
+http://<server-ip>:7860/proxy?url=<URL_LISTA_M3U>
+```
+
+**Dove:**
+-   `<server-ip>`: L'indirizzo IP o hostname del tuo server proxy.
+-   `<URL_LISTA_M3U>`: L'URL completo della lista M3U che vuoi proxare.
+
+> 📝 **Nota:** Questo endpoint è ideale per gestire l'intera collezione di flussi contenuta in un file M3U.
+
+---
+
+### 2. Proxy per Singoli Flussi M3U8 (con Headers Personalizzati) 📺✨
+
+Questo endpoint è specifico per proxare singoli flussi video `.m3u8`. La sua caratteristica distintiva è la capacità di inoltrare headers HTTP personalizzati, essenziale per scenari che richiedono autenticazione specifica o per simulare richieste da client particolari.
+
+**Formato URL Base:**
+```text
+http://<server-ip>:7860/proxy/m3u?url=<URL_FLUSSO_M3U8>
+```
+
+**Esempio:**
+```text
+http://<server-ip>:7860/proxy/m3u?url=https://example.com/stream.m3u8
+```
+
+**Dove:**
+-   `<server-ip>`: L'indirizzo IP o hostname del tuo server proxy.
+-   `<URL_FLUSSO_M3U8>`: L'URL completo del singolo flusso M3U8.
+
+#### 🎯 Aggiungere Headers HTTP Personalizzati (Opzionale)
+
+Per includere headers personalizzati nella richiesta al flusso M3U8, accodali all'URL del proxy. Ogni header deve essere prefissato da `&h_`, seguito dal nome dell'header, un segno di uguale (`=`), e il valore dell'header.
+
+**Formato per gli Headers:**
+```text
+&h_<NOME_HEADER>=<VALORE_HEADER>
+```
+
+**Esempio con Headers Personalizzati:**
+```text
+http://<server-ip>:7860/proxy/m3u?url=https://example.com/stream.m3u8&h_user-agent=Mozilla/5.0...&h_referer=https://ilovetoplay.xyz/&h_origin=https://ilovetoplay.xyz
+```
+
+> ⚠️ **Attenzione:**
+> - Ricorda di sostituire `Mozilla/5.0...` con lo User-Agent completo che intendi utilizzare.
+> - Se i valori degli header contengono caratteri speciali (es. spazi, due punti), assicurati che siano correttamente URL-encoded per evitare errori.
+
+---
+
+## ✅ Caratteristiche
+
+- 📁 Supporta **.m3u** e **.m3u8** automaticamente
+- 🧾 Inoltra gli **HTTP Headers** necessari (Auth, Referer, etc.)
+- 🔓 Supera restrizioni geografiche o di accesso
+- ����️ Compatibile con **qualsiasi player IPTV**
+- 🐳 Totalmente dockerizzato, pronto per il deploy
+- 🐍 Avviabile anche direttamente con **Python**
+
+---
+
+## 🎉 Fine!
+
+> Ora puoi guardare flussi M3U8 ovunque, senza restrizioni!  
+> Enjoy the Stream 🚀

app.py

@@ -0,0 +1,391 @@
+from flask import Flask, request, Response
+import requests
+from urllib.parse import urlparse, urljoin, quote, unquote
+import re
+import json
+import os
+
+app = Flask(__name__)
+
+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 resolve_m3u8_link(url, headers=None):
+    """
+    Tenta di risolvere un URL M3U8 supportando sia URL puliti che URL con header concatenati.
+    Gestisce automaticamente l'estrazione degli header dai parametri dell'URL.
+    """
+    if not url:
+        print("Errore: URL non fornito.")
+        return {"resolved_url": None, "headers": {}}
+
+    print(f"Tentativo di risoluzione URL: {url}")
+    
+    # Inizializza gli header di default
+    current_headers = headers if headers else {
+        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36'
+    }
+    
+    # **SUPPORTO PER ENTRAMBE LE VERSIONI**
+    clean_url = url
+    extracted_headers = {}
+
+    # Define newkso.ru specific sites and headers
+    daddy_php_sites = [
+        "https://new.newkso.ru/wind/",
+        "https://new.newkso.ru/ddy6/",
+        "https://new.newkso.ru/zeko/",
+        "https://new.newkso.ru/nfs/",
+        "https://new.newkso.ru/dokko1/",
+    ]
+    
+    # Verifica se l'URL contiene parametri header concatenati
+    if '&h_' in url or '%26h_' in url:
+        print("Rilevati parametri header nell'URL - Estrazione in corso...")
+        
+        # Gestisci sia il formato normale che quello URL-encoded
+        if '%26h_' in url:
+            # Per vavoo.to, sostituisci solo %26 con & senza doppia decodifica
+            if 'vavoo.to' in url.lower():
+                url = url.replace('%26', '&')
+                print(f"URL vavoo.to processato: {url}")
+            else:
+                # Per altri URL, applica la doppia decodifica completa
+                url = unquote(unquote(url))
+                print(f"URL con doppia decodifica: {url}")
+        
+        # Separa l'URL base dai parametri degli header
+        url_parts = url.split('&h_', 1)
+        clean_url = url_parts[0]
+        header_params = '&h_' + url_parts[1]
+        
+        # Estrai gli header dai parametri
+        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
+                        print(f"Header estratto: {key} = {value}")
+                except Exception as e:
+                    print(f"Errore nell'estrazione dell'header {param}: {e}")
+        
+        # Combina gli header estratti con quelli esistenti
+        current_headers.update(extracted_headers)
+        print(f"URL pulito: {clean_url}")
+        print(f"Header finali: {current_headers}")
+    else:
+        print("URL pulito rilevato - Nessuna estrazione header necessaria")
+
+    # New logic for thedaddy.click .php URLs
+    if clean_url.endswith('.php'):
+        print(f"Rilevato URL .php {clean_url}")
+        channel_id_match = re.search(r'stream-(\d+)\.php', clean_url)
+        if channel_id_match:
+            channel_id = channel_id_match.group(1)
+            print(f"Channel ID estratto: {channel_id}")
+
+            newkso_headers_for_php_resolution = {
+                'User-Agent': 'Mozilla/5.0 (iPhone; CPU iPhone OS 17_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.0 Mobile/15E148 Safari/604.1',
+                'Referer': 'https://forcedtoplay.xyz/',
+                'Origin': 'https://forcedtoplay.xyz/'
+            }
+
+            # Handle Tennis Channels (ID starts with 15 and length 4)
+            if channel_id.startswith("15") and len(channel_id) == 4:
+                tennis_suffix = channel_id[2:]
+                folder_name = f"wikiten{tennis_suffix}"
+                test_url = f"https://new.newkso.ru/wikihz/{folder_name}/mono.m3u8"
+                print(f"Tentativo canale Tennis: {test_url}")
+                try:
+                    response = requests.head(test_url, headers=newkso_headers_for_php_resolution, timeout=2.5, allow_redirects=True)
+                    if response.status_code == 200:
+                        print(f"Stream Tennis trovato: {test_url}")
+                        return {"resolved_url": test_url, "headers": newkso_headers_for_php_resolution}
+                except requests.RequestException as e:
+                    print(f"Errore HEAD per Tennis stream {test_url}: {e}")
+            
+            # Handle Other Daddy Channels
+            else:
+                folder_name = f"premium{channel_id}"
+                for site in daddy_php_sites:
+                    test_url = f"{site}{folder_name}/mono.m3u8"
+                    print(f"Tentativo canale Daddy: {test_url}")
+                    try:
+                        response = requests.head(test_url, headers=newkso_headers_for_php_resolution, timeout=2.5, allow_redirects=True)
+                        if response.status_code == 200:
+                            print(f"Stream Daddy trovato: {test_url}")
+                            return {"resolved_url": test_url, "headers": newkso_headers_for_php_resolution}
+                    except requests.RequestException as e:
+                        print(f"Errore HEAD per Daddy stream {test_url}: {e}")
+            
+            print(f"Nessuno stream diretto .m3u8 trovato nei siti newkso.ru per {clean_url}. Si procederà con la logica di fallback se applicabile.")
+            # If no specific newkso.ru stream is found for the .php URL, 
+            # we will let it fall through to the generic M3U8 resolution logic below.
+            # The generic logic will attempt to fetch clean_url (the .php URL).
+            # If that .php page itself returns M3U8 content, it will be processed.
+            # Otherwise, it will likely be treated as non-M3U8 content by proxy_m3u.
+
+    initial_response_text = None
+    final_url_after_redirects = None
+
+    # La logica iframe è stata rimossa come richiesto.
+
+    try:
+        with requests.Session() as session:
+            print(f"Passo 1: Richiesta a {clean_url}")
+            response = session.get(clean_url, headers=current_headers, allow_redirects=True, timeout=(5, 15))
+            response.raise_for_status()
+            initial_response_text = response.text
+            final_url_after_redirects = response.url
+            print(f"Passo 1 completato. URL finale dopo redirect: {final_url_after_redirects}")
+
+            # Verifica se la risposta iniziale è un file M3U8 diretto
+            if initial_response_text and initial_response_text.strip().startswith('#EXTM3U'):
+                print("Trovato file M3U8 diretto.")
+                return {
+                    "resolved_url": final_url_after_redirects,
+                    "headers": current_headers
+                }
+            else:
+                print("La risposta iniziale non era un M3U8 diretto.")
+                return {
+                    "resolved_url": clean_url,
+                    "headers": current_headers
+                }
+
+    except requests.exceptions.RequestException as e:
+        print(f"Errore durante la richiesta HTTP iniziale: {e}")
+        return {"resolved_url": clean_url, "headers": current_headers}
+    except Exception as e:
+        print(f"Errore generico durante la risoluzione: {e}")
+        return {"resolved_url": clean_url, "headers": current_headers}
+
+@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:
+        # Ottieni l'IP del server
+        server_ip = request.host
+        
+        # Scarica la lista M3U originale
+        response = requests.get(m3u_url, timeout=(10, 30)) # Timeout connessione 10s, lettura 30s
+        response.raise_for_status()
+        m3u_content = response.text
+        
+        modified_lines = []
+        exthttp_headers_query_params = "" # Stringa per conservare gli header da #EXTHTTP
+
+        for line in m3u_content.splitlines():
+            line = line.strip()
+            if line.startswith('#EXTHTTP:'):
+                try:
+                    # Estrai la parte JSON dalla riga #EXTHTTP:
+                    json_str = line.split(':', 1)[1].strip()
+                    headers_dict = json.loads(json_str)
+                    
+                    # Costruisci la stringa dei parametri di query per gli header con doppia codifica
+                    temp_params = []
+                    for key, value in headers_dict.items():
+                        # Doppia codifica: prima codifica normale, poi codifica di nuovo
+                        encoded_key = quote(quote(key))
+                        encoded_value = quote(quote(str(value)))
+                        temp_params.append(f"h_{encoded_key}={encoded_value}")
+                    
+                    if temp_params:
+                        # Usa %26 invece di & come separatore per gli header
+                        exthttp_headers_query_params = "%26" + "%26".join(temp_params)
+                    else:
+                        exthttp_headers_query_params = ""
+                except Exception as e:
+                    print(f"Errore nel parsing di #EXTHTTP '{line}': {e}")
+                    exthttp_headers_query_params = "" # Resetta in caso di errore
+                modified_lines.append(line) # Mantieni la riga #EXTHTTP originale
+            elif line and not line.startswith('#'):
+                # Questa è una riga di URL del flusso
+                # Verifica se è un URL di Pluto.tv e saltalo
+                if 'pluto.tv' in line.lower():
+                    modified_lines.append(line)  # Mantieni l'URL originale senza proxy
+                    exthttp_headers_query_params = ""  # Resetta gli header
+                else:
+                    # Applica gli header #EXTHTTP se presenti e poi resettali
+                    # Assicurati che l'URL sia completamente codificato, inclusi gli slash
+                    encoded_line = quote(line, safe='')
+                    modified_line = f"http://{server_ip}/proxy/m3u?url={encoded_line}{exthttp_headers_query_params}"
+                    modified_lines.append(modified_line)
+                    exthttp_headers_query_params = ""  # Resetta gli header dopo averli usati
+            else:
+                # Mantieni invariate le altre righe di metadati o righe vuote
+                modified_lines.append(line)
+        
+        modified_content = '\n'.join(modified_lines)
+
+        # Estrai il nome del file dall'URL originale
+        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:
+        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/m3u')
+def proxy_m3u():
+    """Proxy per file M3U e M3U8 con supporto per entrambe le versioni di URL"""
+    m3u_url = request.args.get('url', '').strip()
+    if not m3u_url:
+        return "Errore: Parametro 'url' mancante", 400
+
+    default_headers = {
+        "User-Agent": "Mozilla/5.0 (iPhone; CPU iPhone OS 14_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) FxiOS/33.0 Mobile/15E148 Safari/605.1.15",
+        "Referer": "https://vavoo.to/",
+        "Origin": "https://vavoo.to"
+    }
+
+    # Estrai gli header dalla richiesta (versione parametri query)
+    request_headers = {
+        unquote(key[2:]).replace("_", "-"): unquote(value).strip()
+        for key, value in request.args.items()
+        if key.lower().startswith("h_")
+    }
+    
+    # Combina header di default con quelli della richiesta
+    headers = {**default_headers, **request_headers}
+
+    # --- Logica per trasformare l'URL se necessario ---
+    processed_url = m3u_url
+    
+    # La logica specifica per thedaddy.click e URL premium è stata rimossa.
+    print(f"URL {processed_url} processato per la risoluzione.")
+
+    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}")
+
+        # Fetchare il contenuto M3U8 effettivo dall'URL risolto
+        print(f"Fetching M3U8 content from resolved URL: {resolved_url}")
+        m3u_response = requests.get(resolved_url, headers=current_headers_for_proxy, allow_redirects=True, timeout=(10, 20)) # Timeout connessione 10s, lettura 20s
+        m3u_response.raise_for_status()
+        # Applica la codifica corretta
+        m3u_response.encoding = m3u_response.apparent_encoding or 'utf-8'
+        m3u_content = m3u_response.text
+        final_url = m3u_response.url
+
+        # Processa il contenuto M3U8
+        file_type = detect_m3u_type(m3u_content)
+
+        if file_type == "m3u":
+            return Response(m3u_content, content_type="application/vnd.apple.mpegurl; charset=utf-8")
+
+        # Processa contenuto M3U8
+        parsed_url = urlparse(final_url)
+        base_url = f"{parsed_url.scheme}://{parsed_url.netloc}{parsed_url.path.rsplit('/', 1)[0]}/"
+
+        # Prepara la query degli header per segmenti/chiavi proxati
+        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)
+        return Response(modified_m3u8_content, content_type="application/vnd.apple.mpegurl; charset=utf-8")
+
+    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/ts')
+def proxy_ts():
+    """Proxy per segmenti .TS con headers personalizzati - SENZA CACHE"""
+    ts_url = request.args.get('url', '').strip()
+    if not ts_url:
+        return "Errore: Parametro 'url' mancante", 400
+
+    headers = {
+        unquote(key[2:]).replace("_", "-"): unquote(value).strip()
+        for key, value in request.args.items()
+        if key.lower().startswith("h_")
+    }
+
+    try:
+        # Stream diretto senza cache per evitare freezing
+        response = requests.get(ts_url, headers=headers, stream=True, allow_redirects=True, timeout=(10, 30)) # Timeout di connessione 10s, lettura 30s
+        response.raise_for_status()
+        
+        def generate():
+            for chunk in response.iter_content(chunk_size=8192):
+                if chunk:
+                    yield chunk
+        
+        return Response(generate(), content_type="video/mp2t")
+    
+    except requests.RequestException as e:
+        return f"Errore durante il download del segmento TS: {str(e)}", 500
+
+@app.route('/proxy/key')
+def proxy_key():
+    """Proxy per la chiave AES-128 con header personalizzati"""
+    key_url = request.args.get('url', '').strip()
+    if not key_url:
+        return "Errore: Parametro 'url' mancante per la chiave", 400
+
+    headers = {
+        unquote(key[2:]).replace("_", "-"): unquote(value).strip()
+        for key, value in request.args.items()
+        if key.lower().startswith("h_")
+    }
+
+    try:
+        response = requests.get(key_url, headers=headers, allow_redirects=True, timeout=(5, 15)) # Timeout connessione 5s, lettura 15s
+        response.raise_for_status()
+        
+        return Response(response.content, content_type="application/octet-stream")
+    
+    except requests.RequestException as e:
+        return f"Errore durante il download della chiave: {str(e)}", 500
+
+@app.route('/')
+def index():
+    """Pagina principale che mostra un messaggio di benvenuto"""
+    return "Proxy started!"
+
+if __name__ == '__main__':
+    app.run(host="0.0.0.0", port=7860, debug=False)

requirements.txt

@@ -0,0 +1,3 @@
+flask
+requests
+gunicorn[gevent]