Upload 3 files

templates/README.md

@@ -0,0 +1,40 @@
+# Crypto Data Source API (Dual Mode)
+
+**Updated:** 2025-11-11T20:56:45.223511Z
+
+This backend is designed to support **both** frontend shapes you used:
+- Classic `/api/*` endpoints (status/providers/categories/charts/logs/failures/freshness/config/keys/custom/add).
+- Alternate aliases and extras that some UIs expect: `/health`, `/info`, `/api/rate-limits`, `/api/alerts`, `/api/logs?type=...`,
+  plus synthetic **Hugging Face** helpers under `/api/hf/*`.
+
+## Files
+- `app.py` — FastAPI application (single file, no `frontend/` folder needed). Place your `index.html` next to it if you want static SPA routing.
+- `requirements.txt` — minimal, conflict-free pins tested for HF Spaces.
+
+## Run (local)
+```bash
+pip install -r requirements.txt
+uvicorn app:app --host 0.0.0.0 --port 7860
+```
+
+## Endpoints
+- `/` → serves `index.html` if present; else JSON hint
+- `/ws/live` → live events (`live_metrics`, `status_update`, `provider_status_change`, `new_alert`)
+- `/health` → alias of `/api/health`
+- `/info` → status-like payload
+- `/api/health`
+- `/api/status`
+- `/api/providers`
+- `/api/categories`
+- `/api/charts/health-history?hours=24`
+- `/api/charts/compliance?days=7`
+- `/api/freshness`
+- `/api/logs` (optional `?type=connection|error`)
+- `/api/failures` (alias exposed also at `/api/alerts`)
+- `/api/rate-limits`
+- `/api/config/keys`
+- `/api/custom/add` (POST query params: `name`, `url`, `category`, optional `test_field`)
+- `/api/markets`, `/api/ticker/{symbol}` (via ccxt)
+- `/api/hf/health`, `/api/hf/refresh` (POST), `/api/hf/registry?type=models|datasets`, `/api/hf/search?q=&kind=`, `/api/hf/run-sentiment` (POST JSON: `{"text": "..."}`)
+
+All non-critical data are **synthetic** to keep it lightweight on Spaces.

templates/app.py

@@ -0,0 +1,529 @@
+from fastapi import FastAPI, WebSocket, WebSocketDisconnect, Query, Body
+from fastapi.responses import FileResponse, JSONResponse
+from fastapi.middleware.cors import CORSMiddleware
+from pathlib import Path
+from datetime import datetime, timedelta, timezone, date
+from typing import Any, Dict, List, Optional
+import asyncio
+import random
+import ccxt
+
+app = FastAPI(title="Crypto Data Source API (Dual Mode)")
+
+# CORS
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+BASE_DIR = Path(__file__).resolve().parent
+INDEX_FILE = BASE_DIR / "index.html"
+START_TIME = datetime.now(timezone.utc)
+
+# ------------------------------
+# Sample data
+# ------------------------------
+BASE_PROVIDERS: List[Dict[str, Any]] = [
+    {"name": "Binance Spot", "category": "market_data", "has_key": False, "priority": 5, "base_url": "https://api.binance.com"},
+    {"name": "Binance Futures", "category": "market_data", "has_key": False, "priority": 4, "base_url": "https://fapi.binance.com"},
+    {"name": "CoinGecko", "category": "market_data", "has_key": False, "priority": 4, "base_url": "https://api.coingecko.com"},
+    {"name": "CoinPaprika", "category": "market_data", "has_key": False, "priority": 3, "base_url": "https://api.coinpaprika.com"},
+    {"name": "Etherscan", "category": "blockchain", "has_key": True, "priority": 4, "base_url": "https://api.etherscan.io"},
+    {"name": "BscScan", "category": "blockchain", "has_key": True, "priority": 3, "base_url": "https://api.bscscan.com"},
+    {"name": "TronScan", "category": "blockchain", "has_key": False, "priority": 3, "base_url": "https://apilist.tronscanapi.com"},
+    {"name": "CryptoPanic", "category": "news", "has_key": False, "priority": 2, "base_url": "https://cryptopanic.com/api"},
+]
+
+CUSTOM_APIS: List[Dict[str, Any]] = []
+
+API_KEYS: List[Dict[str, str]] = [
+    {"provider": "Binance", "key_masked": "BINANCE-****-****-1234"},
+    {"provider": "Etherscan", "key_masked": "ETHERSCAN-****-****-ABCD"},
+    {"provider": "BscScan", "key_masked": "BSCSCAN-****-****-5678"},
+]
+
+
+def _utc_now() -> datetime:
+    return datetime.now(timezone.utc)
+
+
+def _provider_snapshot(provider: Dict[str, Any]) -> Dict[str, Any]:
+    """Return one provider item in *rich* shape for *both* frontends."""
+    rt = random.randint(80, 900)
+    minutes_ago = random.uniform(0, 30)
+    last_dt = _utc_now() - timedelta(minutes=minutes_ago)
+
+    if rt < 300:
+        status = "online"
+    elif rt < 700:
+        status = "degraded"
+    else:
+        status = "offline"
+
+    # Common fields
+    item = {
+        "name": provider["name"],
+        "category": provider["category"],
+        "status": status,
+        "response_time_ms": rt,
+        "last_fetch": last_dt.isoformat(),
+        "has_key": bool(provider.get("has_key", False)),
+        "priority": int(provider.get("priority", 3)),
+    }
+    # Extended fields for the other UI flavor
+    item.update({
+        "base_url": provider.get("base_url", ""),
+        "response_time": rt,                       # alias
+        "last_checked": last_dt.isoformat(),       # alias
+        "success_rate": round(random.uniform(80, 99), 2),
+        "last_success": (last_dt - timedelta(minutes=random.randint(1, 10))).isoformat(),
+        "error_count_24h": random.randint(0, 12),
+    })
+    return item
+
+
+def _generate_providers_snapshot() -> List[Dict[str, Any]]:
+    providers = [_provider_snapshot(p) for p in (BASE_PROVIDERS + CUSTOM_APIS)]
+    return providers
+
+
+# ------------------------------
+# CCXT basic APIs
+# ------------------------------
+@app.get("/api/health")
+async def api_health():
+    return {
+        "status": "online",
+        "version": "1.0.0",
+        "timestamp": _utc_now().isoformat(),
+        "ccxt_version": ccxt.__version__,
+    }
+
+
+@app.get("/api/markets")
+async def api_markets():
+    try:
+        exchange = ccxt.binance()
+        markets = exchange.load_markets()
+        return {
+            "success": True,
+            "total_markets": len(markets),
+            "markets": list(markets.keys())[:50],
+        }
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+@app.get("/api/ticker/{symbol}")
+async def api_ticker(symbol: str):
+    try:
+        exchange = ccxt.binance()
+        ticker = exchange.fetch_ticker(symbol)
+        return {"success": True, "data": ticker}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+# ------------------------------
+# Dual-mode status & KPI
+# ------------------------------
+def _status_payload() -> Dict[str, Any]:
+    providers = _generate_providers_snapshot()
+    total = len(providers)
+    online = sum(1 for p in providers if p["status"] == "online")
+    offline = sum(1 for p in providers if p["status"] == "offline")
+    degraded = sum(1 for p in providers if p["status"] == "degraded")
+    avg_response = int(sum(p["response_time_ms"] for p in providers) / total) if total else 0
+    total_requests_hour = random.randint(200, 1200)
+    total_failures_hour = random.randint(0, max(20, degraded * 2 + offline * 5))
+    system_health = "healthy" if offline == 0 and degraded <= max(1, total // 4) else "degraded"
+    now = _utc_now()
+    uptime_seconds = (now - START_TIME).total_seconds()
+
+    return {
+        "status": "online",
+        "service": "crypto-data-source",
+        "version": "1.0.0",
+        "timestamp": now.isoformat(),
+        "uptime_seconds": uptime_seconds,
+        "total_providers": total,
+        "online": online,
+        "offline": offline,
+        "degraded": degraded,
+        "avg_response_time_ms": avg_response,
+        "system_health": system_health,
+        "total_requests_hour": total_requests_hour,
+        "total_failures_hour": total_failures_hour,
+    }
+
+
+@app.get("/api/status")
+async def api_status():
+    return _status_payload()
+
+
+# Aliases for alternate frontend:
+@app.get("/health")
+async def alias_health():
+    # Some UIs call /health (without /api)
+    return await api_health()
+
+
+@app.get("/info")
+async def alias_info():
+    # Some UIs call /info expecting a status-like object
+    return _status_payload()
+
+
+# ------------------------------
+# Providers & categories
+# ------------------------------
+@app.get("/api/providers")
+async def api_providers():
+    return _generate_providers_snapshot()
+
+
+@app.get("/api/categories")
+async def api_categories():
+    providers = _generate_providers_snapshot()
+    by_cat: Dict[str, List[Dict[str, Any]]] = {}
+    for p in providers:
+        by_cat.setdefault(p["category"], []).append(p)
+
+    payload: List[Dict[str, Any]] = []
+    for category, items in by_cat.items():
+        total_sources = len(items)
+        online_sources = sum(1 for i in items if i["status"] == "online")
+        avg_rt = int(sum(i["response_time_ms"] for i in items) / total_sources) if total_sources else 0
+        # minimal fields expected by both UIs:
+        payload.append({
+            # our previous UI:
+            "name": category,
+            "status": "online" if online_sources > 0 else "offline",
+            "online_sources": online_sources,
+            "total_sources": total_sources,
+            "avg_response_time_ms": avg_rt,
+            # aliases for other UI:
+            "online": online_sources,
+            "avg_response": avg_rt,
+            "health_percentage": int((online_sources / total_sources) * 100) if total_sources else 0,
+            "last_updated": _utc_now().isoformat(),
+        })
+    return payload
+
+
+# ------------------------------
+# Charts
+# ------------------------------
+@app.get("/api/charts/health-history")
+async def api_chart_health_history(hours: int = 24):
+    now = _utc_now()
+    points = max(12, hours)
+    timestamps: List[str] = []
+    success_rate: List[float] = []
+    for i in range(points):
+        ts = now - timedelta(hours=(hours * (points - 1 - i) / points))
+        base = 90
+        noise = random.uniform(-10, 5)
+        value = max(50.0, min(100.0, base + noise))
+        timestamps.append(ts.isoformat())
+        success_rate.append(round(value, 2))
+    return {"timestamps": timestamps, "success_rate": success_rate}
+
+
+@app.get("/api/charts/compliance")
+async def api_chart_compliance(days: int = 7):
+    today = date.today()
+    dates: List[str] = []
+    compliance_percentage: List[float] = []
+    for i in range(days):
+        d = today - timedelta(days=(days - 1 - i))
+        base = 88
+        noise = random.uniform(-8, 5)
+        value = max(60.0, min(100.0, base + noise))
+        dates.append(d.isoformat())
+        compliance_percentage.append(round(value, 2))
+    return {"dates": dates, "compliance_percentage": compliance_percentage}
+
+
+# ------------------------------
+# Freshness & Logs & Failures
+# ------------------------------
+@app.get("/api/freshness")
+async def api_freshness():
+    providers = _generate_providers_snapshot()
+    items: List[Dict[str, Any]] = []
+    for p in providers:
+        fetch_time = datetime.fromisoformat(p["last_fetch"])
+        staleness_minutes = (_utc_now() - fetch_time).total_seconds() / 60.0
+        ttl_minutes = 30
+        status = "fresh" if staleness_minutes <= ttl_minutes else "stale"
+        items.append({
+            "provider": p["name"],
+            "category": p["category"],
+            "fetch_time": fetch_time.isoformat(),
+            "staleness_minutes": round(staleness_minutes, 1),
+            "ttl_minutes": ttl_minutes,
+            "status": status,
+        })
+    return items
+
+
+def _synth_logs() -> List[Dict[str, Any]]:
+    providers = _generate_providers_snapshot()
+    logs: List[Dict[str, Any]] = []
+    now = _utc_now()
+    for p in providers:
+        # success
+        logs.append({
+            "timestamp": (now - timedelta(minutes=random.randint(0, 60))).isoformat(),
+            "provider": p["name"],
+            "endpoint": "/api/status",
+            "status": "success",
+            "http_code": 200,
+            "response_time_ms": p["response_time_ms"],
+            "error_message": None,
+            "type": "connection"
+        })
+        # possible error
+        if p["status"] != "online" and random.random() < 0.5:
+            logs.append({
+                "timestamp": (now - timedelta(minutes=random.randint(0, 60))).isoformat(),
+                "provider": p["name"],
+                "endpoint": "/api/markets",
+                "status": "error",
+                "http_code": random.choice([429, 500, 504]),
+                "response_time_ms": random.randint(500, 2000),
+                "error_message": "Upstream error or timeout",
+                "type": "error"
+            })
+    logs.sort(key=lambda x: x["timestamp"], reverse=True)
+    return logs
+
+
+@app.get("/api/logs")
+async def api_logs(log_type: Optional[str] = Query(None, alias="type")):
+    """
+    Optional ?type=connection|error to filter.
+    """
+    logs = _synth_logs()
+    if log_type in {"connection", "error"}:
+        logs = [l for l in logs if l.get("type") == log_type]
+    return logs
+
+
+@app.get("/api/failures")
+async def api_failures():
+    logs = _synth_logs()
+    failures: List[Dict[str, Any]] = []
+    for log in logs:
+        if log["status"] == "error":
+            failures.append({
+                "timestamp": log["timestamp"],
+                "provider": log["provider"],
+                "error_type": "HTTP " + str(log["http_code"]),
+                "error_message": log["error_message"] or "Unknown error",
+                "retry_attempted": random.random() < 0.6,
+            })
+    return {"recent_failures": failures}
+
+
+# alias for another UI calling /api/alerts
+@app.get("/api/alerts")
+async def api_alerts():
+    return await api_failures()
+
+
+# ------------------------------
+# Rate limits (synthetic)
+# ------------------------------
+@app.get("/api/rate-limits")
+async def api_rate_limits():
+    providers = _generate_providers_snapshot()
+    out = []
+    for p in providers:
+        out.append({
+            "provider": p["name"],
+            "limit_per_min": random.choice([60, 120, 300, 600]),
+            "used_in_min": random.randint(0, 60),
+            "cooldown_sec": random.choice([0, 0, 0, 10, 20, 30]),
+            "status": p["status"],
+        })
+    return out
+
+
+# ------------------------------
+# Config keys & custom add
+# ------------------------------
+@app.get("/api/config/keys")
+async def api_config_keys():
+    return API_KEYS
+
+
+@app.post("/api/custom/add")
+async def api_custom_add(
+    name: str = Query(...),
+    url: str = Query(...),
+    category: str = Query(...),
+    test_field: Optional[str] = Query(None),
+):
+    CUSTOM_APIS.append({
+        "name": name,
+        "url": url,
+        "category": category or "other",
+        "test_field": test_field,
+        "has_key": False,
+        "priority": 3,
+        "base_url": url
+    })
+    return {"success": True, "message": "Custom API added successfully"}
+
+
+# ------------------------------
+# Hugging Face synthetic endpoints
+# ------------------------------
+@app.get("/api/hf/health")
+async def hf_health():
+    return {
+        "space_status": "running",
+        "last_refresh": _utc_now().isoformat(),
+        "hardware": "cpu-basic",
+        "queued_jobs": random.randint(0, 2),
+    }
+
+
+@app.post("/api/hf/refresh")
+async def hf_refresh():
+    # pretend we refreshed space metadata / cache
+    return {"success": True, "refreshed_at": _utc_now().isoformat()}
+
+
+@app.get("/api/hf/registry")
+async def hf_registry(kind: str = Query("models")):
+    if kind == "datasets":
+        return [{"id": "imdb", "downloads": 12345}, {"id": "ag_news", "downloads": 54321}]
+    return [{"id": "distilbert-base-uncased", "likes": 12000}, {"id": "bert-base-uncased", "likes": 25000}]
+
+
+@app.get("/api/hf/search")
+async def hf_search(q: str, kind: str = Query("models")):
+    # return mock search results
+    return {
+        "query": q,
+        "kind": kind,
+        "results": [
+            {"id": f"{kind}/{q}-result-1", "score": round(random.uniform(0.6, 0.99), 3)},
+            {"id": f"{kind}/{q}-result-2", "score": round(random.uniform(0.6, 0.99), 3)},
+        ],
+    }
+
+
+@app.post("/api/hf/run-sentiment")
+async def hf_run_sentiment(text: str = Body(..., embed=True)):
+    # fake analyser
+    label = random.choice(["POSITIVE", "NEGATIVE", "NEUTRAL"])
+    score = round(random.uniform(0.5, 0.99), 3)
+    return {"label": label, "score": score, "text": text}
+
+
+# ------------------------------
+# WebSocket with richer event types
+# ------------------------------
+class LiveConnections:
+    def __init__(self) -> None:
+        self.active: List[WebSocket] = []
+
+    async def connect(self, websocket: WebSocket) -> None:
+        await websocket.accept()
+        self.active.append(websocket)
+
+    def disconnect(self, websocket: WebSocket) -> None:
+        if websocket in self.active:
+            self.active.remove(websocket)
+
+    async def broadcast(self, message: Dict[str, Any]) -> None:
+        for ws in list(self.active):
+            try:
+                await ws.send_json(message)
+            except Exception:
+                self.disconnect(ws)
+
+
+live_manager = LiveConnections()
+
+
+@app.websocket("/ws/live")
+async def websocket_live(websocket: WebSocket):
+    await live_manager.connect(websocket)
+    try:
+        await websocket.send_json({
+            "type": "welcome",
+            "service": "crypto-data-source",
+            "timestamp": _utc_now().isoformat(),
+        })
+
+        while True:
+            # rotate between event types to satisfy different UIs
+            event_choice = random.choice(["live_metrics", "status_update", "provider_status_change", "new_alert"])
+            if event_choice == "live_metrics":
+                payload = {
+                    "type": "live_metrics",
+                    "timestamp": _utc_now().isoformat(),
+                    "metrics": {
+                        "cpu_usage": random.randint(5, 40),
+                        "memory_usage": random.randint(20, 75),
+                        "active_requests": random.randint(1, 30),
+                        "error_rate_percent": round(random.uniform(0.0, 3.0), 2),
+                    },
+                }
+            elif event_choice == "status_update":
+                payload = {"type": "status_update", "status": _status_payload()}
+            elif event_choice == "provider_status_change":
+                prov = random.choice(_generate_providers_snapshot())
+                payload = {"type": "provider_status_change", "provider": prov}
+            else:
+                payload = {
+                    "type": "new_alert",
+                    "data": {
+                        "timestamp": _utc_now().isoformat(),
+                        "provider": random.choice(BASE_PROVIDERS)["name"],
+                        "error_type": random.choice(["HTTP 429", "HTTP 500", "Timeout"]),
+                        "message": "Synthetic alert for demo",
+                    },
+                }
+
+            await websocket.send_json(payload)
+            await asyncio.sleep(4)
+    except WebSocketDisconnect:
+        live_manager.disconnect(websocket)
+    except Exception:
+        live_manager.disconnect(websocket)
+
+
+# ------------------------------
+# Serve root index.html if present
+# ------------------------------
+@app.get("/")
+async def root():
+    if INDEX_FILE.exists():
+        return FileResponse(INDEX_FILE)
+    return JSONResponse(
+        {"message": "index.html not found next to app.py.", "hint": "Put index.html in the same folder as app.py or use /docs."}
+    )
+
+
+@app.get("/{full_path:path}")
+async def spa_catch_all(full_path: str):
+    if full_path.startswith("api/"):
+        return JSONResponse({"error": "API endpoint not found", "path": full_path}, status_code=404)
+    if INDEX_FILE.exists():
+        return FileResponse(INDEX_FILE)
+    return JSONResponse({"error": "No frontend available for this path.", "path": full_path}, status_code=404)
+
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=7860)

templates/requirements.txt

@@ -0,0 +1,8 @@
+fastapi==0.104.1
+uvicorn[standard]==0.24.0
+pydantic==2.5.0
+python-multipart==0.0.6
+websockets==11.0.3
+ccxt==4.3.59
+requests==2.31.0
+httpx>=0.24