Upload 143 files

.dockerignore

@@ -1,121 +1,16 @@
-# Python
 __pycache__/
 *.py[cod]
 *$py.class
 *.so
-.Python
-build/
-develop-eggs/
-dist/
-downloads/
-eggs/
-.eggs/
-lib/
-lib64/
-parts/
-sdist/
-var/
-wheels/
-*.egg-info/
-.installed.cfg
-*.egg
-MANIFEST
-pip-log.txt
-pip-delete-this-directory.txt
-
-# Virtual environments
+.env
+.venv
+env/
 venv/
 ENV/
-env/
-.venv
-
-# IDE
-.vscode/
-.idea/
-*.swp
-*.swo
-*~
 .DS_Store
-
-# Git
-.git/
+.git
 .gitignore
-.gitattributes
-
-# Documentation
-*.md
-docs/
-README*.md
-CHANGELOG.md
-LICENSE
-
-# Testing
-.pytest_cache/
-.coverage
-htmlcov/
-.tox/
-.hypothesis/
-tests/
-test_*.py
-
-# Logs and databases (will be created in container)
 *.log
-logs/
-data/*.db
-data/*.sqlite
-data/*.db-journal
-
-# Environment files (should be set via docker-compose or HF Secrets)
-.env
-.env.*
-!.env.example
-
-# Docker
-docker-compose*.yml
-!docker-compose.yml
-Dockerfile
-.dockerignore
-
-# CI/CD
-.github/
-.gitlab-ci.yml
-.travis.yml
-azure-pipelines.yml
-
-# Temporary files
-*.tmp
-*.bak
-*.swp
-temp/
-tmp/
-
-# Node modules (if any)
-node_modules/
-package-lock.json
-yarn.lock
-
-# OS files
-Thumbs.db
-.DS_Store
-desktop.ini
-
-# Jupyter notebooks
-.ipynb_checkpoints/
-*.ipynb
-
-# Model cache (models will be downloaded in container)
-models/
-.cache/
-.huggingface/
-
-# Large files that shouldn't be in image
-*.tar
-*.tar.gz
-*.zip
-*.rar
-*.7z
-
-# Screenshots and assets not needed
-screenshots/
-assets/*.png
-assets/*.jpg
+*.sqlite
+.idea/
+.vscode/

DEPLOYMENT_GUIDE.md

@@ -0,0 +1,600 @@
+# Deployment Guide - Crypto Resource Aggregator
+
+## Quick Deployment to Hugging Face Spaces
+
+### Method 1: Web Interface (Recommended for Beginners)
+
+1. **Create a Hugging Face Account**
+   - Go to https://huggingface.co/join
+   - Sign up for a free account
+
+2. **Create a New Space**
+   - Go to https://huggingface.co/new-space
+   - Choose a name (e.g., `crypto-resource-aggregator`)
+   - Select SDK: **Docker**
+   - Choose visibility: **Public** or **Private**
+   - Click "Create Space"
+
+3. **Upload Files**
+   Upload the following files to your Space:
+   - `app.py` - Main application file
+   - `requirements.txt` - Python dependencies
+   - `all_apis_merged_2025.json` - Resource configuration
+   - `README.md` - Documentation
+   - `Dockerfile` - Docker configuration
+
+4. **Wait for Build**
+   - The Space will automatically build and deploy
+   - This may take 2-5 minutes
+   - You'll see the build logs in real-time
+
+5. **Access Your API**
+   - Once deployed, your API will be available at:
+     `https://[your-username]-[space-name].hf.space`
+   - Example: `https://username-crypto-resource-aggregator.hf.space`
+
+### Method 2: Git CLI (Recommended for Advanced Users)
+
+```bash
+# Clone your Space repository
+git clone https://huggingface.co/spaces/[your-username]/[space-name]
+cd [space-name]
+
+# Copy all files to the repository
+cp app.py requirements.txt all_apis_merged_2025.json README.md Dockerfile .
+
+# Commit and push
+git add .
+git commit -m "Initial deployment of Crypto Resource Aggregator"
+git push
+```
+
+---
+
+## Alternative Deployment Options
+
+### Option 1: Heroku
+
+```bash
+# Install Heroku CLI
+# https://devcenter.heroku.com/articles/heroku-cli
+
+# Create a new app
+heroku create crypto-resource-aggregator
+
+# Create Procfile
+echo "web: python app.py" > Procfile
+
+# Deploy
+git add .
+git commit -m "Deploy to Heroku"
+git push heroku main
+
+# Open your app
+heroku open
+```
+
+### Option 2: Railway
+
+```bash
+# Install Railway CLI
+npm i -g @railway/cli
+
+# Login
+railway login
+
+# Initialize project
+railway init
+
+# Deploy
+railway up
+
+# Get deployment URL
+railway domain
+```
+
+### Option 3: Render
+
+1. Go to https://render.com
+2. Click "New +" → "Web Service"
+3. Connect your GitHub repository
+4. Configure:
+   - **Build Command**: `pip install -r requirements.txt`
+   - **Start Command**: `python app.py`
+   - **Environment**: Python 3
+5. Click "Create Web Service"
+
+### Option 4: Docker (Self-Hosted)
+
+```bash
+# Build the Docker image
+docker build -t crypto-aggregator .
+
+# Run the container
+docker run -d -p 7860:7860 --name crypto-aggregator crypto-aggregator
+
+# Check logs
+docker logs crypto-aggregator
+
+# Stop the container
+docker stop crypto-aggregator
+
+# Remove the container
+docker rm crypto-aggregator
+```
+
+### Option 5: Docker Compose (Self-Hosted)
+
+Create `docker-compose.yml`:
+
+```yaml
+version: '3.8'
+
+services:
+  aggregator:
+    build: .
+    ports:
+      - "7860:7860"
+    restart: unless-stopped
+    volumes:
+      - ./history.db:/app/history.db
+    environment:
+      - ENVIRONMENT=production
+```
+
+Run:
+```bash
+docker-compose up -d
+```
+
+### Option 6: AWS EC2
+
+```bash
+# Connect to your EC2 instance
+ssh -i your-key.pem ubuntu@your-instance-ip
+
+# Install Python and dependencies
+sudo apt update
+sudo apt install python3-pip python3-venv -y
+
+# Create virtual environment
+python3 -m venv venv
+source venv/bin/activate
+
+# Upload files (from local machine)
+scp -i your-key.pem app.py requirements.txt all_apis_merged_2025.json ubuntu@your-instance-ip:~/
+
+# Install dependencies
+pip install -r requirements.txt
+
+# Run with nohup
+nohup python app.py > output.log 2>&1 &
+
+# Or use systemd service (recommended)
+sudo nano /etc/systemd/system/crypto-aggregator.service
+```
+
+Create systemd service file:
+```ini
+[Unit]
+Description=Crypto Resource Aggregator
+After=network.target
+
+[Service]
+User=ubuntu
+WorkingDirectory=/home/ubuntu/crypto-aggregator
+ExecStart=/home/ubuntu/venv/bin/python app.py
+Restart=always
+
+[Install]
+WantedBy=multi-user.target
+```
+
+Enable and start:
+```bash
+sudo systemctl enable crypto-aggregator
+sudo systemctl start crypto-aggregator
+sudo systemctl status crypto-aggregator
+```
+
+### Option 7: Google Cloud Run
+
+```bash
+# Install gcloud CLI
+# https://cloud.google.com/sdk/docs/install
+
+# Authenticate
+gcloud auth login
+
+# Set project
+gcloud config set project YOUR_PROJECT_ID
+
+# Build and deploy
+gcloud run deploy crypto-aggregator \
+  --source . \
+  --platform managed \
+  --region us-central1 \
+  --allow-unauthenticated
+
+# Get URL
+gcloud run services describe crypto-aggregator --region us-central1 --format 'value(status.url)'
+```
+
+### Option 8: DigitalOcean App Platform
+
+1. Go to https://cloud.digitalocean.com/apps
+2. Click "Create App"
+3. Connect your GitHub repository
+4. Configure:
+   - **Run Command**: `python app.py`
+   - **Environment**: Python 3.11
+   - **HTTP Port**: 7860
+5. Click "Deploy"
+
+---
+
+## Environment Variables (Optional)
+
+You can configure the following environment variables:
+
+```bash
+# Port (default: 7860)
+export PORT=8000
+
+# Log level (default: INFO)
+export LOG_LEVEL=DEBUG
+
+# Database path (default: history.db)
+export DATABASE_PATH=/path/to/history.db
+```
+
+---
+
+## Post-Deployment Testing
+
+### 1. Test Health Endpoint
+
+```bash
+curl https://your-deployment-url.com/health
+```
+
+Expected response:
+```json
+{
+  "status": "healthy",
+  "timestamp": "2025-11-10T...",
+  "resources_loaded": true,
+  "database_connected": true
+}
+```
+
+### 2. Test Resource Listing
+
+```bash
+curl https://your-deployment-url.com/resources
+```
+
+### 3. Test Query Endpoint
+
+```bash
+curl -X POST https://your-deployment-url.com/query \
+  -H "Content-Type: application/json" \
+  -d '{
+    "resource_type": "market_data",
+    "resource_name": "coingecko",
+    "endpoint": "/simple/price",
+    "params": {
+      "ids": "bitcoin",
+      "vs_currencies": "usd"
+    }
+  }'
+```
+
+### 4. Test Status Monitoring
+
+```bash
+curl https://your-deployment-url.com/status
+```
+
+### 5. Run Full Test Suite
+
+From your local machine:
+
+```bash
+# Update BASE_URL in test_aggregator.py
+# Change: BASE_URL = "http://localhost:7860"
+# To: BASE_URL = "https://your-deployment-url.com"
+
+# Run tests
+python test_aggregator.py
+```
+
+---
+
+## Performance Optimization
+
+### 1. Enable Caching
+
+Add Redis for caching (optional):
+
+```python
+import redis
+import json
+
+# Connect to Redis
+redis_client = redis.Redis(host='localhost', port=6379, decode_responses=True)
+
+# Cache resource data
+def get_cached_data(key, ttl=300):
+    cached = redis_client.get(key)
+    if cached:
+        return json.loads(cached)
+    return None
+
+def set_cached_data(key, data, ttl=300):
+    redis_client.setex(key, ttl, json.dumps(data))
+```
+
+### 2. Use Connection Pooling
+
+Already implemented with `aiohttp.ClientSession`
+
+### 3. Add Rate Limiting
+
+Install:
+```bash
+pip install slowapi
+```
+
+Add to `app.py`:
+```python
+from slowapi import Limiter, _rate_limit_exceeded_handler
+from slowapi.util import get_remote_address
+from slowapi.errors import RateLimitExceeded
+
+limiter = Limiter(key_func=get_remote_address)
+app.state.limiter = limiter
+app.add_exception_handler(RateLimitExceeded, _rate_limit_exceeded_handler)
+
+@app.post("/query")
+@limiter.limit("60/minute")
+async def query_resource(request: Request, query: ResourceQuery):
+    # ... existing code
+```
+
+### 4. Add Monitoring
+
+Use Sentry for error tracking:
+
+```bash
+pip install sentry-sdk
+```
+
+```python
+import sentry_sdk
+from sentry_sdk.integrations.fastapi import FastApiIntegration
+
+sentry_sdk.init(
+    dsn="your-sentry-dsn",
+    integrations=[FastApiIntegration()],
+    traces_sample_rate=1.0,
+)
+```
+
+---
+
+## Security Best Practices
+
+### 1. API Key Management
+
+Store API keys in environment variables:
+
+```python
+import os
+
+API_KEYS = {
+    'etherscan': os.getenv('ETHERSCAN_API_KEY', 'default-key'),
+    'coinmarketcap': os.getenv('CMC_API_KEY', 'default-key'),
+}
+```
+
+### 2. Enable HTTPS
+
+Most platforms (Hugging Face, Heroku, etc.) provide HTTPS by default.
+
+For self-hosted, use Let's Encrypt:
+
+```bash
+# Install Certbot
+sudo apt install certbot python3-certbot-nginx
+
+# Get certificate
+sudo certbot --nginx -d your-domain.com
+```
+
+### 3. Add Authentication (Optional)
+
+```bash
+pip install python-jose[cryptography] passlib[bcrypt]
+```
+
+```python
+from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+from fastapi import Security
+
+security = HTTPBearer()
+
+@app.post("/query")
+async def query_resource(
+    query: ResourceQuery,
+    credentials: HTTPAuthorizationCredentials = Security(security)
+):
+    # Verify token
+    if credentials.credentials != "your-secret-token":
+        raise HTTPException(status_code=401, detail="Invalid token")
+    # ... existing code
+```
+
+---
+
+## Monitoring & Maintenance
+
+### 1. Monitor Logs
+
+Hugging Face Spaces:
+- View logs in the Space settings → "Logs" tab
+
+Docker:
+```bash
+docker logs -f crypto-aggregator
+```
+
+Systemd:
+```bash
+journalctl -u crypto-aggregator -f
+```
+
+### 2. Database Maintenance
+
+Backup database regularly:
+
+```bash
+# Local backup
+cp history.db history_backup_$(date +%Y%m%d).db
+
+# Remote backup
+scp user@server:/path/to/history.db ./backups/
+```
+
+Clean old records:
+
+```sql
+-- Remove records older than 30 days
+DELETE FROM query_history WHERE timestamp < datetime('now', '-30 days');
+DELETE FROM resource_status WHERE last_check < datetime('now', '-30 days');
+```
+
+### 3. Update Resources
+
+To add new resources, update `all_apis_merged_2025.json` and redeploy.
+
+### 4. Health Checks
+
+Set up automated health checks:
+
+```bash
+# Cron job (every 5 minutes)
+*/5 * * * * curl https://your-deployment-url.com/health || echo "API is down!"
+```
+
+Use UptimeRobot or similar service for monitoring.
+
+---
+
+## Troubleshooting
+
+### Issue: Server won't start
+
+**Solution:**
+```bash
+# Check if port 7860 is in use
+lsof -i :7860
+
+# Kill existing process
+kill -9 $(lsof -t -i:7860)
+
+# Or use a different port
+PORT=8000 python app.py
+```
+
+### Issue: Database locked
+
+**Solution:**
+```bash
+# Stop all instances
+pkill -f app.py
+
+# Remove lock (if exists)
+rm history.db-journal
+
+# Restart
+python app.py
+```
+
+### Issue: High memory usage
+
+**Solution:**
+- Add connection limits
+- Implement request queuing
+- Scale horizontally with multiple instances
+
+### Issue: API rate limits
+
+**Solution:**
+- Implement caching
+- Add multiple API keys for rotation
+- Use fallback resources
+
+---
+
+## Scaling
+
+### Horizontal Scaling
+
+Use a load balancer with multiple instances:
+
+```yaml
+# docker-compose-scaled.yml
+version: '3.8'
+
+services:
+  aggregator:
+    build: .
+    deploy:
+      replicas: 3
+    environment:
+      - WORKER_ID=${HOSTNAME}
+
+  nginx:
+    image: nginx:alpine
+    ports:
+      - "80:80"
+    volumes:
+      - ./nginx.conf:/etc/nginx/nginx.conf
+    depends_on:
+      - aggregator
+```
+
+### Vertical Scaling
+
+Increase resources on your hosting platform:
+- Hugging Face: Upgrade to paid tier
+- AWS: Use larger EC2 instance
+- Docker: Adjust container resources
+
+---
+
+## Support
+
+For issues or questions:
+1. Check `/health` endpoint
+2. Review application logs
+3. Test individual resources with `/status`
+4. Verify database with SQLite browser
+
+---
+
+## Next Steps
+
+After deployment:
+
+1. **Integrate with your main app** using the provided client examples
+2. **Set up monitoring** with health checks and alerts
+3. **Configure backups** for the history database
+4. **Add custom resources** by updating the JSON file
+5. **Implement caching** for frequently accessed data
+6. **Enable authentication** if needed for security
+
+---
+
+**Congratulations! Your Crypto Resource Aggregator is now deployed and ready to use!** 🚀

Dockerfile

@@ -1,41 +1,38 @@
-# Use Python 3.11 Slim base image
-FROM python:3.11-slim
+FROM python:3.9-slim
 
-# Set environment variables
-ENV PYTHONUNBUFFERED=1 \
-    PYTHONDONTWRITEBYTECODE=1 \
-    PIP_NO_CACHE_DIR=1 \
-    PIP_DISABLE_PIP_VERSION_CHECK=1 \
-    ENABLE_AUTO_DISCOVERY=false
+WORKDIR /code
 
 # Install system dependencies
-RUN apt-get update && apt-get install -y \
-    gcc \
-    g++ \
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends \
+    build-essential \
     curl \
+    git \
+    && apt-get clean \
     && rm -rf /var/lib/apt/lists/*
 
-# Set working directory
-WORKDIR /app
+# Create necessary directories
+RUN mkdir -p /code/data /code/logs
 
-# Copy dependency files
+# Copy requirements first to leverage Docker cache
 COPY requirements.txt .
 
 # Install Python dependencies
-RUN pip install --no-cache-dir -r requirements.txt
+RUN pip install --no-cache-dir --upgrade pip && \
+    pip install --no-cache-dir -r requirements.txt
 
 # Copy application code
 COPY . .
 
-# Create necessary directories
-RUN mkdir -p logs data data/exports data/backups
+# Ensure directories have correct permissions
+RUN chmod -R 755 /code/data /code/logs
 
-# Expose ports (Hugging Face uses PORT env variable, default 7860)
-EXPOSE 7860 8000
+# Set environment variables
+ENV PYTHONPATH=/code
+ENV PORT=7860
 
-# Health check (simplified to avoid requests dependency in healthcheck)
-HEALTHCHECK --interval=30s --timeout=10s --start-period=40s --retries=3 \
-    CMD curl -f http://localhost:${PORT:-8000}/health || exit 1
+# Expose the port
+EXPOSE 7860
 
-# Run server with uvicorn (supports Hugging Face PORT env variable)
-CMD ["sh", "-c", "uvicorn api_server_extended:app --host 0.0.0.0 --port ${PORT:-8000}"]
+# Run the application
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

HUGGINGFACE_DEPLOYMENT.md

@@ -0,0 +1,349 @@
+# 🤗 HuggingFace Spaces Deployment Guide
+
+This guide explains how to deploy the Crypto API Monitoring System to HuggingFace Spaces.
+
+## Overview
+
+The application is fully optimized for HuggingFace Spaces deployment with:
+- **Docker-based deployment** using the standard HF Spaces port (7860)
+- **Automatic environment detection** for frontend API calls
+- **HuggingFace ML integration** for crypto sentiment analysis
+- **WebSocket support** for real-time data streaming
+- **Persistent data storage** with SQLite
+
+## Prerequisites
+
+1. A HuggingFace account ([sign up here](https://huggingface.co/join))
+2. Git installed on your local machine
+3. Basic familiarity with Docker and HuggingFace Spaces
+
+## Deployment Steps
+
+### 1. Create a New Space
+
+1. Go to [HuggingFace Spaces](https://huggingface.co/spaces)
+2. Click "Create new Space"
+3. Configure your Space:
+   - **Name**: `Datasourceforcryptocurrency` (or your preferred name)
+   - **License**: Choose appropriate license (e.g., MIT)
+   - **SDK**: Select **Docker**
+   - **Visibility**: Public or Private (your choice)
+4. Click "Create Space"
+
+### 2. Clone Your Space Repository
+
+```bash
+# Clone your newly created space
+git clone https://huggingface.co/spaces/YOUR_USERNAME/YOUR_SPACE_NAME
+cd YOUR_SPACE_NAME
+```
+
+### 3. Copy Application Files
+
+Copy all files from this repository to your Space directory:
+
+```bash
+# Copy all files (adjust paths as needed)
+cp -r /path/to/crypto-dt-source/* .
+```
+
+**Essential files for HuggingFace Spaces:**
+- `Dockerfile` - Docker configuration optimized for HF Spaces
+- `requirements.txt` - Python dependencies including transformers
+- `app.py` - Main FastAPI application
+- `config.js` - Frontend configuration with environment detection
+- `*.html` - UI files (index.html, hf_console.html, etc.)
+- All backend directories (`api/`, `backend/`, `monitoring/`, etc.)
+
+### 4. Configure Environment Variables (Optional but Recommended)
+
+In your HuggingFace Space settings, add these secrets:
+
+**Required:**
+- `HUGGINGFACE_TOKEN` - Your HF token for accessing models (optional if using public models)
+
+**Optional API Keys (for enhanced data collection):**
+- `ETHERSCAN_KEY_1` - Etherscan API key
+- `COINMARKETCAP_KEY_1` - CoinMarketCap API key
+- `NEWSAPI_KEY` - NewsAPI key
+- `CRYPTOCOMPARE_KEY` - CryptoCompare API key
+
+**HuggingFace Configuration:**
+- `ENABLE_SENTIMENT=true` - Enable sentiment analysis
+- `SENTIMENT_SOCIAL_MODEL=ElKulako/cryptobert` - Social sentiment model
+- `SENTIMENT_NEWS_MODEL=kk08/CryptoBERT` - News sentiment model
+- `HF_REGISTRY_REFRESH_SEC=21600` - Registry refresh interval (6 hours)
+
+### 5. Push to HuggingFace
+
+```bash
+# Add all files
+git add .
+
+# Commit changes
+git commit -m "Initial deployment of Crypto API Monitor"
+
+# Push to HuggingFace
+git push
+```
+
+### 6. Wait for Build
+
+HuggingFace Spaces will automatically:
+1. Build your Docker image (takes 5-10 minutes)
+2. Download required ML models
+3. Start the application on port 7860
+4. Run health checks
+
+Monitor the build logs in your Space's "Logs" tab.
+
+### 7. Access Your Application
+
+Once deployed, your application will be available at:
+```
+https://huggingface.co/spaces/YOUR_USERNAME/YOUR_SPACE_NAME
+```
+
+## Features Available in HuggingFace Spaces
+
+### 🎯 Real-Time Dashboard
+- Access the main dashboard at the root URL
+- Real-time WebSocket updates for all metrics
+- Provider health monitoring
+- System status and analytics
+
+### 🤗 HuggingFace Console
+- Access at `/hf_console.html`
+- Test HF model registry
+- Run sentiment analysis
+- Search crypto-related models and datasets
+
+### 📊 API Documentation
+- Swagger UI: `/docs`
+- ReDoc: `/redoc`
+- API Info: `/api-info`
+
+### 🔌 WebSocket Endpoints
+All WebSocket endpoints are available for real-time data:
+- `/ws` - Master WebSocket endpoint
+- `/ws/market_data` - Market data updates
+- `/ws/news` - News updates
+- `/ws/sentiment` - Sentiment analysis updates
+- `/ws/health` - Health monitoring
+- `/ws/huggingface` - HF integration updates
+
+## Local Development & Testing
+
+### Using Docker Compose
+
+```bash
+# Build and start the application
+docker-compose up --build
+
+# Access at http://localhost:7860
+```
+
+### Using Docker Directly
+
+```bash
+# Build the image
+docker build -t crypto-api-monitor .
+
+# Run the container
+docker run -p 7860:7860 \
+  -e HUGGINGFACE_TOKEN=your_token \
+  -e ENABLE_SENTIMENT=true \
+  -v $(pwd)/data:/app/data \
+  crypto-api-monitor
+```
+
+### Using Python Directly
+
+```bash
+# Install dependencies
+pip install -r requirements.txt
+
+# Set environment variables
+export ENABLE_SENTIMENT=true
+export HUGGINGFACE_TOKEN=your_token
+
+# Run the application
+python app.py
+```
+
+## Configuration
+
+### Frontend Configuration (`config.js`)
+
+The frontend automatically detects the environment:
+- **HuggingFace Spaces**: Uses relative URLs with Space origin
+- **Localhost**: Uses `http://localhost:7860`
+- **Custom Deployment**: Uses current window origin
+
+No manual configuration needed!
+
+### Backend Configuration
+
+Edit `.env` or set environment variables:
+
+```bash
+# HuggingFace
+HUGGINGFACE_TOKEN=your_token_here
+ENABLE_SENTIMENT=true
+SENTIMENT_SOCIAL_MODEL=ElKulako/cryptobert
+SENTIMENT_NEWS_MODEL=kk08/CryptoBERT
+HF_REGISTRY_REFRESH_SEC=21600
+HF_HTTP_TIMEOUT=8.0
+
+# API Keys (optional)
+ETHERSCAN_KEY_1=your_key
+COINMARKETCAP_KEY_1=your_key
+NEWSAPI_KEY=your_key
+```
+
+## Architecture
+
+```
+┌─────────────────────────────────────────────────┐
+│         HuggingFace Spaces (Docker)             │
+├─────────────────────────────────────────────────┤
+│                                                  │
+│  Frontend (HTML/JS)                             │
+│  ├── config.js (auto-detects environment)      │
+│  ├── index.html (main dashboard)               │
+│  └── hf_console.html (HF integration UI)       │
+│                                                  │
+│  Backend (FastAPI)                              │
+│  ├── app.py (main application)                 │
+│  ├── WebSocket Manager (real-time updates)     │
+│  ├── HF Integration (sentiment analysis)       │
+│  ├── Data Collectors (200+ APIs)               │
+│  └── SQLite Database (persistent storage)      │
+│                                                  │
+│  ML Models (HuggingFace Transformers)          │
+│  ├── ElKulako/cryptobert                       │
+│  └── kk08/CryptoBERT                           │
+│                                                  │
+└─────────────────────────────────────────────────┘
+```
+
+## Troubleshooting
+
+### Build Fails
+
+1. Check Docker logs in HF Spaces
+2. Verify `requirements.txt` has all dependencies
+3. Ensure Dockerfile uses Python 3.10
+4. Check for syntax errors in Python files
+
+### Application Won't Start
+
+1. Check health endpoint: `https://your-space-url/health`
+2. Review application logs in HF Spaces
+3. Verify port 7860 is exposed in Dockerfile
+4. Check environment variables are set correctly
+
+### WebSocket Connections Fail
+
+1. Ensure your Space URL uses HTTPS
+2. WebSockets automatically upgrade to WSS on HTTPS
+3. Check browser console for connection errors
+4. Verify CORS settings in `app.py`
+
+### Sentiment Analysis Not Working
+
+1. Set `HUGGINGFACE_TOKEN` in Space secrets
+2. Verify models are accessible: `ElKulako/cryptobert`, `kk08/CryptoBERT`
+3. Check HF console at `/hf_console.html`
+4. Review logs for model download errors
+
+### Performance Issues
+
+1. Increase Space hardware tier (if available)
+2. Reduce number of concurrent API monitors
+3. Adjust `HF_REGISTRY_REFRESH_SEC` to longer interval
+4. Consider disabling sentiment analysis if not needed
+
+## Resource Requirements
+
+**Minimum (Free Tier):**
+- 2 CPU cores
+- 2GB RAM
+- 1GB disk space
+
+**Recommended:**
+- 4 CPU cores
+- 4GB RAM
+- 2GB disk space
+- For better ML model performance
+
+## Updating Your Space
+
+```bash
+# Pull latest changes
+git pull
+
+# Make your modifications
+# ...
+
+# Commit and push
+git add .
+git commit -m "Update: description of changes"
+git push
+```
+
+HuggingFace will automatically rebuild and redeploy.
+
+## Security Best Practices
+
+1. **Use HF Secrets** for sensitive data (API keys, tokens)
+2. **Don't commit** `.env` files with actual keys
+3. **Review API keys** permissions (read-only when possible)
+4. **Monitor usage** of external APIs to avoid rate limits
+5. **Keep dependencies updated** for security patches
+
+## Advanced Configuration
+
+### Custom ML Models
+
+To use custom sentiment analysis models:
+
+```bash
+# Set environment variables in HF Spaces
+SENTIMENT_SOCIAL_MODEL=your-username/your-model
+SENTIMENT_NEWS_MODEL=your-username/another-model
+```
+
+### Custom Port (Not Recommended for HF Spaces)
+
+HuggingFace Spaces requires port 7860. Don't change unless deploying elsewhere.
+
+### Multiple Workers
+
+Edit Dockerfile CMD:
+```dockerfile
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860", "--workers", "2"]
+```
+
+**Note**: More workers = more memory usage. Adjust based on Space tier.
+
+## Support & Resources
+
+- **HuggingFace Docs**: https://huggingface.co/docs/hub/spaces
+- **FastAPI Docs**: https://fastapi.tiangolo.com/
+- **Transformers Docs**: https://huggingface.co/docs/transformers/
+- **Project Issues**: https://github.com/nimazasinich/crypto-dt-source/issues
+
+## License
+
+[Specify your license here]
+
+## Contributing
+
+Contributions are welcome! Please read the contributing guidelines before submitting PRs.
+
+---
+
+**Need help?** Open an issue or contact the maintainers.
+
+**Enjoy your crypto monitoring dashboard on HuggingFace Spaces! 🚀**

QUICK_START.md

@@ -1,221 +1,182 @@
-# 🚀 راهنمای سریع شروع - Quick Start Guide
-
-## ⚡ نصب و راه‌اندازی سریع
-
-### 1️⃣ نصب وابستگی‌ها
-```bash
-pip install -r requirements.txt
+# 🚀 Quick Start Guide - Crypto API Monitor with HuggingFace Integration
+
+## ✅ Server is Running!
+
+Your application is now live at: **http://localhost:7860**
+
+## 📱 Access Points
+
+### 1. Main Dashboard (Full Features)
+**URL:** http://localhost:7860/index.html
+
+Features:
+- Real-time API monitoring
+- Provider inventory
+- Rate limit tracking
+- Connection logs
+- Schedule management
+- Data freshness monitoring
+- Failure analysis
+- **🤗 HuggingFace Tab** (NEW!)
+
+### 2. HuggingFace Console (Standalone)
+**URL:** http://localhost:7860/hf_console.html
+
+Features:
+- HF Health Status
+- Models Registry Browser
+- Datasets Registry Browser
+- Local Search (snapshot)
+- Sentiment Analysis (local pipeline)
+
+### 3. API Documentation
+**URL:** http://localhost:7860/docs
+
+Interactive API documentation with all endpoints
+
+## 🤗 HuggingFace Features
+
+### Available Endpoints:
+
+1. **Health Check**
+   ```
+   GET /api/hf/health
+   ```
+   Returns: Registry health, last refresh time, model/dataset counts
+
+2. **Force Refresh Registry**
+   ```
+   POST /api/hf/refresh
+   ```
+   Manually trigger registry update from HuggingFace Hub
+
+3. **Get Models Registry**
+   ```
+   GET /api/hf/registry?kind=models
+   ```
+   Returns: List of all cached crypto-related models
+
+4. **Get Datasets Registry**
+   ```
+   GET /api/hf/registry?kind=datasets
+   ```
+   Returns: List of all cached crypto-related datasets
+
+5. **Search Registry**
+   ```
+   GET /api/hf/search?q=crypto&kind=models
+   ```
+   Search local snapshot for models or datasets
+
+6. **Run Sentiment Analysis**
+   ```
+   POST /api/hf/run-sentiment
+   Body: {"texts": ["BTC strong", "ETH weak"]}
+   ```
+   Analyze crypto sentiment using local transformers
+
+## 🎯 How to Use
+
+### Option 1: Main Dashboard
+1. Open http://localhost:7860/index.html in your browser
+2. Click on the **"🤗 HuggingFace"** tab at the top
+3. Explore:
+   - Health status
+   - Models and datasets registries
+   - Search functionality
+   - Sentiment analysis
+
+### Option 2: Standalone HF Console
+1. Open http://localhost:7860/hf_console.html
+2. All HF features in a clean, focused interface
+3. Perfect for testing and development
+
+## 🧪 Test the Integration
+
+### Test 1: Check Health
+```powershell
+Invoke-WebRequest -Uri "http://localhost:7860/api/hf/health" -UseBasicParsing | Select-Object -ExpandProperty Content
 ```
 
-### 2️⃣ Import منابع از فایل‌های JSON
-```bash
-python import_resources.py
+### Test 2: Refresh Registry
+```powershell
+Invoke-WebRequest -Uri "http://localhost:7860/api/hf/refresh" -Method POST -UseBasicParsing | Select-Object -ExpandProperty Content
 ```
-این اسکریپت به‌طور خودکار همه منابع را از فایل‌های JSON موجود import می‌کند.
-
-### 3️⃣ راه‌اندازی سرور
-```bash
-# روش 1: استفاده از اسکریپت راه‌انداز
-python start_server.py
 
-# روش 2: مستقیم
-python api_server_extended.py
-
-# روش 3: با uvicorn
-uvicorn api_server_extended:app --reload --host 0.0.0.0 --port 8000
+### Test 3: Get Models
+```powershell
+Invoke-WebRequest -Uri "http://localhost:7860/api/hf/registry?kind=models" -UseBasicParsing | Select-Object -ExpandProperty Content
 ```
 
-### 4️⃣ دسترسی به داشبورد
-```
-http://localhost:8000
+### Test 4: Run Sentiment Analysis
+```powershell
+$body = @{texts = @("BTC strong breakout", "ETH looks weak")} | ConvertTo-Json
+Invoke-WebRequest -Uri "http://localhost:7860/api/hf/run-sentiment" -Method POST -Body $body -ContentType "application/json" -UseBasicParsing | Select-Object -ExpandProperty Content
 ```
 
-## 📋 تب‌های داشبورد
-
-### 📊 Market
-- آمار کلی بازار
-- لیست کریپتوکارنسی‌ها
-- نمودارها و ترندینگ
-
-### 📡 API Monitor
-- وضعیت همه ارائه‌دهندگان
-- زمان پاسخ
-- Health Check
-
-### ⚡ Advanced
-- Export JSON/CSV
-- Backup
-- Clear Cache
-- Activity Logs
-
-### ⚙️ Admin
-- افزودن API جدید
-- تنظیمات
-- آمار کلی
-
-### 🤗 HuggingFace
-- مدل‌های Sentiment Analysis
-- Datasets
-- جستجو در Registry
-
-### 🔄 Pools
-- مدیریت Pool‌ها
-- افزودن/حذف اعضا
-- چرخش دستی
-
-### 📋 Logs (جدید!)
-- نمایش لاگ‌ها با فیلتر
-- Export به JSON/CSV
-- جستجو و آمار
-
-### 📦 Resources (جدید!)
-- مدیریت منابع API
-- Import/Export
-- Backup
-- فیلتر بر اساس Category
-
-## 🔧 استفاده از API
-
-### دریافت لاگ‌ها
-```bash
-# همه لاگ‌ها
-curl http://localhost:8000/api/logs
-
-# فیلتر بر اساس Level
-curl http://localhost:8000/api/logs?level=error
-
-# جستجو
-curl http://localhost:8000/api/logs?search=timeout
-```
-
-### Export لاگ‌ها
-```bash
-# Export به JSON
-curl http://localhost:8000/api/logs/export/json?level=error
-
-# Export به CSV
-curl http://localhost:8000/api/logs/export/csv
-```
-
-### مدیریت منابع
-```bash
-# دریافت همه منابع
-curl http://localhost:8000/api/resources
-
-# Export منابع
-curl http://localhost:8000/api/resources/export/json
+## 📊 What's Included
 
-# Backup
-curl -X POST http://localhost:8000/api/resources/backup
+### Seed Models (Always Available):
+- ElKulako/cryptobert
+- kk08/CryptoBERT
 
-# Import
-curl -X POST "http://localhost:8000/api/resources/import/json?file_path=api-resources/crypto_resources_unified_2025-11-11.json&merge=true"
-```
-
-## 📝 مثال‌های استفاده
+### Seed Datasets (Always Available):
+- linxy/CryptoCoin
+- WinkingFace/CryptoLM-Bitcoin-BTC-USDT
+- WinkingFace/CryptoLM-Ethereum-ETH-USDT
+- WinkingFace/CryptoLM-Solana-SOL-USDT
+- WinkingFace/CryptoLM-Ripple-XRP-USDT
 
-### افزودن Provider جدید
-```python
-from resource_manager import ResourceManager
+### Auto-Discovery:
+- Searches HuggingFace Hub for crypto-related models
+- Searches for sentiment-analysis models
+- Auto-refreshes every 6 hours (configurable)
 
-manager = ResourceManager()
+## ⚙️ Configuration
 
-provider = {
-    "id": "my_new_api",
-    "name": "My New API",
-    "category": "market_data",
-    "base_url": "https://api.example.com",
-    "requires_auth": False,
-    "priority": 5,
-    "weight": 50,
-    "free": True
-}
+Edit `.env` file to customize:
 
-manager.add_provider(provider)
-manager.save_resources()
-```
+```env
+# HuggingFace Token (optional, for higher rate limits)
+HUGGINGFACE_TOKEN=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
 
-### ثبت لاگ
-```python
-from log_manager import log_info, log_error, LogCategory
+# Enable/disable local sentiment analysis
+ENABLE_SENTIMENT=true
 
-# لاگ Info
-log_info(LogCategory.PROVIDER, "Provider health check completed", 
-         provider_id="coingecko", response_time=234.5)
+# Model selection
+SENTIMENT_SOCIAL_MODEL=ElKulako/cryptobert
+SENTIMENT_NEWS_MODEL=kk08/CryptoBERT
 
-# لاگ Error
-log_error(LogCategory.PROVIDER, "Provider failed", 
-          provider_id="etherscan", error="Timeout")
-```
+# Refresh interval (seconds)
+HF_REGISTRY_REFRESH_SEC=21600
 
-### استفاده از Provider Manager
-```python
-from provider_manager import ProviderManager
-import asyncio
-
-async def main():
-    manager = ProviderManager()
-    
-    # Health Check
-    await manager.health_check_all()
-    
-    # دریافت Provider از Pool
-    provider = manager.get_next_from_pool("primary_market_data_pool")
-    if provider:
-        print(f"Selected: {provider.name}")
-    
-    await manager.close_session()
-
-asyncio.run(main())
+# HTTP timeout (seconds)
+HF_HTTP_TIMEOUT=8.0
 ```
 
-## 🐳 استفاده با Docker
-
-```bash
-# Build
-docker build -t crypto-monitor .
+## 🛑 Stop the Server
 
-# Run
-docker run -p 8000:8000 crypto-monitor
+Press `CTRL+C` in the terminal where the server is running
 
-# یا با docker-compose
-docker-compose up -d
-```
+Or use the process manager to stop process ID 6
 
-## 🔍 عیب‌یابی
+## 🔄 Restart the Server
 
-### مشکل: Port در حال استفاده است
-```bash
-# تغییر پورت
-uvicorn api_server_extended:app --port 8001
+```powershell
+python simple_server.py
 ```
 
-### مشکل: فایل‌های JSON یافت نشد
-```bash
-# بررسی وجود فایل‌ها
-ls -la api-resources/
-ls -la providers_config*.json
-```
-
-### مشکل: Import منابع ناموفق
-```bash
-# بررسی ساختار JSON
-python -m json.tool api-resources/crypto_resources_unified_2025-11-11.json | head -20
-```
-
-## 📚 مستندات بیشتر
-
-- [README.md](README.md) - مستندات کامل انگلیسی
-- [README_FA.md](README_FA.md) - مستندات کامل فارسی
-- [api-resources/README.md](api-resources/README.md) - راهنمای منابع API
+## 📝 Notes
 
-## 🆘 پشتیبانی
+- **First Load**: The first sentiment analysis may take 30-60 seconds as models download
+- **Registry**: Auto-refreshes every 6 hours, or manually via the UI
+- **Free Resources**: All endpoints use free HuggingFace APIs
+- **No API Key Required**: Works without authentication (with rate limits)
+- **Local Inference**: Sentiment analysis runs locally using transformers
 
-در صورت بروز مشکل:
-1. لاگ‌ها را بررسی کنید: `logs/app.log`
-2. از تب Logs در داشبورد استفاده کنید
-3. آمار سیستم را بررسی کنید: `/api/status`
+## 🎉 You're All Set!
 
----
+The application is running and ready to use. Open your browser and explore!
 
-**موفق باشید! 🚀**
+**Main Dashboard:** http://localhost:7860/index.html
+**HF Console:** http://localhost:7860/hf_console.html

README.md

@@ -1,492 +1,29 @@
----
-sdk: gradio
----
-# Crypto-DT-Source
+# 🚀 Crypto API Monitor Pro v2.0
 
-<div align="center">
+## ویژگی‌ها
+✅ 40+ Provider (Exchanges, Data, DeFi, NFT, Blockchain)
+✅ 20 Cryptocurrency با داده کامل
+✅ UI حرفه‌ای Dark Mode
+✅ Real-time WebSocket
+✅ نمودارهای تعاملی
+✅ آمار و تحلیل کامل
 
-**Production-Ready Cryptocurrency Data Aggregator**
+## Providers:
+**Exchanges:** Binance, Coinbase, Kraken, Huobi, KuCoin, Bitfinex, Bitstamp, Gemini, OKX, Bybit, Gate.io, Crypto.com, Bittrex, Poloniex, MEXC
 
-*Real-time data collection • AI-powered analysis • Enterprise-grade security*
+**Data:** CoinGecko, CoinMarketCap, CryptoCompare, Messari, Glassnode, Santiment, Kaiko, Nomics
 
-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
-[![Python 3.8+](https://img.shields.io/badge/python-3.8+-blue.svg)](https://www.python.org/downloads/)
-[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
+**DeFi:** Uniswap, SushiSwap, PancakeSwap, Curve, 1inch, Aave, Compound, MakerDAO
 
-[Quick Start](#-quick-start) • [Features](#-features) • [Documentation](#-documentation) • [فارسی](docs/persian/README_FA.md)
+**NFT:** OpenSea, Blur, Magic Eden, Rarible
 
-</div>
-
----
-
-## 🚀 Quick Start
-
-Get up and running in 3 simple steps:
-
-```bash
-# 1. Clone the repository
-git clone https://github.com/nimazasinich/crypto-dt-source.git
-cd crypto-dt-source
-
-# 2. Install dependencies
-pip install -r requirements.txt
-
-# 3. Run the application
-python app.py
-```
-
-Open your browser to **http://localhost:7860** 🎉
-
-> **Need more help?** See the [complete Quick Start guide](QUICK_START.md) or [Installation Guide](docs/deployment/INSTALL.md)
-
----
-
-## ✨ Features
-
-### 🔥 Core Capabilities
-
-- **Real-Time Data** - Monitor 100+ cryptocurrencies with live price updates
-- **AI-Powered Analysis** - Sentiment analysis using HuggingFace transformers
-- **200+ Free Data Sources** - No API keys required for basic features
-- **Interactive Dashboards** - 6-tab Gradio interface + 10+ HTML dashboards
-- **WebSocket Streaming** - Real-time data streaming via WebSocket API
-- **REST API** - 20+ endpoints for programmatic access
-- **SQLite Database** - Persistent storage with automatic migrations
-
-### 🆕 Production Features (Nov 2024)
-
-- ✅ **Authentication & Authorization** - JWT tokens + API key management
-- ✅ **Rate Limiting** - Multi-tier protection (30/min, 1000/hour)
-- ✅ **Async Architecture** - 5x faster data collection
-- ✅ **Database Migrations** - Version-controlled schema updates
-- ✅ **Testing Suite** - pytest with 60%+ coverage
-- ✅ **CI/CD Pipeline** - Automated testing & deployment
-- ✅ **Code Quality Tools** - black, flake8, mypy, pylint
-- ✅ **Security Scanning** - Automated vulnerability checks
-
-> **See what's new:** [Implementation Fixes](IMPLEMENTATION_FIXES.md) • [Fixes Summary](FIXES_SUMMARY.md)
-
----
-
-## 📊 Data Sources
-
-### Price & Market Data
-- **CoinGecko** - Top 100+ cryptocurrencies, market cap rankings
-- **CoinCap** - Real-time prices, backup data source
-- **Binance** - Trading volumes, OHLCV data
-- **Kraken** - Historical price data
-- **Messari** - Advanced analytics
-
-### News & Sentiment
-- **RSS Feeds** - CoinDesk, Cointelegraph, Bitcoin Magazine, Decrypt
-- **CryptoPanic** - Aggregated crypto news
-- **Reddit** - r/cryptocurrency, r/bitcoin, r/ethtrader
-- **Alternative.me** - Fear & Greed Index
-
-### Blockchain Data
-- **Etherscan** - Ethereum blockchain (optional key)
-- **BscScan** - Binance Smart Chain
-- **TronScan** - Tron blockchain
-- **Blockchair** - Multi-chain explorer
-
-**All basic features work without API keys!** 🎁
-
----
-
-## 🏗️ Architecture
-
-```
-crypto-dt-source/
-├── 📱 UI Layer
-│   ├── app.py                    # Main Gradio dashboard
-│   ├── ui/                       # Modular UI components (NEW)
-│   │   ├── dashboard_live.py     # Live price dashboard
-│   │   ├── dashboard_charts.py   # Historical charts
-│   │   ├── dashboard_news.py     # News & sentiment
-│   │   └── ...
-│   └── *.html                    # 10+ HTML dashboards
-│
-├── 🔌 API Layer
-│   ├── api/
-│   │   ├── endpoints.py          # 20+ REST endpoints
-│   │   ├── websocket.py          # WebSocket streaming
-│   │   ├── data_endpoints.py     # Data delivery
-│   │   └── pool_endpoints.py     # Provider management
-│   └── api_server_extended.py    # FastAPI server
-│
-├── 💾 Data Layer
-│   ├── database.py               # SQLite manager
-│   ├── database/
-│   │   ├── db_manager.py         # Connection pooling
-│   │   ├── migrations.py         # Schema migrations (NEW)
-│   │   └── models.py             # Data models
-│   └── collectors/
-│       ├���─ market_data.py        # Price collection
-│       ├── news.py               # News aggregation
-│       ├── sentiment.py          # Sentiment analysis
-│       └── ...
-│
-├── 🤖 AI Layer
-│   ├── ai_models.py              # HuggingFace integration
-│   └── crypto_data_bank/ai/      # Alternative AI engine
-│
-├── 🛠️ Utilities
-│   ├── utils.py                  # General utilities
-│   ├── utils/
-│   │   ├── async_api_client.py   # Async HTTP client (NEW)
-│   │   ├── auth.py               # Authentication (NEW)
-│   │   └── rate_limiter_enhanced.py  # Rate limiting (NEW)
-│   └── monitoring/
-│       ├── health_monitor.py     # Health checks
-│       └── scheduler.py          # Background tasks
-│
-├── 🧪 Testing
-│   ├── tests/
-│   │   ├── test_database.py      # Database tests (NEW)
-│   │   ├── test_async_api_client.py  # Async tests (NEW)
-│   │   └── ...
-│   └── pytest.ini                # Test configuration
-│
-├── ⚙️ Configuration
-│   ├── config.py                 # Application config
-│   ├── .env.example              # Environment template
-│   ├── requirements.txt          # Production deps
-│   ├── requirements-dev.txt      # Dev dependencies (NEW)
-│   ├── pyproject.toml            # Tool config (NEW)
-│   └── .flake8                   # Linting config (NEW)
-│
-└── 📚 Documentation
-    ├── README.md                 # This file
-    ├── CHANGELOG.md              # Version history
-    ├── QUICK_START.md            # Quick start guide
-    ├── IMPLEMENTATION_FIXES.md   # Latest improvements (NEW)
-    ├── FIXES_SUMMARY.md          # Fixes summary (NEW)
-    └── docs/                     # Organized documentation (NEW)
-        ├── INDEX.md              # Documentation index
-        ├── deployment/           # Deployment guides
-        ├── components/           # Component docs
-        ├── reports/              # Analysis reports
-        ├── guides/               # How-to guides
-        ├── persian/              # Persian/Farsi docs
-        └── archive/              # Historical docs
-```
-
----
-
-## 🎯 Use Cases
-
-### For Traders
-- Real-time price monitoring across 100+ coins
-- AI sentiment analysis from news and social media
-- Technical indicators (RSI, MACD, Moving Averages)
-- Fear & Greed Index tracking
-
-### For Developers
-- REST API for building crypto applications
-- WebSocket streaming for real-time updates
-- 200+ free data sources aggregated
-- Well-documented, modular codebase
-
-### For Researchers
-- Historical price data and analysis
-- Sentiment analysis on crypto news
-- Database of aggregated market data
-- Export data to CSV for analysis
-
-### For DevOps
-- Docker containerization ready
-- HuggingFace Spaces deployment
-- Health monitoring endpoints
-- Automated testing and CI/CD
-
----
-
-## 🔧 Installation & Setup
-
-### Prerequisites
-- Python 3.8 or higher
-- 4GB+ RAM (for AI models)
-- Internet connection
-
-### Basic Installation
-
-```bash
-# Install dependencies
-pip install -r requirements.txt
-
-# Run application
-python app.py
-```
-
-### Development Setup
-
-```bash
-# Install dev dependencies
-pip install -r requirements-dev.txt
-
-# Run tests
-pytest --cov=.
-
-# Format code
-black .
-isort .
-
-# Lint
-flake8 .
-mypy .
-```
-
-### Production Deployment
-
-```bash
-# Set environment variables
-cp .env.example .env
-# Edit .env with your configuration
-
-# Run database migrations
-python -c "from database.migrations import auto_migrate; auto_migrate('data/database/crypto_aggregator.db')"
-
-# Enable authentication
-export ENABLE_AUTH=true
-export SECRET_KEY=$(python -c "import secrets; print(secrets.token_urlsafe(32))")
-
-# Start application
-python app.py
-```
-
-### Docker Deployment
+**Blockchain:** Etherscan, BscScan, Polygonscan, Blockchair, Blockchain.com
 
+## راه‌اندازی
 ```bash
-# Build image
-docker build -t crypto-dt-source .
-
-# Run container
-docker run -p 7860:7860 -v $(pwd)/data:/app/data crypto-dt-source
-
-# Or use docker-compose
-docker-compose up -d
+1. دابل کلیک start.bat
+2. برو http://localhost:8000/dashboard
 ```
 
-> **Detailed guides:** [Deployment Guide](docs/deployment/DEPLOYMENT_GUIDE.md) • [Production Guide](docs/deployment/PRODUCTION_DEPLOYMENT_GUIDE.md) • [HuggingFace Spaces](docs/deployment/HUGGINGFACE_DEPLOYMENT.md)
-
----
-
-## 📖 Documentation
-
-### Getting Started
-- 📘 [Quick Start Guide](QUICK_START.md) - Get running in 3 steps
-- 📘 [Installation Guide](docs/deployment/INSTALL.md) - Detailed installation
-- 📘 [راهنمای فارسی](docs/persian/README_FA.md) - Persian/Farsi guide
-
-### Core Documentation
-- 📗 [Implementation Fixes](IMPLEMENTATION_FIXES.md) - Latest production improvements
-- 📗 [Fixes Summary](FIXES_SUMMARY.md) - Quick reference
-- 📗 [Changelog](CHANGELOG.md) - Version history
-
-### Component Documentation
-- 📙 [WebSocket API](docs/components/WEBSOCKET_API_DOCUMENTATION.md) - Real-time streaming
-- 📙 [Data Collectors](docs/components/COLLECTORS_README.md) - Data collection system
-- 📙 [Gradio Dashboard](docs/components/GRADIO_DASHBOARD_README.md) - UI documentation
-- 📙 [Backend Services](docs/components/README_BACKEND.md) - Backend architecture
-
-### Deployment & DevOps
-- 📕 [Deployment Guide](docs/deployment/DEPLOYMENT_GUIDE.md) - General deployment
-- 📕 [Production Guide](docs/deployment/PRODUCTION_DEPLOYMENT_GUIDE.md) - Production setup
-- 📕 [HuggingFace Deployment](docs/deployment/HUGGINGFACE_DEPLOYMENT.md) - Cloud deployment
-
-### Reports & Analysis
-- 📔 [Project Analysis](docs/reports/PROJECT_ANALYSIS_COMPLETE.md) - 40,600+ line analysis
-- 📔 [Production Audit](docs/reports/PRODUCTION_AUDIT_COMPREHENSIVE.md) - Security audit
-- 📔 [System Capabilities](docs/reports/SYSTEM_CAPABILITIES_REPORT.md) - Feature overview
-
-### Complete Index
-📚 **[Full Documentation Index](docs/INDEX.md)** - Browse all 60+ documentation files
-
----
-
-## 🔐 Security & Authentication
-
-### Authentication (Optional)
-
-Enable authentication for production deployments:
-
-```bash
-# .env configuration
-ENABLE_AUTH=true
-SECRET_KEY=your-secret-key-here
-ADMIN_USERNAME=admin
-ADMIN_PASSWORD=secure-password
-ACCESS_TOKEN_EXPIRE_MINUTES=60
-API_KEYS=key1,key2,key3
-```
-
-**Features:**
-- JWT token authentication
-- API key management
-- Password hashing (SHA-256)
-- Token expiration
-- Usage tracking
-
-> **Learn more:** [Authentication Guide](IMPLEMENTATION_FIXES.md#3-authentication--authorization-system)
-
-### Rate Limiting
-
-Protect your API from abuse:
-
-- **30 requests/minute** per client
-- **1,000 requests/hour** per client
-- **Burst protection** up to 10 requests
-
-> **Learn more:** [Rate Limiting Guide](IMPLEMENTATION_FIXES.md#4-enhanced-rate-limiting-system)
-
----
-
-## 🧪 Testing
-
-```bash
-# Install test dependencies
-pip install -r requirements-dev.txt
-
-# Run all tests
-pytest
-
-# Run with coverage
-pytest --cov=. --cov-report=html
-
-# Run specific test file
-pytest tests/test_database.py -v
-
-# Run integration tests
-pytest tests/test_integration.py
-```
-
-**Test Coverage:** 60%+ (target: 80%)
-
-> **Learn more:** [Testing Guide](IMPLEMENTATION_FIXES.md#6-comprehensive-testing-suite)
-
----
-
-## 🚢 CI/CD Pipeline
-
-Automated testing on every push:
-
-- ✅ Code quality checks (black, flake8, mypy)
-- ✅ Tests on Python 3.8, 3.9, 3.10, 3.11
-- ✅ Security scanning (bandit, safety)
-- ✅ Docker build verification
-- ✅ Integration tests
-- ✅ Performance benchmarks
-
-> **See:** [.github/workflows/ci.yml](.github/workflows/ci.yml)
-
----
-
-## 📊 Performance
-
-### Optimizations Implemented
-- ⚡ **5x faster** data collection (async parallel requests)
-- ⚡ **3x faster** database queries (optimized indices)
-- ⚡ **10x reduced** API calls (TTL-based caching)
-- ⚡ **Better resource** utilization (async I/O)
-
-### Benchmarks
-- Data collection: ~30 seconds for 100 coins
-- Database queries: <10ms average
-- WebSocket latency: <100ms
-- Memory usage: ~500MB (with AI models loaded)
-
----
-
-## 🤝 Contributing
-
-We welcome contributions! Here's how:
-
-1. **Fork** the repository
-2. **Create** a feature branch (`git checkout -b feature/amazing-feature`)
-3. **Make** your changes with tests
-4. **Run** quality checks (`black . && flake8 . && pytest`)
-5. **Commit** with descriptive message
-6. **Push** to your branch
-7. **Open** a Pull Request
-
-**Guidelines:**
-- Follow code style (black, isort)
-- Add tests for new features
-- Update documentation
-- Check [Pull Request Checklist](docs/guides/PR_CHECKLIST.md)
-
----
-
-## 📜 License
-
-This project is licensed under the **MIT License** - see the [LICENSE](LICENSE) file for details.
-
----
-
-## 🙏 Acknowledgments
-
-### AI Models
-- [HuggingFace](https://huggingface.co/) - Transformers library
-- [Cardiff NLP](https://huggingface.co/cardiffnlp) - Twitter sentiment model
-- [ProsusAI](https://huggingface.co/ProsusAI) - FinBERT model
-- [Facebook](https://huggingface.co/facebook) - BART summarization
-
-### Data Sources
-- [CoinGecko](https://www.coingecko.com/) - Free crypto API
-- [CoinCap](https://coincap.io/) - Real-time data
-- [Binance](https://www.binance.com/) - Trading data
-- [Alternative.me](https://alternative.me/) - Fear & Greed Index
-
-### Frameworks & Libraries
-- [Gradio](https://gradio.app/) - Web UI framework
-- [FastAPI](https://fastapi.tiangolo.com/) - REST API
-- [Plotly](https://plotly.com/) - Interactive charts
-- [PyTorch](https://pytorch.org/) - Deep learning
-
----
-
-## 📞 Support
-
-- **Issues:** [GitHub Issues](https://github.com/nimazasinich/crypto-dt-source/issues)
-- **Documentation:** [docs/](docs/INDEX.md)
-- **Changelog:** [CHANGELOG.md](CHANGELOG.md)
-
----
-
-## 🗺️ Roadmap
-
-### Short-term (Q4 2024)
-- [x] Modular UI architecture
-- [x] Authentication system
-- [x] Rate limiting
-- [x] Database migrations
-- [x] Testing suite
-- [x] CI/CD pipeline
-- [ ] 80%+ test coverage
-- [ ] GraphQL API
-
-### Medium-term (Q1 2025)
-- [ ] Microservices architecture
-- [ ] Message queue (Redis/RabbitMQ)
-- [ ] Database replication
-- [ ] Multi-tenancy support
-- [ ] Advanced ML models
-
-### Long-term (2025)
-- [ ] Kubernetes deployment
-- [ ] Multi-region support
-- [ ] Premium data sources
-- [ ] Enterprise features
-- [ ] Mobile app
-
----
-
-<div align="center">
-
-**Made with ❤️ for the crypto community**
-
-⭐ **Star us on GitHub** if you find this project useful!
-
-[Documentation](docs/INDEX.md) • [Quick Start](QUICK_START.md) • [فارسی](docs/persian/README_FA.md) • [Changelog](CHANGELOG.md)
-
-</div>
+## نیاز
+Python 3.8+

app.py

@@ -1,1495 +1,358 @@
 #!/usr/bin/env python3
 """
-Crypto Data Aggregator - Complete Gradio Dashboard
-6-tab comprehensive interface for cryptocurrency data analysis
+Crypto API Monitor - Complete Professional Backend
+Full coverage of all major crypto providers
 """
 
-import gradio as gr
-import pandas as pd
-import plotly.graph_objects as go
-from plotly.subplots import make_subplots
-from datetime import datetime, timedelta
+from fastapi import FastAPI, WebSocket, WebSocketDisconnect
+from fastapi.responses import HTMLResponse
+from fastapi.middleware.cors import CORSMiddleware
+from typing import List, Dict
+import asyncio
+import random
 import json
-import threading
-import time
-import logging
-from typing import List, Dict, Optional, Tuple, Any
-import traceback
-
-# Import local modules
-import config
-from database import Database
-import collectors
-import ai_models
-import utils
-
-# Setup logging
-logger = utils.setup_logging()
-
-# Initialize database
-db = Database()
-
-# Global state for background collection
-_collection_started = False
-_collection_lock = threading.Lock()
-
-# ==================== TAB 1: LIVE DASHBOARD ====================
-
-def get_live_dashboard(search_filter: str = "") -> pd.DataFrame:
-    """
-    Get live dashboard data with top 100 cryptocurrencies
-
-    Args:
-        search_filter: Search/filter text for cryptocurrencies
-
-    Returns:
-        DataFrame with formatted cryptocurrency data
-    """
-    try:
-        logger.info("Fetching live dashboard data...")
-
-        # Get latest prices from database
-        prices = db.get_latest_prices(100)
+from datetime import datetime, timedelta
+import uvicorn
 
-        if not prices:
-            logger.warning("No price data available")
-            return pd.DataFrame({
-                "Rank": [],
-                "Name": [],
-                "Symbol": [],
-                "Price (USD)": [],
-                "24h Change (%)": [],
-                "Volume": [],
-                "Market Cap": []
-            })
+app = FastAPI(title="Crypto API Monitor Pro", version="2.0.0")
 
-        # Convert to DataFrame
-        df_data = []
-        for price in prices:
-            # Apply search filter if provided
-            if search_filter:
-                search_lower = search_filter.lower()
-                name_lower = (price.get('name') or '').lower()
-                symbol_lower = (price.get('symbol') or '').lower()
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
 
-                if search_lower not in name_lower and search_lower not in symbol_lower:
-                    continue
+class ConnectionManager:
+    def __init__(self):
+        self.active_connections: List[WebSocket] = []
 
-            df_data.append({
-                "Rank": price.get('rank', 999),
-                "Name": price.get('name', 'Unknown'),
-                "Symbol": price.get('symbol', 'N/A').upper(),
-                "Price (USD)": f"${price.get('price_usd', 0):,.2f}" if price.get('price_usd') else "N/A",
-                "24h Change (%)": f"{price.get('percent_change_24h', 0):+.2f}%" if price.get('percent_change_24h') is not None else "N/A",
-                "Volume": utils.format_number(price.get('volume_24h', 0)),
-                "Market Cap": utils.format_number(price.get('market_cap', 0))
-            })
+    async def connect(self, websocket: WebSocket):
+        await websocket.accept()
+        self.active_connections.append(websocket)
 
-        df = pd.DataFrame(df_data)
+    def disconnect(self, websocket: WebSocket):
+        self.active_connections.remove(websocket)
 
-        if df.empty:
-            logger.warning("No data matches filter criteria")
-            return pd.DataFrame({
-                "Rank": [],
-                "Name": [],
-                "Symbol": [],
-                "Price (USD)": [],
-                "24h Change (%)": [],
-                "Volume": [],
-                "Market Cap": []
+    async def broadcast(self, message: dict):
+        for connection in self.active_connections:
+            try:
+                await connection.send_json(message)
+            except:
+                pass
+
+manager = ConnectionManager()
+
+# Complete list of crypto providers
+PROVIDERS = {
+    "exchanges": [
+        {"name": "Binance", "type": "Exchange", "region": "Global", "base_price": 180},
+        {"name": "Coinbase", "type": "Exchange", "region": "US", "base_price": 220},
+        {"name": "Kraken", "type": "Exchange", "region": "US", "base_price": 150},
+        {"name": "Huobi", "type": "Exchange", "region": "Asia", "base_price": 140},
+        {"name": "KuCoin", "type": "Exchange", "region": "Global", "base_price": 130},
+        {"name": "Bitfinex", "type": "Exchange", "region": "Global", "base_price": 160},
+        {"name": "Bitstamp", "type": "Exchange", "region": "EU", "base_price": 145},
+        {"name": "Gemini", "type": "Exchange", "region": "US", "base_price": 200},
+        {"name": "OKX", "type": "Exchange", "region": "Global", "base_price": 135},
+        {"name": "Bybit", "type": "Exchange", "region": "Global", "base_price": 125},
+        {"name": "Gate.io", "type": "Exchange", "region": "Global", "base_price": 120},
+        {"name": "Crypto.com", "type": "Exchange", "region": "Global", "base_price": 155},
+        {"name": "Bittrex", "type": "Exchange", "region": "US", "base_price": 140},
+        {"name": "Poloniex", "type": "Exchange", "region": "Global", "base_price": 110},
+        {"name": "MEXC", "type": "Exchange", "region": "Global", "base_price": 105},
+    ],
+    "data_providers": [
+        {"name": "CoinGecko", "type": "Data Provider", "region": "Global", "base_price": 100},
+        {"name": "CoinMarketCap", "type": "Data Provider", "region": "Global", "base_price": 120},
+        {"name": "CryptoCompare", "type": "Data Provider", "region": "Global", "base_price": 110},
+        {"name": "Messari", "type": "Analytics", "region": "Global", "base_price": 180},
+        {"name": "Glassnode", "type": "Analytics", "region": "Global", "base_price": 200},
+        {"name": "Santiment", "type": "Analytics", "region": "Global", "base_price": 170},
+        {"name": "Kaiko", "type": "Data Provider", "region": "Global", "base_price": 190},
+        {"name": "Nomics", "type": "Data Provider", "region": "Global", "base_price": 95},
+    ],
+    "blockchain": [
+        {"name": "Etherscan", "type": "Block Explorer", "region": "Global", "base_price": 85},
+        {"name": "BscScan", "type": "Block Explorer", "region": "Global", "base_price": 80},
+        {"name": "Polygonscan", "type": "Block Explorer", "region": "Global", "base_price": 75},
+        {"name": "Blockchair", "type": "Block Explorer", "region": "Global", "base_price": 90},
+        {"name": "Blockchain.com", "type": "Block Explorer", "region": "Global", "base_price": 95},
+    ],
+    "defi": [
+        {"name": "Uniswap", "type": "DEX", "region": "Global", "base_price": 70},
+        {"name": "SushiSwap", "type": "DEX", "region": "Global", "base_price": 65},
+        {"name": "PancakeSwap", "type": "DEX", "region": "Global", "base_price": 60},
+        {"name": "Curve", "type": "DEX", "region": "Global", "base_price": 75},
+        {"name": "1inch", "type": "DEX Aggregator", "region": "Global", "base_price": 80},
+        {"name": "Aave", "type": "Lending", "region": "Global", "base_price": 85},
+        {"name": "Compound", "type": "Lending", "region": "Global", "base_price": 90},
+        {"name": "MakerDAO", "type": "Stablecoin", "region": "Global", "base_price": 100},
+    ],
+    "nft": [
+        {"name": "OpenSea", "type": "NFT Marketplace", "region": "Global", "base_price": 120},
+        {"name": "Blur", "type": "NFT Marketplace", "region": "Global", "base_price": 110},
+        {"name": "Magic Eden", "type": "NFT Marketplace", "region": "Global", "base_price": 95},
+        {"name": "Rarible", "type": "NFT Marketplace", "region": "Global", "base_price": 85},
+    ]
+}
+
+CRYPTOCURRENCIES = [
+    {"symbol": "BTC", "name": "Bitcoin", "base_price": 43500, "category": "Layer 1"},
+    {"symbol": "ETH", "name": "Ethereum", "base_price": 2280, "category": "Smart Contract"},
+    {"symbol": "BNB", "name": "Binance Coin", "base_price": 315, "category": "Exchange"},
+    {"symbol": "SOL", "name": "Solana", "base_price": 98, "category": "Layer 1"},
+    {"symbol": "XRP", "name": "Ripple", "base_price": 0.53, "category": "Payment"},
+    {"symbol": "ADA", "name": "Cardano", "base_price": 0.39, "category": "Smart Contract"},
+    {"symbol": "AVAX", "name": "Avalanche", "base_price": 24, "category": "Layer 1"},
+    {"symbol": "DOGE", "name": "Dogecoin", "base_price": 0.08, "category": "Meme"},
+    {"symbol": "DOT", "name": "Polkadot", "base_price": 5.3, "category": "Layer 0"},
+    {"symbol": "MATIC", "name": "Polygon", "base_price": 0.74, "category": "Layer 2"},
+    {"symbol": "LINK", "name": "Chainlink", "base_price": 14.5, "category": "Oracle"},
+    {"symbol": "UNI", "name": "Uniswap", "base_price": 6.2, "category": "DeFi"},
+    {"symbol": "ATOM", "name": "Cosmos", "base_price": 8.9, "category": "Layer 0"},
+    {"symbol": "LTC", "name": "Litecoin", "base_price": 72, "category": "Payment"},
+    {"symbol": "APT", "name": "Aptos", "base_price": 7.8, "category": "Layer 1"},
+    {"symbol": "ARB", "name": "Arbitrum", "base_price": 1.2, "category": "Layer 2"},
+    {"symbol": "OP", "name": "Optimism", "base_price": 2.1, "category": "Layer 2"},
+    {"symbol": "NEAR", "name": "NEAR Protocol", "base_price": 3.4, "category": "Layer 1"},
+    {"symbol": "ICP", "name": "Internet Computer", "base_price": 4.7, "category": "Layer 1"},
+    {"symbol": "FIL", "name": "Filecoin", "base_price": 4.2, "category": "Storage"},
+]
+
+def generate_all_providers():
+    """Generate complete provider data"""
+    result = []
+    
+    for category, providers in PROVIDERS.items():
+        for provider in providers:
+            status = random.choices(
+                ["operational", "degraded", "maintenance"],
+                weights=[85, 10, 5]
+            )[0]
+            
+            uptime = random.uniform(97, 99.99) if status == "operational" else random.uniform(85, 97)
+            response_time = provider["base_price"] + random.randint(-20, 40)
+            
+            result.append({
+                "name": provider["name"],
+                "type": provider["type"],
+                "category": category,
+                "region": provider["region"],
+                "status": status,
+                "uptime": round(uptime, 2),
+                "response_time_ms": response_time,
+                "requests_today": random.randint(50000, 2000000),
+                "requests_per_minute": random.randint(100, 5000),
+                "error_rate": round(random.uniform(0.01, 2.5), 2),
+                "last_check": datetime.now().isoformat(),
+                "api_version": f"v{random.randint(1,3)}.{random.randint(0,9)}",
+                "rate_limit": random.randint(100, 10000),
+                "endpoint": f"https://api.{provider['name'].lower().replace(' ', '').replace('.', '')}.com"
             })
-
-        # Sort by rank
-        df = df.sort_values('Rank')
-
-        logger.info(f"Dashboard loaded with {len(df)} cryptocurrencies")
-        return df
-
-    except Exception as e:
-        logger.error(f"Error in get_live_dashboard: {e}\n{traceback.format_exc()}")
-        return pd.DataFrame({
-            "Error": [f"Failed to load dashboard: {str(e)}"]
+    
+    return result
+
+def generate_crypto_prices():
+    """Generate realistic cryptocurrency prices"""
+    result = []
+    
+    for crypto in CRYPTOCURRENCIES:
+        change_24h = random.uniform(-15, 18)
+        change_7d = random.uniform(-25, 30)
+        volume = crypto["base_price"] * random.uniform(1e9, 5e10)
+        market_cap = crypto["base_price"] * random.uniform(1e9, 8e11)
+        
+        result.append({
+            "symbol": crypto["symbol"],
+            "name": crypto["name"],
+            "category": crypto["category"],
+            "price": round(crypto["base_price"] * (1 + random.uniform(-0.08, 0.08)), 4),
+            "change_24h": round(change_24h, 2),
+            "change_7d": round(change_7d, 2),
+            "volume_24h": int(volume),
+            "market_cap": int(market_cap),
+            "circulating_supply": int(market_cap / crypto["base_price"]),
+            "total_supply": int(market_cap / crypto["base_price"] * random.uniform(1, 1.5)),
+            "ath": round(crypto["base_price"] * random.uniform(1.5, 8), 2),
+            "atl": round(crypto["base_price"] * random.uniform(0.01, 0.3), 4),
+            "rank": CRYPTOCURRENCIES.index(crypto) + 1,
+            "last_updated": datetime.now().isoformat()
         })
-
-
-def refresh_price_data() -> Tuple[pd.DataFrame, str]:
-    """
-    Manually trigger price data collection and refresh dashboard
-
-    Returns:
-        Tuple of (DataFrame, status_message)
-    """
-    try:
-        logger.info("Manual refresh triggered...")
-
-        # Collect fresh price data
-        success, count = collectors.collect_price_data()
-
-        if success:
-            message = f"✅ Successfully refreshed! Collected {count} price records."
-        else:
-            message = f"⚠️ Refresh completed with warnings. Collected {count} records."
-
-        # Return updated dashboard
-        df = get_live_dashboard()
-
-        return df, message
-
-    except Exception as e:
-        logger.error(f"Error in refresh_price_data: {e}")
-        return get_live_dashboard(), f"❌ Refresh failed: {str(e)}"
-
-
-# ==================== TAB 2: HISTORICAL CHARTS ====================
-
-def get_available_symbols() -> List[str]:
-    """Get list of available cryptocurrency symbols from database"""
-    try:
-        prices = db.get_latest_prices(100)
-        symbols = sorted(list(set([
-            f"{p.get('name', 'Unknown')} ({p.get('symbol', 'N/A').upper()})"
-            for p in prices if p.get('symbol')
-        ])))
-
-        if not symbols:
-            return ["BTC", "ETH", "BNB"]
-
-        return symbols
-
-    except Exception as e:
-        logger.error(f"Error getting symbols: {e}")
-        return ["BTC", "ETH", "BNB"]
-
-
-def generate_chart(symbol_display: str, timeframe: str) -> go.Figure:
-    """
-    Generate interactive plotly chart with price history and technical indicators
-
-    Args:
-        symbol_display: Display name like "Bitcoin (BTC)"
-        timeframe: Time period (1d, 7d, 30d, 90d, 1y, All)
-
-    Returns:
-        Plotly figure with price chart, volume, MA, and RSI
-    """
-    try:
-        logger.info(f"Generating chart for {symbol_display} - {timeframe}")
-
-        # Extract symbol from display name
-        if '(' in symbol_display and ')' in symbol_display:
-            symbol = symbol_display.split('(')[1].split(')')[0].strip().upper()
-        else:
-            symbol = symbol_display.strip().upper()
-
-        # Determine hours to look back
-        timeframe_hours = {
-            "1d": 24,
-            "7d": 24 * 7,
-            "30d": 24 * 30,
-            "90d": 24 * 90,
-            "1y": 24 * 365,
-            "All": 24 * 365 * 10  # 10 years
-        }
-        hours = timeframe_hours.get(timeframe, 168)
-
-        # Get price history
-        history = db.get_price_history(symbol, hours)
-
-        if not history:
-            # Try to find by name instead
-            prices = db.get_latest_prices(100)
-            matching = [p for p in prices if symbol.lower() in (p.get('name') or '').lower()]
-
-            if matching:
-                symbol = matching[0].get('symbol', symbol)
-                history = db.get_price_history(symbol, hours)
-
-        if not history or len(history) < 2:
-            # Create empty chart with message
-            fig = go.Figure()
-            fig.add_annotation(
-                text=f"No historical data available for {symbol}<br>Try refreshing or selecting a different cryptocurrency",
-                xref="paper", yref="paper",
-                x=0.5, y=0.5, showarrow=False,
-                font=dict(size=16)
-            )
-            fig.update_layout(
-                title=f"{symbol} - No Data Available",
-                height=600
-            )
-            return fig
-
-        # Extract data
-        timestamps = [datetime.fromisoformat(h['timestamp'].replace('Z', '+00:00')) if isinstance(h['timestamp'], str) else datetime.now() for h in history]
-        prices_data = [h.get('price_usd', 0) for h in history]
-        volumes = [h.get('volume_24h', 0) for h in history]
-
-        # Calculate technical indicators
-        ma7_values = []
-        ma30_values = []
-        rsi_values = []
-
-        for i in range(len(prices_data)):
-            # MA7
-            if i >= 6:
-                ma7 = utils.calculate_moving_average(prices_data[:i+1], 7)
-                ma7_values.append(ma7)
-            else:
-                ma7_values.append(None)
-
-            # MA30
-            if i >= 29:
-                ma30 = utils.calculate_moving_average(prices_data[:i+1], 30)
-                ma30_values.append(ma30)
-            else:
-                ma30_values.append(None)
-
-            # RSI
-            if i >= 14:
-                rsi = utils.calculate_rsi(prices_data[:i+1], 14)
-                rsi_values.append(rsi)
-            else:
-                rsi_values.append(None)
-
-        # Create subplots: Price + Volume + RSI
-        fig = make_subplots(
-            rows=3, cols=1,
-            shared_xaxes=True,
-            vertical_spacing=0.05,
-            row_heights=[0.5, 0.25, 0.25],
-            subplot_titles=(f'{symbol} Price Chart', 'Volume', 'RSI (14)')
-        )
-
-        # Price line
-        fig.add_trace(
-            go.Scatter(
-                x=timestamps,
-                y=prices_data,
-                name='Price',
-                line=dict(color='#2962FF', width=2),
-                hovertemplate='<b>Price</b>: $%{y:,.2f}<br><b>Date</b>: %{x}<extra></extra>'
-            ),
-            row=1, col=1
-        )
-
-        # MA7
-        fig.add_trace(
-            go.Scatter(
-                x=timestamps,
-                y=ma7_values,
-                name='MA(7)',
-                line=dict(color='#FF6D00', width=1, dash='dash'),
-                hovertemplate='<b>MA(7)</b>: $%{y:,.2f}<extra></extra>'
-            ),
-            row=1, col=1
-        )
-
-        # MA30
-        fig.add_trace(
-            go.Scatter(
-                x=timestamps,
-                y=ma30_values,
-                name='MA(30)',
-                line=dict(color='#00C853', width=1, dash='dot'),
-                hovertemplate='<b>MA(30)</b>: $%{y:,.2f}<extra></extra>'
-            ),
-            row=1, col=1
-        )
-
-        # Volume bars
-        fig.add_trace(
-            go.Bar(
-                x=timestamps,
-                y=volumes,
-                name='Volume',
-                marker=dict(color='rgba(100, 149, 237, 0.5)'),
-                hovertemplate='<b>Volume</b>: %{y:,.0f}<extra></extra>'
-            ),
-            row=2, col=1
-        )
-
-        # RSI
-        fig.add_trace(
-            go.Scatter(
-                x=timestamps,
-                y=rsi_values,
-                name='RSI',
-                line=dict(color='#9C27B0', width=2),
-                hovertemplate='<b>RSI</b>: %{y:.2f}<extra></extra>'
-            ),
-            row=3, col=1
-        )
-
-        # Add RSI reference lines
-        fig.add_hline(y=70, line_dash="dash", line_color="red", opacity=0.5, row=3, col=1)
-        fig.add_hline(y=30, line_dash="dash", line_color="green", opacity=0.5, row=3, col=1)
-
-        # Update layout
-        fig.update_layout(
-            title=f'{symbol} - {timeframe} Analysis',
-            height=800,
-            hovermode='x unified',
-            showlegend=True,
-            legend=dict(
-                orientation="h",
-                yanchor="bottom",
-                y=1.02,
-                xanchor="right",
-                x=1
-            )
-        )
-
-        # Update axes
-        fig.update_xaxes(title_text="Date", row=3, col=1)
-        fig.update_yaxes(title_text="Price (USD)", row=1, col=1)
-        fig.update_yaxes(title_text="Volume", row=2, col=1)
-        fig.update_yaxes(title_text="RSI", row=3, col=1, range=[0, 100])
-
-        logger.info(f"Chart generated successfully for {symbol}")
-        return fig
-
-    except Exception as e:
-        logger.error(f"Error generating chart: {e}\n{traceback.format_exc()}")
-
-        # Return error chart
-        fig = go.Figure()
-        fig.add_annotation(
-            text=f"Error generating chart:<br>{str(e)}",
-            xref="paper", yref="paper",
-            x=0.5, y=0.5, showarrow=False,
-            font=dict(size=14, color="red")
-        )
-        fig.update_layout(title="Chart Error", height=600)
-        return fig
-
-
-# ==================== TAB 3: NEWS & SENTIMENT ====================
-
-def get_news_feed(sentiment_filter: str = "All", coin_filter: str = "All") -> str:
-    """
-    Get news feed with sentiment analysis as HTML cards
-
-    Args:
-        sentiment_filter: Filter by sentiment (All, Positive, Neutral, Negative)
-        coin_filter: Filter by coin (All, BTC, ETH, etc.)
-
-    Returns:
-        HTML string with news cards
-    """
-    try:
-        logger.info(f"Fetching news feed: sentiment={sentiment_filter}, coin={coin_filter}")
-
-        # Map sentiment filter
-        sentiment_map = {
-            "All": None,
-            "Positive": "positive",
-            "Neutral": "neutral",
-            "Negative": "negative",
-            "Very Positive": "very_positive",
-            "Very Negative": "very_negative"
+    
+    return sorted(result, key=lambda x: x["market_cap"], reverse=True)
+
+def generate_system_health():
+    """Enhanced system health data"""
+    providers = generate_all_providers()
+    
+    healthy = len([p for p in providers if p["status"] == "operational"])
+    degraded = len([p for p in providers if p["status"] == "degraded"])
+    down = len([p for p in providers if p["status"] == "maintenance"])
+    total = len(providers)
+    
+    return {
+        "status": "healthy" if healthy / total > 0.9 else "degraded",
+        "timestamp": datetime.now().isoformat(),
+        "uptime_percentage": round((healthy / total) * 100, 2),
+        "summary": {
+            "total_providers": total,
+            "operational": healthy,
+            "degraded": degraded,
+            "maintenance": down,
+            "total_requests_today": sum(p["requests_today"] for p in providers),
+            "avg_response_time": round(sum(p["response_time_ms"] for p in providers) / total, 1),
+            "total_api_calls": random.randint(10000000, 50000000)
+        },
+        "by_category": {
+            category: {
+                "total": len([p for p in providers if p["category"] == category]),
+                "operational": len([p for p in providers if p["category"] == category and p["status"] == "operational"])
+            }
+            for category in PROVIDERS.keys()
         }
+    }
 
-        sentiment_db = sentiment_map.get(sentiment_filter)
-
-        # Get news from database
-        if coin_filter != "All":
-            news_list = db.get_news_by_coin(coin_filter, limit=50)
-        else:
-            news_list = db.get_latest_news(limit=50, sentiment=sentiment_db)
-
-        if not news_list:
-            return """
-            <div style='text-align: center; padding: 40px; color: #666;'>
-                <h3>No news articles found</h3>
-                <p>Try adjusting your filters or refresh the data</p>
-            </div>
-            """
-
-        # Calculate overall market sentiment
-        sentiment_scores = [n.get('sentiment_score', 0) for n in news_list if n.get('sentiment_score') is not None]
-        avg_sentiment = sum(sentiment_scores) / len(sentiment_scores) if sentiment_scores else 0
-        sentiment_gauge = int((avg_sentiment + 1) * 50)  # Convert -1 to 1 -> 0 to 100
-
-        # Determine gauge color
-        if sentiment_gauge >= 60:
-            gauge_color = "#4CAF50"
-            gauge_label = "Bullish"
-        elif sentiment_gauge <= 40:
-            gauge_color = "#F44336"
-            gauge_label = "Bearish"
-        else:
-            gauge_color = "#FF9800"
-            gauge_label = "Neutral"
-
-        # Build HTML
-        html = f"""
-        <style>
-            .sentiment-gauge {{
-                background: linear-gradient(90deg, #F44336 0%, #FF9800 50%, #4CAF50 100%);
-                height: 30px;
-                border-radius: 15px;
-                position: relative;
-                margin: 20px 0;
-            }}
-            .sentiment-indicator {{
-                position: absolute;
-                left: {sentiment_gauge}%;
-                top: -5px;
-                width: 40px;
-                height: 40px;
-                background: white;
-                border: 3px solid {gauge_color};
-                border-radius: 50%;
-                transform: translateX(-50%);
-            }}
-            .news-card {{
-                background: white;
-                border: 1px solid #e0e0e0;
-                border-radius: 8px;
-                padding: 16px;
-                margin: 12px 0;
-                box-shadow: 0 2px 4px rgba(0,0,0,0.1);
-                transition: box-shadow 0.3s;
-            }}
-            .news-card:hover {{
-                box-shadow: 0 4px 8px rgba(0,0,0,0.2);
-            }}
-            .news-title {{
-                font-size: 18px;
-                font-weight: bold;
-                color: #333;
-                margin-bottom: 8px;
-            }}
-            .news-meta {{
-                font-size: 12px;
-                color: #666;
-                margin-bottom: 8px;
-            }}
-            .sentiment-badge {{
-                display: inline-block;
-                padding: 4px 12px;
-                border-radius: 12px;
-                font-size: 11px;
-                font-weight: bold;
-                margin-left: 8px;
-            }}
-            .sentiment-positive {{ background: #C8E6C9; color: #2E7D32; }}
-            .sentiment-very_positive {{ background: #81C784; color: #1B5E20; }}
-            .sentiment-neutral {{ background: #FFF9C4; color: #F57F17; }}
-            .sentiment-negative {{ background: #FFCDD2; color: #C62828; }}
-            .sentiment-very_negative {{ background: #EF5350; color: #B71C1C; }}
-            .news-summary {{
-                color: #555;
-                line-height: 1.5;
-                margin-bottom: 8px;
-            }}
-            .news-link {{
-                color: #2962FF;
-                text-decoration: none;
-                font-weight: 500;
-            }}
-            .news-link:hover {{
-                text-decoration: underline;
-            }}
-        </style>
-
-        <div style='margin-bottom: 30px;'>
-            <h2 style='margin-bottom: 10px;'>Market Sentiment Gauge</h2>
-            <div style='text-align: center; font-size: 24px; font-weight: bold; color: {gauge_color};'>
-                {gauge_label} ({sentiment_gauge}/100)
-            </div>
-            <div class='sentiment-gauge'>
-                <div class='sentiment-indicator'></div>
-            </div>
-        </div>
-
-        <h2>Latest News ({len(news_list)} articles)</h2>
-        """
-
-        # Add news cards
-        for news in news_list:
-            title = news.get('title', 'No Title')
-            summary = news.get('summary', '')
-            url = news.get('url', '#')
-            source = news.get('source', 'Unknown')
-            published = news.get('published_date', news.get('timestamp', ''))
-
-            # Format date
-            try:
-                if published:
-                    dt = datetime.fromisoformat(published.replace('Z', '+00:00'))
-                    date_str = dt.strftime('%b %d, %Y %H:%M')
-                else:
-                    date_str = 'Unknown date'
-            except:
-                date_str = 'Unknown date'
-
-            # Get sentiment
-            sentiment_label = news.get('sentiment_label', 'neutral')
-            sentiment_class = f"sentiment-{sentiment_label}"
-            sentiment_display = sentiment_label.replace('_', ' ').title()
-
-            # Related coins
-            related_coins = news.get('related_coins', [])
-            if isinstance(related_coins, str):
-                try:
-                    related_coins = json.loads(related_coins)
-                except:
-                    related_coins = []
-
-            coins_str = ', '.join(related_coins[:5]) if related_coins else 'General'
-
-            html += f"""
-            <div class='news-card'>
-                <div class='news-title'>
-                    <a href='{url}' target='_blank' class='news-link'>{title}</a>
-                </div>
-                <div class='news-meta'>
-                    <strong>{source}</strong> | {date_str} | Coins: {coins_str}
-                    <span class='sentiment-badge {sentiment_class}'>{sentiment_display}</span>
-                </div>
-                <div class='news-summary'>{summary}</div>
-            </div>
-            """
-
-        return html
-
-    except Exception as e:
-        logger.error(f"Error in get_news_feed: {e}\n{traceback.format_exc()}")
-        return f"""
-        <div style='color: red; padding: 20px;'>
-            <h3>Error Loading News</h3>
-            <p>{str(e)}</p>
-        </div>
-        """
-
-
-# ==================== TAB 4: AI ANALYSIS ====================
-
-def generate_ai_analysis(symbol_display: str) -> str:
-    """
-    Generate AI-powered market analysis for a cryptocurrency
-
-    Args:
-        symbol_display: Display name like "Bitcoin (BTC)"
-
-    Returns:
-        HTML with analysis results
-    """
-    try:
-        logger.info(f"Generating AI analysis for {symbol_display}")
-
-        # Extract symbol
-        if '(' in symbol_display and ')' in symbol_display:
-            symbol = symbol_display.split('(')[1].split(')')[0].strip().upper()
-        else:
-            symbol = symbol_display.strip().upper()
-
-        # Get price history (last 30 days)
-        history = db.get_price_history(symbol, hours=24*30)
-
-        if not history or len(history) < 2:
-            return f"""
-            <div style='padding: 20px; text-align: center; color: #666;'>
-                <h3>Insufficient Data</h3>
-                <p>Not enough historical data available for {symbol} to perform analysis.</p>
-                <p>Please try a different cryptocurrency or wait for more data to be collected.</p>
-            </div>
-            """
+@app.get("/")
+async def root():
+    return {
+        "name": "Crypto API Monitor Pro",
+        "version": "2.0.0",
+        "total_providers": sum(len(p) for p in PROVIDERS.values()),
+        "categories": list(PROVIDERS.keys()),
+        "endpoints": ["/health", "/api/providers", "/api/crypto/prices", "/api/stats", "/ws/live"]
+    }
 
-        # Prepare price history for AI analysis
-        price_history = [
-            {
-                'price': h.get('price_usd', 0),
-                'timestamp': h.get('timestamp', ''),
-                'volume': h.get('volume_24h', 0)
-            }
-            for h in history
+@app.get("/health")
+@app.get("/api/health")
+async def health():
+    return generate_system_health()
+
+@app.get("/api/providers")
+async def get_providers(category: str = None):
+    providers = generate_all_providers()
+    if category:
+        providers = [p for p in providers if p["category"] == category]
+    return providers
+
+@app.get("/api/providers/{name}")
+async def get_provider_detail(name: str):
+    providers = generate_all_providers()
+    provider = next((p for p in providers if p["name"].lower() == name.lower()), None)
+    if provider:
+        provider["history"] = [
+            {"timestamp": (datetime.now() - timedelta(minutes=i*5)).isoformat(),
+             "response_time": random.randint(80, 250),
+             "status": "operational"}
+            for i in range(12)
         ]
-
-        # Call AI analysis
-        analysis = ai_models.analyze_market_trend(price_history)
-
-        # Get trend info
-        trend = analysis.get('trend', 'Neutral')
-        current_price = analysis.get('current_price', 0)
-        support = analysis.get('support_level', 0)
-        resistance = analysis.get('resistance_level', 0)
-        prediction = analysis.get('prediction', 'No prediction available')
-        confidence = analysis.get('confidence', 0)
-        rsi = analysis.get('rsi', 50)
-        ma7 = analysis.get('ma7', 0)
-        ma30 = analysis.get('ma30', 0)
-
-        # Determine trend color and icon
-        if trend == "Bullish":
-            trend_color = "#4CAF50"
-            trend_icon = "📈"
-        elif trend == "Bearish":
-            trend_color = "#F44336"
-            trend_icon = "📉"
-        else:
-            trend_color = "#FF9800"
-            trend_icon = "➡️"
-
-        # Format confidence as percentage
-        confidence_pct = int(confidence * 100)
-
-        # Build HTML
-        html = f"""
-        <style>
-            .analysis-container {{
-                padding: 20px;
-                background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
-                border-radius: 12px;
-                color: white;
-                margin-bottom: 20px;
-            }}
-            .analysis-header {{
-                text-align: center;
-                margin-bottom: 30px;
-            }}
-            .trend-indicator {{
-                font-size: 48px;
-                margin: 20px 0;
-            }}
-            .metric-grid {{
-                display: grid;
-                grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
-                gap: 15px;
-                margin: 20px 0;
-            }}
-            .metric-card {{
-                background: rgba(255, 255, 255, 0.1);
-                padding: 15px;
-                border-radius: 8px;
-                backdrop-filter: blur(10px);
-            }}
-            .metric-label {{
-                font-size: 12px;
-                opacity: 0.8;
-                margin-bottom: 5px;
-            }}
-            .metric-value {{
-                font-size: 24px;
-                font-weight: bold;
-            }}
-            .prediction-box {{
-                background: rgba(255, 255, 255, 0.15);
-                padding: 20px;
-                border-radius: 8px;
-                margin: 20px 0;
-                border-left: 4px solid {trend_color};
-            }}
-            .confidence-bar {{
-                background: rgba(255, 255, 255, 0.2);
-                height: 30px;
-                border-radius: 15px;
-                overflow: hidden;
-                margin-top: 10px;
-            }}
-            .confidence-fill {{
-                background: {trend_color};
-                height: 100%;
-                width: {confidence_pct}%;
-                transition: width 0.5s ease;
-                display: flex;
-                align-items: center;
-                justify-content: center;
-                font-weight: bold;
-            }}
-            .history-section {{
-                background: white;
-                padding: 20px;
-                border-radius: 8px;
-                margin-top: 20px;
-                color: #333;
-            }}
-        </style>
-
-        <div class='analysis-container'>
-            <div class='analysis-header'>
-                <h1>{symbol} Market Analysis</h1>
-                <div class='trend-indicator'>{trend_icon}</div>
-                <h2 style='color: {trend_color};'>{trend} Trend</h2>
-            </div>
-
-            <div class='metric-grid'>
-                <div class='metric-card'>
-                    <div class='metric-label'>Current Price</div>
-                    <div class='metric-value'>${current_price:,.2f}</div>
-                </div>
-                <div class='metric-card'>
-                    <div class='metric-label'>Support Level</div>
-                    <div class='metric-value'>${support:,.2f}</div>
-                </div>
-                <div class='metric-card'>
-                    <div class='metric-label'>Resistance Level</div>
-                    <div class='metric-value'>${resistance:,.2f}</div>
-                </div>
-                <div class='metric-card'>
-                    <div class='metric-label'>RSI (14)</div>
-                    <div class='metric-value'>{rsi:.1f}</div>
-                </div>
-                <div class='metric-card'>
-                    <div class='metric-label'>MA (7)</div>
-                    <div class='metric-value'>${ma7:,.2f}</div>
-                </div>
-                <div class='metric-card'>
-                    <div class='metric-label'>MA (30)</div>
-                    <div class='metric-value'>${ma30:,.2f}</div>
-                </div>
-            </div>
-
-            <div class='prediction-box'>
-                <h3>📊 Market Prediction</h3>
-                <p style='font-size: 16px; line-height: 1.6;'>{prediction}</p>
-            </div>
-
-            <div>
-                <h3>Confidence Score</h3>
-                <div class='confidence-bar'>
-                    <div class='confidence-fill'>{confidence_pct}%</div>
-                </div>
-            </div>
-        </div>
-
-        <div class='history-section'>
-            <h3>📜 Recent Analysis History</h3>
-            <p>Latest analysis generated on {datetime.now().strftime('%B %d, %Y at %H:%M:%S')}</p>
-            <p><strong>Data Points Analyzed:</strong> {len(price_history)}</p>
-            <p><strong>Time Range:</strong> {len(price_history)} hours of historical data</p>
-        </div>
-        """
-
-        # Save analysis to database
-        db.save_analysis({
-            'symbol': symbol,
-            'timeframe': '30d',
-            'trend': trend,
-            'support_level': support,
-            'resistance_level': resistance,
-            'prediction': prediction,
-            'confidence': confidence
-        })
-
-        logger.info(f"AI analysis completed for {symbol}")
-        return html
-
-    except Exception as e:
-        logger.error(f"Error in generate_ai_analysis: {e}\n{traceback.format_exc()}")
-        return f"""
-        <div style='padding: 20px; color: red;'>
-            <h3>Analysis Error</h3>
-            <p>Failed to generate analysis: {str(e)}</p>
-            <p>Please try again or select a different cryptocurrency.</p>
-        </div>
-        """
-
-
-# ==================== TAB 5: DATABASE EXPLORER ====================
-
-def execute_database_query(query_type: str, custom_query: str = "") -> Tuple[pd.DataFrame, str]:
-    """
-    Execute database query and return results
-
-    Args:
-        query_type: Type of pre-built query or "Custom"
-        custom_query: Custom SQL query (if query_type is "Custom")
-
-    Returns:
-        Tuple of (DataFrame with results, status message)
-    """
-    try:
-        logger.info(f"Executing database query: {query_type}")
-
-        if query_type == "Top 10 gainers in last 24h":
-            results = db.get_top_gainers(10)
-            message = f"✅ Found {len(results)} gainers"
-
-        elif query_type == "All news with positive sentiment":
-            results = db.get_latest_news(limit=100, sentiment="positive")
-            message = f"✅ Found {len(results)} positive news articles"
-
-        elif query_type == "Price history for BTC":
-            results = db.get_price_history("BTC", 168)
-            message = f"✅ Found {len(results)} BTC price records"
-
-        elif query_type == "Database statistics":
-            stats = db.get_database_stats()
-            # Convert stats to DataFrame
-            results = [{"Metric": k, "Value": str(v)} for k, v in stats.items()]
-            message = "✅ Database statistics retrieved"
-
-        elif query_type == "Latest 100 prices":
-            results = db.get_latest_prices(100)
-            message = f"✅ Retrieved {len(results)} latest prices"
-
-        elif query_type == "Recent news (50)":
-            results = db.get_latest_news(50)
-            message = f"✅ Retrieved {len(results)} recent news articles"
-
-        elif query_type == "All market analyses":
-            results = db.get_all_analyses(100)
-            message = f"✅ Retrieved {len(results)} market analyses"
-
-        elif query_type == "Custom Query":
-            if not custom_query.strip():
-                return pd.DataFrame(), "⚠️ Please enter a custom query"
-
-            # Security check
-            if not custom_query.strip().upper().startswith('SELECT'):
-                return pd.DataFrame(), "❌ Only SELECT queries are allowed for security reasons"
-
-            results = db.execute_safe_query(custom_query)
-            message = f"✅ Custom query returned {len(results)} rows"
-
-        else:
-            return pd.DataFrame(), "❌ Unknown query type"
-
-        # Convert to DataFrame
-        if results:
-            df = pd.DataFrame(results)
-
-            # Truncate long text fields for display
-            for col in df.columns:
-                if df[col].dtype == 'object':
-                    df[col] = df[col].apply(lambda x: str(x)[:100] + '...' if isinstance(x, str) and len(str(x)) > 100 else x)
-
-            return df, message
-        else:
-            return pd.DataFrame(), f"⚠️ Query returned no results"
-
-    except Exception as e:
-        logger.error(f"Error executing query: {e}\n{traceback.format_exc()}")
-        return pd.DataFrame(), f"❌ Query failed: {str(e)}"
-
-
-def export_query_results(df: pd.DataFrame) -> Tuple[str, str]:
-    """
-    Export query results to CSV file
-
-    Args:
-        df: DataFrame to export
-
-    Returns:
-        Tuple of (file_path, status_message)
-    """
-    try:
-        if df.empty:
-            return None, "⚠️ No data to export"
-
-        # Create export filename with timestamp
-        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-        filename = f"query_export_{timestamp}.csv"
-        filepath = config.DATA_DIR / filename
-
-        # Export using utils
-        success = utils.export_to_csv(df.to_dict('records'), str(filepath))
-
-        if success:
-            return str(filepath), f"✅ Exported {len(df)} rows to {filename}"
-        else:
-            return None, "❌ Export failed"
-
-    except Exception as e:
-        logger.error(f"Error exporting results: {e}")
-        return None, f"❌ Export error: {str(e)}"
-
-
-# ==================== TAB 6: DATA SOURCES STATUS ====================
-
-def get_data_sources_status() -> Tuple[pd.DataFrame, str]:
-    """
-    Get status of all data sources
-
-    Returns:
-        Tuple of (DataFrame with status, HTML with error log)
-    """
-    try:
-        logger.info("Checking data sources status...")
-
-        status_data = []
-
-        # Check CoinGecko
-        try:
-            import requests
-            response = requests.get(f"{config.COINGECKO_BASE_URL}/ping", timeout=5)
-            if response.status_code == 200:
-                coingecko_status = "🟢 Online"
-                coingecko_error = 0
-            else:
-                coingecko_status = f"🟡 Status {response.status_code}"
-                coingecko_error = 1
-        except:
-            coingecko_status = "🔴 Offline"
-            coingecko_error = 1
-
-        status_data.append({
-            "Data Source": "CoinGecko API",
-            "Status": coingecko_status,
-            "Last Update": datetime.now().strftime("%H:%M:%S"),
-            "Errors": coingecko_error
-        })
-
-        # Check CoinCap
-        try:
-            import requests
-            response = requests.get(f"{config.COINCAP_BASE_URL}/assets", timeout=5)
-            if response.status_code == 200:
-                coincap_status = "🟢 Online"
-                coincap_error = 0
-            else:
-                coincap_status = f"🟡 Status {response.status_code}"
-                coincap_error = 1
-        except:
-            coincap_status = "🔴 Offline"
-            coincap_error = 1
-
-        status_data.append({
-            "Data Source": "CoinCap API",
-            "Status": coincap_status,
-            "Last Update": datetime.now().strftime("%H:%M:%S"),
-            "Errors": coincap_error
-        })
-
-        # Check Binance
-        try:
-            import requests
-            response = requests.get(f"{config.BINANCE_BASE_URL}/ping", timeout=5)
-            if response.status_code == 200:
-                binance_status = "🟢 Online"
-                binance_error = 0
-            else:
-                binance_status = f"🟡 Status {response.status_code}"
-                binance_error = 1
-        except:
-            binance_status = "🔴 Offline"
-            binance_error = 1
-
-        status_data.append({
-            "Data Source": "Binance API",
-            "Status": binance_status,
-            "Last Update": datetime.now().strftime("%H:%M:%S"),
-            "Errors": binance_error
-        })
-
-        # Check RSS Feeds
-        rss_ok = 0
-        rss_failed = 0
-        for feed_name in config.RSS_FEEDS.keys():
-            if feed_name in ["coindesk", "cointelegraph"]:
-                rss_ok += 1
-            else:
-                rss_ok += 1  # Assume OK for now
-
-        status_data.append({
-            "Data Source": f"RSS Feeds ({len(config.RSS_FEEDS)} sources)",
-            "Status": f"🟢 {rss_ok} active",
-            "Last Update": datetime.now().strftime("%H:%M:%S"),
-            "Errors": rss_failed
-        })
-
-        # Check Reddit
-        reddit_ok = 0
-        for subreddit in config.REDDIT_ENDPOINTS.keys():
-            reddit_ok += 1  # Assume OK
-
-        status_data.append({
-            "Data Source": f"Reddit ({len(config.REDDIT_ENDPOINTS)} subreddits)",
-            "Status": f"🟢 {reddit_ok} active",
-            "Last Update": datetime.now().strftime("%H:%M:%S"),
-            "Errors": 0
-        })
-
-        # Check Database
-        try:
-            stats = db.get_database_stats()
-            db_status = "🟢 Connected"
-            db_error = 0
-            last_update = stats.get('latest_price_update', 'Unknown')
-        except:
-            db_status = "🔴 Error"
-            db_error = 1
-            last_update = "Unknown"
-
-        status_data.append({
-            "Data Source": "SQLite Database",
-            "Status": db_status,
-            "Last Update": last_update if last_update != 'Unknown' else datetime.now().strftime("%H:%M:%S"),
-            "Errors": db_error
-        })
-
-        df = pd.DataFrame(status_data)
-
-        # Get error log
-        error_html = get_error_log_html()
-
-        return df, error_html
-
-    except Exception as e:
-        logger.error(f"Error getting data sources status: {e}")
-        return pd.DataFrame(), f"<p style='color: red;'>Error: {str(e)}</p>"
-
-
-def get_error_log_html() -> str:
-    """Get last 10 errors from log file as HTML"""
-    try:
-        if not config.LOG_FILE.exists():
-            return "<p>No error log file found</p>"
-
-        # Read last 100 lines of log file
-        with open(config.LOG_FILE, 'r') as f:
-            lines = f.readlines()
-
-        # Get lines with ERROR or WARNING
-        error_lines = [line for line in lines[-100:] if 'ERROR' in line or 'WARNING' in line]
-
-        if not error_lines:
-            return "<p style='color: green;'>✅ No recent errors or warnings</p>"
-
-        # Take last 10
-        error_lines = error_lines[-10:]
-
-        html = "<h3>Recent Errors & Warnings</h3><div style='background: #f5f5f5; padding: 10px; border-radius: 5px; font-family: monospace; font-size: 12px;'>"
-
-        for line in error_lines:
-            # Color code by severity
-            if 'ERROR' in line:
-                color = 'red'
-            elif 'WARNING' in line:
-                color = 'orange'
-            else:
-                color = 'black'
-
-            html += f"<div style='color: {color}; margin: 5px 0;'>{line.strip()}</div>"
-
-        html += "</div>"
-
-        return html
-
-    except Exception as e:
-        logger.error(f"Error reading log file: {e}")
-        return f"<p style='color: red;'>Error reading log: {str(e)}</p>"
-
-
-def manual_data_collection() -> Tuple[pd.DataFrame, str, str]:
-    """
-    Manually trigger data collection for all sources
-
-    Returns:
-        Tuple of (status DataFrame, status HTML, message)
-    """
-    try:
-        logger.info("Manual data collection triggered...")
-
-        message = "🔄 Collecting data from all sources...\n\n"
-
-        # Collect price data
-        try:
-            success, count = collectors.collect_price_data()
-            if success:
-                message += f"✅ Prices: {count} records collected\n"
-            else:
-                message += f"⚠️ Prices: Collection had issues\n"
-        except Exception as e:
-            message += f"❌ Prices: {str(e)}\n"
-
-        # Collect news data
-        try:
-            count = collectors.collect_news_data()
-            message += f"✅ News: {count} articles collected\n"
-        except Exception as e:
-            message += f"❌ News: {str(e)}\n"
-
-        # Collect sentiment data
-        try:
-            sentiment = collectors.collect_sentiment_data()
-            if sentiment:
-                message += f"✅ Sentiment: {sentiment.get('classification', 'N/A')}\n"
-            else:
-                message += "⚠️ Sentiment: No data collected\n"
-        except Exception as e:
-            message += f"❌ Sentiment: {str(e)}\n"
-
-        message += "\n✅ Data collection complete!"
-
-        # Get updated status
-        df, html = get_data_sources_status()
-
-        return df, html, message
-
-    except Exception as e:
-        logger.error(f"Error in manual data collection: {e}")
-        df, html = get_data_sources_status()
-        return df, html, f"❌ Collection failed: {str(e)}"
-
-
-# ==================== GRADIO INTERFACE ====================
-
-def create_gradio_interface():
-    """Create the complete Gradio interface with all 6 tabs"""
-
-    # Custom CSS for better styling
-    custom_css = """
-    .gradio-container {
-        max-width: 1400px !important;
-    }
-    .tab-nav button {
-        font-size: 16px !important;
-        font-weight: 600 !important;
+    return provider
+
+@app.get("/api/crypto/prices")
+async def get_crypto_prices(limit: int = 20):
+    return generate_crypto_prices()[:limit]
+
+@app.get("/api/crypto/{symbol}")
+async def get_crypto_detail(symbol: str):
+    prices = generate_crypto_prices()
+    crypto = next((c for c in prices if c["symbol"].upper() == symbol.upper()), None)
+    if crypto:
+        crypto["price_history"] = [
+            {"timestamp": (datetime.now() - timedelta(hours=i)).isoformat(),
+             "price": crypto["price"] * random.uniform(0.95, 1.05)}
+            for i in range(24)
+        ]
+    return crypto
+
+@app.get("/api/stats")
+async def get_stats():
+    providers = generate_all_providers()
+    prices = generate_crypto_prices()
+    
+    return {
+        "providers": {
+            "total": len(providers),
+            "by_type": {
+                "exchanges": len([p for p in providers if p["type"] == "Exchange"]),
+                "data_providers": len([p for p in providers if "Data" in p["type"]]),
+                "analytics": len([p for p in providers if p["type"] == "Analytics"]),
+                "defi": len([p for p in providers if p["category"] == "defi"]),
+            },
+            "by_status": {
+                "operational": len([p for p in providers if p["status"] == "operational"]),
+                "degraded": len([p for p in providers if p["status"] == "degraded"]),
+                "maintenance": len([p for p in providers if p["status"] == "maintenance"]),
+            }
+        },
+        "market": {
+            "total_market_cap": sum(c["market_cap"] for c in prices),
+            "total_volume_24h": sum(c["volume_24h"] for c in prices),
+            "avg_change_24h": round(sum(c["change_24h"] for c in prices) / len(prices), 2),
+            "btc_dominance": round((prices[0]["market_cap"] / sum(c["market_cap"] for c in prices)) * 100, 2),
+        },
+        "performance": {
+            "total_requests": sum(p["requests_today"] for p in providers),
+            "avg_response_time": round(sum(p["response_time_ms"] for p in providers) / len(providers), 1),
+            "uptime": round((len([p for p in providers if p["status"] == "operational"]) / len(providers)) * 100, 2),
+        }
     }
-    """
-
-    with gr.Blocks(
-        title="Crypto Data Aggregator - Complete Dashboard",
-        theme=gr.themes.Soft(),
-        css=custom_css
-    ) as interface:
-
-        # Header
-        gr.Markdown("""
-        # 🚀 Crypto Data Aggregator - Complete Dashboard
-
-        **Comprehensive cryptocurrency analytics platform** with real-time data, AI-powered insights, and advanced technical analysis.
-
-        **Key Features:**
-        - 📊 Live price tracking for top 100 cryptocurrencies
-        - 📈 Historical charts with technical indicators (MA, RSI)
-        - 📰 News aggregation with sentiment analysis
-        - 🤖 AI-powered market trend predictions
-        - 🗄️ Powerful database explorer with export functionality
-        - 🔍 Real-time data source monitoring
-        """)
-
-        with gr.Tabs():
-
-            # ==================== TAB 1: LIVE DASHBOARD ====================
-            with gr.Tab("📊 Live Dashboard"):
-                gr.Markdown("### Real-time cryptocurrency prices and market data")
-
-                with gr.Row():
-                    search_box = gr.Textbox(
-                        label="Search/Filter",
-                        placeholder="Enter coin name or symbol (e.g., Bitcoin, BTC)...",
-                        scale=3
-                    )
-                    refresh_btn = gr.Button("🔄 Refresh Data", variant="primary", scale=1)
-
-                dashboard_table = gr.Dataframe(
-                    label="Top 100 Cryptocurrencies",
-                    interactive=False,
-                    wrap=True,
-                    height=600
-                )
-
-                refresh_status = gr.Textbox(label="Status", interactive=False)
-
-                # Auto-refresh timer
-                timer = gr.Timer(value=config.AUTO_REFRESH_INTERVAL)
-
-                # Load initial data
-                interface.load(
-                    fn=get_live_dashboard,
-                    outputs=dashboard_table
-                )
-
-                # Search/filter functionality
-                search_box.change(
-                    fn=get_live_dashboard,
-                    inputs=search_box,
-                    outputs=dashboard_table
-                )
-
-                # Refresh button
-                refresh_btn.click(
-                    fn=refresh_price_data,
-                    outputs=[dashboard_table, refresh_status]
-                )
-
-                # Auto-refresh
-                timer.tick(
-                    fn=get_live_dashboard,
-                    outputs=dashboard_table
-                )
-
-            # ==================== TAB 2: HISTORICAL CHARTS ====================
-            with gr.Tab("📈 Historical Charts"):
-                gr.Markdown("### Interactive price charts with technical analysis")
-
-                with gr.Row():
-                    symbol_dropdown = gr.Dropdown(
-                        label="Select Cryptocurrency",
-                        choices=get_available_symbols(),
-                        value=get_available_symbols()[0] if get_available_symbols() else "BTC",
-                        scale=2
-                    )
-
-                    timeframe_buttons = gr.Radio(
-                        label="Timeframe",
-                        choices=["1d", "7d", "30d", "90d", "1y", "All"],
-                        value="7d",
-                        scale=2
-                    )
-
-                chart_plot = gr.Plot(label="Price Chart with Indicators")
-
-                with gr.Row():
-                    generate_chart_btn = gr.Button("📊 Generate Chart", variant="primary")
-                    export_chart_btn = gr.Button("💾 Export Chart (PNG)")
-
-                # Generate chart
-                generate_chart_btn.click(
-                    fn=generate_chart,
-                    inputs=[symbol_dropdown, timeframe_buttons],
-                    outputs=chart_plot
-                )
-
-                # Also update on dropdown/timeframe change
-                symbol_dropdown.change(
-                    fn=generate_chart,
-                    inputs=[symbol_dropdown, timeframe_buttons],
-                    outputs=chart_plot
-                )
-
-                timeframe_buttons.change(
-                    fn=generate_chart,
-                    inputs=[symbol_dropdown, timeframe_buttons],
-                    outputs=chart_plot
-                )
-
-                # Load initial chart
-                interface.load(
-                    fn=generate_chart,
-                    inputs=[symbol_dropdown, timeframe_buttons],
-                    outputs=chart_plot
-                )
-
-            # ==================== TAB 3: NEWS & SENTIMENT ====================
-            with gr.Tab("📰 News & Sentiment"):
-                gr.Markdown("### Latest cryptocurrency news with AI sentiment analysis")
-
-                with gr.Row():
-                    sentiment_filter = gr.Dropdown(
-                        label="Filter by Sentiment",
-                        choices=["All", "Positive", "Neutral", "Negative", "Very Positive", "Very Negative"],
-                        value="All",
-                        scale=1
-                    )
-
-                    coin_filter = gr.Dropdown(
-                        label="Filter by Coin",
-                        choices=["All", "BTC", "ETH", "BNB", "XRP", "ADA", "SOL", "DOT", "DOGE"],
-                        value="All",
-                        scale=1
-                    )
-
-                    news_refresh_btn = gr.Button("🔄 Refresh News", variant="primary", scale=1)
-
-                news_html = gr.HTML(label="News Feed")
-
-                # Load initial news
-                interface.load(
-                    fn=get_news_feed,
-                    inputs=[sentiment_filter, coin_filter],
-                    outputs=news_html
-                )
-
-                # Update on filter change
-                sentiment_filter.change(
-                    fn=get_news_feed,
-                    inputs=[sentiment_filter, coin_filter],
-                    outputs=news_html
-                )
-
-                coin_filter.change(
-                    fn=get_news_feed,
-                    inputs=[sentiment_filter, coin_filter],
-                    outputs=news_html
-                )
-
-                # Refresh button
-                news_refresh_btn.click(
-                    fn=get_news_feed,
-                    inputs=[sentiment_filter, coin_filter],
-                    outputs=news_html
-                )
 
-            # ==================== TAB 4: AI ANALYSIS ====================
-            with gr.Tab("🤖 AI Analysis"):
-                gr.Markdown("### AI-powered market trend analysis and predictions")
-
-                with gr.Row():
-                    analysis_symbol = gr.Dropdown(
-                        label="Select Cryptocurrency for Analysis",
-                        choices=get_available_symbols(),
-                        value=get_available_symbols()[0] if get_available_symbols() else "BTC",
-                        scale=3
-                    )
-
-                    analyze_btn = gr.Button("🔮 Generate Analysis", variant="primary", scale=1)
-
-                analysis_html = gr.HTML(label="AI Analysis Results")
-
-                # Generate analysis
-                analyze_btn.click(
-                    fn=generate_ai_analysis,
-                    inputs=analysis_symbol,
-                    outputs=analysis_html
-                )
-
-            # ==================== TAB 5: DATABASE EXPLORER ====================
-            with gr.Tab("🗄️ Database Explorer"):
-                gr.Markdown("### Query and explore the cryptocurrency database")
-
-                query_type = gr.Dropdown(
-                    label="Select Query",
-                    choices=[
-                        "Top 10 gainers in last 24h",
-                        "All news with positive sentiment",
-                        "Price history for BTC",
-                        "Database statistics",
-                        "Latest 100 prices",
-                        "Recent news (50)",
-                        "All market analyses",
-                        "Custom Query"
-                    ],
-                    value="Database statistics"
-                )
-
-                custom_query_box = gr.Textbox(
-                    label="Custom SQL Query (SELECT only)",
-                    placeholder="SELECT * FROM prices WHERE symbol = 'BTC' LIMIT 10",
-                    lines=3,
-                    visible=False
-                )
-
-                with gr.Row():
-                    execute_btn = gr.Button("▶️ Execute Query", variant="primary")
-                    export_btn = gr.Button("💾 Export to CSV")
-
-                query_results = gr.Dataframe(label="Query Results", interactive=False, wrap=True)
-                query_status = gr.Textbox(label="Status", interactive=False)
-                export_status = gr.Textbox(label="Export Status", interactive=False)
-
-                # Show/hide custom query box
-                def toggle_custom_query(query_type):
-                    return gr.update(visible=(query_type == "Custom Query"))
-
-                query_type.change(
-                    fn=toggle_custom_query,
-                    inputs=query_type,
-                    outputs=custom_query_box
-                )
-
-                # Execute query
-                execute_btn.click(
-                    fn=execute_database_query,
-                    inputs=[query_type, custom_query_box],
-                    outputs=[query_results, query_status]
-                )
-
-                # Export results
-                export_btn.click(
-                    fn=export_query_results,
-                    inputs=query_results,
-                    outputs=[gr.Textbox(visible=False), export_status]
-                )
-
-                # Load initial query
-                interface.load(
-                    fn=execute_database_query,
-                    inputs=[query_type, custom_query_box],
-                    outputs=[query_results, query_status]
-                )
-
-            # ==================== TAB 6: DATA SOURCES STATUS ====================
-            with gr.Tab("🔍 Data Sources Status"):
-                gr.Markdown("### Monitor the health of all data sources")
-
-                with gr.Row():
-                    status_refresh_btn = gr.Button("🔄 Refresh Status", variant="primary")
-                    collect_btn = gr.Button("📥 Run Manual Collection", variant="secondary")
-
-                status_table = gr.Dataframe(label="Data Sources Status", interactive=False)
-                error_log_html = gr.HTML(label="Error Log")
-                collection_status = gr.Textbox(label="Collection Status", lines=8, interactive=False)
-
-                # Load initial status
-                interface.load(
-                    fn=get_data_sources_status,
-                    outputs=[status_table, error_log_html]
-                )
-
-                # Refresh status
-                status_refresh_btn.click(
-                    fn=get_data_sources_status,
-                    outputs=[status_table, error_log_html]
-                )
-
-                # Manual collection
-                collect_btn.click(
-                    fn=manual_data_collection,
-                    outputs=[status_table, error_log_html, collection_status]
-                )
-
-        # Footer
-        gr.Markdown("""
-        ---
-        **Crypto Data Aggregator** | Powered by CoinGecko, CoinCap, Binance APIs | AI Models by HuggingFace
-        """)
-
-    return interface
-
-
-# ==================== MAIN ENTRY POINT ====================
-
-def main():
-    """Main function to initialize and launch the Gradio app"""
-
-    logger.info("=" * 60)
-    logger.info("Starting Crypto Data Aggregator Dashboard")
-    logger.info("=" * 60)
-
-    # Initialize database
-    logger.info("Initializing database...")
-    db = Database()
-    logger.info("Database initialized successfully")
-
-    # Start background data collection
-    global _collection_started
-    with _collection_lock:
-        if not _collection_started:
-            logger.info("Starting background data collection...")
-            collectors.schedule_data_collection()
-            _collection_started = True
-            logger.info("Background collection started")
-
-    # Create Gradio interface
-    logger.info("Creating Gradio interface...")
-    interface = create_gradio_interface()
-
-    # Launch Gradio
-    logger.info("Launching Gradio dashboard...")
-    logger.info(f"Server: {config.GRADIO_SERVER_NAME}:{config.GRADIO_SERVER_PORT}")
-    logger.info(f"Share: {config.GRADIO_SHARE}")
+@app.get("/api/categories")
+async def get_categories():
+    return [
+        {"id": k, "name": k.title(), "count": len(v), "providers": [p["name"] for p in v]}
+        for k, v in PROVIDERS.items()
+    ]
+
+@app.get("/api/alerts")
+async def get_alerts():
+    providers = generate_all_providers()
+    alerts = []
+    
+    for p in providers:
+        if p["status"] == "degraded":
+            alerts.append({
+                "severity": "warning",
+                "provider": p["name"],
+                "message": f"{p['name']} is experiencing degraded performance",
+                "timestamp": datetime.now().isoformat()
+            })
+        if p["response_time_ms"] > 200:
+            alerts.append({
+                "severity": "info",
+                "provider": p["name"],
+                "message": f"High response time: {p['response_time_ms']}ms",
+                "timestamp": datetime.now().isoformat()
+            })
+    
+    return alerts[:10]
 
+@app.websocket("/ws/live")
+async def websocket_endpoint(websocket: WebSocket):
+    await manager.connect(websocket)
     try:
-        interface.launch(
-            share=config.GRADIO_SHARE,
-            server_name=config.GRADIO_SERVER_NAME,
-            server_port=config.GRADIO_SERVER_PORT,
-            show_error=True,
-            quiet=False
-        )
-    except KeyboardInterrupt:
-        logger.info("\nShutting down...")
-        collectors.stop_scheduled_collection()
-        logger.info("Shutdown complete")
-    except Exception as e:
-        logger.error(f"Error launching Gradio: {e}\n{traceback.format_exc()}")
-        raise
+        while True:
+            await asyncio.sleep(3)
+            health = generate_system_health()
+            await websocket.send_json({
+                "type": "status_update",
+                "data": health,
+                "timestamp": datetime.now().isoformat()
+            })
+    except WebSocketDisconnect:
+        manager.disconnect(websocket)
 
+@app.get("/dashboard", response_class=HTMLResponse)
+async def dashboard():
+    try:
+        with open("index.html", "r", encoding="utf-8") as f:
+            return HTMLResponse(content=f.read())
+    except:
+        return HTMLResponse("<h1>Dashboard not found</h1>", 404)
 
 if __name__ == "__main__":
-    main()
+    print("🚀 Crypto API Monitor Pro v2.0")
+    print(f"📊 {sum(len(p) for p in PROVIDERS.values())} Providers")
+    print("🌐 http://localhost:8000/dashboard")
+    uvicorn.run(app, host="0.0.0.0", port=8000)

config.js

@@ -143,4 +143,4 @@ console.log('🚀 Crypto API Monitor - Configuration loaded:', {
                  CONFIG.IS_LOCALHOST ? 'Localhost' : 'Custom Deployment',
     apiBase: CONFIG.API_BASE,
     wsBase: CONFIG.WS_BASE,
-});
+});

config.py

@@ -1,199 +1,320 @@
-#!/usr/bin/env python3
 """
-Configuration constants for Crypto Data Aggregator
-All configuration in one place - no hardcoded values
+Configuration Module for Crypto API Monitor
+Loads and manages API registry from all_apis_merged_2025.json
 """
 
+import json
 import os
+from typing import Dict, List, Any, Optional
 from pathlib import Path
+from utils.logger import setup_logger
 
-# ==================== DIRECTORIES ====================
-BASE_DIR = Path(__file__).parent
-DATA_DIR = BASE_DIR / "data"
-LOG_DIR = BASE_DIR / "logs"
-DB_DIR = DATA_DIR / "database"
-
-# Create directories if they don't exist
-for directory in [DATA_DIR, LOG_DIR, DB_DIR]:
-    directory.mkdir(parents=True, exist_ok=True)
-
-# ==================== DATABASE ====================
-DATABASE_PATH = DB_DIR / "crypto_aggregator.db"
-DATABASE_BACKUP_DIR = DATA_DIR / "backups"
-DATABASE_BACKUP_DIR.mkdir(parents=True, exist_ok=True)
-
-# ==================== API ENDPOINTS (NO KEYS REQUIRED) ====================
-
-# CoinGecko API (Free, no key)
-COINGECKO_BASE_URL = "https://api.coingecko.com/api/v3"
-COINGECKO_ENDPOINTS = {
-    "ping": "/ping",
-    "price": "/simple/price",
-    "coins_list": "/coins/list",
-    "coins_markets": "/coins/markets",
-    "coin_data": "/coins/{id}",
-    "trending": "/search/trending",
-    "global": "/global",
-}
-
-# CoinCap API (Free, no key)
-COINCAP_BASE_URL = "https://api.coincap.io/v2"
-COINCAP_ENDPOINTS = {
-    "assets": "/assets",
-    "asset_detail": "/assets/{id}",
-    "asset_history": "/assets/{id}/history",
-    "markets": "/markets",
-    "rates": "/rates",
-}
-
-# Binance Public API (Free, no key)
-BINANCE_BASE_URL = "https://api.binance.com/api/v3"
-BINANCE_ENDPOINTS = {
-    "ping": "/ping",
-    "ticker_24h": "/ticker/24hr",
-    "ticker_price": "/ticker/price",
-    "klines": "/klines",
-    "trades": "/trades",
-}
-
-# Alternative.me Fear & Greed Index (Free, no key)
-ALTERNATIVE_ME_URL = "https://api.alternative.me/fng/"
-
-# ==================== RSS FEEDS ====================
-RSS_FEEDS = {
-    "coindesk": "https://www.coindesk.com/arc/outboundfeeds/rss/",
-    "cointelegraph": "https://cointelegraph.com/rss",
-    "bitcoin_magazine": "https://bitcoinmagazine.com/.rss/full/",
-    "decrypt": "https://decrypt.co/feed",
-    "bitcoinist": "https://bitcoinist.com/feed/",
-}
-
-# ==================== REDDIT ENDPOINTS (NO AUTH) ====================
-REDDIT_ENDPOINTS = {
-    "cryptocurrency": "https://www.reddit.com/r/cryptocurrency/.json",
-    "bitcoin": "https://www.reddit.com/r/bitcoin/.json",
-    "ethtrader": "https://www.reddit.com/r/ethtrader/.json",
-    "cryptomarkets": "https://www.reddit.com/r/CryptoMarkets/.json",
-}
-
-# ==================== HUGGING FACE MODELS ====================
-HUGGINGFACE_MODELS = {
-    "sentiment_twitter": "cardiffnlp/twitter-roberta-base-sentiment-latest",
-    "sentiment_financial": "ProsusAI/finbert",
-    "summarization": "facebook/bart-large-cnn",
-}
-
-# ==================== DATA COLLECTION SETTINGS ====================
-COLLECTION_INTERVALS = {
-    "price_data": 300,  # 5 minutes in seconds
-    "news_data": 1800,  # 30 minutes in seconds
-    "sentiment_data": 1800,  # 30 minutes in seconds
-}
-
-# Number of top cryptocurrencies to track
-TOP_COINS_LIMIT = 100
-
-# Request timeout in seconds
-REQUEST_TIMEOUT = 10
-
-# Max retries for failed requests
-MAX_RETRIES = 3
-
-# ==================== CACHE SETTINGS ====================
-CACHE_TTL = 300  # 5 minutes in seconds
-CACHE_MAX_SIZE = 1000  # Maximum number of cached items
-
-# ==================== LOGGING SETTINGS ====================
-LOG_FILE = LOG_DIR / "crypto_aggregator.log"
-LOG_LEVEL = "INFO"
-LOG_FORMAT = "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
-LOG_MAX_BYTES = 10 * 1024 * 1024  # 10 MB
-LOG_BACKUP_COUNT = 5
-
-# ==================== GRADIO SETTINGS ====================
-GRADIO_SHARE = False
-GRADIO_SERVER_NAME = "0.0.0.0"
-GRADIO_SERVER_PORT = 7860
-GRADIO_THEME = "default"
-AUTO_REFRESH_INTERVAL = 30  # seconds
-
-# ==================== DATA VALIDATION ====================
-MIN_PRICE = 0.0
-MAX_PRICE = 1000000000.0  # 1 billion
-MIN_VOLUME = 0.0
-MIN_MARKET_CAP = 0.0
-
-# ==================== CHART SETTINGS ====================
-CHART_TIMEFRAMES = {
-    "1d": {"days": 1, "interval": "1h"},
-    "7d": {"days": 7, "interval": "4h"},
-    "30d": {"days": 30, "interval": "1d"},
-    "90d": {"days": 90, "interval": "1d"},
-    "1y": {"days": 365, "interval": "1w"},
-}
-
-# Technical indicators
-MA_PERIODS = [7, 30]  # Moving Average periods
-RSI_PERIOD = 14  # RSI period
-
-# ==================== SENTIMENT THRESHOLDS ====================
-SENTIMENT_LABELS = {
-    "very_negative": (-1.0, -0.6),
-    "negative": (-0.6, -0.2),
-    "neutral": (-0.2, 0.2),
-    "positive": (0.2, 0.6),
-    "very_positive": (0.6, 1.0),
-}
-
-# ==================== AI ANALYSIS SETTINGS ====================
-AI_CONFIDENCE_THRESHOLD = 0.6
-PREDICTION_HORIZON_HOURS = 72
-
-# ==================== USER AGENT ====================
-USER_AGENT = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
-
-# ==================== RATE LIMITING ====================
-RATE_LIMIT_CALLS = 50
-RATE_LIMIT_PERIOD = 60  # seconds
-
-# ==================== COIN SYMBOLS ====================
-# Top cryptocurrencies to focus on
-FOCUS_COINS = [
-    "bitcoin", "ethereum", "binancecoin", "ripple", "cardano",
-    "solana", "polkadot", "dogecoin", "avalanche-2", "polygon",
-    "chainlink", "uniswap", "litecoin", "cosmos", "algorand"
-]
-
-COIN_SYMBOL_MAPPING = {
-    "bitcoin": "BTC",
-    "ethereum": "ETH",
-    "binancecoin": "BNB",
-    "ripple": "XRP",
-    "cardano": "ADA",
-    "solana": "SOL",
-    "polkadot": "DOT",
-    "dogecoin": "DOGE",
-    "avalanche-2": "AVAX",
-    "polygon": "MATIC",
-}
-
-# ==================== ERROR MESSAGES ====================
-ERROR_MESSAGES = {
-    "api_unavailable": "API service is currently unavailable. Using cached data.",
-    "no_data": "No data available at the moment.",
-    "database_error": "Database operation failed.",
-    "network_error": "Network connection error.",
-    "invalid_input": "Invalid input provided.",
-}
-
-# ==================== SUCCESS MESSAGES ====================
-SUCCESS_MESSAGES = {
-    "data_collected": "Data successfully collected and saved.",
-    "cache_cleared": "Cache cleared successfully.",
-    "database_initialized": "Database initialized successfully.",
-}
-
-# Backward-compatible alias so that `from config import config`
-# returns the config module itself.
-import sys as _sys
-config = _sys.modules[__name__]
+logger = setup_logger("config")
+
+
+class ProviderConfig:
+    """Provider configuration data class"""
+
+    def __init__(
+        self,
+        name: str,
+        category: str,
+        endpoint_url: str,
+        requires_key: bool = False,
+        api_key: Optional[str] = None,
+        rate_limit_type: Optional[str] = None,
+        rate_limit_value: Optional[int] = None,
+        timeout_ms: int = 10000,
+        priority_tier: int = 3,
+        health_check_endpoint: Optional[str] = None
+    ):
+        self.name = name
+        self.category = category
+        self.endpoint_url = endpoint_url
+        self.requires_key = requires_key
+        self.api_key = api_key
+        self.rate_limit_type = rate_limit_type
+        self.rate_limit_value = rate_limit_value
+        self.timeout_ms = timeout_ms
+        self.priority_tier = priority_tier
+        self.health_check_endpoint = health_check_endpoint or endpoint_url
+
+    def to_dict(self) -> Dict:
+        """Convert to dictionary"""
+        return {
+            "name": self.name,
+            "category": self.category,
+            "endpoint_url": self.endpoint_url,
+            "requires_key": self.requires_key,
+            "api_key_masked": self._mask_key() if self.api_key else None,
+            "rate_limit_type": self.rate_limit_type,
+            "rate_limit_value": self.rate_limit_value,
+            "timeout_ms": self.timeout_ms,
+            "priority_tier": self.priority_tier,
+            "health_check_endpoint": self.health_check_endpoint
+        }
+
+    def _mask_key(self) -> str:
+        """Mask API key for security"""
+        if not self.api_key:
+            return None
+        if len(self.api_key) < 10:
+            return "***"
+        return f"{self.api_key[:8]}...{self.api_key[-4:]}"
+
+
+class Config:
+    """Configuration manager for API resources"""
+
+    def __init__(self, config_file: str = "all_apis_merged_2025.json"):
+        """
+        Initialize configuration
+
+        Args:
+            config_file: Path to JSON configuration file
+        """
+        self.base_dir = Path(__file__).parent
+        self.config_file = self.base_dir / config_file
+        self.providers: Dict[str, ProviderConfig] = {}
+        self.api_keys: Dict[str, List[str]] = {}
+        self.cors_proxies: List[str] = [
+            'https://api.allorigins.win/get?url=',
+            'https://proxy.cors.sh/',
+            'https://proxy.corsfix.com/?url=',
+            'https://api.codetabs.com/v1/proxy?quest=',
+            'https://thingproxy.freeboard.io/fetch/'
+        ]
+
+        # Load environment variables
+        self._load_env_keys()
+
+        # Load from JSON
+        self._load_from_json()
+
+        # Build provider registry
+        self._build_provider_registry()
+
+    def _load_env_keys(self):
+        """Load API keys from environment variables"""
+        env_keys = {
+            'etherscan': [
+                os.getenv('ETHERSCAN_KEY_1', ''),
+                os.getenv('ETHERSCAN_KEY_2', '')
+            ],
+            'bscscan': [os.getenv('BSCSCAN_KEY', '')],
+            'tronscan': [os.getenv('TRONSCAN_KEY', '')],
+            'coinmarketcap': [
+                os.getenv('COINMARKETCAP_KEY_1', ''),
+                os.getenv('COINMARKETCAP_KEY_2', '')
+            ],
+            'newsapi': [os.getenv('NEWSAPI_KEY', '')],
+            'cryptocompare': [os.getenv('CRYPTOCOMPARE_KEY', '')],
+            'huggingface': [os.getenv('HUGGINGFACE_KEY', '')]
+        }
+
+        # Filter out empty keys
+        for provider, keys in env_keys.items():
+            self.api_keys[provider] = [k for k in keys if k]
+
+    def _load_from_json(self):
+        """Load configuration from JSON file"""
+        try:
+            if not self.config_file.exists():
+                logger.warning(f"Config file not found: {self.config_file}")
+                return
+
+            with open(self.config_file, 'r', encoding='utf-8') as f:
+                data = json.load(f)
+
+            # Load discovered keys
+            discovered_keys = data.get('discovered_keys', {})
+            for provider, keys in discovered_keys.items():
+                if isinstance(keys, list):
+                    # Merge with env keys, preferring env keys
+                    if provider not in self.api_keys or not self.api_keys[provider]:
+                        self.api_keys[provider] = keys
+                    else:
+                        # Add discovered keys that aren't in env
+                        for key in keys:
+                            if key not in self.api_keys[provider]:
+                                self.api_keys[provider].append(key)
+
+            logger.info(f"Loaded {len(self.api_keys)} provider keys from config")
+
+        except Exception as e:
+            logger.error(f"Error loading config file: {e}")
+
+    def _build_provider_registry(self):
+        """Build provider registry from configuration"""
+
+        # Market Data Providers
+        self.providers['CoinGecko'] = ProviderConfig(
+            name='CoinGecko',
+            category='market_data',
+            endpoint_url='https://api.coingecko.com/api/v3',
+            requires_key=False,
+            rate_limit_type='per_minute',
+            rate_limit_value=50,
+            timeout_ms=10000,
+            priority_tier=1,
+            health_check_endpoint='https://api.coingecko.com/api/v3/ping'
+        )
+
+        # CoinMarketCap
+        cmc_keys = self.api_keys.get('coinmarketcap', [])
+        self.providers['CoinMarketCap'] = ProviderConfig(
+            name='CoinMarketCap',
+            category='market_data',
+            endpoint_url='https://pro-api.coinmarketcap.com/v1',
+            requires_key=True,
+            api_key=cmc_keys[0] if cmc_keys else None,
+            rate_limit_type='per_hour',
+            rate_limit_value=100,
+            timeout_ms=10000,
+            priority_tier=2,
+            health_check_endpoint='https://pro-api.coinmarketcap.com/v1/cryptocurrency/map?limit=1'
+        )
+
+        # Blockchain Explorers
+        etherscan_keys = self.api_keys.get('etherscan', [])
+        self.providers['Etherscan'] = ProviderConfig(
+            name='Etherscan',
+            category='blockchain_explorers',
+            endpoint_url='https://api.etherscan.io/api',
+            requires_key=True,
+            api_key=etherscan_keys[0] if etherscan_keys else None,
+            rate_limit_type='per_second',
+            rate_limit_value=5,
+            timeout_ms=10000,
+            priority_tier=1,
+            health_check_endpoint='https://api.etherscan.io/api?module=stats&action=ethsupply'
+        )
+
+        bscscan_keys = self.api_keys.get('bscscan', [])
+        self.providers['BscScan'] = ProviderConfig(
+            name='BscScan',
+            category='blockchain_explorers',
+            endpoint_url='https://api.bscscan.com/api',
+            requires_key=True,
+            api_key=bscscan_keys[0] if bscscan_keys else None,
+            rate_limit_type='per_second',
+            rate_limit_value=5,
+            timeout_ms=10000,
+            priority_tier=1,
+            health_check_endpoint='https://api.bscscan.com/api?module=stats&action=bnbsupply'
+        )
+
+        tronscan_keys = self.api_keys.get('tronscan', [])
+        self.providers['TronScan'] = ProviderConfig(
+            name='TronScan',
+            category='blockchain_explorers',
+            endpoint_url='https://apilist.tronscanapi.com/api',
+            requires_key=True,
+            api_key=tronscan_keys[0] if tronscan_keys else None,
+            rate_limit_type='per_minute',
+            rate_limit_value=60,
+            timeout_ms=10000,
+            priority_tier=2,
+            health_check_endpoint='https://apilist.tronscanapi.com/api/system/status'
+        )
+
+        # News APIs
+        self.providers['CryptoPanic'] = ProviderConfig(
+            name='CryptoPanic',
+            category='news',
+            endpoint_url='https://cryptopanic.com/api/v1',
+            requires_key=False,
+            rate_limit_type='per_hour',
+            rate_limit_value=100,
+            timeout_ms=10000,
+            priority_tier=2,
+            health_check_endpoint='https://cryptopanic.com/api/v1/posts/?auth_token=free&public=true'
+        )
+
+        newsapi_keys = self.api_keys.get('newsapi', [])
+        self.providers['NewsAPI'] = ProviderConfig(
+            name='NewsAPI',
+            category='news',
+            endpoint_url='https://newsdata.io/api/1',
+            requires_key=True,
+            api_key=newsapi_keys[0] if newsapi_keys else None,
+            rate_limit_type='per_day',
+            rate_limit_value=200,
+            timeout_ms=10000,
+            priority_tier=3,
+            health_check_endpoint='https://newsdata.io/api/1/news?category=business'
+        )
+
+        # Sentiment APIs
+        self.providers['AlternativeMe'] = ProviderConfig(
+            name='AlternativeMe',
+            category='sentiment',
+            endpoint_url='https://api.alternative.me',
+            requires_key=False,
+            rate_limit_type='per_minute',
+            rate_limit_value=60,
+            timeout_ms=10000,
+            priority_tier=2,
+            health_check_endpoint='https://api.alternative.me/fng/'
+        )
+
+        # CryptoCompare
+        cryptocompare_keys = self.api_keys.get('cryptocompare', [])
+        self.providers['CryptoCompare'] = ProviderConfig(
+            name='CryptoCompare',
+            category='market_data',
+            endpoint_url='https://min-api.cryptocompare.com/data',
+            requires_key=True,
+            api_key=cryptocompare_keys[0] if cryptocompare_keys else None,
+            rate_limit_type='per_hour',
+            rate_limit_value=250,
+            timeout_ms=10000,
+            priority_tier=2,
+            health_check_endpoint='https://min-api.cryptocompare.com/data/price?fsym=BTC&tsyms=USD'
+        )
+
+        logger.info(f"Built provider registry with {len(self.providers)} providers")
+
+    def get_provider(self, name: str) -> Optional[ProviderConfig]:
+        """Get provider configuration by name"""
+        return self.providers.get(name)
+
+    def get_all_providers(self) -> List[ProviderConfig]:
+        """Get all provider configurations"""
+        return list(self.providers.values())
+
+    def get_providers_by_category(self, category: str) -> List[ProviderConfig]:
+        """Get providers by category"""
+        return [p for p in self.providers.values() if p.category == category]
+
+    def get_providers_by_tier(self, tier: int) -> List[ProviderConfig]:
+        """Get providers by priority tier"""
+        return [p for p in self.providers.values() if p.priority_tier == tier]
+
+    def get_api_key(self, provider: str, index: int = 0) -> Optional[str]:
+        """Get API key for provider"""
+        keys = self.api_keys.get(provider.lower(), [])
+        if keys and 0 <= index < len(keys):
+            return keys[index]
+        return None
+
+    def get_categories(self) -> List[str]:
+        """Get all unique categories"""
+        return list(set(p.category for p in self.providers.values()))
+
+    def stats(self) -> Dict[str, Any]:
+        """Get configuration statistics"""
+        return {
+            'total_providers': len(self.providers),
+            'categories': len(self.get_categories()),
+            'providers_with_keys': sum(1 for p in self.providers.values() if p.requires_key),
+            'tier1_count': len(self.get_providers_by_tier(1)),
+            'tier2_count': len(self.get_providers_by_tier(2)),
+            'tier3_count': len(self.get_providers_by_tier(3)),
+            'api_keys_loaded': len(self.api_keys),
+            'categories_list': self.get_categories()
+        }
+
+
+# Global config instance
+config = Config()

dashboard.html

@@ -492,90 +492,39 @@ Market is bullish today</textarea>
     <script>
         async function loadData() {
             try {
-                // Show loading state
-                const tbody = document.getElementById('providersTable');
-                if (tbody) {
-                    tbody.innerHTML = '<tr><td colspan="5" style="text-align: center; padding: 40px;"><div class="loading"></div><div style="margin-top: 10px; color: #6c757d;">در حال بارگذاری...</div></td></tr>';
-                }
-                if (document.getElementById('lastUpdate')) {
-                    document.getElementById('lastUpdate').textContent = 'در حال بارگذاری...';
-                }
-
                 // Load status
                 const statusRes = await fetch('/api/status');
-                if (!statusRes.ok) {
-                    throw new Error(`خطا در دریافت وضعیت: ${statusRes.status} ${statusRes.statusText}`);
-                }
                 const status = await statusRes.json();
                 
-                if (!status || typeof status.total_providers === 'undefined') {
-                    throw new Error('داده‌های وضعیت نامعتبر است');
-                }
-
-                if (document.getElementById('totalAPIs')) {
-                    document.getElementById('totalAPIs').textContent = status.total_providers || 0;
-                }
-                if (document.getElementById('onlineAPIs')) {
-                    document.getElementById('onlineAPIs').textContent = status.online || 0;
-                }
-                if (document.getElementById('offlineAPIs')) {
-                    document.getElementById('offlineAPIs').textContent = status.offline || 0;
-                }
-                if (document.getElementById('avgResponse')) {
-                    document.getElementById('avgResponse').textContent = (status.avg_response_time_ms || 0) + 'ms';
-                }
-                if (document.getElementById('lastUpdate')) {
-                    document.getElementById('lastUpdate').textContent = status.timestamp ? new Date(status.timestamp).toLocaleString('fa-IR') : 'نامشخص';
-                }
+                document.getElementById('totalAPIs').textContent = status.total_providers;
+                document.getElementById('onlineAPIs').textContent = status.online;
+                document.getElementById('offlineAPIs').textContent = status.offline;
+                document.getElementById('avgResponse').textContent = status.avg_response_time_ms + 'ms';
+                document.getElementById('lastUpdate').textContent = new Date(status.timestamp).toLocaleString();
                 
                 // Load providers
                 const providersRes = await fetch('/api/providers');
-                if (!providersRes.ok) {
-                    throw new Error(`خطا در دریافت لیست APIها: ${providersRes.status} ${providersRes.statusText}`);
-                }
                 const providers = await providersRes.json();
                 
-                if (!providers || !Array.isArray(providers)) {
-                    throw new Error('لیست APIها نامعتبر است');
-                }
-
-                if (tbody) {
-                    if (providers.length === 0) {
-                        tbody.innerHTML = '<tr><td colspan="5" style="text-align: center; padding: 40px; color: #6c757d;">هیچ APIای یافت نشد</td></tr>';
-                    } else {
-                        tbody.innerHTML = providers.map(p => {
-                            let responseClass = 'response-fast';
-                            const responseTime = p.response_time_ms || p.avg_response_time_ms || 0;
-                            if (responseTime > 3000) responseClass = 'response-slow';
-                            else if (responseTime > 1000) responseClass = 'response-medium';
-                            
-                            return `
-                            <tr>
-                                <td><strong style="font-size: 15px;">${p.name || 'نامشخص'}</strong></td>
-                                <td><span style="background: #f8f9fa; padding: 4px 10px; border-radius: 8px; font-size: 12px; font-weight: 600;">${p.category || 'نامشخص'}</span></td>
-                                <td><span class="status-badge status-${p.status || 'unknown'}">${(p.status || 'unknown').toUpperCase()}</span></td>
-                                <td><span class="response-time ${responseClass}">${responseTime}ms</span></td>
-                                <td style="color: #6c757d; font-size: 13px;">${p.last_fetch ? new Date(p.last_fetch).toLocaleTimeString('fa-IR') : 'نامشخص'}</td>
-                            </tr>
-                        `}).join('');
-                    }
-                }
+                const tbody = document.getElementById('providersTable');
+                tbody.innerHTML = providers.map(p => {
+                    let responseClass = 'response-fast';
+                    if (p.response_time_ms > 3000) responseClass = 'response-slow';
+                    else if (p.response_time_ms > 1000) responseClass = 'response-medium';
+                    
+                    return `
+                    <tr>
+                        <td><strong style="font-size: 15px;">${p.name}</strong></td>
+                        <td><span style="background: #f8f9fa; padding: 4px 10px; border-radius: 8px; font-size: 12px; font-weight: 600;">${p.category}</span></td>
+                        <td><span class="status-badge status-${p.status}">${p.status.toUpperCase()}</span></td>
+                        <td><span class="response-time ${responseClass}">${p.response_time_ms}ms</span></td>
+                        <td style="color: #6c757d; font-size: 13px;">${new Date(p.last_fetch).toLocaleTimeString()}</td>
+                    </tr>
+                `}).join('');
                 
             } catch (error) {
                 console.error('Error loading data:', error);
-                const tbody = document.getElementById('providersTable');
-                if (tbody) {
-                    tbody.innerHTML = `<tr><td colspan="5" style="text-align: center; padding: 40px; color: #ef4444;">
-                        <div style="font-size: 24px; margin-bottom: 10px;">❌</div>
-                        <div style="font-weight: 600; margin-bottom: 5px;">خطا در بارگذاری داده‌ها</div>
-                        <div style="font-size: 14px; color: #6c757d; margin-bottom: 15px;">${error.message || 'خطای نامشخص'}</div>
-                        <button onclick="loadData()" style="padding: 10px 20px; background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); border: none; border-radius: 12px; color: white; cursor: pointer; font-weight: 700; text-transform: uppercase; letter-spacing: 0.5px;">تلاش مجدد</button>
-                    </td></tr>`;
-                }
-                if (document.getElementById('lastUpdate')) {
-                    document.getElementById('lastUpdate').textContent = 'خطا در بارگذاری';
-                }
-                alert('❌ خطا در بارگذاری داده‌ها:\n' + (error.message || 'خطای نامشخص'));
+                alert('Error loading data: ' + error.message);
             }
         }
 

database.py

@@ -1,665 +1,480 @@
-#!/usr/bin/env python3
 """
-Database module for Crypto Data Aggregator
-Complete CRUD operations with the exact schema specified
+SQLite Database Module for Persistent Storage
+Stores health metrics, incidents, and historical data
 """
 
 import sqlite3
-import threading
 import json
+import logging
+from typing import List, Dict, Optional, Tuple
 from datetime import datetime, timedelta
-from typing import List, Dict, Optional, Any, Tuple
+from pathlib import Path
 from contextlib import contextmanager
-import logging
+from monitor import HealthCheckResult, HealthStatus
 
-import config
-
-# Setup logging
-logging.basicConfig(
-    level=getattr(logging, config.LOG_LEVEL),
-    format=config.LOG_FORMAT,
-    handlers=[
-        logging.FileHandler(config.LOG_FILE),
-        logging.StreamHandler()
-    ]
-)
 logger = logging.getLogger(__name__)
 
 
-class CryptoDatabase:
-    """
-    Database manager for cryptocurrency data with full CRUD operations
-    Thread-safe implementation using context managers
-    """
+class Database:
+    """SQLite database manager for metrics and history"""
 
-    def __init__(self, db_path: str = None):
-        """Initialize database with connection pooling"""
-        self.db_path = str(db_path or config.DATABASE_PATH)
-        self._local = threading.local()
+    def __init__(self, db_path: str = "data/health_metrics.db"):
+        """Initialize database connection"""
+        self.db_path = Path(db_path)
+        self.db_path.parent.mkdir(parents=True, exist_ok=True)
         self._init_database()
-        logger.info(f"Database initialized at {self.db_path}")
 
     @contextmanager
     def get_connection(self):
-        """Get thread-safe database connection"""
-        if not hasattr(self._local, 'conn'):
-            self._local.conn = sqlite3.connect(
-                self.db_path,
-                check_same_thread=False,
-                timeout=30.0
-            )
-            self._local.conn.row_factory = sqlite3.Row
-
+        """Context manager for database connections"""
+        conn = sqlite3.connect(self.db_path)
+        conn.row_factory = sqlite3.Row  # Enable column access by name
         try:
-            yield self._local.conn
+            yield conn
+            conn.commit()
         except Exception as e:
-            self._local.conn.rollback()
+            conn.rollback()
             logger.error(f"Database error: {e}")
             raise
+        finally:
+            conn.close()
 
     def _init_database(self):
-        """Initialize all database tables with exact schema"""
+        """Initialize database schema"""
         with self.get_connection() as conn:
             cursor = conn.cursor()
 
-            # ==================== PRICES TABLE ====================
+            # Status log table
             cursor.execute("""
-                CREATE TABLE IF NOT EXISTS prices (
+                CREATE TABLE IF NOT EXISTS status_log (
                     id INTEGER PRIMARY KEY AUTOINCREMENT,
-                    symbol TEXT NOT NULL,
-                    name TEXT,
-                    price_usd REAL NOT NULL,
-                    volume_24h REAL,
-                    market_cap REAL,
-                    percent_change_1h REAL,
-                    percent_change_24h REAL,
-                    percent_change_7d REAL,
-                    rank INTEGER,
-                    timestamp DATETIME DEFAULT CURRENT_TIMESTAMP
+                    provider_name TEXT NOT NULL,
+                    category TEXT NOT NULL,
+                    status TEXT NOT NULL,
+                    response_time REAL,
+                    status_code INTEGER,
+                    error_message TEXT,
+                    endpoint_tested TEXT,
+                    timestamp REAL NOT NULL,
+                    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
                 )
             """)
 
-            # ==================== NEWS TABLE ====================
+            # Response times table (aggregated)
             cursor.execute("""
-                CREATE TABLE IF NOT EXISTS news (
+                CREATE TABLE IF NOT EXISTS response_times (
                     id INTEGER PRIMARY KEY AUTOINCREMENT,
-                    title TEXT NOT NULL,
-                    summary TEXT,
-                    url TEXT UNIQUE,
-                    source TEXT,
-                    sentiment_score REAL,
-                    sentiment_label TEXT,
-                    related_coins TEXT,
-                    published_date DATETIME,
-                    timestamp DATETIME DEFAULT CURRENT_TIMESTAMP
+                    provider_name TEXT NOT NULL,
+                    avg_response_time REAL NOT NULL,
+                    min_response_time REAL NOT NULL,
+                    max_response_time REAL NOT NULL,
+                    sample_count INTEGER NOT NULL,
+                    period_start TIMESTAMP NOT NULL,
+                    period_end TIMESTAMP NOT NULL,
+                    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
                 )
             """)
 
-            # ==================== MARKET ANALYSIS TABLE ====================
+            # Incidents table
             cursor.execute("""
-                CREATE TABLE IF NOT EXISTS market_analysis (
+                CREATE TABLE IF NOT EXISTS incidents (
                     id INTEGER PRIMARY KEY AUTOINCREMENT,
-                    symbol TEXT NOT NULL,
-                    timeframe TEXT,
-                    trend TEXT,
-                    support_level REAL,
-                    resistance_level REAL,
-                    prediction TEXT,
-                    confidence REAL,
-                    timestamp DATETIME DEFAULT CURRENT_TIMESTAMP
+                    provider_name TEXT NOT NULL,
+                    category TEXT NOT NULL,
+                    incident_type TEXT NOT NULL,
+                    description TEXT,
+                    severity TEXT,
+                    start_time TIMESTAMP NOT NULL,
+                    end_time TIMESTAMP,
+                    duration_seconds INTEGER,
+                    resolved BOOLEAN DEFAULT 0,
+                    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
                 )
             """)
 
-            # ==================== USER QUERIES TABLE ====================
+            # Alerts table
             cursor.execute("""
-                CREATE TABLE IF NOT EXISTS user_queries (
+                CREATE TABLE IF NOT EXISTS alerts (
                     id INTEGER PRIMARY KEY AUTOINCREMENT,
-                    query TEXT,
-                    result_count INTEGER,
-                    timestamp DATETIME DEFAULT CURRENT_TIMESTAMP
+                    provider_name TEXT NOT NULL,
+                    alert_type TEXT NOT NULL,
+                    message TEXT,
+                    threshold_value REAL,
+                    actual_value REAL,
+                    triggered_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                    acknowledged BOOLEAN DEFAULT 0
                 )
             """)
 
-            # ==================== CREATE INDEXES ====================
-            cursor.execute("CREATE INDEX IF NOT EXISTS idx_prices_symbol ON prices(symbol)")
-            cursor.execute("CREATE INDEX IF NOT EXISTS idx_prices_timestamp ON prices(timestamp)")
-            cursor.execute("CREATE INDEX IF NOT EXISTS idx_prices_rank ON prices(rank)")
-            cursor.execute("CREATE INDEX IF NOT EXISTS idx_news_url ON news(url)")
-            cursor.execute("CREATE INDEX IF NOT EXISTS idx_news_published ON news(published_date)")
-            cursor.execute("CREATE INDEX IF NOT EXISTS idx_news_sentiment ON news(sentiment_label)")
-            cursor.execute("CREATE INDEX IF NOT EXISTS idx_analysis_symbol ON market_analysis(symbol)")
-            cursor.execute("CREATE INDEX IF NOT EXISTS idx_analysis_timestamp ON market_analysis(timestamp)")
-
-            conn.commit()
-            logger.info("Database tables and indexes created successfully")
-
-    # ==================== PRICES CRUD OPERATIONS ====================
-
-    def save_price(self, price_data: Dict[str, Any]) -> bool:
-        """
-        Save a single price record
-
-        Args:
-            price_data: Dictionary containing price information
-
-        Returns:
-            bool: True if successful, False otherwise
-        """
-        try:
-            with self.get_connection() as conn:
-                cursor = conn.cursor()
-                cursor.execute("""
-                    INSERT INTO prices
-                    (symbol, name, price_usd, volume_24h, market_cap,
-                     percent_change_1h, percent_change_24h, percent_change_7d, rank)
-                    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
-                """, (
-                    price_data.get('symbol'),
-                    price_data.get('name'),
-                    price_data.get('price_usd', 0.0),
-                    price_data.get('volume_24h'),
-                    price_data.get('market_cap'),
-                    price_data.get('percent_change_1h'),
-                    price_data.get('percent_change_24h'),
-                    price_data.get('percent_change_7d'),
-                    price_data.get('rank')
-                ))
-                conn.commit()
-                return True
-        except Exception as e:
-            logger.error(f"Error saving price: {e}")
-            return False
-
-    def save_prices_batch(self, prices: List[Dict[str, Any]]) -> int:
-        """
-        Save multiple price records in batch (minimum 100 records for efficiency)
+            # Configuration table
+            cursor.execute("""
+                CREATE TABLE IF NOT EXISTS configuration (
+                    key TEXT PRIMARY KEY,
+                    value TEXT NOT NULL,
+                    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+                )
+            """)
 
-        Args:
-            prices: List of price dictionaries
+            # Create indexes
+            cursor.execute("""
+                CREATE INDEX IF NOT EXISTS idx_status_log_provider
+                ON status_log(provider_name, timestamp)
+            """)
+            cursor.execute("""
+                CREATE INDEX IF NOT EXISTS idx_status_log_timestamp
+                ON status_log(timestamp)
+            """)
+            cursor.execute("""
+                CREATE INDEX IF NOT EXISTS idx_incidents_provider
+                ON incidents(provider_name, start_time)
+            """)
 
-        Returns:
-            int: Number of records saved
-        """
-        saved_count = 0
-        try:
-            with self.get_connection() as conn:
-                cursor = conn.cursor()
-                for price_data in prices:
-                    try:
-                        cursor.execute("""
-                            INSERT INTO prices
-                            (symbol, name, price_usd, volume_24h, market_cap,
-                             percent_change_1h, percent_change_24h, percent_change_7d, rank)
-                            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
-                        """, (
-                            price_data.get('symbol'),
-                            price_data.get('name'),
-                            price_data.get('price_usd', 0.0),
-                            price_data.get('volume_24h'),
-                            price_data.get('market_cap'),
-                            price_data.get('percent_change_1h'),
-                            price_data.get('percent_change_24h'),
-                            price_data.get('percent_change_7d'),
-                            price_data.get('rank')
-                        ))
-                        saved_count += 1
-                    except Exception as e:
-                        logger.warning(f"Error saving individual price: {e}")
-                        continue
-                conn.commit()
-                logger.info(f"Batch saved {saved_count} price records")
-        except Exception as e:
-            logger.error(f"Error in batch save: {e}")
-        return saved_count
+            logger.info("Database initialized successfully")
 
-    def get_latest_prices(self, limit: int = 100) -> List[Dict[str, Any]]:
-        """
-        Get latest prices for top cryptocurrencies
+    def save_health_check(self, result: HealthCheckResult):
+        """Save a single health check result"""
+        with self.get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute("""
+                INSERT INTO status_log
+                (provider_name, category, status, response_time, status_code,
+                 error_message, endpoint_tested, timestamp)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+            """, (
+                result.provider_name,
+                result.category,
+                result.status.value,
+                result.response_time,
+                result.status_code,
+                result.error_message,
+                result.endpoint_tested,
+                result.timestamp
+            ))
+
+    def save_health_checks(self, results: List[HealthCheckResult]):
+        """Save multiple health check results"""
+        with self.get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.executemany("""
+                INSERT INTO status_log
+                (provider_name, category, status, response_time, status_code,
+                 error_message, endpoint_tested, timestamp)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+            """, [
+                (r.provider_name, r.category, r.status.value, r.response_time,
+                 r.status_code, r.error_message, r.endpoint_tested, r.timestamp)
+                for r in results
+            ])
+        logger.info(f"Saved {len(results)} health check results")
+
+    def get_recent_status(
+        self,
+        provider_name: Optional[str] = None,
+        hours: int = 24,
+        limit: int = 1000
+    ) -> List[Dict]:
+        """Get recent status logs"""
+        with self.get_connection() as conn:
+            cursor = conn.cursor()
 
-        Args:
-            limit: Maximum number of records to return
+            cutoff_time = datetime.now() - timedelta(hours=hours)
 
-        Returns:
-            List of price dictionaries
-        """
-        try:
-            with self.get_connection() as conn:
-                cursor = conn.cursor()
-                cursor.execute("""
-                    SELECT DISTINCT ON (symbol) *
-                    FROM prices
-                    WHERE timestamp >= datetime('now', '-1 hour')
-                    ORDER BY symbol, timestamp DESC, rank ASC
-                    LIMIT ?
-                """, (limit,))
-
-                # SQLite doesn't support DISTINCT ON, use subquery instead
-                cursor.execute("""
-                    SELECT p1.*
-                    FROM prices p1
-                    INNER JOIN (
-                        SELECT symbol, MAX(timestamp) as max_ts
-                        FROM prices
-                        WHERE timestamp >= datetime('now', '-1 hour')
-                        GROUP BY symbol
-                    ) p2 ON p1.symbol = p2.symbol AND p1.timestamp = p2.max_ts
-                    ORDER BY p1.rank ASC, p1.market_cap DESC
+            if provider_name:
+                query = """
+                    SELECT * FROM status_log
+                    WHERE provider_name = ? AND created_at >= ?
+                    ORDER BY timestamp DESC
                     LIMIT ?
-                """, (limit,))
-
-                return [dict(row) for row in cursor.fetchall()]
-        except Exception as e:
-            logger.error(f"Error getting latest prices: {e}")
-            return []
-
-    def get_price_history(self, symbol: str, hours: int = 24) -> List[Dict[str, Any]]:
-        """
-        Get price history for a specific symbol
-
-        Args:
-            symbol: Cryptocurrency symbol
-            hours: Number of hours to look back
-
-        Returns:
-            List of price dictionaries
-        """
-        try:
-            with self.get_connection() as conn:
-                cursor = conn.cursor()
-                cursor.execute("""
-                    SELECT * FROM prices
-                    WHERE symbol = ?
-                    AND timestamp >= datetime('now', '-' || ? || ' hours')
-                    ORDER BY timestamp ASC
-                """, (symbol, hours))
-                return [dict(row) for row in cursor.fetchall()]
-        except Exception as e:
-            logger.error(f"Error getting price history: {e}")
-            return []
-
-    def get_top_gainers(self, limit: int = 10) -> List[Dict[str, Any]]:
-        """Get top gaining cryptocurrencies in last 24h"""
-        try:
-            with self.get_connection() as conn:
-                cursor = conn.cursor()
-                cursor.execute("""
-                    SELECT p1.*
-                    FROM prices p1
-                    INNER JOIN (
-                        SELECT symbol, MAX(timestamp) as max_ts
-                        FROM prices
-                        WHERE timestamp >= datetime('now', '-1 hour')
-                        GROUP BY symbol
-                    ) p2 ON p1.symbol = p2.symbol AND p1.timestamp = p2.max_ts
-                    WHERE p1.percent_change_24h IS NOT NULL
-                    ORDER BY p1.percent_change_24h DESC
+                """
+                cursor.execute(query, (provider_name, cutoff_time, limit))
+            else:
+                query = """
+                    SELECT * FROM status_log
+                    WHERE created_at >= ?
+                    ORDER BY timestamp DESC
                     LIMIT ?
-                """, (limit,))
-                return [dict(row) for row in cursor.fetchall()]
-        except Exception as e:
-            logger.error(f"Error getting top gainers: {e}")
-            return []
-
-    def delete_old_prices(self, days: int = 30) -> int:
-        """
-        Delete price records older than specified days
-
-        Args:
-            days: Number of days to keep
-
-        Returns:
-            Number of deleted records
-        """
-        try:
-            with self.get_connection() as conn:
-                cursor = conn.cursor()
-                cursor.execute("""
-                    DELETE FROM prices
-                    WHERE timestamp < datetime('now', '-' || ? || ' days')
-                """, (days,))
-                conn.commit()
-                deleted = cursor.rowcount
-                logger.info(f"Deleted {deleted} old price records")
-                return deleted
-        except Exception as e:
-            logger.error(f"Error deleting old prices: {e}")
-            return 0
+                """
+                cursor.execute(query, (cutoff_time, limit))
 
-    # ==================== NEWS CRUD OPERATIONS ====================
+            return [dict(row) for row in cursor.fetchall()]
 
-    def save_news(self, news_data: Dict[str, Any]) -> bool:
-        """
-        Save a single news record
-
-        Args:
-            news_data: Dictionary containing news information
-
-        Returns:
-            bool: True if successful, False otherwise
-        """
-        try:
-            with self.get_connection() as conn:
-                cursor = conn.cursor()
-                cursor.execute("""
-                    INSERT OR IGNORE INTO news
-                    (title, summary, url, source, sentiment_score,
-                     sentiment_label, related_coins, published_date)
-                    VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-                """, (
-                    news_data.get('title'),
-                    news_data.get('summary'),
-                    news_data.get('url'),
-                    news_data.get('source'),
-                    news_data.get('sentiment_score'),
-                    news_data.get('sentiment_label'),
-                    json.dumps(news_data.get('related_coins', [])),
-                    news_data.get('published_date')
-                ))
-                conn.commit()
-                return True
-        except Exception as e:
-            logger.error(f"Error saving news: {e}")
-            return False
-
-    def get_latest_news(self, limit: int = 50, sentiment: Optional[str] = None) -> List[Dict[str, Any]]:
-        """
-        Get latest news articles
-
-        Args:
-            limit: Maximum number of articles
-            sentiment: Filter by sentiment label (optional)
+    def get_uptime_percentage(
+        self,
+        provider_name: str,
+        hours: int = 24
+    ) -> float:
+        """Calculate uptime percentage from database"""
+        with self.get_connection() as conn:
+            cursor = conn.cursor()
 
-        Returns:
-            List of news dictionaries
-        """
-        try:
-            with self.get_connection() as conn:
-                cursor = conn.cursor()
-
-                if sentiment:
-                    cursor.execute("""
-                        SELECT * FROM news
-                        WHERE sentiment_label = ?
-                        ORDER BY published_date DESC, timestamp DESC
-                        LIMIT ?
-                    """, (sentiment, limit))
-                else:
-                    cursor.execute("""
-                        SELECT * FROM news
-                        ORDER BY published_date DESC, timestamp DESC
-                        LIMIT ?
-                    """, (limit,))
-
-                results = []
-                for row in cursor.fetchall():
-                    news_dict = dict(row)
-                    if news_dict.get('related_coins'):
-                        try:
-                            news_dict['related_coins'] = json.loads(news_dict['related_coins'])
-                        except:
-                            news_dict['related_coins'] = []
-                    results.append(news_dict)
-
-                return results
-        except Exception as e:
-            logger.error(f"Error getting latest news: {e}")
-            return []
+            cutoff_time = datetime.now() - timedelta(hours=hours)
 
-    def get_news_by_coin(self, coin: str, limit: int = 20) -> List[Dict[str, Any]]:
-        """Get news related to a specific coin"""
-        try:
-            with self.get_connection() as conn:
-                cursor = conn.cursor()
-                cursor.execute("""
-                    SELECT * FROM news
-                    WHERE related_coins LIKE ?
-                    ORDER BY published_date DESC
-                    LIMIT ?
-                """, (f'%{coin}%', limit))
-
-                results = []
-                for row in cursor.fetchall():
-                    news_dict = dict(row)
-                    if news_dict.get('related_coins'):
-                        try:
-                            news_dict['related_coins'] = json.loads(news_dict['related_coins'])
-                        except:
-                            news_dict['related_coins'] = []
-                    results.append(news_dict)
-
-                return results
-        except Exception as e:
-            logger.error(f"Error getting news by coin: {e}")
-            return []
+            cursor.execute("""
+                SELECT
+                    COUNT(*) as total,
+                    SUM(CASE WHEN status = 'online' THEN 1 ELSE 0 END) as online
+                FROM status_log
+                WHERE provider_name = ? AND created_at >= ?
+            """, (provider_name, cutoff_time))
+
+            row = cursor.fetchone()
+            if row['total'] > 0:
+                return round((row['online'] / row['total']) * 100, 2)
+            return 0.0
+
+    def get_avg_response_time(
+        self,
+        provider_name: str,
+        hours: int = 24
+    ) -> float:
+        """Get average response time from database"""
+        with self.get_connection() as conn:
+            cursor = conn.cursor()
 
-    def update_news_sentiment(self, news_id: int, sentiment_score: float, sentiment_label: str) -> bool:
-        """Update sentiment for a news article"""
-        try:
-            with self.get_connection() as conn:
-                cursor = conn.cursor()
-                cursor.execute("""
-                    UPDATE news
-                    SET sentiment_score = ?, sentiment_label = ?
-                    WHERE id = ?
-                """, (sentiment_score, sentiment_label, news_id))
-                conn.commit()
-                return True
-        except Exception as e:
-            logger.error(f"Error updating news sentiment: {e}")
-            return False
+            cutoff_time = datetime.now() - timedelta(hours=hours)
 
-    def delete_old_news(self, days: int = 30) -> int:
-        """Delete news older than specified days"""
-        try:
-            with self.get_connection() as conn:
-                cursor = conn.cursor()
-                cursor.execute("""
-                    DELETE FROM news
-                    WHERE timestamp < datetime('now', '-' || ? || ' days')
-                """, (days,))
-                conn.commit()
-                deleted = cursor.rowcount
-                logger.info(f"Deleted {deleted} old news records")
-                return deleted
-        except Exception as e:
-            logger.error(f"Error deleting old news: {e}")
-            return 0
+            cursor.execute("""
+                SELECT AVG(response_time) as avg_time
+                FROM status_log
+                WHERE provider_name = ?
+                  AND created_at >= ?
+                  AND response_time IS NOT NULL
+            """, (provider_name, cutoff_time))
+
+            row = cursor.fetchone()
+            return round(row['avg_time'], 2) if row['avg_time'] else 0.0
+
+    def create_incident(
+        self,
+        provider_name: str,
+        category: str,
+        incident_type: str,
+        description: str,
+        severity: str = "medium"
+    ) -> int:
+        """Create a new incident"""
+        with self.get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute("""
+                INSERT INTO incidents
+                (provider_name, category, incident_type, description, severity, start_time)
+                VALUES (?, ?, ?, ?, ?, ?)
+            """, (provider_name, category, incident_type, description, severity, datetime.now()))
+            return cursor.lastrowid
+
+    def resolve_incident(self, incident_id: int):
+        """Resolve an incident"""
+        with self.get_connection() as conn:
+            cursor = conn.cursor()
 
-    # ==================== MARKET ANALYSIS CRUD OPERATIONS ====================
+            # Get start time
+            cursor.execute("SELECT start_time FROM incidents WHERE id = ?", (incident_id,))
+            row = cursor.fetchone()
+            if not row:
+                return
 
-    def save_analysis(self, analysis_data: Dict[str, Any]) -> bool:
-        """Save market analysis"""
-        try:
-            with self.get_connection() as conn:
-                cursor = conn.cursor()
-                cursor.execute("""
-                    INSERT INTO market_analysis
-                    (symbol, timeframe, trend, support_level, resistance_level,
-                     prediction, confidence)
-                    VALUES (?, ?, ?, ?, ?, ?, ?)
-                """, (
-                    analysis_data.get('symbol'),
-                    analysis_data.get('timeframe'),
-                    analysis_data.get('trend'),
-                    analysis_data.get('support_level'),
-                    analysis_data.get('resistance_level'),
-                    analysis_data.get('prediction'),
-                    analysis_data.get('confidence')
-                ))
-                conn.commit()
-                return True
-        except Exception as e:
-            logger.error(f"Error saving analysis: {e}")
-            return False
+            start_time = datetime.fromisoformat(row['start_time'])
+            end_time = datetime.now()
+            duration = int((end_time - start_time).total_seconds())
 
-    def get_latest_analysis(self, symbol: str) -> Optional[Dict[str, Any]]:
-        """Get latest analysis for a symbol"""
-        try:
-            with self.get_connection() as conn:
-                cursor = conn.cursor()
-                cursor.execute("""
-                    SELECT * FROM market_analysis
-                    WHERE symbol = ?
-                    ORDER BY timestamp DESC
-                    LIMIT 1
-                """, (symbol,))
-                row = cursor.fetchone()
-                return dict(row) if row else None
-        except Exception as e:
-            logger.error(f"Error getting latest analysis: {e}")
-            return None
+            cursor.execute("""
+                UPDATE incidents
+                SET end_time = ?, duration_seconds = ?, resolved = 1
+                WHERE id = ?
+            """, (end_time, duration, incident_id))
 
-    def get_all_analyses(self, limit: int = 100) -> List[Dict[str, Any]]:
-        """Get all market analyses"""
-        try:
-            with self.get_connection() as conn:
-                cursor = conn.cursor()
-                cursor.execute("""
-                    SELECT * FROM market_analysis
-                    ORDER BY timestamp DESC
-                    LIMIT ?
-                """, (limit,))
-                return [dict(row) for row in cursor.fetchall()]
-        except Exception as e:
-            logger.error(f"Error getting all analyses: {e}")
-            return []
+    def get_active_incidents(self) -> List[Dict]:
+        """Get all active incidents"""
+        with self.get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute("""
+                SELECT * FROM incidents
+                WHERE resolved = 0
+                ORDER BY start_time DESC
+            """)
+            return [dict(row) for row in cursor.fetchall()]
 
-    # ==================== USER QUERIES CRUD OPERATIONS ====================
+    def get_incident_history(self, hours: int = 24, limit: int = 100) -> List[Dict]:
+        """Get incident history"""
+        with self.get_connection() as conn:
+            cursor = conn.cursor()
 
-    def log_user_query(self, query: str, result_count: int) -> bool:
-        """Log a user query"""
-        try:
-            with self.get_connection() as conn:
-                cursor = conn.cursor()
-                cursor.execute("""
-                    INSERT INTO user_queries (query, result_count)
-                    VALUES (?, ?)
-                """, (query, result_count))
-                conn.commit()
-                return True
-        except Exception as e:
-            logger.error(f"Error logging user query: {e}")
-            return False
+            cutoff_time = datetime.now() - timedelta(hours=hours)
 
-    def get_recent_queries(self, limit: int = 50) -> List[Dict[str, Any]]:
-        """Get recent user queries"""
-        try:
-            with self.get_connection() as conn:
-                cursor = conn.cursor()
-                cursor.execute("""
-                    SELECT * FROM user_queries
-                    ORDER BY timestamp DESC
-                    LIMIT ?
-                """, (limit,))
-                return [dict(row) for row in cursor.fetchall()]
-        except Exception as e:
-            logger.error(f"Error getting recent queries: {e}")
-            return []
+            cursor.execute("""
+                SELECT * FROM incidents
+                WHERE start_time >= ?
+                ORDER BY start_time DESC
+                LIMIT ?
+            """, (cutoff_time, limit))
+
+            return [dict(row) for row in cursor.fetchall()]
+
+    def create_alert(
+        self,
+        provider_name: str,
+        alert_type: str,
+        message: str,
+        threshold_value: Optional[float] = None,
+        actual_value: Optional[float] = None
+    ) -> int:
+        """Create a new alert"""
+        with self.get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute("""
+                INSERT INTO alerts
+                (provider_name, alert_type, message, threshold_value, actual_value)
+                VALUES (?, ?, ?, ?, ?)
+            """, (provider_name, alert_type, message, threshold_value, actual_value))
+            return cursor.lastrowid
+
+    def get_unacknowledged_alerts(self) -> List[Dict]:
+        """Get all unacknowledged alerts"""
+        with self.get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute("""
+                SELECT * FROM alerts
+                WHERE acknowledged = 0
+                ORDER BY triggered_at DESC
+            """)
+            return [dict(row) for row in cursor.fetchall()]
 
-    # ==================== UTILITY OPERATIONS ====================
+    def acknowledge_alert(self, alert_id: int):
+        """Acknowledge an alert"""
+        with self.get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute("""
+                UPDATE alerts
+                SET acknowledged = 1
+                WHERE id = ?
+            """, (alert_id,))
 
-    def execute_safe_query(self, query: str, params: Tuple = ()) -> List[Dict[str, Any]]:
-        """
-        Execute a safe read-only query
+    def aggregate_response_times(self, period_hours: int = 1):
+        """Aggregate response times for the period"""
+        with self.get_connection() as conn:
+            cursor = conn.cursor()
 
-        Args:
-            query: SQL query (must start with SELECT)
-            params: Query parameters
+            period_start = datetime.now() - timedelta(hours=period_hours)
 
-        Returns:
-            List of result dictionaries
-        """
-        try:
-            # Security: Only allow SELECT queries
-            if not query.strip().upper().startswith('SELECT'):
-                logger.warning(f"Attempted non-SELECT query: {query}")
-                return []
-
-            with self.get_connection() as conn:
-                cursor = conn.cursor()
-                cursor.execute(query, params)
-                return [dict(row) for row in cursor.fetchall()]
-        except Exception as e:
-            logger.error(f"Error executing safe query: {e}")
-            return []
+            cursor.execute("""
+                INSERT INTO response_times
+                (provider_name, avg_response_time, min_response_time, max_response_time,
+                 sample_count, period_start, period_end)
+                SELECT
+                    provider_name,
+                    AVG(response_time) as avg_time,
+                    MIN(response_time) as min_time,
+                    MAX(response_time) as max_time,
+                    COUNT(*) as count,
+                    ? as period_start,
+                    ? as period_end
+                FROM status_log
+                WHERE created_at >= ? AND response_time IS NOT NULL
+                GROUP BY provider_name
+            """, (period_start, datetime.now(), period_start))
+
+            logger.info(f"Aggregated response times for period: {period_start}")
+
+    def cleanup_old_data(self, days: int = 7):
+        """Clean up data older than specified days"""
+        with self.get_connection() as conn:
+            cursor = conn.cursor()
 
-    def get_database_stats(self) -> Dict[str, Any]:
-        """Get database statistics"""
-        try:
-            with self.get_connection() as conn:
-                cursor = conn.cursor()
+            cutoff_date = datetime.now() - timedelta(days=days)
 
-                stats = {}
+            # Delete old status logs
+            cursor.execute("""
+                DELETE FROM status_log
+                WHERE created_at < ?
+            """, (cutoff_date,))
+            deleted_logs = cursor.rowcount
 
-                # Count records in each table
-                for table in ['prices', 'news', 'market_analysis', 'user_queries']:
-                    cursor.execute(f"SELECT COUNT(*) as count FROM {table}")
-                    stats[f'{table}_count'] = cursor.fetchone()['count']
+            # Delete old resolved incidents
+            cursor.execute("""
+                DELETE FROM incidents
+                WHERE resolved = 1 AND end_time < ?
+            """, (cutoff_date,))
+            deleted_incidents = cursor.rowcount
 
-                # Get unique symbols
-                cursor.execute("SELECT COUNT(DISTINCT symbol) as count FROM prices")
-                stats['unique_symbols'] = cursor.fetchone()['count']
+            # Delete old acknowledged alerts
+            cursor.execute("""
+                DELETE FROM alerts
+                WHERE acknowledged = 1 AND triggered_at < ?
+            """, (cutoff_date,))
+            deleted_alerts = cursor.rowcount
+
+            logger.info(
+                f"Cleanup: {deleted_logs} logs, {deleted_incidents} incidents, "
+                f"{deleted_alerts} alerts older than {days} days"
+            )
 
-                # Get latest price update
-                cursor.execute("SELECT MAX(timestamp) as latest FROM prices")
-                stats['latest_price_update'] = cursor.fetchone()['latest']
+    def get_provider_stats(self, provider_name: str, hours: int = 24) -> Dict:
+        """Get comprehensive stats for a provider"""
+        with self.get_connection() as conn:
+            cursor = conn.cursor()
 
-                # Get latest news update
-                cursor.execute("SELECT MAX(timestamp) as latest FROM news")
-                stats['latest_news_update'] = cursor.fetchone()['latest']
+            cutoff_time = datetime.now() - timedelta(hours=hours)
 
-                # Database file size
-                import os
-                if os.path.exists(self.db_path):
-                    stats['database_size_bytes'] = os.path.getsize(self.db_path)
-                    stats['database_size_mb'] = stats['database_size_bytes'] / (1024 * 1024)
+            # Get status distribution
+            cursor.execute("""
+                SELECT
+                    status,
+                    COUNT(*) as count
+                FROM status_log
+                WHERE provider_name = ? AND created_at >= ?
+                GROUP BY status
+            """, (provider_name, cutoff_time))
 
-                return stats
-        except Exception as e:
-            logger.error(f"Error getting database stats: {e}")
-            return {}
+            status_dist = {row['status']: row['count'] for row in cursor.fetchall()}
 
-    def vacuum_database(self) -> bool:
-        """Vacuum database to reclaim space"""
-        try:
-            with self.get_connection() as conn:
-                conn.execute("VACUUM")
-                logger.info("Database vacuumed successfully")
-                return True
-        except Exception as e:
-            logger.error(f"Error vacuuming database: {e}")
-            return False
+            # Get response time stats
+            cursor.execute("""
+                SELECT
+                    AVG(response_time) as avg_time,
+                    MIN(response_time) as min_time,
+                    MAX(response_time) as max_time,
+                    COUNT(*) as total_checks
+                FROM status_log
+                WHERE provider_name = ?
+                  AND created_at >= ?
+                  AND response_time IS NOT NULL
+            """, (provider_name, cutoff_time))
+
+            row = cursor.fetchone()
+
+            return {
+                'provider_name': provider_name,
+                'period_hours': hours,
+                'status_distribution': status_dist,
+                'avg_response_time': round(row['avg_time'], 2) if row['avg_time'] else 0,
+                'min_response_time': round(row['min_time'], 2) if row['min_time'] else 0,
+                'max_response_time': round(row['max_time'], 2) if row['max_time'] else 0,
+                'total_checks': row['total_checks'] or 0,
+                'uptime_percentage': self.get_uptime_percentage(provider_name, hours)
+            }
+
+    def export_to_csv(self, output_path: str, hours: int = 24):
+        """Export recent data to CSV"""
+        import csv
 
-    def backup_database(self, backup_path: Optional[str] = None) -> bool:
-        """Create database backup"""
-        try:
-            import shutil
-            if backup_path is None:
-                timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-                backup_path = config.DATABASE_BACKUP_DIR / f"backup_{timestamp}.db"
-
-            shutil.copy2(self.db_path, backup_path)
-            logger.info(f"Database backed up to {backup_path}")
-            return True
-        except Exception as e:
-            logger.error(f"Error backing up database: {e}")
-            return False
+        with self.get_connection() as conn:
+            cursor = conn.cursor()
 
-    def close(self):
-        """Close database connection"""
-        if hasattr(self._local, 'conn'):
-            self._local.conn.close()
-            delattr(self._local, 'conn')
-            logger.info("Database connection closed")
+            cutoff_time = datetime.now() - timedelta(hours=hours)
 
+            cursor.execute("""
+                SELECT * FROM status_log
+                WHERE created_at >= ?
+                ORDER BY timestamp DESC
+            """, (cutoff_time,))
 
-# Singleton instance
-_db_instance = None
+            rows = cursor.fetchall()
 
+            if rows:
+                with open(output_path, 'w', newline='') as csvfile:
+                    writer = csv.DictWriter(csvfile, fieldnames=rows[0].keys())
+                    writer.writeheader()
+                    for row in rows:
+                        writer.writerow(dict(row))
 
-def get_database() -> CryptoDatabase:
-    """Get database singleton instance"""
-    global _db_instance
-    if _db_instance is None:
-        _db_instance = CryptoDatabase()
-    return _db_instance
+                logger.info(f"Exported {len(rows)} rows to {output_path}")

database/__init__.py

@@ -1,47 +1,8 @@
-"""Database package exports.
+"""Database module for crypto API monitoring"""
 
-This package exposes both the new SQLAlchemy-based ``DatabaseManager`` and the
-legacy SQLite-backed ``Database`` class that the existing application modules
-still import via ``from database import Database``. During the transition phase
-we dynamically load the legacy implementation from the root ``database.py``
-module (renamed here as ``legacy_database`` when importing) and fall back to the
-new manager if that module is unavailable.
-"""
+from database.db_manager import DatabaseManager
 
-from importlib import util as _importlib_util
-from pathlib import Path as _Path
-from typing import Optional as _Optional
+# For backward compatibility
+Database = DatabaseManager
 
-from .db_manager import DatabaseManager
-
-def _load_legacy_database() -> _Optional[type]:
-    """Load the legacy Database class from the root-level ``database.py`` if it exists."""
-    legacy_path = _Path(__file__).resolve().parent.parent / "database.py"
-    if not legacy_path.exists():
-        return None
-
-    spec = _importlib_util.spec_from_file_location("legacy_database", legacy_path)
-    if spec is None or spec.loader is None:
-        return None
-
-    module = _importlib_util.module_from_spec(spec)
-    try:
-        spec.loader.exec_module(module)
-    except Exception:
-        # If loading the legacy module fails we silently fall back to DatabaseManager
-        return None
-
-    return getattr(module, "Database", None)
-
-
-_LegacyDatabase = _load_legacy_database()
-
-if _LegacyDatabase is not None:
-    Database = _LegacyDatabase
-else:
-    Database = DatabaseManager
-
-__all__ = ["DatabaseManager", "Database", "CryptoDatabase"]
-
-# Backward-compatible alias for older imports
-CryptoDatabase = Database
+__all__ = ['DatabaseManager', 'Database']

docker-compose.yml

@@ -1,102 +1,92 @@
 version: '3.8'
 
 services:
-  # سرور اصلی Crypto Monitor
   crypto-monitor:
-    build: .
-    container_name: crypto-monitor-app
+    build:
+      context: .
+      dockerfile: Dockerfile
+    container_name: crypto-api-monitor
+    image: crypto-api-monitor:latest
+
+    # Port mapping (HuggingFace Spaces standard port)
     ports:
-      - "8000:8000"
+      - "7860:7860"
+
+    # Environment variables
     environment:
-      - HOST=0.0.0.0
-      - PORT=8000
-      - LOG_LEVEL=INFO
-      - ENABLE_AUTO_DISCOVERY=false
+      - PYTHONUNBUFFERED=1
+      - ENABLE_SENTIMENT=true
+      - HF_REGISTRY_REFRESH_SEC=21600
+      - HF_HTTP_TIMEOUT=8.0
+      # Add your HuggingFace token here or via .env file
+      # - HUGGINGFACE_TOKEN=your_token_here
+
+      # Sentiment models (optional customization)
+      - SENTIMENT_SOCIAL_MODEL=ElKulako/cryptobert
+      - SENTIMENT_NEWS_MODEL=kk08/CryptoBERT
+
+    # Optional: Load environment variables from .env file
+    env_file:
+      - .env
+
+    # Volume mounts for data persistence
     volumes:
-      - ./logs:/app/logs
+      # Persist SQLite database
       - ./data:/app/data
-    restart: unless-stopped
-    networks:
-      - crypto-network
+
+      # Persist logs
+      - ./logs:/app/logs
+
+      # Optional: Mount config for live updates during development
+      # - ./config.py:/app/config.py
+      # - ./all_apis_merged_2025.json:/app/all_apis_merged_2025.json
+
+      # Optional: Mount frontend files for live updates
+      # - ./index.html:/app/index.html
+      # - ./hf_console.html:/app/hf_console.html
+      # - ./config.js:/app/config.js
+
+    # Health check configuration
     healthcheck:
-      test: ["CMD", "python", "-c", "import requests; requests.get('http://localhost:8000/health')"]
+      test: ["CMD", "curl", "-f", "http://localhost:7860/health"]
       interval: 30s
       timeout: 10s
+      start_period: 40s
       retries: 3
-      start_period: 10s
 
-  # Redis برای Cache (اختیاری)
-  redis:
-    image: redis:7-alpine
-    container_name: crypto-monitor-redis
-    profiles: ["observability"]
-    ports:
-      - "6379:6379"
-    volumes:
-      - redis-data:/data
+    # Restart policy
     restart: unless-stopped
-    networks:
-      - crypto-network
-    command: redis-server --appendonly yes
 
-  # PostgreSQL برای ذخیره داده‌ها (اختیاری)
-  postgres:
-    image: postgres:15-alpine
-    container_name: crypto-monitor-db
-    profiles: ["observability"]
-    environment:
-      POSTGRES_DB: crypto_monitor
-      POSTGRES_USER: crypto_user
-      POSTGRES_PASSWORD: crypto_pass_change_me
-    ports:
-      - "5432:5432"
-    volumes:
-      - postgres-data:/var/lib/postgresql/data
-    restart: unless-stopped
-    networks:
-      - crypto-network
+    # Resource limits (adjust based on your system)
+    deploy:
+      resources:
+        limits:
+          cpus: '2.0'
+          memory: 4G
+        reservations:
+          cpus: '0.5'
+          memory: 1G
 
-  # Prometheus برای مانیتورینگ (اختیاری)
-  prometheus:
-    image: prom/prometheus:latest
-    container_name: crypto-monitor-prometheus
-    profiles: ["observability"]
-    ports:
-      - "9090:9090"
-    volumes:
-      - ./prometheus.yml:/etc/prometheus/prometheus.yml
-      - prometheus-data:/prometheus
-    command:
-      - '--config.file=/etc/prometheus/prometheus.yml'
-      - '--storage.tsdb.path=/prometheus'
-    restart: unless-stopped
+    # Network configuration
     networks:
       - crypto-network
 
-  # Grafana برای نمایش داده‌ها (اختیاری)
-  grafana:
-    image: grafana/grafana:latest
-    container_name: crypto-monitor-grafana
-    profiles: ["observability"]
-    ports:
-      - "3000:3000"
-    environment:
-      - GF_SECURITY_ADMIN_PASSWORD=admin_change_me
-      - GF_USERS_ALLOW_SIGN_UP=false
-    volumes:
-      - grafana-data:/var/lib/grafana
-    restart: unless-stopped
-    networks:
-      - crypto-network
-    depends_on:
-      - prometheus
+    # Logging configuration
+    logging:
+      driver: "json-file"
+      options:
+        max-size: "10m"
+        max-file: "3"
 
+# Network definition
 networks:
   crypto-network:
     driver: bridge
+    name: crypto-monitor-network
 
+# Volume definitions (optional - for named volumes instead of bind mounts)
 volumes:
-  redis-data:
-  postgres-data:
-  prometheus-data:
-  grafana-data:
+  crypto-data:
+    name: crypto-monitor-data
+  crypto-logs:
+    name: crypto-monitor-logs

index.html

@@ -1,1216 +1,896 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>Crypto API Monitor</title>
-    <link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&display=swap" rel="stylesheet">
-    <script src="https://cdn.jsdelivr.net/npm/chart.js@4.4.0/dist/chart.umd.min.js"></script>
-    <style>
-        * { box-sizing: border-box; }
-        :root {
-            --bg: #f5f6fb;
-            --card: #ffffff;
-            --muted: #6b7280;
-            --text: #1f2937;
-            --primary: #2563eb;
-            --success: #16a34a;
-            --danger: #dc2626;
-            --warning: #d97706;
-            --border: #e5e7eb;
-        }
-        body {
-            margin: 0;
-            font-family: 'Inter', sans-serif;
-            background: var(--bg);
-            color: var(--text);
-        }
-        .container {
-            max-width: 1400px;
-            margin: 0 auto;
-            padding: 20px;
-        }
-        .header {
-            background: var(--card);
-            padding: 18px 24px;
-            border-radius: 10px;
-            box-shadow: 0 1px 3px rgba(15,23,42,0.08);
-            display: flex;
-            justify-content: space-between;
-            align-items: center;
-            flex-wrap: wrap;
-            gap: 16px;
-        }
-        .logo h1 { margin: 0; font-size: 20px; color: var(--primary); }
-        .header-actions { display: flex; gap: 12px; align-items: center; }
-        .status-pill {
-            padding: 6px 12px;
-            border-radius: 999px;
-            font-size: 12px;
-            font-weight: 600;
-            background: #fee2e2;
-            color: var(--danger);
-        }
-        .btn {
-            padding: 10px 18px;
-            border-radius: 8px;
-            border: none;
-            font-weight: 600;
-            font-size: 13px;
-            cursor: pointer;
-            background: var(--primary);
-            color: #fff;
-            transition: all 0.2s ease;
-            display: inline-flex;
-            align-items: center;
-            gap: 6px;
-            box-shadow: 0 2px 4px rgba(37,99,235,0.2);
-        }
-        .btn:hover {
-            background: #1d4ed8;
-            transform: translateY(-1px);
-            box-shadow: 0 4px 8px rgba(37,99,235,0.3);
-        }
-        .btn:active {
-            transform: translateY(0);
-            box-shadow: 0 1px 2px rgba(37,99,235,0.2);
-        }
-        .btn.secondary {
-            background: var(--card);
-            border: 1px solid var(--border);
-            color: var(--text);
-            box-shadow: 0 1px 2px rgba(15,23,42,0.1);
-        }
-        .btn.secondary:hover {
-            background: #f9fafb;
-            border-color: var(--primary);
-            color: var(--primary);
-            box-shadow: 0 2px 4px rgba(37,99,235,0.15);
-        }
-        .kpi-grid {
-            display: grid;
-            grid-template-columns: repeat(auto-fit, minmax(180px, 1fr));
-            gap: 10px;
-            margin: 16px 0;
-        }
-        .kpi-card {
-            background: var(--card);
-            padding: 14px;
-            border-radius: 8px;
-            box-shadow: 0 1px 3px rgba(15,23,42,0.08);
-            border: 1px solid var(--border);
-            transition: all 0.2s ease;
-            display: flex;
-            flex-direction: column;
-            gap: 8px;
-        }
-        .kpi-card:hover {
-            box-shadow: 0 4px 12px rgba(37,99,235,0.15);
-            transform: translateY(-2px);
-            border-color: var(--primary);
-        }
-        .kpi-header {
-            display: flex;
-            align-items: center;
-            justify-content: space-between;
-            gap: 8px;
-        }
-        .kpi-icon {
-            width: 32px;
-            height: 32px;
-            padding: 6px;
-            border-radius: 6px;
-            display: flex;
-            align-items: center;
-            justify-content: center;
-            flex-shrink: 0;
-        }
-        .kpi-icon svg {
-            width: 20px;
-            height: 20px;
-            stroke-width: 2;
-        }
-        .kpi-icon.blue { background: #dbeafe; color: #2563eb; }
-        .kpi-icon.green { background: #dcfce7; color: #16a34a; }
-        .kpi-icon.orange { background: #fed7aa; color: #ea580c; }
-        .kpi-icon.purple { background: #e9d5ff; color: #9333ea; }
-        .kpi-label {
-            font-size: 11px;
-            color: var(--muted);
-            letter-spacing: 0.3px;
-            text-transform: uppercase;
-            font-weight: 600;
-            flex: 1;
-        }
-        .kpi-value {
-            font-size: 24px;
-            font-weight: 700;
-            color: var(--text);
-            line-height: 1.2;
-        }
-        .kpi-trend {
-            font-size: 11px;
-            color: var(--muted);
-            display: flex;
-            align-items: center;
-            gap: 4px;
-        }
-        .tabs {
-            background: var(--card);
-            border-radius: 10px;
-            padding: 8px;
-            display: flex;
-            gap: 6px;
-            overflow-x: auto;
-            box-shadow: 0 1px 3px rgba(15,23,42,0.08);
-        }
-        .tab {
-            border: none;
-            background: transparent;
-            padding: 8px 16px;
-            border-radius: 6px;
-            font-weight: 600;
-            color: var(--muted);
-            cursor: pointer;
-        }
-        .tab.active { background: var(--primary); color: #fff; }
-        .tab-content { margin-top: 16px; display: none; }
-        .tab-content.active { display: block; }
-        .card {
-            background: var(--card);
-            border-radius: 12px;
-            padding: 20px;
-            box-shadow: 0 1px 3px rgba(15,23,42,0.08);
-            border: 1px solid var(--border);
-            margin-bottom: 16px;
-            transition: all 0.2s ease;
-        }
-        .card:hover {
-            box-shadow: 0 4px 12px rgba(15,23,42,0.12);
-            border-color: rgba(37,99,235,0.2);
-        }
-        .card-header {
-            display: flex;
-            justify-content: space-between;
-            align-items: center;
-            margin-bottom: 16px;
-            padding-bottom: 12px;
-            border-bottom: 2px solid var(--border);
-        }
-        .card-title {
-            font-size: 16px;
-            font-weight: 700;
-            color: var(--text);
-            display: flex;
-            align-items: center;
-            gap: 8px;
-        }
-        .grid { display: grid; gap: 16px; }
-        .grid-2 { grid-template-columns: repeat(auto-fit, minmax(420px, 1fr)); }
-        .table-wrapper {
-            overflow-x: auto;
-            border-radius: 8px;
-            border: 1px solid var(--border);
-        }
-        table {
-            width: 100%;
-            border-collapse: separate;
-            border-spacing: 0;
-            font-size: 13px;
-        }
-        thead {
-            background: linear-gradient(135deg, #f9fafb 0%, #f3f4f6 100%);
-            position: sticky;
-            top: 0;
-            z-index: 10;
-        }
-        thead th {
-            padding: 14px 16px;
-            text-align: left;
-            font-weight: 700;
-            font-size: 11px;
-            text-transform: uppercase;
-            letter-spacing: 0.5px;
-            color: var(--muted);
-            border-bottom: 2px solid var(--border);
-            white-space: nowrap;
-        }
-        thead th:first-child { border-top-left-radius: 8px; }
-        thead th:last-child { border-top-right-radius: 8px; }
-        tbody tr {
-            transition: all 0.15s ease;
-            border-bottom: 1px solid #f3f4f6;
-        }
-        tbody tr:hover {
-            background: #f9fafb;
-            transform: scale(1.001);
-            box-shadow: 0 2px 8px rgba(37,99,235,0.08);
-        }
-        tbody tr:last-child td:first-child { border-bottom-left-radius: 8px; }
-        tbody tr:last-child td:last-child { border-bottom-right-radius: 8px; }
-        tbody td {
-            padding: 14px 16px;
-            color: var(--text);
-            vertical-align: middle;
-        }
-        tbody td strong {
-            font-weight: 600;
-            color: var(--text);
-        }
-        tbody td:first-child {
-            font-weight: 600;
-        }
-        .badge {
-            padding: 5px 12px;
-            border-radius: 6px;
-            font-size: 11px;
-            font-weight: 700;
-            display: inline-flex;
-            align-items: center;
-            gap: 5px;
-            text-transform: uppercase;
-            letter-spacing: 0.3px;
-            border: 1px solid transparent;
-            transition: all 0.2s ease;
-        }
-        .badge.success {
-            background: #dcfce7;
-            color: #15803d;
-            border-color: #86efac;
-        }
-        .badge.warn {
-            background: #fef3c7;
-            color: #d97706;
-            border-color: #fde047;
-        }
-        .badge.danger {
-            background: #fee2e2;
-            color: #b91c1c;
-            border-color: #fca5a5;
-        }
-        .badge.info {
-            background: #dbeafe;
-            color: #1e40af;
-            border-color: #93c5fd;
-        }
-        .list {
-            display: flex;
-            flex-direction: column;
-            gap: 10px;
-        }
-        .list-item {
-            padding: 12px;
-            border-radius: 8px;
-            border: 1px solid var(--border);
-            background: var(--card);
-            transition: all 0.15s ease;
-        }
-        .list-item:hover {
-            background: #f9fafb;
-            border-color: var(--primary);
-            transform: translateX(2px);
-            box-shadow: 0 2px 8px rgba(37,99,235,0.1);
-        }
-        .list-item:last-child {
-            margin-bottom: 0;
-        }
-        .resource-search { display: flex; gap: 12px; }
-        .resource-search input {
-            flex: 1;
-            padding: 10px 12px;
-            border-radius: 6px;
-            border: 1px solid var(--border);
-            font-size: 14px;
-        }
-        .resource-columns {
-            display: grid;
-            grid-template-columns: repeat(auto-fit, minmax(260px, 1fr));
-            gap: 12px;
-            margin-top: 16px;
-        }
-        .resource-item {
-            padding: 10px;
-            border: 1px solid var(--border);
-            border-radius: 6px;
-            margin-bottom: 8px;
-            font-size: 13px;
-        }
-        .form-grid {
-            display: grid;
-            grid-template-columns: repeat(auto-fit, minmax(180px, 1fr));
-            gap: 10px;
-        }
-        label { font-size: 12px; font-weight: 600; color: var(--muted); }
-        input, textarea, select {
-            width: 100%;
-            padding: 10px 14px;
-            border: 1px solid var(--border);
-            border-radius: 8px;
-            font-size: 14px;
-            font-family: inherit;
-            background: var(--card);
-            color: var(--text);
-            transition: all 0.2s ease;
-        }
-        input:focus, textarea:focus, select:focus {
-            outline: none;
-            border-color: var(--primary);
-            box-shadow: 0 0 0 3px rgba(37,99,235,0.1);
-        }
-        input:hover, textarea:hover, select:hover {
-            border-color: rgba(37,99,235,0.3);
-        }
-        textarea {
-            min-height: 120px;
-            resize: vertical;
-            font-family: 'Monaco', 'Courier New', monospace;
-            font-size: 13px;
-        }
-        .toast-container {
-            position: fixed;
-            bottom: 20px;
-            right: 20px;
-            display: flex;
-            flex-direction: column;
-            gap: 10px;
-        }
-        .toast {
-            background: #111827;
-            color: white;
-            padding: 12px 16px;
-            border-radius: 6px;
-            min-width: 240px;
-            box-shadow: 0 8px 20px rgba(15,23,42,0.25);
-        }
-        @media (max-width: 720px) {
-            .kpi-grid { grid-template-columns: repeat(auto-fit, minmax(160px, 1fr)); }
-            .grid-2 { grid-template-columns: 1fr; }
-            .resource-search { flex-direction: column; }
-        }
-    </style>
-</head>
-<body>
-<div class="toast-container" id="toastContainer"></div>
-<div class="container">
-    <div class="header">
-        <div class="logo">
-            <h1>🚀 Crypto API Monitor</h1>
-            <div style="font-size:12px; color:var(--muted);">Real API diagnostics + market intelligence</div>
-        </div>
-        <div class="header-actions">
-            <div class="status-pill" id="wsStatus">Connecting...</div>
-            <button class="btn secondary" onclick="refreshAll()">Refresh</button>
-            <button class="btn" onclick="loadErrorSummary()">Diagnostics</button>
-        </div>
-    </div>
-
-    <div class="kpi-grid">
-        <div class="kpi-card">
-            <div class="kpi-header">
-                <div class="kpi-label">Total APIs</div>
-                <div class="kpi-icon blue">
-                    <svg fill="none" stroke="currentColor" viewBox="0 0 24 24">
-                        <path stroke-linecap="round" stroke-linejoin="round" d="M9 12h6m-6 4h6m2 5H7a2 2 0 01-2-2V5a2 2 0 012-2h5.586a1 1 0 01.707.293l5.414 5.414a1 1 0 01.293.707V19a2 2 0 01-2 2z"/>
-                    </svg>
-                </div>
-            </div>
-            <div class="kpi-value" id="kpiTotalAPIs">--</div>
-            <div class="kpi-trend" id="kpiTotalTrend">Loading…</div>
-        </div>
-        <div class="kpi-card">
-            <div class="kpi-header">
-                <div class="kpi-label">Online</div>
-                <div class="kpi-icon green">
-                    <svg fill="none" stroke="currentColor" viewBox="0 0 24 24">
-                        <path stroke-linecap="round" stroke-linejoin="round" d="M9 12l2 2 4-4m6 2a9 9 0 11-18 0 9 9 0 0118 0z"/>
-                    </svg>
-                </div>
-            </div>
-            <div class="kpi-value" id="kpiOnline">--</div>
-            <div class="kpi-trend" id="kpiOnlineTrend">Loading…</div>
-        </div>
-        <div class="kpi-card">
-            <div class="kpi-header">
-                <div class="kpi-label">Avg Response</div>
-                <div class="kpi-icon orange">
-                    <svg fill="none" stroke="currentColor" viewBox="0 0 24 24">
-                        <path stroke-linecap="round" stroke-linejoin="round" d="M13 10V3L4 14h7v7l9-11h-7z"/>
-                    </svg>
-                </div>
-            </div>
-            <div class="kpi-value" id="kpiAvgResponse">--</div>
-            <div class="kpi-trend" id="kpiResponseTrend">Loading…</div>
-        </div>
-        <div class="kpi-card">
-            <div class="kpi-header">
-                <div class="kpi-label">Last Update</div>
-                <div class="kpi-icon purple">
-                    <svg fill="none" stroke="currentColor" viewBox="0 0 24 24">
-                        <path stroke-linecap="round" stroke-linejoin="round" d="M12 8v4l3 3m6-3a9 9 0 11-18 0 9 9 0 0118 0z"/>
-                    </svg>
-                </div>
-            </div>
-            <div class="kpi-value" id="kpiLastUpdate" style="font-size:16px;">--</div>
-            <div class="kpi-trend">Auto-refresh</div>
-        </div>
-    </div>
-
-    <div class="tabs" id="tabBar">
-        <button class="tab active" data-tab="dashboard" onclick="switchTab(event, 'dashboard')">Dashboard</button>
-        <button class="tab" data-tab="providers" onclick="switchTab(event, 'providers')">Providers</button>
-        <button class="tab" data-tab="market" onclick="switchTab(event, 'market')">Market</button>
-        <button class="tab" data-tab="sentiment" onclick="switchTab(event, 'sentiment')">Sentiment</button>
-        <button class="tab" data-tab="news" onclick="switchTab(event, 'news')">News</button>
-        <button class="tab" data-tab="resources" onclick="switchTab(event, 'resources')">Resources & Tools</button>
-    </div>
-
-    <div class="tab-content active" id="tab-dashboard">
-        <div class="grid grid-2">
-            <div class="card">
-                <div class="card-header">
-                    <h3 class="card-title">Provider Overview</h3>
-                    <button class="btn secondary" onclick="loadProviders()">Reload</button>
-                </div>
-                <div class="table-wrapper" style="overflow:auto;">
-                    <table>
-                        <thead>
-                        <tr><th>Provider</th><th>Status</th><th>Response</th><th>Uptime</th></tr>
-                        </thead>
-                        <tbody id="providersTableBody">
-                        <tr><td colspan="4" style="text-align:center; padding:40px; color:var(--muted);">Loading providers…</td></tr>
-                        </tbody>
-                    </table>
-                </div>
-            </div>
-            <div class="card">
-                <div class="card-header">
-                    <h3 class="card-title">Error Monitor</h3>
-                    <button class="btn secondary" onclick="loadErrorSummary()">Refresh</button>
-                </div>
-                <div id="errorSummaryCard" style="font-size:13px; color:var(--muted);">Gathering diagnostics…</div>
-                <div id="diagnosticsList" class="list" style="margin-top:12px;"></div>
-            </div>
-        </div>
-        <div class="grid grid-2">
-            <div class="card">
-                <div class="card-header"><h3 class="card-title">Health Trend</h3></div>
-                <div style="height:260px;"><canvas id="healthChart"></canvas></div>
-            </div>
-            <div class="card">
-                <div class="card-header"><h3 class="card-title">Status Distribution</h3></div>
-                <div style="height:260px;"><canvas id="statusChart"></canvas></div>
-            </div>
-        </div>
-    </div>
-
-    <div class="tab-content" id="tab-providers">
-        <div class="card">
-            <div class="card-header">
-                <h3 class="card-title">Providers Detail</h3>
-                <button class="btn secondary" onclick="loadProviders()">Reload</button>
-            </div>
-            <div id="providersDetail"></div>
-        </div>
-    </div>
-
-    <div class="tab-content" id="tab-market">
-        <div class="grid grid-2">
-            <div class="card">
-                <div class="card-header"><h3 class="card-title">Global Stats</h3></div>
-                <div id="marketGlobalStats" class="list"></div>
-            </div>
-            <div class="card">
-                <div class="card-header"><h3 class="card-title">Top Movers</h3></div>
-                <div style="height:260px;"><canvas id="marketChart"></canvas></div>
-            </div>
-        </div>
-        <div class="grid grid-2">
-            <div class="card">
-                <div class="card-header"><h3 class="card-title">Top Assets</h3></div>
-                <div class="table-wrapper" style="overflow:auto; max-height:320px;">
-                    <table>
-                        <thead><tr><th>Rank</th><th>Name</th><th>Price</th><th>24h</th><th>Market Cap</th></tr></thead>
-                        <tbody id="marketTableBody"></tbody>
-                    </table>
-                </div>
-            </div>
-            <div class="card">
-                <div class="card-header"><h3 class="card-title">Trending Now</h3></div>
-                <div id="trendingList" class="list"></div>
-            </div>
-        </div>
-    </div>
-
-    <div class="tab-content" id="tab-sentiment">
-        <div class="grid grid-2">
-            <div class="card">
-                <div class="card-header"><h3 class="card-title">Fear & Greed Index</h3></div>
-                <div id="sentimentCard" style="font-size:14px; color:var(--muted);">Loading sentiment…</div>
-            </div>
-            <div class="card">
-                <div class="card-header"><h3 class="card-title">DeFi TVL</h3></div>
-                <div class="table-wrapper" style="overflow:auto; max-height:280px;">
-                    <table>
-                        <thead><tr><th>Protocol</th><th>TVL</th><th>24h</th><th>Chain</th></tr></thead>
-                        <tbody id="defiTableBody"></tbody>
-                    </table>
-                </div>
-            </div>
-        </div>
-    </div>
-
-    <div class="tab-content" id="tab-news">
-        <div class="card">
-            <div class="card-header">
-                <h3 class="card-title">Latest Headlines</h3>
-                <button class="btn secondary" onclick="loadNews()">Reload</button>
-            </div>
-            <div id="newsList" class="list"></div>
-        </div>
-    </div>
-
-    <div class="tab-content" id="tab-resources">
-        <div class="card">
-            <div class="card-header">
-                <h3 class="card-title">Resource Search</h3>
-                <span style="font-size:12px;color:var(--muted);">Live search across providers + HuggingFace registry</span>
-            </div>
-            <div class="resource-search">
-                <input type="text" id="resourceSearch" placeholder="Search provider, model or dataset..." />
-                <select id="resourceFilter" onchange="loadResourceSearch()">
-                    <option value="all">All sources</option>
-                    <option value="providers">Providers</option>
-                    <option value="models">Models</option>
-                    <option value="datasets">Datasets</option>
-                </select>
-            </div>
-            <div class="resource-columns">
-                <div>
-                    <h4>Providers <span id="resourceCountProviders" style="color:var(--muted);"></span></h4>
-                    <div id="resourceResultsProviders"></div>
-                </div>
-                <div>
-                    <h4>Models <span id="resourceCountModels" style="color:var(--muted);"></span></h4>
-                    <div id="resourceResultsModels"></div>
-                </div>
-                <div>
-                    <h4>Datasets <span id="resourceCountDatasets" style="color:var(--muted);"></span></h4>
-                    <div id="resourceResultsDatasets"></div>
-                </div>
-            </div>
-        </div>
-        <div class="grid grid-2">
-            <div class="card">
-                <div class="card-header"><h3 class="card-title">Export & Backup</h3></div>
-                <div style="display:flex; gap:10px; flex-wrap:wrap;">
-                    <button class="btn" onclick="handleExport('json')">Export JSON Snapshot</button>
-                    <button class="btn" onclick="handleExport('csv')">Export CSV</button>
-                    <button class="btn secondary" onclick="handleBackup()">Create Backup</button>
-                </div>
-                <div id="exportHistory" class="list" style="margin-top:12px;"></div>
-            </div>
-            <div class="card">
-                <div class="card-header"><h3 class="card-title">Import Provider</h3></div>
-                <form id="importForm" onsubmit="handleImportSingle(event)">
-                    <div class="form-grid">
-                        <div><label>Name</label><input name="name" required></div>
-                        <div><label>Category</label><input name="category" required></div>
-                        <div><label>Endpoint URL</label><input name="endpoint_url" required></div>
-                        <div><label>Health Endpoint</label><input name="health_check_endpoint"></div>
-                        <div><label>Rate Limit</label><input name="rate_limit"></div>
-                        <div><label>Timeout (ms)</label><input name="timeout_ms" type="number" value="10000"></div>
-                    </div>
-                    <label style="margin-top:12px; display:block;">Notes<textarea name="notes"></textarea></label>
-                    <div style="margin-top:12px; display:flex; gap:10px; align-items:center;">
-                        <label style="display:flex; gap:6px; align-items:center; font-size:13px;">
-                            <input type="checkbox" name="requires_key"> Requires API Key
-                        </label>
-                        <input name="api_key" placeholder="API Key (optional)" style="flex:1;">
-                    </div>
-                    <button class="btn" style="margin-top:12px;" type="submit">Import Provider</button>
-                </form>
-                <hr style="margin:20px 0; border:none; border-top:1px solid var(--border);">
-                <label style="display:block; font-size:13px; color:var(--muted); margin-bottom:6px;">Bulk JSON Import</label>
-                <textarea id="bulkImportTextarea" placeholder='[{"name":"Sample API","category":"market","endpoint_url":"https://..."}]'></textarea>
-                <button class="btn secondary" style="margin-top:10px;" onclick="handleImportBulk()">Run Bulk Import</button>
-            </div>
-        </div>
-    </div>
-</div>
-
-<script>
-const config = {
-    apiBaseUrl: '',
-    wsUrl: (() => {
-        const protocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
-        return `${protocol}//${window.location.host}/ws`;
-    })(),
-    autoRefreshInterval: 30000
-};
-
-const state = {
-    ws: null,
-    wsConnected: false,
-    providers: [],
-    market: { cryptocurrencies: [], global: {} },
-    trending: [],
-    sentiment: null,
-    defi: [],
-    news: [],
-    errorSummary: null,
-    diagnostics: null,
-    resources: { providers: [], models: [], datasets: [] },
-    exports: [],
-    charts: { health: null, status: null, market: null },
-    currentTab: 'dashboard',
-    resourceSearchTimeout: null,
-    lastUpdate: null
-};
-
-function showToast(message, type = 'info') {
-    const container = document.getElementById('toastContainer');
-    const toast = document.createElement('div');
-    toast.className = 'toast';
-    toast.style.background = type === 'error' ? '#b91c1c' : (type === 'success' ? '#065f46' : '#111827');
-    toast.textContent = message;
-    container.appendChild(toast);
-    setTimeout(() => toast.remove(), 3000);
-}
-
-async function apiCall(endpoint, options = {}) {
-    const response = await fetch(config.apiBaseUrl + endpoint, options);
-    if (!response.ok) throw new Error(`HTTP ${response.status}`);
-    return await response.json();
-}
-
-function initializeWebSocket() {
-    try {
-        state.ws = new WebSocket(config.wsUrl);
-        state.ws.onopen = () => {
-            state.wsConnected = true;
-            const pill = document.getElementById('wsStatus');
-            pill.textContent = 'Connected';
-            pill.style.background = '#dcfce7';
-            pill.style.color = '#15803d';
-        };
-        state.ws.onclose = () => {
-            state.wsConnected = false;
-            const pill = document.getElementById('wsStatus');
-            pill.textContent = 'Disconnected';
-            pill.style.background = '#fee2e2';
-            pill.style.color = '#b91c1c';
-        };
-        state.ws.onmessage = (event) => {
-            const data = JSON.parse(event.data);
-            if (data.type === 'status_update' && data.data?.providers) {
-                updateKPIs(data.data.providers);
-            }
-            if (data.type === 'market_update' && Array.isArray(data.data)) {
-                state.market.cryptocurrencies = data.data;
-                renderMarketTable();
-                updateMarketChart();
-            }
-            if (data.type === 'sentiment_update') {
-                state.sentiment = data.data;
-                renderSentiment();
-            }
-        };
-    } catch (err) {
-        console.error('WebSocket error', err);
-    }
-}
-
-async function loadInitialData() {
-    try {
-        await Promise.all([
-            loadProviders(),
-            loadMarket(),
-            loadTrending(),
-            loadSentimentData(),
-            loadDefi(),
-            loadErrorSummary(),
-            loadNews(),
-            loadResourceSearch()
-        ]);
-        initializeCharts();
-        state.lastUpdate = new Date();
-        updateLastUpdateDisplay();
-        showToast('Dashboard ready', 'success');
-    } catch (err) {
-        console.error(err);
-        showToast('Failed to load initial data', 'error');
-    }
-}
-
-async function loadProviders() {
-    try {
-        const data = await apiCall('/api/providers');
-        state.providers = Array.isArray(data) ? data : [];
-        renderProvidersTable();
-        renderProvidersDetail();
-        updateStatusChart();
-        updateKPIs(state.providers);
-    } catch (err) {
-        console.error(err);
-        document.getElementById('providersTableBody').innerHTML = `<tr><td colspan="4" style="padding:40px; text-align:center;">${err.message}</td></tr>`;
-    }
-}
-
-function renderProvidersTable() {
-    const tbody = document.getElementById('providersTableBody');
-    if (!state.providers.length) {
-        tbody.innerHTML = '<tr><td colspan="4" style="text-align:center; padding:40px; color:var(--muted);">No providers available</td></tr>';
-        return;
-    }
-    tbody.innerHTML = state.providers.slice(0, 8).map(p => `
-        <tr>
-            <td>
-                <div style="font-weight:600;">${p.name || 'Unknown'}</div>
-                <div style="font-size:11px;color:var(--muted);">${p.category || 'general'}</div>
-            </td>
-            <td>${renderStatusBadge(p.status)}</td>
-            <td>${p.response_time_ms ? `${p.response_time_ms}ms` : '--'}</td>
-            <td>${p.uptime ? `${Math.round(p.uptime)}%` : '--'}</td>
-        </tr>
-    `).join('');
-}
-
-function renderProvidersDetail() {
-    const container = document.getElementById('providersDetail');
-    if (!state.providers.length) {
-        container.innerHTML = '<div style="padding:40px; text-align:center; color:var(--muted);">No providers data available</div>';
-        return;
-    }
-    container.innerHTML = `
-        <div class="table-wrapper">
-            <table>
-                <thead>
-                    <tr>
-                        <th>Name</th>
-                        <th>Status</th>
-                        <th>Response Time</th>
-                        <th>Success Rate</th>
-                        <th>Rate Limit</th>
-                    </tr>
-                </thead>
-                <tbody>
-                    ${state.providers.map(p => `
-                        <tr>
-                            <td>
-                                <strong>${p.name || 'Unknown'}</strong>
-                                <div style="font-size:11px;color:var(--muted);margin-top:2px;">${p.category || 'general'}</div>
-                            </td>
-                            <td>${renderStatusBadge(p.status)}</td>
-                            <td><strong>${p.avg_response_time_ms ? `${p.avg_response_time_ms}ms` : (p.response_time_ms ? `${p.response_time_ms}ms` : '--')}</strong></td>
-                            <td><strong>${p.uptime ? `${Math.round(p.uptime)}%` : '--'}</strong></td>
-                            <td style="font-size:12px;color:var(--muted);">${p.rate_limit || '—'}</td>
-                        </tr>`).join('')}
-                </tbody>
-            </table>
-        </div>`;
-}
-
-function renderStatusBadge(status = 'unknown') {
-    const normalized = (status || '').toLowerCase();
-    let cls = 'badge warn';
-    if (['online', 'healthy'].includes(normalized)) cls = 'badge success';
-    if (['offline', 'error'].includes(normalized)) cls = 'badge danger';
-    return `<span class="${cls}">${status || 'unknown'}</span>`;
-}
-
-function updateKPIs(data) {
-    const providers = Array.isArray(data) ? data : (data?.providers || []);
-    const total = providers.length;
-    const online = providers.filter(p => ['online', 'healthy'].includes((p.status || '').toLowerCase())).length;
-    const responseTimes = providers.map(p => p.response_time_ms || p.avg_response_time_ms).filter(Boolean);
-    const avgResponse = responseTimes.length ? Math.round(responseTimes.reduce((a, b) => a + b, 0) / responseTimes.length) : 0;
-
-    document.getElementById('kpiTotalAPIs').textContent = total;
-    document.getElementById('kpiTotalTrend').textContent = `${total} tracked providers`;
-    document.getElementById('kpiOnline').textContent = online;
-    document.getElementById('kpiOnlineTrend').textContent = total ? `${Math.round((online / total) * 100)}% uptime` : 'No data';
-    document.getElementById('kpiAvgResponse').textContent = avgResponse ? `${avgResponse}ms` : '--';
-    document.getElementById('kpiResponseTrend').textContent = avgResponse < 500 ? 'Optimal' : avgResponse < 1000 ? 'Acceptable' : 'Slow';
-    updateHealthChart(avgResponse);
-}
-
-function updateLastUpdateDisplay() {
-    if (!state.lastUpdate) return;
-    document.getElementById('kpiLastUpdate').textContent = state.lastUpdate.toLocaleTimeString();
-}
-
-function initializeCharts() {
-    const healthCtx = document.getElementById('healthChart').getContext('2d');
-    const statusCtx = document.getElementById('statusChart').getContext('2d');
-    const marketCtx = document.getElementById('marketChart').getContext('2d');
-
-    if (state.charts.health) state.charts.health.destroy();
-    if (state.charts.status) state.charts.status.destroy();
-    if (state.charts.market) state.charts.market.destroy();
-
-    state.charts.health = new Chart(healthCtx, {
-        type: 'line',
-        data: { labels: [], datasets: [{ label: 'Avg Response (ms)', data: [], borderColor: '#2563eb', fill: false }] },
-        options: { responsive: true, maintainAspectRatio: false }
-    });
-
-    state.charts.status = new Chart(statusCtx, {
-        type: 'doughnut',
-        data: { labels: ['Online', 'Degraded', 'Offline'], datasets: [{ data: [0, 0, 0], backgroundColor: ['#16a34a', '#fcd34d', '#f87171'] }] },
-        options: { responsive: true, maintainAspectRatio: false }
-    });
-
-    state.charts.market = new Chart(marketCtx, {
-        type: 'bar',
-        data: { labels: [], datasets: [{ label: 'Market Cap (B USD)', data: [], backgroundColor: '#93c5fd' }] },
-        options: { responsive: true, maintainAspectRatio: false, scales: { y: { beginAtZero: true } } }
-    });
-}
-
-function updateHealthChart(value) {
-    if (!state.charts.health || !value) return;
-    const chart = state.charts.health;
-    chart.data.labels.push(new Date().toLocaleTimeString());
-    chart.data.datasets[0].data.push(value);
-    if (chart.data.labels.length > 12) {
-        chart.data.labels.shift();
-        chart.data.datasets[0].data.shift();
-    }
-    chart.update();
-}
-
-function updateStatusChart() {
-    if (!state.charts.status) return;
-    const online = state.providers.filter(p => (p.status || '').toLowerCase() === 'online').length;
-    const degraded = state.providers.filter(p => (p.status || '').toLowerCase() === 'degraded').length;
-    const offline = state.providers.length - online - degraded;
-    state.charts.status.data.datasets[0].data = [online, degraded, offline];
-    state.charts.status.update();
-}
-
-async function loadMarket() {
-    const data = await apiCall('/api/market');
-    state.market = data;
-    renderMarketCards();
-    renderMarketTable();
-    updateMarketChart();
-}
-
-function renderMarketCards() {
-    const stats = state.market.global || {};
-    const container = document.getElementById('marketGlobalStats');
-    container.innerHTML = `
-        <div><strong>Total Market Cap:</strong> $${formatNumber(stats.total_market_cap)}</div>
-        <div><strong>Total Volume:</strong> $${formatNumber(stats.total_volume)}</div>
-        <div><strong>BTC Dominance:</strong> ${stats.btc_dominance ? stats.btc_dominance.toFixed(2) + '%' : '--'}</div>
-        <div><strong>ETH Dominance:</strong> ${stats.eth_dominance ? stats.eth_dominance.toFixed(2) + '%' : '--'}</div>
-        <div><strong>Active Cryptos:</strong> ${stats.active_cryptocurrencies || '--'}</div>
-        <div><strong>Markets:</strong> ${stats.markets || '--'}</div>
-    `;
-}
-
-function renderMarketTable() {
-    const tbody = document.getElementById('marketTableBody');
-    const coins = state.market.cryptocurrencies || [];
-    if (!coins.length) {
-        tbody.innerHTML = '<tr><td colspan="5" style="text-align:center; padding:40px; color:var(--muted);">Market data unavailable</td></tr>';
-        return;
-    }
-    tbody.innerHTML = coins.slice(0, 12).map(coin => `
-        <tr>
-            <td>${coin.rank || coin.market_cap_rank || '-'}</td>
-            <td>${coin.name} <span style="color:var(--muted);">${coin.symbol}</span></td>
-            <td>$${formatNumber(coin.price)}</td>
-            <td style="color:${coin.change_24h >= 0 ? '#16a34a' : '#dc2626'};">${coin.change_24h ? coin.change_24h.toFixed(2) : '0'}%</td>
-            <td>$${formatNumber(coin.market_cap)}</td>
-        </tr>
-    `).join('');
-}
-
-function updateMarketChart() {
-    if (!state.charts.market) return;
-    const coins = state.market.cryptocurrencies || [];
-    const top = coins.slice(0, 5);
-    state.charts.market.data.labels = top.map(c => c.name);
-    state.charts.market.data.datasets[0].data = top.map(c => c.market_cap ? (c.market_cap / 1e9).toFixed(2) : 0);
-    state.charts.market.update();
-}
-
-async function loadTrending() {
-    const data = await apiCall('/api/trending');
-    state.trending = data.trending || [];
-    const list = document.getElementById('trendingList');
-    if (!state.trending.length) {
-        list.innerHTML = '<div class="list-item" style="color:var(--muted);">No trending assets</div>';
-        return;
-    }
-    list.innerHTML = state.trending.map(item => `
-        <div class="list-item">
-            <div style="font-weight:600;">${item.name} (${item.symbol})</div>
-            <div style="font-size:12px;color:var(--muted);">Rank: ${item.rank || '—'}</div>
-        </div>`).join('');
-}
-
-async function loadSentimentData() {
-    const data = await apiCall('/api/sentiment');
-    state.sentiment = data.fear_greed_index;
-    renderSentiment();
-}
-
-function renderSentiment() {
-    const container = document.getElementById('sentimentCard');
-    if (!state.sentiment) {
-        container.textContent = 'No sentiment data';
-        return;
-    }
-    const timestamp = Number(state.sentiment.timestamp);
-    container.innerHTML = `
-        <div style="font-size:32px; font-weight:700;">${state.sentiment.value}</div>
-        <div style="font-size:14px; text-transform:uppercase; letter-spacing:1px; margin-bottom:8px;">${state.sentiment.classification}</div>
-        <div style="font-size:12px; color:var(--muted);">Updated: ${timestamp ? new Date(timestamp * 1000).toLocaleString() : '--'}</div>
-    `;
-}
-
-async function loadDefi() {
-    const data = await apiCall('/api/defi');
-    state.defi = data.protocols || [];
-    const tbody = document.getElementById('defiTableBody');
-    if (!state.defi.length) {
-        tbody.innerHTML = '<tr><td colspan="4" style="text-align:center; padding:40px; color:var(--muted);">No DeFi data</td></tr>';
-        return;
-    }
-    tbody.innerHTML = state.defi.slice(0, 10).map(proto => `
-        <tr>
-            <td>${proto.name}</td>
-            <td>$${formatNumber(proto.tvl)}</td>
-            <td style="color:${proto.change_24h >= 0 ? '#16a34a' : '#dc2626'};">${proto.change_24h ? proto.change_24h.toFixed(2) : 0}%</td>
-            <td>${proto.chain || '—'}</td>
-        </tr>`).join('');
-}
-
-async function loadNews() {
-    const data = await apiCall('/api/news');
-    state.news = data.articles || [];
-    const list = document.getElementById('newsList');
-    if (!state.news.length) {
-        list.innerHTML = '<div class="list-item" style="color:var(--muted);">No news available</div>';
-        return;
-    }
-    list.innerHTML = state.news.slice(0, 12).map(article => `
-        <div class="news-item list-item">
-            <h4>${article.title}</h4>
-            <div class="news-meta">${article.source || 'Unknown'} • ${article.published_at ? new Date(article.published_at).toLocaleString() : ''}</div>
-            <p style="margin:6px 0;">${article.description || ''}</p>
-            <a href="${article.link}" target="_blank" style="font-size:12px; color:var(--primary);">Read article →</a>
-        </div>`).join('');
-}
-
-async function loadErrorSummary() {
-    try {
-        const [summary, diagnostics] = await Promise.all([
-            apiCall('/api/logs/summary'),
-            apiCall('/api/diagnostics/errors')
-        ]);
-        state.errorSummary = summary;
-        state.diagnostics = diagnostics;
-        renderErrorSummary();
-    } catch (err) {
-        console.error(err);
-        document.getElementById('errorSummaryCard').textContent = 'Failed to load diagnostics';
-    }
-}
-
-function renderErrorSummary() {
-    const summary = state.errorSummary;
-    const card = document.getElementById('errorSummaryCard');
-    if (!summary) {
-        card.textContent = 'No diagnostics available';
-        return;
-    }
-    card.innerHTML = `
-        <div><strong>Total Logs:</strong> ${summary.total}</div>
-        <div><strong>Last Error:</strong> ${summary.last_error ? summary.last_error.provider + ' @ ' + summary.last_error.timestamp : 'None'}</div>
-        <div><strong>Top Offenders:</strong> ${Object.keys(summary.by_provider || {}).slice(0,3).join(', ') || '—'}</div>
-    `;
-    const diag = state.diagnostics || { recent: [] };
-    const list = document.getElementById('diagnosticsList');
-    list.innerHTML = diag.recent.slice(0,5).map(item => `
-        <div class="list-item">
-            <div style="font-weight:600;">${item.provider}</div>
-            <div style="font-size:12px; color:var(--muted);">${item.timestamp}</div>
-            <div style="font-size:13px; color:${item.status === 'offline' ? '#dc2626' : '#d97706'};">${item.message || 'No message'}</div>
-        </div>`).join('');
-}
-
-async function loadResourceSearch() {
-    const query = document.getElementById('resourceSearch')?.value || '';
-    const source = document.getElementById('resourceFilter').value;
-    const data = await apiCall(`/api/resources/search?q=${encodeURIComponent(query)}&source=${source}`);
-    state.resources = data.results;
-    document.getElementById('resourceCountProviders').textContent = `(${data.counts.providers})`;
-    document.getElementById('resourceCountModels').textContent = `(${data.counts.models})`;
-    document.getElementById('resourceCountDatasets').textContent = `(${data.counts.datasets})`;
-    renderResourceResults();
-}
-
-function renderResourceResults() {
-    const providersContainer = document.getElementById('resourceResultsProviders');
-    const modelsContainer = document.getElementById('resourceResultsModels');
-    const datasetsContainer = document.getElementById('resourceResultsDatasets');
-
-    providersContainer.innerHTML = state.resources.providers.slice(0,6).map(p => `
-        <div class="resource-item">
-            <strong>${p.name}</strong>
-            <div style="font-size:12px;color:var(--muted);">${p.category}</div>
-            <div style="font-size:12px;">Status: ${p.status}</div>
-        </div>`).join('') || '<div class="resource-item" style="color:var(--muted);">No matches</div>';
-
-    modelsContainer.innerHTML = state.resources.models.slice(0,6).map(m => `
-        <div class="resource-item">
-            <strong>${m.id}</strong>
-            <div style="font-size:12px;color:var(--muted);">${m.description || 'No description'}</div>
-        </div>`).join('') || '<div class="resource-item" style="color:var(--muted);">No matches</div>';
-
-    datasetsContainer.innerHTML = state.resources.datasets.slice(0,6).map(d => `
-        <div class="resource-item">
-            <strong>${d.id}</strong>
-            <div style="font-size:12px;color:var(--muted);">${d.description || 'No description'}</div>
-        </div>`).join('') || '<div class="resource-item" style="color:var(--muted);">No matches</div>';
-}
-
-async function handleExport(type) {
-    try {
-        const res = await apiCall(`/api/v2/export/${type}`, { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: '{}' });
-        state.exports.unshift({ type, url: res.download_url, timestamp: res.timestamp });
-        renderExportHistory();
-        showToast(`${type.toUpperCase()} export ready`, 'success');
-    } catch (err) {
-        console.error(err);
-        showToast('Export failed', 'error');
-    }
-}
-
-async function handleBackup() {
-    try {
-        const res = await apiCall('/api/v2/backup', { method: 'POST' });
-        state.exports.unshift({ type: 'backup', url: res.download_url, timestamp: res.timestamp });
-        renderExportHistory();
-        showToast('Backup created', 'success');
-    } catch (err) {
-        console.error(err);
-        showToast('Backup failed', 'error');
-    }
-}
-
-function renderExportHistory() {
-    const container = document.getElementById('exportHistory');
-    if (!state.exports.length) {
-        container.innerHTML = '<div style="color:var(--muted); font-size:13px;">No exports yet</div>';
-        return;
-    }
-    container.innerHTML = state.exports.slice(0,5).map(entry => `
-        <div class="list-item" style="border-bottom:1px solid var(--border);">
-            <div style="font-weight:600;">${entry.type.toUpperCase()}</div>
-            <div style="font-size:12px; color:var(--muted);">${new Date(entry.timestamp).toLocaleString()}</div>
-            <a href="${entry.url}" style="font-size:12px; color:var(--primary);" target="_blank">Download</a>
-        </div>`).join('');
-}
-
-async function handleImportSingle(event) {
-    event.preventDefault();
-    const form = event.target;
-    const payload = Object.fromEntries(new FormData(form).entries());
-    payload.requires_key = form.elements['requires_key'].checked;
-    payload.timeout_ms = Number(payload.timeout_ms) || 10000;
-    try {
-        await apiCall('/api/providers', {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify(payload)
-        });
-        showToast('Provider imported', 'success');
-        form.reset();
-        loadProviders();
-    } catch (err) {
-        console.error(err);
-        showToast('Import failed', 'error');
-    }
-}
-
-async function handleImportBulk() {
-    const textarea = document.getElementById('bulkImportTextarea');
-    if (!textarea.value.trim()) {
-        showToast('Paste provider JSON first', 'error');
-        return;
-    }
-    try {
-        const providers = JSON.parse(textarea.value);
-        await apiCall('/api/v2/import/providers', {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({ providers })
-        });
-        showToast('Bulk import complete', 'success');
-        textarea.value = '';
-        loadProviders();
-    } catch (err) {
-        console.error(err);
-        showToast('Bulk import failed', 'error');
-    }
-}
-
-function switchTab(event, tabName) {
-    document.querySelectorAll('.tab').forEach(tab => tab.classList.remove('active'));
-    document.querySelectorAll('.tab-content').forEach(content => content.classList.remove('active'));
-    event.currentTarget.classList.add('active');
-    document.getElementById(`tab-${tabName}`).classList.add('active');
-    state.currentTab = tabName;
-    if (tabName === 'market') loadMarket();
-    if (tabName === 'sentiment') { loadSentimentData(); loadDefi(); }
-    if (tabName === 'news') loadNews();
-}
-
-function startAutoRefresh() {
-    setInterval(() => {
-        if (state.wsConnected) {
-            refreshAll();
-        }
-    }, config.autoRefreshInterval);
-}
-
-function refreshAll() {
-    loadProviders();
-    loadMarket();
-    loadTrending();
-    loadSentimentData();
-    loadDefi();
-    loadErrorSummary();
-    loadNews();
-    loadResourceSearch();
-}
-
-function formatNumber(value) {
-    if (!value && value !== 0) return '--';
-    if (value >= 1e12) return (value / 1e12).toFixed(2) + 'T';
-    if (value >= 1e9) return (value / 1e9).toFixed(2) + 'B';
-    if (value >= 1e6) return (value / 1e6).toFixed(2) + 'M';
-    if (value >= 1e3) return (value / 1e3).toFixed(2) + 'K';
-    return Number(value).toFixed(2);
-}
-
-function setupResourceSearch() {
-    const input = document.getElementById('resourceSearch');
-    input.addEventListener('input', () => {
-        clearTimeout(state.resourceSearchTimeout);
-        state.resourceSearchTimeout = setTimeout(loadResourceSearch, 400);
-    });
-}
-
-initializeWebSocket();
-setupResourceSearch();
-loadInitialData();
-startAutoRefresh();
-</script>
-</body>
-</html>
-
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Crypto API Monitor Pro - Real-time Dashboard</title>
+    <link href="https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700;800;900&display=swap" rel="stylesheet">
+    <script src="https://cdn.jsdelivr.net/npm/chart.js@4.4.0/dist/chart.umd.min.js"></script>
+    <style>
+        * {
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
+        }
+
+        :root {
+            --bg-dark: #0a0a0f;
+            --bg-card: #12121a;
+            --bg-card-hover: #1a1a24;
+            --text-primary: #ffffff;
+            --text-secondary: #a0a0b0;
+            --accent-blue: #3b82f6;
+            --accent-purple: #8b5cf6;
+            --accent-pink: #ec4899;
+            --accent-green: #10b981;
+            --accent-red: #ef4444;
+            --accent-yellow: #f59e0b;
+            --border: rgba(255, 255, 255, 0.1);
+            --shadow: 0 20px 60px rgba(0, 0, 0, 0.5);
+        }
+
+        body {
+            font-family: 'Inter', sans-serif;
+            background: var(--bg-dark);
+            color: var(--text-primary);
+            line-height: 1.6;
+            overflow-x: hidden;
+        }
+
+        body::before {
+            content: '';
+            position: fixed;
+            top: 0;
+            left: 0;
+            right: 0;
+            bottom: 0;
+            background: 
+                radial-gradient(circle at 20% 20%, rgba(59, 130, 246, 0.1) 0%, transparent 50%),
+                radial-gradient(circle at 80% 80%, rgba(139, 92, 246, 0.1) 0%, transparent 50%),
+                radial-gradient(circle at 50% 50%, rgba(236, 72, 153, 0.05) 0%, transparent 50%);
+            pointer-events: none;
+            z-index: 0;
+        }
+
+        .container {
+            max-width: 1800px;
+            margin: 0 auto;
+            padding: 20px;
+            position: relative;
+            z-index: 1;
+        }
+
+        /* Header */
+        .header {
+            background: linear-gradient(135deg, var(--bg-card) 0%, rgba(59, 130, 246, 0.1) 100%);
+            border: 1px solid var(--border);
+            border-radius: 24px;
+            padding: 30px;
+            margin-bottom: 30px;
+            backdrop-filter: blur(20px);
+            box-shadow: var(--shadow);
+        }
+
+        .header-top {
+            display: flex;
+            align-items: center;
+            justify-content: space-between;
+            flex-wrap: wrap;
+            gap: 20px;
+            margin-bottom: 25px;
+        }
+
+        .logo {
+            display: flex;
+            align-items: center;
+            gap: 15px;
+        }
+
+        .logo-icon {
+            width: 50px;
+            height: 50px;
+            background: linear-gradient(135deg, var(--accent-blue), var(--accent-purple));
+            border-radius: 12px;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            font-size: 24px;
+            box-shadow: 0 10px 30px rgba(59, 130, 246, 0.3);
+        }
+
+        .logo-text h1 {
+            font-size: 28px;
+            font-weight: 800;
+            background: linear-gradient(135deg, var(--accent-blue), var(--accent-purple), var(--accent-pink));
+            -webkit-background-clip: text;
+            -webkit-text-fill-color: transparent;
+            background-clip: text;
+        }
+
+        .logo-text p {
+            font-size: 13px;
+            color: var(--text-secondary);
+        }
+
+        .header-actions {
+            display: flex;
+            gap: 15px;
+            align-items: center;
+        }
+
+        .status-badge {
+            display: flex;
+            align-items: center;
+            gap: 8px;
+            padding: 10px 20px;
+            background: rgba(16, 185, 129, 0.1);
+            border: 1px solid rgba(16, 185, 129, 0.3);
+            border-radius: 12px;
+            font-size: 13px;
+            font-weight: 600;
+        }
+
+        .status-dot {
+            width: 8px;
+            height: 8px;
+            background: var(--accent-green);
+            border-radius: 50%;
+            animation: pulse 2s infinite;
+        }
+
+        @keyframes pulse {
+            0%, 100% { opacity: 1; transform: scale(1); }
+            50% { opacity: 0.5; transform: scale(1.2); }
+        }
+
+        /* Stats Grid */
+        .stats-grid {
+            display: grid;
+            grid-template-columns: repeat(auto-fit, minmax(280px, 1fr));
+            gap: 20px;
+            margin-bottom: 30px;
+        }
+
+        .stat-card {
+            background: var(--bg-card);
+            border: 1px solid var(--border);
+            border-radius: 20px;
+            padding: 25px;
+            transition: all 0.3s ease;
+            position: relative;
+            overflow: hidden;
+        }
+
+        .stat-card::before {
+            content: '';
+            position: absolute;
+            top: 0;
+            left: 0;
+            right: 0;
+            height: 4px;
+            background: linear-gradient(90deg, var(--accent-blue), var(--accent-purple));
+            transform: scaleX(0);
+            transition: transform 0.3s ease;
+        }
+
+        .stat-card:hover {
+            transform: translateY(-5px);
+            border-color: rgba(59, 130, 246, 0.5);
+            box-shadow: 0 15px 40px rgba(59, 130, 246, 0.2);
+        }
+
+        .stat-card:hover::before {
+            transform: scaleX(1);
+        }
+
+        .stat-header {
+            display: flex;
+            align-items: center;
+            justify-content: space-between;
+            margin-bottom: 15px;
+        }
+
+        .stat-icon {
+            width: 40px;
+            height: 40px;
+            border-radius: 10px;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            font-size: 20px;
+        }
+
+        .stat-value {
+            font-size: 32px;
+            font-weight: 800;
+            margin-bottom: 5px;
+            background: linear-gradient(135deg, var(--text-primary), var(--text-secondary));
+            -webkit-background-clip: text;
+            -webkit-text-fill-color: transparent;
+        }
+
+        .stat-label {
+            font-size: 13px;
+            color: var(--text-secondary);
+            text-transform: uppercase;
+            letter-spacing: 1px;
+        }
+
+        .stat-change {
+            font-size: 13px;
+            font-weight: 600;
+            margin-top: 10px;
+            display: flex;
+            align-items: center;
+            gap: 5px;
+        }
+
+        .stat-change.positive { color: var(--accent-green); }
+        .stat-change.negative { color: var(--accent-red); }
+
+        /* Tabs */
+        .tabs {
+            display: flex;
+            gap: 10px;
+            margin-bottom: 25px;
+            padding: 8px;
+            background: var(--bg-card);
+            border-radius: 16px;
+            border: 1px solid var(--border);
+        }
+
+        .tab {
+            padding: 12px 24px;
+            background: transparent;
+            border: none;
+            border-radius: 12px;
+            color: var(--text-secondary);
+            font-weight: 600;
+            cursor: pointer;
+            transition: all 0.3s ease;
+            font-size: 14px;
+        }
+
+        .tab:hover {
+            color: var(--text-primary);
+            background: rgba(59, 130, 246, 0.1);
+        }
+
+        .tab.active {
+            background: linear-gradient(135deg, var(--accent-blue), var(--accent-purple));
+            color: white;
+            box-shadow: 0 5px 20px rgba(59, 130, 246, 0.3);
+        }
+
+        .tab-content {
+            display: none;
+        }
+
+        .tab-content.active {
+            display: block;
+            animation: fadeIn 0.3s ease;
+        }
+
+        @keyframes fadeIn {
+            from { opacity: 0; transform: translateY(10px); }
+            to { opacity: 1; transform: translateY(0); }
+        }
+
+        /* Provider Grid */
+        .provider-grid {
+            display: grid;
+            grid-template-columns: repeat(auto-fill, minmax(320px, 1fr));
+            gap: 20px;
+        }
+
+        .provider-card {
+            background: var(--bg-card);
+            border: 1px solid var(--border);
+            border-radius: 16px;
+            padding: 20px;
+            transition: all 0.3s ease;
+            cursor: pointer;
+        }
+
+        .provider-card:hover {
+            transform: translateY(-3px);
+            border-color: rgba(59, 130, 246, 0.5);
+            box-shadow: 0 10px 30px rgba(0, 0, 0, 0.3);
+        }
+
+        .provider-header {
+            display: flex;
+            align-items: center;
+            justify-content: space-between;
+            margin-bottom: 15px;
+        }
+
+        .provider-name {
+            font-size: 18px;
+            font-weight: 700;
+        }
+
+        .provider-status {
+            padding: 4px 12px;
+            border-radius: 20px;
+            font-size: 11px;
+            font-weight: 600;
+            text-transform: uppercase;
+        }
+
+        .provider-status.operational {
+            background: rgba(16, 185, 129, 0.2);
+            color: var(--accent-green);
+        }
+
+        .provider-status.degraded {
+            background: rgba(245, 158, 11, 0.2);
+            color: var(--accent-yellow);
+        }
+
+        .provider-status.maintenance {
+            background: rgba(239, 68, 68, 0.2);
+            color: var(--accent-red);
+        }
+
+        .provider-meta {
+            display: flex;
+            gap: 15px;
+            font-size: 12px;
+            color: var(--text-secondary);
+            margin-bottom: 12px;
+        }
+
+        .provider-meta span {
+            display: flex;
+            align-items: center;
+            gap: 5px;
+        }
+
+        .provider-stats {
+            display: grid;
+            grid-template-columns: repeat(2, 1fr);
+            gap: 10px;
+            margin-top: 15px;
+            padding-top: 15px;
+            border-top: 1px solid var(--border);
+        }
+
+        .provider-stat {
+            font-size: 12px;
+        }
+
+        .provider-stat-value {
+            font-size: 16px;
+            font-weight: 700;
+            color: var(--text-primary);
+        }
+
+        /* Crypto Table */
+        .crypto-table {
+            background: var(--bg-card);
+            border: 1px solid var(--border);
+            border-radius: 16px;
+            overflow: hidden;
+        }
+
+        .table-wrapper {
+            overflow-x: auto;
+        }
+
+        table {
+            width: 100%;
+            border-collapse: collapse;
+        }
+
+        thead {
+            background: rgba(59, 130, 246, 0.05);
+        }
+
+        th {
+            padding: 15px;
+            text-align: left;
+            font-size: 12px;
+            font-weight: 600;
+            color: var(--text-secondary);
+            text-transform: uppercase;
+            letter-spacing: 1px;
+        }
+
+        td {
+            padding: 15px;
+            border-top: 1px solid var(--border);
+        }
+
+        tr:hover {
+            background: rgba(59, 130, 246, 0.05);
+        }
+
+        .crypto-name {
+            display: flex;
+            align-items: center;
+            gap: 10px;
+        }
+
+        .crypto-icon {
+            width: 32px;
+            height: 32px;
+            border-radius: 8px;
+            background: linear-gradient(135deg, var(--accent-blue), var(--accent-purple));
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            font-weight: 700;
+            font-size: 14px;
+        }
+
+        .price-change {
+            font-weight: 600;
+            padding: 4px 8px;
+            border-radius: 6px;
+        }
+
+        .price-change.positive {
+            background: rgba(16, 185, 129, 0.1);
+            color: var(--accent-green);
+        }
+
+        .price-change.negative {
+            background: rgba(239, 68, 68, 0.1);
+            color: var(--accent-red);
+        }
+
+        /* Charts */
+        .chart-container {
+            background: var(--bg-card);
+            border: 1px solid var(--border);
+            border-radius: 16px;
+            padding: 25px;
+            margin-bottom: 25px;
+        }
+
+        .chart-header {
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            margin-bottom: 20px;
+        }
+
+        .chart-title {
+            font-size: 18px;
+            font-weight: 700;
+        }
+
+        canvas {
+            max-height: 300px;
+        }
+
+        /* Loading */
+        .loading {
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            padding: 50px;
+        }
+
+        .spinner {
+            width: 40px;
+            height: 40px;
+            border: 3px solid var(--border);
+            border-top-color: var(--accent-blue);
+            border-radius: 50%;
+            animation: spin 1s linear infinite;
+        }
+
+        @keyframes spin {
+            to { transform: rotate(360deg); }
+        }
+
+        /* Responsive */
+        @media (max-width: 768px) {
+            .stats-grid {
+                grid-template-columns: 1fr;
+            }
+            
+            .provider-grid {
+                grid-template-columns: 1fr;
+            }
+            
+            .header-top {
+                flex-direction: column;
+                align-items: flex-start;
+            }
+        }
+
+        /* Scrollbar */
+        ::-webkit-scrollbar {
+            width: 8px;
+            height: 8px;
+        }
+
+        ::-webkit-scrollbar-track {
+            background: var(--bg-dark);
+        }
+
+        ::-webkit-scrollbar-thumb {
+            background: var(--border);
+            border-radius: 4px;
+        }
+
+        ::-webkit-scrollbar-thumb:hover {
+            background: rgba(255, 255, 255, 0.2);
+        }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <!-- Header -->
+        <div class="header">
+            <div class="header-top">
+                <div class="logo">
+                    <div class="logo-icon">₿</div>
+                    <div class="logo-text">
+                        <h1>Crypto API Monitor Pro</h1>
+                        <p>Real-time monitoring of 40+ providers</p>
+                    </div>
+                </div>
+                <div class="header-actions">
+                    <div class="status-badge" id="systemStatus">
+                        <div class="status-dot"></div>
+                        <span id="statusText">System Operational</span>
+                    </div>
+                </div>
+            </div>
+
+            <!-- Stats Grid -->
+            <div class="stats-grid">
+                <div class="stat-card">
+                    <div class="stat-header">
+                        <div class="stat-icon" style="background: linear-gradient(135deg, #3b82f6, #8b5cf6);">🌐</div>
+                    </div>
+                    <div class="stat-value" id="totalProviders">--</div>
+                    <div class="stat-label">Total Providers</div>
+                    <div class="stat-change positive" id="providersChange">
+                        <span>↑</span> <span>100% Active</span>
+                    </div>
+                </div>
+
+                <div class="stat-card">
+                    <div class="stat-header">
+                        <div class="stat-icon" style="background: linear-gradient(135deg, #10b981, #06b6d4);">⚡</div>
+                    </div>
+                    <div class="stat-value" id="avgResponseTime">--</div>
+                    <div class="stat-label">Avg Response Time</div>
+                    <div class="stat-change positive">
+                        <span>↓</span> <span>12% faster</span>
+                    </div>
+                </div>
+
+                <div class="stat-card">
+                    <div class="stat-header">
+                        <div class="stat-icon" style="background: linear-gradient(135deg, #ec4899, #f59e0b);">💰</div>
+                    </div>
+                    <div class="stat-value" id="marketCap">--</div>
+                    <div class="stat-label">Total Market Cap</div>
+                    <div class="stat-change positive" id="marketChange">
+                        <span>↑</span> <span>5.2%</span>
+                    </div>
+                </div>
+
+                <div class="stat-card">
+                    <div class="stat-header">
+                        <div class="stat-icon" style="background: linear-gradient(135deg, #8b5cf6, #ec4899);">📊</div>
+                    </div>
+                    <div class="stat-value" id="totalRequests">--</div>
+                    <div class="stat-label">API Requests Today</div>
+                    <div class="stat-change positive">
+                        <span>↑</span> <span>15K/min</span>
+                    </div>
+                </div>
+            </div>
+        </div>
+
+        <!-- Tabs -->
+        <div class="tabs">
+            <button class="tab active" onclick="switchTab('overview')">📊 Overview</button>
+            <button class="tab" onclick="switchTab('providers')">🌐 Providers</button>
+            <button class="tab" onclick="switchTab('crypto')">₿ Cryptocurrencies</button>
+            <button class="tab" onclick="switchTab('analytics')">📈 Analytics</button>
+        </div>
+
+        <!-- Overview Tab -->
+        <div class="tab-content active" id="overview">
+            <div class="chart-container">
+                <div class="chart-header">
+                    <div class="chart-title">Provider Status Distribution</div>
+                </div>
+                <canvas id="statusChart"></canvas>
+            </div>
+
+            <div style="display: grid; grid-template-columns: repeat(auto-fit, minmax(400px, 1fr)); gap: 25px;">
+                <div class="chart-container">
+                    <div class="chart-header">
+                        <div class="chart-title">Response Time Trends</div>
+                    </div>
+                    <canvas id="responseChart"></canvas>
+                </div>
+
+                <div class="chart-container">
+                    <div class="chart-header">
+                        <div class="chart-title">Requests by Category</div>
+                    </div>
+                    <canvas id="categoryChart"></canvas>
+                </div>
+            </div>
+        </div>
+
+        <!-- Providers Tab -->
+        <div class="tab-content" id="providers">
+            <div class="provider-grid" id="providerGrid">
+                <div class="loading"><div class="spinner"></div></div>
+            </div>
+        </div>
+
+        <!-- Crypto Tab -->
+        <div class="tab-content" id="crypto">
+            <div class="crypto-table">
+                <div class="table-wrapper">
+                    <table>
+                        <thead>
+                            <tr>
+                                <th>#</th>
+                                <th>Name</th>
+                                <th>Price</th>
+                                <th>24h Change</th>
+                                <th>7d Change</th>
+                                <th>Market Cap</th>
+                                <th>Volume 24h</th>
+                                <th>Category</th>
+                            </tr>
+                        </thead>
+                        <tbody id="cryptoTableBody">
+                            <tr><td colspan="8" style="text-align: center;"><div class="loading"><div class="spinner"></div></div></td></tr>
+                        </tbody>
+                    </table>
+                </div>
+            </div>
+        </div>
+
+        <!-- Analytics Tab -->
+        <div class="tab-content" id="analytics">
+            <div style="display: grid; grid-template-columns: repeat(auto-fit, minmax(300px, 1fr)); gap: 25px; margin-bottom: 25px;">
+                <div class="chart-container">
+                    <div class="chart-header">
+                        <div class="chart-title">Market Dominance</div>
+                    </div>
+                    <canvas id="dominanceChart"></canvas>
+                </div>
+
+                <div class="chart-container">
+                    <div class="chart-header">
+                        <div class="chart-title">Provider Performance</div>
+                    </div>
+                    <canvas id="performanceChart"></canvas>
+                </div>
+            </div>
+        </div>
+    </div>
+
+    <script>
+        let charts = {};
+        let wsConnection = null;
+
+        // Initialize
+        document.addEventListener('DOMContentLoaded', async () => {
+            await loadData();
+            initCharts();
+            connectWebSocket();
+            setInterval(loadData, 30000);
+        });
+
+        async function loadData() {
+            try {
+                const [stats, providers, crypto] = await Promise.all([
+                    fetch('/api/stats').then(r => r.json()),
+                    fetch('/api/providers').then(r => r.json()),
+                    fetch('/api/crypto/prices').then(r => r.json())
+                ]);
+
+                updateStats(stats);
+                updateProviders(providers);
+                updateCrypto(crypto);
+                updateCharts(providers, crypto);
+            } catch (error) {
+                console.error('Error loading data:', error);
+            }
+        }
+
+        function updateStats(stats) {
+            document.getElementById('totalProviders').textContent = stats.providers.total;
+            document.getElementById('avgResponseTime').textContent = stats.performance.avg_response_time + 'ms';
+            document.getElementById('marketCap').textContent = '$' + (stats.market.total_market_cap / 1e12).toFixed(2) + 'T';
+            document.getElementById('totalRequests').textContent = (stats.performance.total_requests / 1e6).toFixed(1) + 'M';
+            
+            const change = stats.market.avg_change_24h;
+            const changeEl = document.getElementById('marketChange');
+            changeEl.className = 'stat-change ' + (change > 0 ? 'positive' : 'negative');
+            changeEl.innerHTML = `<span>${change > 0 ? '↑' : '↓'}</span> <span>${Math.abs(change).toFixed(1)}%</span>`;
+        }
+
+        function updateProviders(providers) {
+            const grid = document.getElementById('providerGrid');
+            grid.innerHTML = providers.map(p => `
+                <div class="provider-card">
+                    <div class="provider-header">
+                        <div class="provider-name">${p.name}</div>
+                        <div class="provider-status ${p.status}">${p.status}</div>
+                    </div>
+                    <div class="provider-meta">
+                        <span>📍 ${p.region}</span>
+                        <span>🏷️ ${p.type}</span>
+                        <span>📂 ${p.category}</span>
+                    </div>
+                    <div class="provider-stats">
+                        <div class="provider-stat">
+                            <div style="color: var(--text-secondary); font-size: 11px;">Uptime</div>
+                            <div class="provider-stat-value">${p.uptime}%</div>
+                        </div>
+                        <div class="provider-stat">
+                            <div style="color: var(--text-secondary); font-size: 11px;">Response</div>
+                            <div class="provider-stat-value">${p.response_time_ms}ms</div>
+                        </div>
+                        <div class="provider-stat">
+                            <div style="color: var(--text-secondary); font-size: 11px;">Requests</div>
+                            <div class="provider-stat-value">${(p.requests_today / 1000).toFixed(0)}K</div>
+                        </div>
+                        <div class="provider-stat">
+                            <div style="color: var(--text-secondary); font-size: 11px;">Rate</div>
+                            <div class="provider-stat-value">${p.rate_limit}/min</div>
+                        </div>
+                    </div>
+                </div>
+            `).join('');
+        }
+
+        function updateCrypto(crypto) {
+            const tbody = document.getElementById('cryptoTableBody');
+            tbody.innerHTML = crypto.map(c => `
+                <tr>
+                    <td>${c.rank}</td>
+                    <td>
+                        <div class="crypto-name">
+                            <div class="crypto-icon">${c.symbol[0]}</div>
+                            <div>
+                                <div style="font-weight: 600;">${c.name}</div>
+                                <div style="font-size: 12px; color: var(--text-secondary);">${c.symbol}</div>
+                            </div>
+                        </div>
+                    </td>
+                    <td style="font-weight: 600;">$${c.price.toLocaleString()}</td>
+                    <td><span class="price-change ${c.change_24h > 0 ? 'positive' : 'negative'}">${c.change_24h > 0 ? '+' : ''}${c.change_24h.toFixed(2)}%</span></td>
+                    <td><span class="price-change ${c.change_7d > 0 ? 'positive' : 'negative'}">${c.change_7d > 0 ? '+' : ''}${c.change_7d.toFixed(2)}%</span></td>
+                    <td>$${(c.market_cap / 1e9).toFixed(2)}B</td>
+                    <td>$${(c.volume_24h / 1e9).toFixed(2)}B</td>
+                    <td><span style="padding: 4px 8px; background: rgba(59, 130, 246, 0.1); border-radius: 6px; font-size: 11px;">${c.category}</span></td>
+                </tr>
+            `).join('');
+        }
+
+        function initCharts() {
+            Chart.defaults.color = '#a0a0b0';
+            Chart.defaults.borderColor = 'rgba(255, 255, 255, 0.1)';
+
+            charts.status = new Chart(document.getElementById('statusChart'), {
+                type: 'doughnut',
+                data: {
+                    labels: ['Operational', 'Degraded', 'Maintenance'],
+                    datasets: [{
+                        data: [85, 10, 5],
+                        backgroundColor: ['#10b981', '#f59e0b', '#ef4444'],
+                        borderWidth: 0
+                    }]
+                },
+                options: {
+                    responsive: true,
+                    plugins: {
+                        legend: { position: 'bottom' }
+                    }
+                }
+            });
+
+            charts.response = new Chart(document.getElementById('responseChart'), {
+                type: 'line',
+                data: {
+                    labels: Array(12).fill(0).map((_, i) => `${i*5}m`),
+                    datasets: [{
+                        label: 'Response Time',
+                        data: Array(12).fill(0).map(() => Math.random() * 100 + 80),
+                        borderColor: '#3b82f6',
+                        backgroundColor: 'rgba(59, 130, 246, 0.1)',
+                        fill: true,
+                        tension: 0.4
+                    }]
+                },
+                options: {
+                    responsive: true,
+                    plugins: { legend: { display: false } }
+                }
+            });
+
+            charts.category = new Chart(document.getElementById('categoryChart'), {
+                type: 'bar',
+                data: {
+                    labels: ['Exchanges', 'Data', 'DeFi', 'NFT', 'Blockchain'],
+                    datasets: [{
+                        label: 'Providers',
+                        data: [15, 8, 8, 4, 5],
+                        backgroundColor: ['#3b82f6', '#8b5cf6', '#ec4899', '#f59e0b', '#10b981']
+                    }]
+                },
+                options: {
+                    responsive: true,
+                    plugins: { legend: { display: false } }
+                }
+            });
+        }
+
+        function updateCharts(providers, crypto) {
+            if (charts.dominance) {
+                const top5 = crypto.slice(0, 5);
+                charts.dominance.data.labels = top5.map(c => c.symbol);
+                charts.dominance.data.datasets[0].data = top5.map(c => c.market_cap);
+                charts.dominance.update();
+            } else {
+                charts.dominance = new Chart(document.getElementById('dominanceChart'), {
+                    type: 'pie',
+                    data: {
+                        labels: crypto.slice(0, 5).map(c => c.symbol),
+                        datasets: [{
+                            data: crypto.slice(0, 5).map(c => c.market_cap),
+                            backgroundColor: ['#3b82f6', '#8b5cf6', '#ec4899', '#f59e0b', '#10b981']
+                        }]
+                    }
+                });
+            }
+
+            if (charts.performance) {
+                charts.performance.data.datasets[0].data = providers.slice(0, 8).map(p => p.uptime);
+                charts.performance.update();
+            } else {
+                charts.performance = new Chart(document.getElementById('performanceChart'), {
+                    type: 'radar',
+                    data: {
+                        labels: providers.slice(0, 8).map(p => p.name),
+                        datasets: [{
+                            label: 'Uptime %',
+                            data: providers.slice(0, 8).map(p => p.uptime),
+                            borderColor: '#8b5cf6',
+                            backgroundColor: 'rgba(139, 92, 246, 0.1)'
+                        }]
+                    }
+                });
+            }
+        }
+
+        function switchTab(tab) {
+            document.querySelectorAll('.tab').forEach(t => t.classList.remove('active'));
+            document.querySelectorAll('.tab-content').forEach(c => c.classList.remove('active'));
+            event.target.classList.add('active');
+            document.getElementById(tab).classList.add('active');
+        }
+
+        function connectWebSocket() {
+            const ws = new WebSocket(`ws://${window.location.host}/ws/live`);
+            ws.onopen = () => console.log('WebSocket connected');
+            ws.onmessage = (e) => {
+                const data = JSON.parse(e.data);
+                if (data.type === 'status_update') {
+                    document.getElementById('statusText').textContent = 
+                        data.data.status === 'healthy' ? 'System Operational' : 'System Degraded';
+                }
+            };
+            ws.onerror = () => console.log('WebSocket error');
+        }
+    </script>
+</body>
+</html>

main.py

@@ -1,30 +1,168 @@
-#!/usr/bin/env python3
-"""
-Local Development Entry Point
-This file is for local development only and is NOT used by Hugging Face Docker runtime.
-For production deployment, use: uvicorn api_server_extended:app
-"""
+from fastapi import FastAPI, HTTPException, Depends
+from fastapi.middleware.cors import CORSMiddleware
+import ccxt
+import os
+import logging
+from datetime import datetime
+import pandas as pd
+import numpy as np
 
-if __name__ == "__main__":
-    import uvicorn
-    import os
+# Setup logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Create data and logs directories
+os.makedirs("data", exist_ok=True)
+os.makedirs("logs", exist_ok=True)
+
+# Initialize FastAPI app
+app = FastAPI(
+    title="Cryptocurrency Data Source API",
+    description="API for fetching cryptocurrency market data and technical indicators",
+    version="1.0.0",
+)
+
+# Configure CORS
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+@app.get("/")
+async def root():
+    """Root endpoint showing API status"""
+    return {
+        "status": "online",
+        "version": "1.0.0",
+        "timestamp": datetime.now().isoformat(),
+        "ccxt_version": ccxt.__version__
+    }
+
+@app.get("/exchanges")
+async def get_exchanges():
+    """List available exchanges"""
+    # Get list of exchanges that support OHLCV data
+    exchanges = []
+    for exchange_id in ccxt.exchanges:
+        try:
+            exchange = getattr(ccxt, exchange_id)()
+            if exchange.has.get('fetchOHLCV'):
+                exchanges.append({
+                    "id": exchange_id,
+                    "name": exchange.name if hasattr(exchange, 'name') else exchange_id,
+                    "url": exchange.urls.get('www') if hasattr(exchange, 'urls') and exchange.urls else None
+                })
+        except:
+            # Skip exchanges that fail to initialize
+            continue
     
-    # Get port from environment or use default
-    port = int(os.getenv("PORT", "8000"))
+    return {"total": len(exchanges), "exchanges": exchanges}
+
+@app.get("/markets/{exchange_id}")
+async def get_markets(exchange_id: str):
+    """Get markets for a specific exchange"""
+    try:
+        # Check if exchange exists
+        if exchange_id not in ccxt.exchanges:
+            raise HTTPException(status_code=404, detail=f"Exchange {exchange_id} not found")
+        
+        # Initialize exchange
+        exchange = getattr(ccxt, exchange_id)({
+            'enableRateLimit': True
+        })
+        
+        # Fetch markets
+        markets = exchange.load_markets()
+        
+        # Format response
+        result = []
+        for symbol, market in markets.items():
+            if market.get('active', False):
+                result.append({
+                    "symbol": symbol,
+                    "base": market.get('base', ''),
+                    "quote": market.get('quote', ''),
+                    "type": market.get('type', 'spot')
+                })
+        
+        return {"exchange": exchange_id, "total": len(result), "markets": result[:100]}
     
-    print(f"""
-    ╔═══════════════════════════════════════════════════════════╗
-    ║   🚀 Crypto Monitor - Local Development Server           ║
-    ║   Port: {port}                                                   ║
-    ║   Docs: http://localhost:{port}/docs                            ║
-    ╚═══════════════════════════════════════════════════════════╝
-    """)
+    except ccxt.BaseError as e:
+        raise HTTPException(status_code=500, detail=str(e))
+    except Exception as e:
+        logger.error(f"Error fetching markets for {exchange_id}: {str(e)}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.get("/ohlcv/{exchange_id}/{symbol}")
+async def get_ohlcv(exchange_id: str, symbol: str, timeframe: str = "1h", limit: int = 100):
+    """Get OHLCV data for a specific market"""
+    try:
+        # Check if exchange exists
+        if exchange_id not in ccxt.exchanges:
+            raise HTTPException(status_code=404, detail=f"Exchange {exchange_id} not found")
+        
+        # Initialize exchange
+        exchange = getattr(ccxt, exchange_id)({
+            'enableRateLimit': True
+        })
+        
+        # Check if exchange supports OHLCV
+        if not exchange.has.get('fetchOHLCV'):
+            raise HTTPException(
+                status_code=400, 
+                detail=f"Exchange {exchange_id} does not support OHLCV data"
+            )
+        
+        # Check timeframe
+        if timeframe not in exchange.timeframes:
+            raise HTTPException(
+                status_code=400, 
+                detail=f"Timeframe {timeframe} not supported by {exchange_id}"
+            )
+        
+        # Fetch OHLCV data
+        ohlcv = exchange.fetch_ohlcv(symbol=symbol, timeframe=timeframe, limit=limit)
+        
+        # Convert to readable format
+        result = []
+        for candle in ohlcv:
+            timestamp, open_price, high, low, close, volume = candle
+            result.append({
+                "timestamp": timestamp,
+                "datetime": datetime.fromtimestamp(timestamp / 1000).isoformat(),
+                "open": open_price,
+                "high": high,
+                "low": low,
+                "close": close,
+                "volume": volume
+            })
+        
+        return {
+            "exchange": exchange_id,
+            "symbol": symbol,
+            "timeframe": timeframe,
+            "data": result
+        }
     
-    # Run with reload for local development
-    uvicorn.run(
-        "api_server_extended:app",
-        host="0.0.0.0",
-        port=port,
-        reload=True,
-        log_level="info"
-    )
+    except ccxt.BaseError as e:
+        raise HTTPException(status_code=500, detail=str(e))
+    except Exception as e:
+        logger.error(f"Error fetching OHLCV data: {str(e)}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.get("/health")
+async def health_check():
+    """Health check endpoint"""
+    return {
+        "status": "healthy",
+        "timestamp": datetime.now().isoformat(),
+        "version": "1.0.0"
+    }
+
+if __name__ == "__main__":
+    import uvicorn
+    port = int(os.getenv("PORT", 7860))
+    uvicorn.run("main:app", host="0.0.0.0", port=port, log_level="info")

requirements.txt

@@ -1,58 +1,3 @@
-# Crypto Data Aggregator - Complete Requirements
-# Production-ready dependencies with exact versions
-
-# ==================== GRADIO INTERFACE ====================
-gradio>=4.44.0
-
-# ==================== DATA PROCESSING ====================
-pandas>=2.0.0
-numpy>=1.24.0
-
-# ==================== HTTP CLIENTS ====================
-requests>=2.31.0
-aiohttp>=3.8.0
-httpx>=0.26.0
-
-# ==================== WEB BACKEND ====================
-fastapi>=0.109.0
-uvicorn[standard]>=0.27.0
-slowapi>=0.1.9
-python-multipart>=0.0.6
-websockets>=12.0
-
-# ==================== DATA MODELS & CONFIG ====================
-pydantic>=2.5.3
-pydantic-settings>=2.1.0
-
-# ==================== WEB SCRAPING & RSS ====================
-beautifulsoup4>=4.12.0
-feedparser>=6.0.10
-
-# ==================== AI/ML - HUGGING FACE ====================
-transformers>=4.30.0
-torch>=2.0.0
-sentencepiece>=0.1.99
-tokenizers>=0.13.0
-huggingface-hub>=0.16.0
-
-# ==================== PLOTTING & VISUALIZATION ====================
-plotly>=5.14.0
-kaleido>=0.2.1
-
-# ==================== DATABASE & STORAGE ====================
-sqlalchemy>=2.0.25
-
-# ==================== AUTHENTICATION & SECURITY ====================
-PyJWT>=2.8.0
-
-# ==================== DATE/TIME HELPERS ====================
-python-dateutil>=2.8.2
-
-# ==================== OPTIONAL: ACCELERATED INFERENCE ====================
-# accelerate>=0.20.0  # Uncomment for faster model loading
-# bitsandbytes>=0.39.0  # Uncomment for quantization
-
-# ==================== NOTES ====================
-# No API keys required - all data sources are free
-# SQLite is included in Python standard library
-# All packages are production-tested and stable
+fastapi==0.104.1
+uvicorn[standard]==0.24.0
+websockets==12.0

start.bat

@@ -1,16 +1,17 @@
 @echo off
 chcp 65001 > nul
-title Crypto Monitor ULTIMATE - Real APIs
+title Crypto API Monitor Pro - Starting...
 
 echo ========================================
-echo   🚀 Crypto Monitor ULTIMATE
-echo   Real-time Data from 100+ Free APIs
+echo   🚀 Crypto API Monitor Pro v2.0
+echo   Professional Dashboard - 40+ Providers
 echo ========================================
 echo.
 
 python --version > nul 2>&1
 if %errorlevel% neq 0 (
     echo ❌ Python not found!
+    echo Install from: https://python.org/downloads/
     pause
     exit /b 1
 )
@@ -31,20 +32,14 @@ pip install -q -r requirements.txt
 
 echo.
 echo ========================================
-echo   🎯 Starting Real-time Server...
+echo   🎯 Starting Server...
 echo ========================================
 echo.
 echo 📊 Dashboard: http://localhost:8000/dashboard
 echo 📡 API Docs: http://localhost:8000/docs
 echo.
-echo 💡 Real APIs:
-echo    ✓ CoinGecko - Market Data
-echo    ✓ CoinCap - Price Data
-echo    ✓ Binance - Exchange Data
-echo    ✓ Fear & Greed Index
-echo    ✓ DeFi Llama - TVL Data
+echo 💡 Press Ctrl+C to stop
 echo.
-echo Press Ctrl+C to stop
 echo ========================================
 echo.
 

start_server.py

@@ -1,241 +1,19 @@
-#!/usr/bin/env python3
-"""
-🚀 Crypto Monitor ULTIMATE - Launcher Script
-اسکریپت راه‌انداز سریع برای سرور
-"""
-
-import sys
-import subprocess
-import os
-from pathlib import Path
-
-
-def check_dependencies():
-    """بررسی وابستگی‌های لازم"""
-    print("🔍 بررسی وابستگی‌ها...")
-    
-    required_packages = [
-        'fastapi',
-        'uvicorn',
-        'aiohttp',
-        'pydantic'
-    ]
-    
-    missing = []
-    for package in required_packages:
-        try:
-            __import__(package)
-            print(f"  ✅ {package}")
-        except ImportError:
-            missing.append(package)
-            print(f"  ❌ {package} - نصب نشده")
-    
-    if missing:
-        print(f"\n⚠️  {len(missing)} پکیج نصب نشده است!")
-        response = input("آیا می‌خواهید الان نصب شوند? (y/n): ")
-        if response.lower() == 'y':
-            install_dependencies()
-        else:
-            print("❌ بدون نصب وابستگی‌ها، سرور نمی‌تواند اجرا شود.")
-            sys.exit(1)
-    else:
-        print("✅ همه وابستگی‌ها نصب شده‌اند\n")
-
-
-def install_dependencies():
-    """نصب وابستگی‌ها از requirements.txt"""
-    print("\n📦 در حال نصب وابستگی‌ها...")
-    try:
-        subprocess.check_call([
-            sys.executable, "-m", "pip", "install", "-r", "requirements.txt"
-        ])
-        print("✅ همه وابستگی‌ها با موفقیت نصب شدند\n")
-    except subprocess.CalledProcessError:
-        print("❌ خطا در نصب وابستگی‌ها")
-        sys.exit(1)
-
-
-def check_config_files():
-    """بررسی فایل‌های پیکربندی"""
-    print("🔍 بررسی فایل‌های پیکربندی...")
-    
-    config_file = Path("providers_config_extended.json")
-    if not config_file.exists():
-        print(f"  ❌ {config_file} یافت نشد!")
-        print("     لطفاً این فایل را از مخزن دانلود کنید.")
-        sys.exit(1)
-    else:
-        print(f"  ✅ {config_file}")
-    
-    dashboard_file = Path("unified_dashboard.html")
-    if not dashboard_file.exists():
-        print(f"  ⚠️  {dashboard_file} یافت نشد - داشبورد در دسترس نخواهد بود")
-    else:
-        print(f"  ✅ {dashboard_file}")
-    
-    print()
-
-
-def show_banner():
-    """نمایش بنر استارت"""
-    banner = """
-    ╔═══════════════════════════════════════════════════════════╗
-    ║                                                           ║
-    ║        🚀  Crypto Monitor ULTIMATE  🚀                   ║
-    ║                                                           ║
-    ║   نسخه توسعه‌یافته با ۱۰۰+ ارائه‌دهنده API رایگان      ║
-    ║   + سیستم پیشرفته Provider Pool Management              ║
-    ║                                                           ║
-    ║   Version: 2.0.0                                          ║
-    ║   Author: Crypto Monitor Team                             ║
-    ║                                                           ║
-    ╚═══════════════════════════════════════════════════════════╝
-    """
-    print(banner)
-
-
-def show_menu():
-    """نمایش منوی انتخاب"""
-    print("\n📋 انتخاب کنید:")
-    print("  1️⃣  اجرای سرور (Production Mode)")
-    print("  2️⃣  اجرای سرور (Development Mode - با Auto Reload)")
-    print("  3️⃣  تست Provider Manager")
-    print("  4️⃣  نمایش آمار ارائه‌دهندگان")
-    print("  5️⃣  نصب/بروزرسانی وابستگی‌ها")
-    print("  0️⃣  خروج")
-    print()
-
-
-def run_server_production():
-    """اجرای سرور در حالت Production"""
-    print("\n🚀 راه‌اندازی سرور در حالت Production...")
-    print("📡 آدرس: http://localhost:8000")
-    print("📊 داشبورد: http://localhost:8000")
-    print("📖 API Docs: http://localhost:8000/docs")
-    print("\n⏸️  برای توقف سرور Ctrl+C را فشار دهید\n")
-    
-    try:
-        subprocess.run([
-            sys.executable, "-m", "uvicorn",
-            "api_server_extended:app",
-            "--host", "0.0.0.0",
-            "--port", "8000",
-            "--log-level", "info"
-        ])
-    except KeyboardInterrupt:
-        print("\n\n🛑 سرور متوقف شد")
-
-
-def run_server_development():
-    """اجرای سرور در حالت Development"""
-    print("\n🔧 راه‌اندازی سرور در حالت Development (Auto Reload)...")
-    print("📡 آدرس: http://localhost:8000")
-    print("📊 داشبورد: http://localhost:8000")
-    print("📖 API Docs: http://localhost:8000/docs")
-    print("\n⏸️  برای توقف سرور Ctrl+C را فشار دهید")
-    print("♻️  تغییرات فایل‌ها به‌طور خودکار اعمال می‌شود\n")
-    
-    try:
-        subprocess.run([
-            sys.executable, "-m", "uvicorn",
-            "api_server_extended:app",
-            "--host", "0.0.0.0",
-            "--port", "8000",
-            "--reload",
-            "--log-level", "debug"
-        ])
-    except KeyboardInterrupt:
-        print("\n\n🛑 سرور متوقف شد")
-
-
-def test_provider_manager():
-    """تست Provider Manager"""
-    print("\n🧪 اجرای تست Provider Manager...\n")
-    try:
-        subprocess.run([sys.executable, "provider_manager.py"])
-    except FileNotFoundError:
-        print("❌ فایل provider_manager.py یافت نشد")
-    except KeyboardInterrupt:
-        print("\n\n🛑 تست متوقف شد")
-
-
-def show_stats():
-    """نمایش آمار ارائه‌دهندگان"""
-    print("\n📊 نمایش آمار ارائه‌دهندگان...\n")
-    try:
-        from provider_manager import ProviderManager
-        manager = ProviderManager()
-        stats = manager.get_all_stats()
-        
-        summary = stats['summary']
-        print("=" * 60)
-        print(f"📈 آمار کلی سیستم")
-        print("=" * 60)
-        print(f"  کل ارائه‌دهندگان:     {summary['total_providers']}")
-        print(f"  آنلاین:              {summary['online']}")
-        print(f"  آفلاین:              {summary['offline']}")
-        print(f"  Degraded:            {summary['degraded']}")
-        print(f"  کل درخواست‌ها:       {summary['total_requests']}")
-        print(f"  درخواست‌های موفق:    {summary['successful_requests']}")
-        print(f"  نرخ موفقیت:          {summary['overall_success_rate']:.2f}%")
-        print("=" * 60)
-        
-        print(f"\n🔄 Pool‌های موجود: {len(stats['pools'])}")
-        for pool_id, pool_data in stats['pools'].items():
-            print(f"\n  📦 {pool_data['pool_name']}")
-            print(f"     دسته: {pool_data['category']}")
-            print(f"     استراتژی: {pool_data['rotation_strategy']}")
-            print(f"     اعضا: {pool_data['total_providers']}")
-            print(f"     در دسترس: {pool_data['available_providers']}")
-        
-        print("\n✅ برای جزئیات بیشتر، سرور را اجرا کرده و به داشبورد مراجعه کنید")
-        
-    except ImportError:
-        print("❌ خطا: provider_manager.py یافت نشد یا وابستگی‌ها نصب نشده‌اند")
-    except Exception as e:
-        print(f"❌ خطا: {e}")
-
-
-def main():
-    """تابع اصلی"""
-    show_banner()
-    
-    # بررسی وابستگی‌ها
-    check_dependencies()
-    
-    # بررسی فایل‌های پیکربندی
-    check_config_files()
-    
-    # حلقه منو
-    while True:
-        show_menu()
-        choice = input("انتخاب شما: ").strip()
-        
-        if choice == "1":
-            run_server_production()
-            break
-        elif choice == "2":
-            run_server_development()
-            break
-        elif choice == "3":
-            test_provider_manager()
-            input("\n⏎ Enter را برای بازگشت به منو فشار دهید...")
-        elif choice == "4":
-            show_stats()
-            input("\n⏎ Enter را برای بازگشت به منو فشار دهید...")
-        elif choice == "5":
-            install_dependencies()
-            input("\n⏎ Enter را برای بازگشت به منو فشار دهید...")
-        elif choice == "0":
-            print("\n👋 خداحافظ!")
-            sys.exit(0)
-        else:
-            print("\n❌ انتخاب نامعتبر! لطفاً دوباره تلاش کنید.")
-
+"""Simple server startup script"""
+import uvicorn
 
 if __name__ == "__main__":
-    try:
-        main()
-    except KeyboardInterrupt:
-        print("\n\n👋 برنامه متوقف شد")
-        sys.exit(0)
+    print("=" * 60)
+    print("Starting Crypto API Monitor Backend")
+    print("Server will be available at: http://localhost:7860")
+    print("Frontend: http://localhost:7860/index.html")
+    print("HF Console: http://localhost:7860/hf_console.html")
+    print("API Docs: http://localhost:7860/docs")
+    print("=" * 60)
+    
+    uvicorn.run(
+        "app:app",
+        host="0.0.0.0",
+        port=7860,
+        log_level="info",
+        access_log=True
+    )

utils/__init__.py

@@ -1,20 +0,0 @@
-"""Utility package for API monitor/crypto aggregator.
-
-Provides convenient accessors like `setup_logging` and shared helpers.
-"""
-
-from .logger import setup_logger, app_logger
-
-def setup_logging(name: str = "crypto_monitor", level: str = "INFO"):
-    """Backward-compatible wrapper expected by older code.
-
-    Older modules call `utils.setup_logging()`. We now route that to the
-    structured logger configuration in `utils.logger`.
-    """
-    return setup_logger(name=name, level=level)
-
-__all__ = [
-    "setup_logger",
-    "setup_logging",
-    "app_logger",
-]