revert: Remove Hola proxy (blocked by Hola from cloud IPs)

Hola permanently blocks requests from cloud/datacenter IPs.
Keep simple PROXY_URL env var support for manual proxy configuration.

app.py

@@ -115,21 +115,8 @@ CHAT_MODELS = [
 
 
 def get_proxy_url() -> str | None:
-    """Get proxy URL from Hola for YouTube downloads."""
-    # Check for manual override first
-    env_proxy = os.environ.get("PROXY_URL")
-    if env_proxy:
-        return env_proxy
-
-    # Use Hola proxy for YouTube downloads
-    try:
-        from hola_proxy import get_hola_proxy
-        country = os.environ.get("HOLA_COUNTRY", "us")
-        proxy_type = os.environ.get("HOLA_PROXY_TYPE", "direct")
-        return get_hola_proxy(country=country, proxy_type=proxy_type)
-    except Exception as e:
-        print(f"Failed to get Hola proxy: {e}")
-        return None
+    """Get proxy URL from environment for YouTube downloads."""
+    return os.environ.get("PROXY_URL")
 
 
 def download_video(url: str, output_dir: str) -> list[dict]:

hola_proxy.py

@@ -1,226 +0,0 @@
-"""
-Hola Proxy Client - Python implementation based on Snawoot/hola-proxy
-
-This module provides access to Hola's proxy network for routing traffic
-through residential IPs. Unlike the official Hola client, this implementation
-does NOT make your connection an exit node for others.
-
-API flow:
-1. Generate UUID for session
-2. Call background_init to authenticate and get session key
-3. Call zgettunnels to get proxy server addresses
-4. Use returned proxy with authentication
-"""
-
-import random
-import time
-import uuid
-from typing import Any
-
-import requests
-
-# Hola API endpoints
-CCGI_URL = "https://client.hola.org/client_cgi/"
-BG_INIT_URL = CCGI_URL + "background_init"
-ZGETTUNNELS_URL = CCGI_URL + "zgettunnels"
-
-# Mimic Chrome extension
-EXT_VER = "1.220.419"
-EXT_BROWSER = "chrome"
-PRODUCT = "cws"
-
-
-def generate_user_uuid() -> str:
-    """Generate a random UUID for Hola session."""
-    return uuid.uuid4().hex
-
-
-def get_chrome_version() -> str:
-    """Return a plausible Chrome version string."""
-    return "120.0.0.0"
-
-
-class HolaProxyClient:
-    """Client for Hola's proxy network."""
-
-    def __init__(self, country: str = "us", proxy_type: str = "lum"):
-        """
-        Initialize Hola proxy client.
-
-        Args:
-            country: Two-letter country code (us, uk, de, etc.)
-            proxy_type: Type of proxy:
-                - "direct": Datacenter proxies (faster, but may be blocked)
-                - "lum": Residential IPs via Luminati/Bright Data (slower, less blocked)
-        """
-        self.country = country.lower()
-        self.proxy_type = proxy_type
-        self.user_uuid = generate_user_uuid()
-        self.session_key: int | None = None
-        self.proxy_host: str | None = None
-        self.proxy_port: int | None = None
-        self.agent_key: str | None = None
-        self._session = requests.Session()
-        self._session.headers.update({
-            "User-Agent": f"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/{get_chrome_version()} Safari/537.36",
-        })
-
-    def _background_init(self) -> dict[str, Any]:
-        """
-        Initialize session with Hola API.
-
-        Returns authentication data including session key.
-        """
-        params = {
-            "login": "1",
-            "ver": EXT_VER,
-            "browser": EXT_BROWSER,
-            "uuid": self.user_uuid,
-        }
-
-        response = self._session.post(BG_INIT_URL, data=params, timeout=30)
-        response.raise_for_status()
-        data = response.json()
-
-        if "blocked" in data:
-            raise RuntimeError(f"Hola account blocked: {data.get('blocked_msg', 'Unknown reason')}")
-
-        self.session_key = data.get("key")
-        return data
-
-    def _zgettunnels(self) -> dict[str, Any]:
-        """
-        Get tunnel/proxy information from Hola.
-
-        Returns proxy server addresses and authentication.
-        """
-        if self.session_key is None:
-            raise RuntimeError("Must call background_init first")
-
-        params = {
-            "country": self.country,
-            "limit": 3,
-            "ping_id": random.random(),
-            "ext_ver": EXT_VER,
-            "browser": EXT_BROWSER,
-            "product": PRODUCT,
-            "uuid": self.user_uuid,
-            "session_key": self.session_key,
-            "is_premium": 0,
-        }
-
-        # Add proxy type
-        if self.proxy_type == "lum":
-            params["type"] = "lum"
-        elif self.proxy_type == "direct":
-            params["type"] = "direct"
-
-        response = self._session.post(ZGETTUNNELS_URL, data=params, timeout=30)
-        response.raise_for_status()
-        data = response.json()
-
-        if "agent_key" not in data:
-            raise RuntimeError(f"Failed to get tunnels: {data}")
-
-        self.agent_key = data["agent_key"]
-
-        # Extract first available proxy
-        if "ip_list" in data and data["ip_list"]:
-            ip_info = list(data["ip_list"].values())[0]
-            self.proxy_host = ip_info.get("ip")
-            self.proxy_port = int(data.get("port", {}).get("direct", 22222))
-        elif "agent_types" in data:
-            # Alternative format
-            agents = data.get("agent_types", {})
-            if agents:
-                agent_type = list(agents.keys())[0]
-                agent_list = agents[agent_type]
-                if agent_list:
-                    self.proxy_host = agent_list[0]
-                    self.proxy_port = int(data.get("port", {}).get("direct", 22222))
-
-        return data
-
-    def connect(self) -> str:
-        """
-        Connect to Hola and get proxy URL.
-
-        Returns:
-            Proxy URL in format http://user:pass@host:port
-        """
-        # Initialize session
-        self._background_init()
-
-        # Get tunnels with retry
-        max_retries = 3
-        for attempt in range(max_retries):
-            try:
-                self._zgettunnels()
-                break
-            except Exception as e:
-                if attempt == max_retries - 1:
-                    raise
-                time.sleep(2 ** attempt)  # Exponential backoff
-
-        if not self.proxy_host or not self.proxy_port:
-            raise RuntimeError("Failed to obtain proxy server")
-
-        # Build authenticated proxy URL
-        # Format: user-uuid-country-session:agent_key@host:port
-        username = f"user-uuid-{self.user_uuid}"
-        password = self.agent_key
-
-        return f"http://{username}:{password}@{self.proxy_host}:{self.proxy_port}"
-
-    def get_proxy_dict(self) -> dict[str, str]:
-        """
-        Get proxy configuration as dict for requests library.
-
-        Returns:
-            Dict with http and https proxy URLs
-        """
-        proxy_url = self.connect()
-        return {
-            "http": proxy_url,
-            "https": proxy_url,
-        }
-
-
-def get_hola_proxy(country: str = "us", proxy_type: str = "lum") -> str | None:
-    """
-    Convenience function to get a Hola proxy URL.
-
-    Args:
-        country: Two-letter country code
-        proxy_type: "direct" or "lum" (residential)
-
-    Returns:
-        Proxy URL or None on failure
-    """
-    try:
-        client = HolaProxyClient(country=country, proxy_type=proxy_type)
-        return client.connect()
-    except Exception as e:
-        print(f"Failed to get Hola proxy: {e}")
-        return None
-
-
-if __name__ == "__main__":
-    # Test the client
-    print("Testing Hola proxy client...")
-    proxy_url = get_hola_proxy(country="us", proxy_type="direct")
-    if proxy_url:
-        print(f"Got proxy: {proxy_url[:50]}...")
-
-        # Test the proxy
-        try:
-            response = requests.get(
-                "https://httpbin.org/ip",
-                proxies={"http": proxy_url, "https": proxy_url},
-                timeout=30,
-            )
-            print(f"Your IP via proxy: {response.json()}")
-        except Exception as e:
-            print(f"Proxy test failed: {e}")
-    else:
-        print("Failed to get proxy")