Update app.py

app.py

@@ -2,6 +2,7 @@
 """
 Crypto API Monitor ULTIMATE - Real API Integration
 Complete professional monitoring system with 100+ real free crypto APIs
+Fixed for Hugging Face Spaces deployment
 """
 
 from fastapi import FastAPI, WebSocket, WebSocketDisconnect, HTTPException, Request
@@ -349,7 +350,6 @@ API_PROVIDERS = {
     ]
 }
 
-# Fallback data used when upstream APIs یا پایگاه داده در دسترس نیستند
 DEFI_FALLBACK = [
     {
         "name": "Sample Protocol",
@@ -389,7 +389,7 @@ KEY_QUERY_MAP = {
     "TronScan": "apikey"
 }
 
-HEALTH_CACHE_TTL = 120  # seconds
+HEALTH_CACHE_TTL = 120
 provider_health_cache: Dict[str, Dict] = {}
 
 
@@ -537,10 +537,8 @@ cache = {
     "defi": {"data": None, "timestamp": None, "ttl": 300}
 }
 
-# Smart Proxy Mode - Cache which providers need proxy
 provider_proxy_cache: Dict[str, Dict] = {}
 
-# CORS proxy list (from config)
 CORS_PROXIES = [
     'https://api.allorigins.win/get?url=',
     'https://proxy.cors.sh/',
@@ -548,7 +546,6 @@ CORS_PROXIES = [
 ]
 
 def should_use_proxy(provider_name: str) -> bool:
-    """Check if a provider should use proxy based on past failures"""
     if not is_feature_enabled("enableProxyAutoMode"):
         return False
 
@@ -556,16 +553,13 @@ def should_use_proxy(provider_name: str) -> bool:
     if not cached:
         return False
 
-    # Check if cache is still valid (5 minutes)
     if (datetime.now() - cached.get("timestamp", datetime.now())).total_seconds() > 300:
-        # Cache expired, remove it
         provider_proxy_cache.pop(provider_name, None)
         return False
 
     return cached.get("use_proxy", False)
 
 def mark_provider_needs_proxy(provider_name: str):
-    """Mark a provider as needing proxy"""
     provider_proxy_cache[provider_name] = {
         "use_proxy": True,
         "timestamp": datetime.now(),
@@ -574,22 +568,19 @@ def mark_provider_needs_proxy(provider_name: str):
     logger.info(f"Provider '{provider_name}' marked for proxy routing")
 
 def mark_provider_direct_ok(provider_name: str):
-    """Mark a provider as working with direct connection"""
     if provider_name in provider_proxy_cache:
         provider_proxy_cache.pop(provider_name)
         logger.info(f"Provider '{provider_name}' restored to direct routing")
 
 async def fetch_with_proxy(session, url: str, proxy_url: str = None):
-    """Fetch data through a CORS proxy"""
     if not proxy_url:
-        proxy_url = CORS_PROXIES[0]  # Default to first proxy
+        proxy_url = CORS_PROXIES[0]
 
     try:
         proxied_url = f"{proxy_url}{url}"
         async with session.get(proxied_url, timeout=aiohttp.ClientTimeout(total=15)) as response:
             if response.status == 200:
                 data = await response.json()
-                # Some proxies wrap the response
                 if isinstance(data, dict) and "contents" in data:
                     return json.loads(data["contents"])
                 return data
@@ -599,33 +590,20 @@ async def fetch_with_proxy(session, url: str, proxy_url: str = None):
         return None
 
 async def smart_fetch(session, url: str, provider_name: str = None, retries=3):
-    """
-    Smart fetch with automatic proxy fallback
-
-    Flow:
-    1. If provider is marked for proxy -> use proxy directly
-    2. Otherwise, try direct connection
-    3. On failure (timeout, CORS, 403, connection error) -> fallback to proxy
-    4. Cache the proxy decision for the provider
-    """
-    # Check if we should go through proxy directly
     if provider_name and should_use_proxy(provider_name):
         logger.debug(f"Using proxy for {provider_name} (cached decision)")
         return await fetch_with_proxy(session, url)
 
-    # Try direct connection first
     for attempt in range(retries):
         try:
             async with session.get(url, timeout=aiohttp.ClientTimeout(total=10)) as response:
                 if response.status == 200:
-                    # Success! Mark provider as working directly
                     if provider_name:
                         mark_provider_direct_ok(provider_name)
                     return await response.json()
-                elif response.status == 429:  # Rate limit
+                elif response.status == 429:
                     await asyncio.sleep(2 ** attempt)
-                elif response.status in [403, 451]:  # Forbidden or CORS
-                    # Try proxy fallback
+                elif response.status in [403, 451]:
                     if provider_name:
                         mark_provider_needs_proxy(provider_name)
                     logger.info(f"HTTP {response.status} on {url}, trying proxy...")
@@ -633,14 +611,12 @@ async def smart_fetch(session, url: str, provider_name: str = None, retries=3):
                 else:
                     return None
         except asyncio.TimeoutError:
-            # Timeout - try proxy on last attempt
             if attempt == retries - 1 and provider_name:
                 mark_provider_needs_proxy(provider_name)
                 logger.info(f"Timeout on {url}, trying proxy...")
                 return await fetch_with_proxy(session, url)
             await asyncio.sleep(1)
         except aiohttp.ClientError as e:
-            # Network error (connection refused, CORS, etc) - try proxy
             if "CORS" in str(e) or "Connection" in str(e) or "SSL" in str(e):
                 if provider_name:
                     mark_provider_needs_proxy(provider_name)
@@ -658,25 +634,20 @@ async def smart_fetch(session, url: str, provider_name: str = None, retries=3):
 
     return None
 
-# Keep old function for backward compatibility
 async def fetch_with_retry(session, url, retries=3):
-    """Fetch data with retry mechanism (uses smart_fetch internally)"""
     return await smart_fetch(session, url, retries=retries)
 
 def is_cache_valid(cache_entry):
-    """Check if cache is still valid"""
     if cache_entry["data"] is None or cache_entry["timestamp"] is None:
         return False
     elapsed = (datetime.now() - cache_entry["timestamp"]).total_seconds()
     return elapsed < cache_entry["ttl"]
 
 async def get_market_data():
-    """Fetch real market data from multiple sources"""
     if is_cache_valid(cache["market_data"]):
         return cache["market_data"]["data"]
     
     async with aiohttp.ClientSession() as session:
-        # Try CoinGecko first
         url = "https://api.coingecko.com/api/v3/coins/markets?vs_currency=usd&order=market_cap_desc&per_page=50&page=1"
         data = await fetch_with_retry(session, url)
         
@@ -698,7 +669,6 @@ async def get_market_data():
             cache["market_data"]["timestamp"] = datetime.now()
             return formatted_data
         
-        # Fallback to CoinCap
         url = "https://api.coincap.io/v2/assets?limit=20"
         data = await fetch_with_retry(session, url)
         
@@ -723,9 +693,7 @@ async def get_market_data():
     return []
 
 async def get_global_stats():
-    """Fetch global crypto market statistics"""
     async with aiohttp.ClientSession() as session:
-        # CoinGecko global data
         url = "https://api.coingecko.com/api/v3/global"
         data = await fetch_with_retry(session, url)
         
@@ -750,7 +718,6 @@ async def get_global_stats():
     }
 
 async def get_trending():
-    """Fetch trending coins"""
     async with aiohttp.ClientSession() as session:
         url = "https://api.coingecko.com/api/v3/search/trending"
         data = await fetch_with_retry(session, url)
@@ -769,7 +736,6 @@ async def get_trending():
     return []
 
 async def get_sentiment():
-    """Fetch Fear & Greed Index"""
     if is_cache_valid(cache["sentiment"]):
         return cache["sentiment"]["data"]
     
@@ -791,7 +757,6 @@ async def get_sentiment():
     return {"value": 50, "classification": "Neutral", "timestamp": ""}
 
 async def get_defi_tvl():
-    """Fetch DeFi Total Value Locked"""
     if is_cache_valid(cache["defi"]):
         return cache["defi"]["data"]
     
@@ -817,7 +782,6 @@ async def get_defi_tvl():
     return []
 
 async def fetch_provider_health(session: aiohttp.ClientSession, provider: Dict, force_refresh: bool = False) -> Dict:
-    """Fetch real health information for a provider"""
     name = provider["name"]
     cached = provider_health_cache.get(name)
     if cached and not force_refresh:
@@ -947,7 +911,6 @@ async def fetch_provider_health(session: aiohttp.ClientSession, provider: Dict,
 
 
 async def get_provider_stats(force_refresh: bool = False):
-    """Generate provider statistics with real health checks"""
     providers = assemble_providers()
     async with aiohttp.ClientSession() as session:
         results = await asyncio.gather(
@@ -1003,12 +966,10 @@ async def health():
 
 @app.get("/api/health")
 async def api_health():
-    """Compatibility endpoint mirroring /health"""
     return await health()
 
 @app.get("/api/market")
 async def market():
-    """Get real-time market data"""
     data = await get_market_data()
     global_stats = await get_global_stats()
     
@@ -1021,7 +982,6 @@ async def market():
 
 @app.get("/api/trending")
 async def trending():
-    """Get trending coins"""
     data = await get_trending()
     return {
         "trending": data,
@@ -1031,7 +991,6 @@ async def trending():
 
 @app.get("/api/sentiment")
 async def sentiment():
-    """Get Fear & Greed Index"""
     data = await get_sentiment()
     return {
         "fear_greed_index": data,
@@ -1041,10 +1000,9 @@ async def sentiment():
 
 @app.get("/api/defi")
 async def defi():
-    """Get DeFi protocols and TVL"""
     try:
         data = await get_defi_tvl()
-    except Exception as exc:  # pragma: no cover - defensive
+    except Exception as exc:
         logger.warning("defi endpoint fallback due to error: %s", exc)
         data = []
 
@@ -1061,20 +1019,17 @@ async def defi():
 
 @app.get("/api/providers")
 async def providers():
-    """Get all API providers status"""
     data = await get_provider_stats()
     return data
 
 
 @app.get("/api/providers/custom")
 async def providers_custom():
-    """Return custom providers registered through the UI."""
     return _get_custom_providers()
 
 
 @app.post("/api/providers", status_code=201)
 async def create_provider(request: ProviderCreateRequest):
-    """Create a custom provider entry."""
     name = request.name.strip()
     if not name:
         raise HTTPException(status_code=400, detail="name is required")
@@ -1106,14 +1061,12 @@ async def create_provider(request: ProviderCreateRequest):
 
 @app.delete("/api/providers/{slug}", status_code=204)
 async def delete_provider(slug: str):
-    """Delete a custom provider by slug."""
     if not _remove_custom_provider(slug):
         raise HTTPException(status_code=404, detail="Provider not found")
     return Response(status_code=204)
 
 @app.get("/api/status")
 async def status():
-    """Get system status for dashboard"""
     providers = await get_provider_stats()
     online = len([p for p in providers if p.get("status") == "online"])
     offline = len([p for p in providers if p.get("status") == "offline"])
@@ -1153,7 +1106,6 @@ async def system_info():
 
 @app.get("/api/stats")
 async def stats():
-    """Get comprehensive statistics"""
     market = await get_market_data()
     global_stats = await get_global_stats()
     providers = await get_provider_stats()
@@ -1184,7 +1136,6 @@ async def stats():
         "timestamp": datetime.now().isoformat()
     }
 
-# HuggingFace endpoints (mock for now)
 @app.get("/api/hf/health")
 async def hf_health():
     return {
@@ -1195,16 +1146,12 @@ async def hf_health():
 
 @app.post("/api/hf/run-sentiment")
 async def hf_run_sentiment(request: SentimentRequest):
-    """Run sentiment analysis on crypto text"""
     texts = request.texts
     
-    # Mock sentiment analysis
-    # In production, this would call HuggingFace API
     results = []
     total_vote = 0
     
     for text in texts:
-        # Simple mock sentiment
         text_lower = text.lower()
         positive_words = ["bullish", "strong", "breakout", "pump", "moon", "buy", "up"]
         negative_words = ["bearish", "weak", "crash", "dump", "sell", "down", "drop"]
@@ -1231,15 +1178,12 @@ async def hf_run_sentiment(request: SentimentRequest):
 
 @app.websocket("/ws")
 async def websocket_root(websocket: WebSocket):
-    """WebSocket endpoint for compatibility with websocket-client.js"""
     await websocket_endpoint(websocket)
 
 @app.websocket("/ws/live")
 async def websocket_endpoint(websocket: WebSocket):
-    """Real-time WebSocket updates"""
     await manager.connect(websocket)
     try:
-        # Send welcome message
         await websocket.send_json({
             "type": "welcome",
             "session_id": str(id(websocket)),
@@ -1249,16 +1193,14 @@ async def websocket_endpoint(websocket: WebSocket):
         while True:
             await asyncio.sleep(5)
             
-            # Send market update
             market_data = await get_market_data()
             if market_data:
                 await websocket.send_json({
                     "type": "market_update",
-                    "data": market_data[:5],  # Top 5 coins
+                    "data": market_data[:5],
                     "timestamp": datetime.now().isoformat()
                 })
             
-            # Send sentiment update every 30 seconds
             if random.random() > 0.8:
                 sentiment_data = await get_sentiment()
                 await websocket.send_json({
@@ -1278,7 +1220,6 @@ async def websocket_endpoint(websocket: WebSocket):
 async def websocket_endpoint_api(websocket: WebSocket):
     await websocket_endpoint(websocket)
 
-# Serve HTML files
 @app.get("/", response_class=HTMLResponse)
 async def root_html():
     try:
@@ -1349,11 +1290,8 @@ async def pool_management():
 
 
 
-# --- UI helper endpoints for categories, rate limits, logs, alerts, and HuggingFace registry ---
-
 @app.get("/api/categories")
 async def api_categories():
-    """Aggregate providers by category for the dashboard UI"""
     providers = await get_provider_stats()
     categories_map: Dict[str, Dict] = {}
     for p in providers:
@@ -1403,7 +1341,6 @@ async def api_categories():
 
 @app.get("/api/rate-limits")
 async def api_rate_limits():
-    """Expose simple rate-limit information per provider for the UI cards"""
     providers = await get_provider_stats()
     now = datetime.now()
     items = []
@@ -1455,7 +1392,6 @@ async def api_rate_limits():
 
 @app.get("/api/logs")
 async def api_logs(type: str = "all"):
-    """Return recent connection logs from SQLite for the logs tab"""
     rows = db.get_recent_status(hours=24, limit=500)
     logs = []
     for row in rows:
@@ -1481,7 +1417,6 @@ async def api_logs(type: str = "all"):
 
 @app.get("/api/logs/summary")
 async def api_logs_summary(hours: int = 24):
-    """Provide aggregated log summary for dashboard widgets."""
     rows = db.get_recent_status(hours=hours, limit=500)
     by_status: Dict[str, int] = defaultdict(int)
     by_provider: Dict[str, int] = defaultdict(int)
@@ -1509,7 +1444,6 @@ async def api_logs_summary(hours: int = 24):
 
 @app.get("/api/alerts")
 async def api_alerts():
-    """Expose active/unacknowledged alerts for the alerts tab"""
     try:
         rows = db.get_unacknowledged_alerts()
     except Exception:
@@ -1536,13 +1470,8 @@ HF_CACHE_TS: Optional[datetime] = None
 
 
 async def _fetch_hf_registry(kind: str = "models", query: str = "crypto", limit: int = 12) -> List[Dict]:
-    """
-    Fetch a small registry snapshot from Hugging Face Hub.
-    If the request fails for any reason, falls back to a small built-in sample.
-    """
     global HF_MODELS, HF_DATASETS, HF_CACHE_TS
 
-    # Basic in-memory TTL cache (6 hours)
     now = datetime.now()
     if HF_CACHE_TS and (now - HF_CACHE_TS).total_seconds() < 6 * 3600:
         if kind == "models" and HF_MODELS:
@@ -1563,7 +1492,6 @@ async def _fetch_hf_registry(kind: str = "models", query: str = "crypto", limit:
             async with session.get(base_url, params=params, headers=headers, timeout=10) as resp:
                 if resp.status == 200:
                     raw = await resp.json()
-                    # HF returns a list of models/datasets
                     for entry in raw:
                         item = {
                             "id": entry.get("id") or entry.get("name"),
@@ -1575,10 +1503,8 @@ async def _fetch_hf_registry(kind: str = "models", query: str = "crypto", limit:
                         }
                         items.append(item)
     except Exception:
-        # ignore and fall back
         items = []
 
-    # Fallback sample if nothing was fetched
     if not items:
         if kind == "models":
             items = [
@@ -1611,7 +1537,6 @@ async def _fetch_hf_registry(kind: str = "models", query: str = "crypto", limit:
                 },
             ]
 
-    # Update cache
     custom_items = _get_custom_hf("models" if kind == "models" else "datasets")
     if custom_items:
         seen_ids = {item.get("id") or item.get("name") for item in items}
@@ -1632,7 +1557,6 @@ async def _fetch_hf_registry(kind: str = "models", query: str = "crypto", limit:
 
 @app.post("/api/hf/refresh")
 async def hf_refresh():
-    """Refresh HF registry data used by the UI."""
     models = await _fetch_hf_registry("models")
     datasets = await _fetch_hf_registry("datasets")
     return {"status": "ok", "models": len(models), "datasets": len(datasets)}
@@ -1640,7 +1564,6 @@ async def hf_refresh():
 
 @app.get("/api/hf/registry")
 async def hf_registry(type: str = "models"):
-    """Return model/dataset registry for the HF panel."""
     if type == "datasets":
         data = await _fetch_hf_registry("datasets")
     else:
@@ -1650,7 +1573,6 @@ async def hf_registry(type: str = "models"):
 
 @app.get("/api/hf/custom")
 async def hf_custom_registry():
-    """Return custom Hugging Face registry entries."""
     return {
         "models": _get_custom_hf("models"),
         "datasets": _get_custom_hf("datasets"),
@@ -1659,7 +1581,6 @@ async def hf_custom_registry():
 
 @app.post("/api/hf/custom", status_code=201)
 async def hf_register_custom(item: HFRegistryItemCreate):
-    """Register a custom Hugging Face model or dataset."""
     payload = {
         "id": item.id.strip(),
         "description": item.description.strip() if item.description else "",
@@ -1677,7 +1598,6 @@ async def hf_register_custom(item: HFRegistryItemCreate):
 
 @app.delete("/api/hf/custom/{kind}/{identifier}", status_code=204)
 async def hf_delete_custom(kind: str, identifier: str):
-    """Remove a custom HF model or dataset."""
     kind = kind.lower()
     if kind not in {"model", "dataset"}:
         raise HTTPException(status_code=400, detail="kind must be 'model' or 'dataset'")
@@ -1689,7 +1609,6 @@ async def hf_delete_custom(kind: str, identifier: str):
 
 @app.get("/api/hf/search")
 async def hf_search(q: str = "", kind: str = "models"):
-    """Search over the HF registry."""
     pool = await _fetch_hf_registry("models" if kind == "models" else "datasets")
     q_lower = (q or "").lower()
     results: List[Dict] = []
@@ -1700,16 +1619,13 @@ async def hf_search(q: str = "", kind: str = "models"):
     return results
 
 
-# Feature Flags Endpoints
 @app.get("/api/feature-flags")
 async def get_feature_flags():
-    """Get all feature flags and their status"""
     return feature_flags.get_feature_info()
 
 
 @app.put("/api/feature-flags")
 async def update_feature_flags(request: FeatureFlagsUpdate):
-    """Update multiple feature flags"""
     success = feature_flags.update_flags(request.flags)
     if success:
         return {
@@ -1723,7 +1639,6 @@ async def update_feature_flags(request: FeatureFlagsUpdate):
 
 @app.put("/api/feature-flags/{flag_name}")
 async def update_single_feature_flag(flag_name: str, request: FeatureFlagUpdate):
-    """Update a single feature flag"""
     success = feature_flags.set_flag(flag_name, request.value)
     if success:
         return {
@@ -1738,7 +1653,6 @@ async def update_single_feature_flag(flag_name: str, request: FeatureFlagUpdate)
 
 @app.post("/api/feature-flags/reset")
 async def reset_feature_flags():
-    """Reset all feature flags to default values"""
     success = feature_flags.reset_to_defaults()
     if success:
         return {
@@ -1752,7 +1666,6 @@ async def reset_feature_flags():
 
 @app.get("/api/feature-flags/{flag_name}")
 async def get_single_feature_flag(flag_name: str):
-    """Get a single feature flag value"""
     value = feature_flags.get_flag(flag_name)
     return {
         "flag_name": flag_name,
@@ -1763,7 +1676,6 @@ async def get_single_feature_flag(flag_name: str):
 
 @app.get("/api/proxy-status")
 async def get_proxy_status():
-    """Get provider proxy routing status"""
     status = []
     for provider_name, cache_data in provider_proxy_cache.items():
         age_seconds = (datetime.now() - cache_data.get("timestamp", datetime.now())).total_seconds()
@@ -1841,12 +1753,16 @@ async def hf_search_legacy(q: str = "", kind: str = "models"):
     return await hf_search(q=q, kind=kind)
 
 
-# Serve static files (JS, CSS, etc.)
-# Serve static files (JS, CSS, etc.)
-if os.path.exists("static"):
+# Serve static files
+static_dir = Path("static")
+if static_dir.exists() and static_dir.is_dir():
     app.mount("/static", StaticFiles(directory="static"), name="static")
+else:
+    static_dir.mkdir(exist_ok=True)
+    (static_dir / "css").mkdir(exist_ok=True)
+    (static_dir / "js").mkdir(exist_ok=True)
+    print("⚠️  Warning: Static files directory created but empty")
 
-# Serve config.js
 @app.get("/config.js")
 async def config_js():
     try:
@@ -1855,10 +1771,8 @@ async def config_js():
     except:
         return Response(content="// Config not found", media_type="application/javascript")
 
-# API v2 endpoints for enhanced dashboard
 @app.get("/api/v2/status")
 async def v2_status():
-    """Enhanced status endpoint"""
     providers = await get_provider_stats()
     return {
         "services": {
@@ -1884,7 +1798,6 @@ async def v2_status():
 
 @app.get("/api/v2/config/apis")
 async def v2_config_apis():
-    """Get API configuration"""
     providers = await get_provider_stats()
     apis = {}
     for p in providers:
@@ -1898,7 +1811,6 @@ async def v2_config_apis():
 
 @app.get("/api/v2/schedule/tasks")
 async def v2_schedule_tasks():
-    """Get scheduled tasks"""
     providers = await get_provider_stats()
     tasks = {}
     for p in providers:
@@ -1914,7 +1826,6 @@ async def v2_schedule_tasks():
 
 @app.get("/api/v2/schedule/tasks/{api_id}")
 async def v2_schedule_task(api_id: str):
-    """Get specific scheduled task"""
     return {
         "api_id": api_id,
         "interval": 300,
@@ -1925,7 +1836,6 @@ async def v2_schedule_task(api_id: str):
 
 @app.put("/api/v2/schedule/tasks/{api_id}")
 async def v2_update_schedule(api_id: str, interval: int = 300, enabled: bool = True):
-    """Update schedule"""
     return {
         "api_id": api_id,
         "interval": interval,
@@ -1935,7 +1845,6 @@ async def v2_update_schedule(api_id: str, interval: int = 300, enabled: bool = T
 
 @app.post("/api/v2/schedule/tasks/{api_id}/force-update")
 async def v2_force_update(api_id: str):
-    """Force update for specific API"""
     return {
         "api_id": api_id,
         "status": "updated",
@@ -1944,7 +1853,6 @@ async def v2_force_update(api_id: str):
 
 @app.post("/api/v2/export/json")
 async def v2_export_json(request: dict):
-    """Export data as JSON"""
     market = await get_market_data()
     return {
         "filepath": "export.json",
@@ -1954,7 +1862,6 @@ async def v2_export_json(request: dict):
 
 @app.post("/api/v2/export/csv")
 async def v2_export_csv(request: dict):
-    """Export data as CSV"""
     return {
         "filepath": "export.csv",
         "download_url": "/api/v2/export/download/export.csv",
@@ -1963,7 +1870,6 @@ async def v2_export_csv(request: dict):
 
 @app.post("/api/v2/backup")
 async def v2_backup():
-    """Create backup"""
     return {
         "backup_file": f"backup_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json",
         "timestamp": datetime.now().isoformat()
@@ -1971,8 +1877,6 @@ async def v2_backup():
 
 @app.post("/api/v2/cleanup/cache")
 async def v2_cleanup_cache():
-    """Clear cache"""
-    # Clear all caches
     for key in cache:
         cache[key]["data"] = None
         cache[key]["timestamp"] = None
@@ -1983,13 +1887,11 @@ async def v2_cleanup_cache():
 
 @app.websocket("/api/v2/ws")
 async def v2_websocket(websocket: WebSocket):
-    """Enhanced WebSocket endpoint"""
     await manager.connect(websocket)
     try:
         while True:
             await asyncio.sleep(5)
             
-            # Send status update
             await websocket.send_json({
                 "type": "status_update",
                 "data": {
@@ -2000,7 +1902,6 @@ async def v2_websocket(websocket: WebSocket):
     except WebSocketDisconnect:
         manager.disconnect(websocket)
 
-# Pool Management Helpers and Endpoints
 def build_pool_payload(pool: Dict, provider_map: Dict[str, Dict]) -> Dict:
     members_payload = []
     current_provider = None
@@ -2029,7 +1930,6 @@ def build_pool_payload(pool: Dict, provider_map: Dict[str, Dict]) -> Dict:
             }
         }
 
-        # keep database stats in sync
         db.update_member_stats(
             pool["id"],
             provider_id,
@@ -2085,7 +1985,6 @@ async def broadcast_pool_update(action: str, pool_id: int, extra: Optional[Dict]
 
 @app.get("/api/pools")
 async def get_pools():
-    """Get all pools"""
     providers = await get_provider_stats()
     provider_map = {provider_slug(p["name"]): p for p in providers}
     pools = db.get_pools()
@@ -2095,7 +1994,6 @@ async def get_pools():
 
 @app.post("/api/pools")
 async def create_pool(pool: PoolCreate):
-    """Create a new pool"""
     valid_strategies = {"round_robin", "priority", "weighted", "least_used"}
     if pool.rotation_strategy not in valid_strategies:
         raise HTTPException(status_code=400, detail="Invalid rotation strategy")
@@ -2124,7 +2022,6 @@ async def create_pool(pool: PoolCreate):
 
 @app.get("/api/pools/{pool_id}")
 async def get_pool(pool_id: int):
-    """Get specific pool"""
     pool = db.get_pool(pool_id)
     if not pool:
         raise HTTPException(status_code=404, detail="Pool not found")
@@ -2136,7 +2033,6 @@ async def get_pool(pool_id: int):
 
 @app.delete("/api/pools/{pool_id}")
 async def delete_pool(pool_id: int):
-    """Delete a pool"""
     pool = db.get_pool(pool_id)
     if not pool:
         raise HTTPException(status_code=404, detail="Pool not found")
@@ -2148,7 +2044,6 @@ async def delete_pool(pool_id: int):
 
 @app.post("/api/pools/{pool_id}/members")
 async def add_pool_member(pool_id: int, member: PoolMemberAdd):
-    """Add a member to a pool"""
     pool = db.get_pool(pool_id)
     if not pool:
         raise HTTPException(status_code=404, detail="Pool not found")
@@ -2187,7 +2082,6 @@ async def add_pool_member(pool_id: int, member: PoolMemberAdd):
 
 @app.delete("/api/pools/{pool_id}/members/{provider_id}")
 async def remove_pool_member(pool_id: int, provider_id: str):
-    """Remove a member from a pool"""
     pool = db.get_pool(pool_id)
     if not pool:
         raise HTTPException(status_code=404, detail="Pool not found")
@@ -2208,7 +2102,6 @@ async def remove_pool_member(pool_id: int, provider_id: str):
 
 @app.post("/api/pools/{pool_id}/rotate")
 async def rotate_pool(pool_id: int, request: Optional[Dict] = None):
-    """Rotate pool to next provider"""
     pool = db.get_pool(pool_id)
     if not pool:
         raise HTTPException(status_code=404, detail="Pool not found")
@@ -2252,7 +2145,7 @@ async def rotate_pool(pool_id: int, request: Optional[Dict] = None):
     elif strategy == "least_used":
         candidates.sort(key=lambda x: x[0].get("use_count", 0))
         selected_member, status_info = candidates[0]
-    else:  # round_robin or default
+    else:
         candidates.sort(key=lambda x: x[0].get("use_count", 0))
         selected_member, status_info = candidates[0]
 
@@ -2291,10 +2184,9 @@ async def rotate_pool(pool_id: int, request: Optional[Dict] = None):
 
 @app.get("/api/pools/{pool_id}/history")
 async def get_pool_history(pool_id: int, limit: int = 20):
-    """Get rotation history for a pool"""
     try:
         raw_history = db.get_pool_rotation_history(pool_id, limit)
-    except Exception as exc:  # pragma: no cover - defensive
+    except Exception as exc:
         logger.warning("pool history fetch failed for %s: %s", pool_id, exc)
         raw_history = []
     history = transform_rotation_history(raw_history)
@@ -2306,10 +2198,9 @@ async def get_pool_history(pool_id: int, limit: int = 20):
 
 @app.get("/api/pools/history")
 async def get_all_history(limit: int = 50):
-    """Get all rotation history"""
     try:
         raw_history = db.get_pool_rotation_history(None, limit)
-    except Exception as exc:  # pragma: no cover - defensive
+    except Exception as exc:
         logger.warning("global pool history fetch failed: %s", exc)
         raw_history = []
     history = transform_rotation_history(raw_history)
@@ -2320,10 +2211,6 @@ async def get_all_history(limit: int = 50):
 
 @app.get("/api/providers/config")
 async def get_providers_config():
-    """
-    Return complete provider configuration from providers_config_ultimate.json
-    This endpoint is used by the Provider Auto-Discovery Engine
-    """
     try:
         config_path = Path(__file__).parent / "providers_config_ultimate.json"
         with open(config_path, 'r', encoding='utf-8') as f:
@@ -2336,12 +2223,7 @@ async def get_providers_config():
 
 @app.get("/api/providers/{provider_id}/health")
 async def check_provider_health_by_id(provider_id: str):
-    """
-    Check health status of a specific provider
-    Returns: { status: 'online'|'offline', response_time: number, error?: string }
-    """
     try:
-        # Load provider config
         config_path = Path(__file__).parent / "providers_config_ultimate.json"
         with open(config_path, 'r', encoding='utf-8') as f:
             config = json.load(f)
@@ -2350,7 +2232,6 @@ async def check_provider_health_by_id(provider_id: str):
         if not provider:
             raise HTTPException(status_code=404, detail=f"Provider '{provider_id}' not found")
 
-        # Try to ping the provider's base URL
         base_url = provider.get('base_url')
         if not base_url:
             return {"status": "unknown", "error": "No base URL configured"}
@@ -2361,7 +2242,7 @@ async def check_provider_health_by_id(provider_id: str):
         async with aiohttp.ClientSession() as session:
             try:
                 async with session.get(base_url, timeout=aiohttp.ClientTimeout(total=5.0)) as response:
-                    response_time = (time.time() - start_time) * 1000  # Convert to milliseconds
+                    response_time = (time.time() - start_time) * 1000
                     status = "online" if response.status in [200, 201, 204, 301, 302, 404] else "offline"
                     return {
                         "status": status,
@@ -2376,62 +2257,23 @@ async def check_provider_health_by_id(provider_id: str):
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))
 
+
 if __name__ == "__main__":
+    import os
+    
+    # Get port from environment (Hugging Face uses 7860)
+    port = int(os.getenv("PORT", 7860))
+    host = os.getenv("HOST", "0.0.0.0")
+    
     print("🚀 Crypto Monitor ULTIMATE")
     print("📊 Real APIs: CoinGecko, CoinCap, Binance, DeFi Llama, Fear & Greed")
-    print("🌐 http://localhost:8000/dashboard")
-    print("📡 API Docs: http://localhost:8000/docs")
-    uvicorn.run(app, host="0.0.0.0", port=8000)
-
-# === Compatibility routes without /api prefix for frontend fallbacks ===
-
-@app.get("/providers")
-async def providers_root():
-    """Compatibility: mirror /api/providers at /providers"""
-    return await providers()
-
-@app.get("/providers/health")
-async def providers_health_root():
-    """Compatibility: health-style endpoint for providers"""
-    data = await get_provider_stats(force_refresh=True)
-    return data
-
-@app.get("/categories")
-async def categories_root():
-    """Compatibility: mirror /api/categories at /categories"""
-    return await api_categories()
-
-@app.get("/rate-limits")
-async def rate_limits_root():
-    """Compatibility: mirror /api/rate-limits at /rate-limits"""
-    return await api_rate_limits()
-
-@app.get("/logs")
-async def logs_root(type: str = "all"):
-    """Compatibility: mirror /api/logs at /logs"""
-    return await api_logs(type=type)
-
-@app.get("/alerts")
-async def alerts_root():
-    """Compatibility: mirror /api/alerts at /alerts"""
-    return await api_alerts()
-
-@app.get("/hf/health")
-async def hf_health_root():
-    """Compatibility: mirror /api/hf/health at /hf/health"""
-    return await hf_health()
-
-@app.get("/hf/registry")
-async def hf_registry_root(type: str = "models"):
-    """Compatibility: mirror /api/hf/registry at /hf/registry"""
-    return await hf_registry(type=type)
-
-@app.get("/hf/search")
-async def hf_search_root(q: str = "", kind: str = "models"):
-    """Compatibility: mirror /api/hf/search at /hf/search"""
-    return await hf_search(q=q, kind=kind)
-
-@app.post("/hf/run-sentiment")
-async def hf_run_sentiment_root(request: SentimentRequest):
-    """Compatibility: mirror /api/hf/run-sentiment at /hf/run-sentiment"""
-    return await hf_run_sentiment(request)
+    print(f"🌐 Server: http://{host}:{port}")
+    print(f"📡 API Docs: http://{host}:{port}/docs")
+    print(f"🎯 Environment: {'Hugging Face Spaces' if port == 7860 else 'Local Development'}")
+    
+    uvicorn.run(
+        app, 
+        host=host, 
+        port=port,
+        log_level="info"
+    )