Upload 10 files

.dockerignore

@@ -1,9 +1,9 @@
-# Python
 __pycache__/
 *.py[cod]
 *$py.class
 *.so
 .Python
+env/
 build/
 develop-eggs/
 dist/
@@ -15,107 +15,17 @@ lib64/
 parts/
 sdist/
 var/
-wheels/
 *.egg-info/
 .installed.cfg
 *.egg
-MANIFEST
-pip-log.txt
-pip-delete-this-directory.txt
-
-# Virtual environments
+.env
+.venv
 venv/
 ENV/
-env/
-.venv
-
-# IDE
-.vscode/
 .idea/
+.vscode/
 *.swp
-*.swo
-*~
-.DS_Store
-
-# 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
+.git
+.gitignore

Dockerfile

@@ -1,71 +1,37 @@
-# Dockerfile for Crypto API Monitoring System
-# Optimized for HuggingFace Spaces deployment
-FROM python:3.10-slim
+FROM python:3.9-slim
 
-# Set working directory
-WORKDIR /app
+WORKDIR /code
 
-# Set environment variables for better Python behavior
-ENV PYTHONUNBUFFERED=1 \
-    PYTHONDONTWRITEBYTECODE=1 \
-    PIP_NO_CACHE_DIR=1 \
-    PIP_DISABLE_PIP_VERSION_CHECK=1
-
-# Install system dependencies required for building Python packages
-RUN apt-get update && apt-get install -y --no-install-recommends \
-    gcc \
-    g++ \
-    git \
+# Install system dependencies
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends \
+    build-essential \
     curl \
+    git \
+    && apt-get clean \
     && rm -rf /var/lib/apt/lists/*
 
-# Copy requirements first for better layer caching
+# Copy requirements first to leverage Docker cache
 COPY requirements.txt .
 
-# Install Python dependencies with optimizations
-# Split into two steps: core dependencies first, then ML libraries
-RUN pip install --no-cache-dir \
-    fastapi==0.104.1 \
-    uvicorn[standard]==0.24.0 \
-    pydantic==2.5.0 \
-    python-multipart==0.0.6 \
-    websockets==12.0 \
-    SQLAlchemy==2.0.23 \
-    APScheduler==3.10.4 \
-    aiohttp==3.9.1 \
-    requests==2.31.0 \
-    httpx \
-    python-dotenv==1.0.0 \
-    feedparser==6.0.11 \
-    gradio==4.14.0 \
-    pandas==2.1.4 \
-    plotly==5.18.0
+# Install Python dependencies
+RUN pip install --no-cache-dir --upgrade pip && \
+    pip install --no-cache-dir -r requirements.txt
 
-# Install HuggingFace ML dependencies separately
-RUN pip install --no-cache-dir \
-    transformers>=4.44.0 \
-    datasets>=3.0.0 \
-    huggingface_hub>=0.24.0 \
-    torch>=2.0.0 --index-url https://download.pytorch.org/whl/cpu \
-    sentencepiece>=0.1.99 \
-    protobuf>=3.20.0
+# Create necessary directories with correct permissions
+RUN mkdir -p /code/data /code/logs && \
+    chmod -R 755 /code/data /code/logs
 
-# Copy all application code
-COPY . .
+# Copy application code
+COPY app /code/app
+COPY main.py /code/
 
-# Create necessary directories
-RUN mkdir -p data logs
+# Set environment variables
+ENV PYTHONPATH=/code
+ENV PORT=7860
 
-# Set proper permissions for data directories
-RUN chmod -R 755 data logs
-
-# Expose port 7860 (HuggingFace Spaces standard port)
+# Expose the port
 EXPOSE 7860
 
-# Health check endpoint for HuggingFace Spaces
-HEALTHCHECK --interval=30s --timeout=10s --start-period=40s --retries=3 \
-    CMD curl -f http://localhost:7860/health || exit 1
-
-# Run the FastAPI application with uvicorn
-# Using multiple workers for better performance (adjust based on available resources)
-CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860", "--log-level", "info", "--workers", "1"]
+# Run the application
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -1,281 +1,45 @@
 ---
-title: Crypto API Monitor - Vidya UI
-emoji: 📊
+title: Cryptocurrency Data API
+emoji: 📈
 colorFrom: blue
-colorTo: purple
+colorTo: green
 sdk: docker
 app_port: 7860
 pinned: false
-license: mit
 ---
 
-# 📊 Cryptocurrency API Monitor - Vidya Dashboard
+# Cryptocurrency Data Source API
 
-> **Production-ready real-time cryptocurrency API monitoring with beautiful Vidya HTML UI**
+This API provides cryptocurrency market data and technical indicators from various exchanges. It's built with FastAPI and designed to be deployed on Hugging Face Spaces.
 
-A comprehensive monitoring system that tracks the health, performance, and availability of 162+ cryptocurrency APIs including market data, blockchain explorers, RPC nodes, news sources, sentiment analyzers, and more. Features a stunning real-time dashboard with WebSocket support.
+## Features
 
-## 🌟 Features
-
-### Beautiful Vidya HTML UI
-- **Modern Design**: Gradient-based UI with smooth animations and transitions
-- **Real-time Updates**: WebSocket-powered live data streaming
-- **Interactive Dashboard**: KPI cards, charts, and data visualizations
-- **Multiple Views**: Dashboard, Inventory, Logs, Analytics, and HuggingFace Integration
-- **Responsive**: Works perfectly on desktop, tablet, and mobile devices
-
-### Core Capabilities
-- **Real-Time Monitoring**: Track 162+ API endpoints with live status updates
-- **WebSocket Streaming**: Real-time data feeds for all services
-- **Multi-Category Support**: Market Data, Blockchain Explorers, RPC Nodes, News, Sentiment, On-chain Analytics
-- **Health Tracking**: Response times, uptime percentages, failure detection
-- **Rate Limit Management**: Automatic rate limiting with configurable rules
-- **Database Persistence**: SQLite-based historical data storage
-- **Automated Scheduling**: Background tasks for continuous monitoring
-- **Alert System**: Real-time alerts for critical failures
-- **HuggingFace Integration**: AI/ML capabilities with sentiment analysis
-
-### WebSocket Services
-The application provides comprehensive WebSocket APIs for real-time streaming:
-
-#### Data Collection Streams
-- `/ws/market_data` - Live market data updates
-- `/ws/news` - Real-time crypto news feed
-- `/ws/sentiment` - Sentiment analysis stream
-- `/ws/whale_tracking` - Whale transaction alerts
-- `/ws/data` - Unified data collection stream
-
-#### Monitoring Streams
-- `/ws/health` - System health status
-- `/ws/pool_status` - Pool management updates
-- `/ws/scheduler_status` - Scheduler activity
-- `/ws/monitoring` - Unified monitoring stream
-
-#### Integration Streams
-- `/ws/huggingface` - HuggingFace AI/ML integration
-- `/ws/ai` - AI services stream
-- `/ws/persistence` - Persistence service updates
-- `/ws/integration` - Unified integration stream
-
-#### Master Streams
-- `/ws` or `/ws/master` - All services combined
-- `/ws/live` - Legacy live updates (compatible with older clients)
+- Access to multiple cryptocurrency exchanges through a unified API
+- OHLCV data retrieval with caching for better performance
+- Technical indicators calculation (RSI, MACD, Bollinger Bands, EMA, etc.)
+- Designed for easy integration with trading systems and analysis tools
 
 ## API Endpoints
 
-### System Status
-- `GET /api/status` - Overall system health
-- `GET /api/categories` - Statistics by category
-- `GET /api/providers` - List all providers with filtering
-
-### Logs & Analytics
-- `GET /api/logs` - Connection logs with pagination
-- `GET /api/failures` - Failure analysis with remediation suggestions
-- `GET /api/freshness` - Data freshness metrics
-
-### Scheduler
-- `GET /api/schedule` - Schedule status and compliance
-- `POST /api/schedule/trigger` - Trigger immediate health check
-
-### Rate Limits
-- `GET /api/rate-limits` - Current rate limit status for all providers
-
-### Configuration
-- `GET /api/config/keys` - API key status (masked)
-- `POST /api/config/keys/test` - Test API key validity
-
-### Charts Data
-- `GET /api/charts/health-history` - Time series for charts
-- `GET /api/charts/compliance` - Compliance trends
-
-## WebSocket Support
-
-Real-time updates at `ws://localhost:7860/ws/live`
-
-### Message Types
-- `status_update` - System status every 10 seconds
-- `new_log_entry` - Real-time log notifications
-- `rate_limit_alert` - Warnings when usage ≥80%
-- `provider_status_change` - Provider status changes
-- `ping` - Heartbeat every 30 seconds
-
-## Architecture
-
-```
-crypto-dt-source/
-├── app.py                      # Main FastAPI application
-├── config.py                   # Configuration loader
-├── monitoring/
-│   ├── health_checker.py       # API health monitoring
-│   ├── rate_limiter.py         # Rate limit tracking
-│   └── scheduler.py            # Task scheduling
-├── database/
-│   ├── models.py               # SQLAlchemy models
-│   └── db_manager.py           # Database operations
-├── collectors/
-│   ├── market_data.py          # Market data collection
-│   ├── explorers.py            # Blockchain explorer data
-│   ├── news.py                 # News aggregation
-│   ├── sentiment.py            # Sentiment data
-│   └── onchain.py              # On-chain analytics
-├── api/
-│   ├── endpoints.py            # REST API endpoints
-│   └── websocket.py            # WebSocket support
-└── utils/
-    ├── logger.py               # Structured JSON logging
-    └── api_client.py           # HTTP client with retry logic
-```
-
-## Database Schema
-
-SQLite database at `data/api_monitor.db` with tables:
-- **providers** - API provider configurations
-- **connection_attempts** - All health check attempts
-- **data_collections** - Data collection logs
-- **rate_limit_usage** - Rate limit snapshots
-- **schedule_config** - Schedule configurations
-- **schedule_compliance** - Schedule execution tracking
-- **failure_logs** - Detailed failure logs
-- **alerts** - System alerts
-- **system_metrics** - System-wide metrics
-
-## Environment Variables
-
-Configure API keys via environment variables:
-
-```bash
-# Blockchain Explorers
-export ETHERSCAN_KEY_1="your_key"
-export ETHERSCAN_KEY_2="your_backup_key"
-export BSCSCAN_KEY="your_key"
-export TRONSCAN_KEY="your_key"
-
-# Market Data
-export COINMARKETCAP_KEY_1="your_key"
-export COINMARKETCAP_KEY_2="your_backup_key"
-export CRYPTOCOMPARE_KEY="your_key"
-
-# News
-export NEWSAPI_KEY="your_key"
-
-# Optional
-export HUGGINGFACE_KEY="your_key"
-```
-
-## 🚀 Quick Start
-
-### Hugging Face Spaces Deployment (Recommended)
-
-This application is configured for **Docker SDK** deployment on Hugging Face Spaces:
-
-1. **Create a new Space** on [Hugging Face](https://huggingface.co/spaces)
-2. **Select SDK**: Choose "Docker" as the SDK
-3. **Link Repository**: Connect this GitHub repository
-4. **Configure Secrets** (Optional - for API keys):
-   ```
-   ETHERSCAN_KEY
-   BSCSCAN_KEY
-   TRONSCAN_KEY
-   CMC_KEY
-   CRYPTOCOMPARE_KEY
-   NEWSAPI_KEY
-   INFURA_KEY
-   ALCHEMY_KEY
-   ```
-5. **Deploy**: Push to your repository - auto-deploy triggers!
-
-The application will be available at `https://YOUR_USERNAME-SPACE_NAME.hf.space`
-
-### Local Development
-
-```bash
-# Clone repository
-git clone https://github.com/nimazasinich/crypto-dt-source.git
-cd crypto-dt-source
-
-# Install dependencies
-pip install -r requirements.txt
-
-# Run the application
-python app.py
-```
-
-Visit `http://localhost:7860` to access the Vidya dashboard.
-
-### Docker Deployment
-
-```bash
-# Build image
-docker build -t crypto-api-monitor .
-
-# Run container
-docker run -p 7860:7860 crypto-api-monitor
-```
-
-## API Documentation
-
-Once running, visit:
-- **Swagger UI**: http://localhost:7860/docs
-- **ReDoc**: http://localhost:7860/redoc
-
-## Tech Stack
-
-- **FastAPI** - Modern async web framework
-- **SQLAlchemy** - Database ORM
-- **APScheduler** - Task scheduling
-- **aiohttp** - Async HTTP client
-- **WebSockets** - Real-time communication
-- **SQLite** - Embedded database
-
-## Features Breakdown
-
-### Health Checking (every 5 minutes)
-- CoinGecko: `GET /api/v3/ping`
-- CoinMarketCap: `GET /v1/cryptocurrency/map?limit=1`
-- Etherscan: `GET /api?module=stats&action=ethsupply`
-- BscScan: `GET /api?module=stats&action=bnbsupply`
-- TronScan: `GET /api/system/status`
-- CryptoPanic: `GET /v1/posts/?auth_token=free`
-- Alternative.me: `GET /fng/`
-- NewsAPI: `GET /news?category=business`
-- CryptoCompare: `GET /data/price?fsym=BTC&tsyms=USD`
-
-### Data Collection Schedules
-- **Market Data** (1 min): Price updates for BTC, ETH, BNB
-- **Explorers** (5 min): Gas prices, network stats
-- **News** (10 min): Latest crypto news posts
-- **Sentiment** (15 min): Fear & Greed Index
-
-### Failure Analysis
-- Error type distribution (timeout, rate_limit, server_error, auth_error)
-- Top 10 failing providers
-- Recent failure log with retry results
-- Intelligent remediation suggestions
-
-### Retry Logic
-- **Timeout**: Retry with timeout +50%, max 3 attempts
-- **Rate Limit**: Wait until reset_time + 10s buffer
-- **5xx Errors**: Exponential backoff (1min, 2min, 4min), max 5 attempts
-- **401 Auth**: No retry, log key_expired alert
-
-## License
-
-MIT License - see LICENSE file for details
+- `GET /exchanges` - List available exchanges
+- `GET /exchanges/{exchange_id}/markets` - List markets for a specific exchange
+- `GET /data/{exchange_id}/{symbol}/{timeframe}` - Get OHLCV data for a market
+- `GET /indicators/{exchange_id}/{symbol}/{timeframe}` - Get technical indicators for a market
+- `GET /data/available` - Get list of available cached data files
+- `GET /health` - Health check endpoint
 
-## Contributing
+## Usage
 
-Contributions welcome! Please open an issue or pull request.
+The API documentation is available at `/docs` once the service is running.
 
-## Monitoring
+## Development
 
-The system provides comprehensive monitoring:
-- Response times in milliseconds
-- Success/failure rates
-- Rate limit usage percentages
-- Data staleness metrics
-- Schedule compliance percentages
-- System health scores
+The API is built with:
+- FastAPI - Modern web framework for building APIs
+- CCXT - Library for cryptocurrency exchange trading
+- TA-Lib - Technical analysis library
+- Pandas - Data manipulation and analysis
 
-## Support
+## Deployment
 
-For issues, please open a GitHub issue or contact the maintainers.
+This application is designed for deployment on Hugging Face Spaces using Docker.

app/__init__.py

@@ -0,0 +1,2 @@
+# Cryptocurrency Data Source API
+# Version 1.0.0

app/indicators.py

@@ -0,0 +1,99 @@
+import pandas as pd
+import numpy as np
+import ta
+from typing import List, Dict, Any
+
+def calculate_indicators(df: pd.DataFrame, indicators: List[str]) -> pd.DataFrame:
+    """
+    Calculate technical indicators for the given OHLCV data
+    
+    Args:
+        df: DataFrame with OHLCV data
+        indicators: List of indicators to calculate
+    
+    Returns:
+        DataFrame with calculated indicators
+    """
+    # Make a copy to avoid modifying the original DataFrame
+    result = df.copy()
+    
+    # Ensure we have required columns
+    required_columns = ['timestamp', 'datetime', 'open', 'high', 'low', 'close', 'volume']
+    for col in required_columns:
+        if col not in result.columns:
+            if col == 'datetime' and 'timestamp' in result.columns:
+                # We can calculate datetime from timestamp
+                continue
+            else:
+                raise ValueError(f"Required column {col} not found in DataFrame")
+    
+    # Calculate RSI
+    if 'rsi' in indicators:
+        result['rsi'] = ta.momentum.RSIIndicator(
+            close=result['close'], 
+            window=14
+        ).rsi()
+    
+    # Calculate MACD
+    if 'macd' in indicators:
+        macd = ta.trend.MACD(
+            close=result['close'],
+            window_fast=12,
+            window_slow=26,
+            window_sign=9
+        )
+        result['macd'] = macd.macd()
+        result['macd_signal'] = macd.macd_signal()
+        result['macd_histogram'] = macd.macd_diff()
+    
+    # Calculate Bollinger Bands
+    if 'bollinger' in indicators:
+        bollinger = ta.volatility.BollingerBands(
+            close=result['close'],
+            window=20,
+            window_dev=2
+        )
+        result['bb_upper'] = bollinger.bollinger_hband()
+        result['bb_middle'] = bollinger.bollinger_mavg()
+        result['bb_lower'] = bollinger.bollinger_lband()
+    
+    # Calculate Exponential Moving Averages
+    if 'ema' in indicators:
+        result['ema_9'] = ta.trend.EMAIndicator(
+            close=result['close'], window=9
+        ).ema_indicator()
+        
+        result['ema_21'] = ta.trend.EMAIndicator(
+            close=result['close'], window=21
+        ).ema_indicator()
+        
+        result['ema_50'] = ta.trend.EMAIndicator(
+            close=result['close'], window=50
+        ).ema_indicator()
+        
+        result['ema_200'] = ta.trend.EMAIndicator(
+            close=result['close'], window=200
+        ).ema_indicator()
+    
+    # Calculate Average True Range (ATR)
+    if 'atr' in indicators:
+        result['atr'] = ta.volatility.AverageTrueRange(
+            high=result['high'],
+            low=result['low'],
+            close=result['close'],
+            window=14
+        ).average_true_range()
+    
+    # Calculate Stochastic Oscillator
+    if 'stoch' in indicators:
+        stoch = ta.momentum.StochasticOscillator(
+            high=result['high'],
+            low=result['low'],
+            close=result['close'],
+            window=14,
+            smooth_window=3
+        )
+        result['stoch_k'] = stoch.stoch()
+        result['stoch_d'] = stoch.stoch_signal()
+    
+    return result

app/models.py

@@ -0,0 +1,55 @@
+from pydantic import BaseModel, Field
+from typing import List, Dict, Any, Optional
+from enum import Enum
+
+class TimeFrame(str, Enum):
+    MINUTE_1 = '1m'
+    MINUTE_5 = '5m'
+    MINUTE_15 = '15m'
+    MINUTE_30 = '30m'
+    HOUR_1 = '1h'
+    HOUR_4 = '4h'
+    DAY_1 = '1d'
+    WEEK_1 = '1w'
+    MONTH_1 = '1M'
+
+class CryptoPair(BaseModel):
+    symbol: str
+    base: str
+    quote: str
+    type: str = "spot"
+
+class ExchangeInfo(BaseModel):
+    id: str
+    name: str
+    has_fetchOHLCV: bool = False
+    timeframes: List[str] = []
+
+class OHLCVData(BaseModel):
+    timestamp: int
+    datetime: str
+    open: float
+    high: float
+    low: float
+    close: float
+    volume: float
+
+class IndicatorValues(BaseModel):
+    timestamp: int
+    datetime: str
+    rsi: Optional[float] = None
+    macd: Optional[float] = None
+    macd_signal: Optional[float] = None
+    macd_histogram: Optional[float] = None
+    ema_9: Optional[float] = None
+    ema_21: Optional[float] = None
+    ema_50: Optional[float] = None
+    ema_200: Optional[float] = None
+    bb_upper: Optional[float] = None
+    bb_middle: Optional[float] = None
+    bb_lower: Optional[float] = None
+    open: Optional[float] = None
+    high: Optional[float] = None
+    low: Optional[float] = None
+    close: Optional[float] = None
+    volume: Optional[float] = None

app/storage.py

@@ -0,0 +1,112 @@
+import os
+import json
+from typing import List, Dict, Any, Union
+import pandas as pd
+
+def save_market_data(data: List[List[Union[int, float]]], file_path: str) -> bool:
+    """
+    Save market data to a JSON file
+    
+    Args:
+        data: List of OHLCV candles
+        file_path: Path to save the data
+    
+    Returns:
+        bool: True if saved successfully
+    """
+    try:
+        # Create directory if it doesn't exist
+        os.makedirs(os.path.dirname(file_path), exist_ok=True)
+        
+        with open(file_path, 'w') as f:
+            json.dump(data, f)
+        
+        return True
+    except Exception as e:
+        print(f"Error saving market data: {str(e)}")
+        return False
+
+def load_market_data(file_path: str) -> List[List[Union[int, float]]]:
+    """
+    Load market data from a JSON file
+    
+    Args:
+        file_path: Path to the data file
+    
+    Returns:
+        List of OHLCV candles
+    """
+    try:
+        with open(file_path, 'r') as f:
+            data = json.load(f)
+        
+        return data
+    except Exception as e:
+        print(f"Error loading market data: {str(e)}")
+        return []
+
+def get_available_data(directory: str) -> List[Dict[str, Any]]:
+    """
+    Get list of available data files
+    
+    Args:
+        directory: Directory to scan
+    
+    Returns:
+        List of data file information
+    """
+    result = []
+    
+    try:
+        # Create directory if it doesn't exist
+        os.makedirs(directory, exist_ok=True)
+        
+        # List files in directory
+        files = os.listdir(directory)
+        
+        for file in files:
+            if file.endswith('.json'):
+                # Parse file name to extract information
+                parts = file.replace('.json', '').split('_')
+                
+                if len(parts) >= 3:
+                    exchange_id = parts[0]
+                    
+                    # Reconstruct symbol (may contain underscores)
+                    timeframe_index = None
+                    for i, part in enumerate(parts[2:], start=2):
+                        if part in ['1m', '5m', '15m', '30m', '1h', '4h', '1d', '1w', '1M']:
+                            timeframe_index = i
+                            break
+                    
+                    if timeframe_index is not None:
+                        symbol_parts = parts[1:timeframe_index]
+                        symbol = '/'.join(symbol_parts) if len(symbol_parts) > 1 else symbol_parts[0]
+                        timeframe = parts[timeframe_index]
+                        
+                        # Get file stats
+                        file_path = os.path.join(directory, file)
+                        file_size = os.path.getsize(file_path)
+                        modified_time = os.path.getmtime(file_path)
+                        
+                        # Get candle count
+                        try:
+                            data = load_market_data(file_path)
+                            candle_count = len(data)
+                        except:
+                            candle_count = 0
+                        
+                        result.append({
+                            'exchange': exchange_id,
+                            'symbol': symbol,
+                            'timeframe': timeframe,
+                            'filename': file,
+                            'size_kb': round(file_size / 1024, 2),
+                            'modified': modified_time,
+                            'candle_count': candle_count
+                        })
+        
+        return result
+    except Exception as e:
+        print(f"Error getting available data: {str(e)}")
+        return []

app/utils.py

@@ -0,0 +1,75 @@
+import os
+import logging
+import ccxt
+from logging.handlers import RotatingFileHandler
+from datetime import datetime
+import json
+from typing import List, Dict, Any
+
+def setup_logger():
+    """Configure and set up the logger"""
+    # Create logs directory if it doesn't exist
+    os.makedirs("logs", exist_ok=True)
+    
+    # Configure logger
+    logger = logging.getLogger("crypto_data_source")
+    logger.setLevel(logging.INFO)
+    
+    # Create console handler
+    console_handler = logging.StreamHandler()
+    console_handler.setLevel(logging.INFO)
+    
+    # Create file handler
+    log_file = f"logs/crypto_data_source_{datetime.now().strftime('%Y%m%d')}.log"
+    file_handler = RotatingFileHandler(
+        log_file, maxBytes=10*1024*1024, backupCount=5
+    )
+    file_handler.setLevel(logging.INFO)
+    
+    # Create formatter
+    formatter = logging.Formatter(
+        '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+    )
+    
+    # Add formatter to handlers
+    console_handler.setFormatter(formatter)
+    file_handler.setFormatter(formatter)
+    
+    # Add handlers to logger
+    logger.addHandler(console_handler)
+    logger.addHandler(file_handler)
+    
+    return logger
+
+def get_available_exchanges() -> List[str]:
+    """Get list of available exchanges with OHLCV support"""
+    exchanges = []
+    
+    # Focus on major exchanges that are reliable and have good API support
+    preferred_exchanges = [
+        'binance', 'kucoin', 'coinbase', 'kraken', 'okx', 'bybit'
+    ]
+    
+    for exchange_id in preferred_exchanges:
+        try:
+            exchange_class = getattr(ccxt, exchange_id)
+            exchange = exchange_class()
+            
+            # Only include exchanges that support OHLCV data
+            if exchange.has['fetchOHLCV']:
+                exchanges.append(exchange_id)
+        except:
+            # Skip exchanges that don't initialize properly
+            continue
+    
+    return exchanges
+
+def format_timestamp(timestamp_ms: int) -> str:
+    """Format timestamp to ISO string"""
+    return datetime.fromtimestamp(timestamp_ms / 1000).isoformat()
+
+def safe_json_serialize(obj):
+    """Custom JSON serializer for handling non-serializable types"""
+    if isinstance(obj, (datetime)):
+        return obj.isoformat()
+    raise TypeError(f"Type {type(obj)} not serializable")

main.py

@@ -0,0 +1,248 @@
+from fastapi import FastAPI, HTTPException, Query, Depends, Path
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import JSONResponse
+import os
+import logging
+from datetime import datetime, timedelta
+from typing import List, Dict, Any, Optional
+import json
+import ccxt
+import pandas as pd
+import numpy as np
+
+from app.models import CryptoPair, TimeFrame, ExchangeInfo
+from app.utils import setup_logger, get_available_exchanges
+from app.indicators import calculate_indicators
+from app.storage import save_market_data, load_market_data, get_available_data
+
+# Setup logging
+logger = setup_logger()
+logger.info("Starting Cryptocurrency Data Source API")
+
+# 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=["*"],
+)
+
+# Initialize exchanges
+available_exchanges = get_available_exchanges()
+exchange_instances = {}
+
+for exchange_id in available_exchanges:
+    try:
+        exchange_instances[exchange_id] = getattr(ccxt, exchange_id)({
+            'enableRateLimit': True,
+        })
+        logger.info(f"Initialized exchange: {exchange_id}")
+    except Exception as e:
+        logger.error(f"Error initializing {exchange_id}: {str(e)}")
+
+@app.get("/", response_class=JSONResponse)
+async def root():
+    """Root endpoint returning API information"""
+    return {
+        "message": "Cryptocurrency Data Source API is running",
+        "version": "1.0.0",
+        "endpoints": {
+            "GET /exchanges": "List available exchanges",
+            "GET /exchanges/{exchange_id}/markets": "List markets for a specific exchange",
+            "GET /data/{exchange_id}/{symbol}/{timeframe}": "Get OHLCV data for a market",
+            "GET /indicators/{exchange_id}/{symbol}/{timeframe}": "Get technical indicators for a market",
+        }
+    }
+
+@app.get("/exchanges", response_model=List[ExchangeInfo])
+async def get_exchanges():
+    """Get list of available exchanges"""
+    result = []
+    for exchange_id, exchange in exchange_instances.items():
+        try:
+            # Add basic exchange info
+            result.append(ExchangeInfo(
+                id=exchange_id,
+                name=exchange.name,
+                has_fetchOHLCV=exchange.has.get('fetchOHLCV', False),
+                timeframes=list(exchange.timeframes.keys()) if hasattr(exchange, 'timeframes') else []
+            ))
+        except Exception as e:
+            logger.error(f"Error getting info for {exchange_id}: {str(e)}")
+    
+    return result
+
+@app.get("/exchanges/{exchange_id}/markets", response_model=List[CryptoPair])
+async def get_markets(exchange_id: str = Path(..., description="Exchange ID")):
+    """Get available markets for a specific exchange"""
+    if exchange_id not in exchange_instances:
+        raise HTTPException(status_code=404, detail=f"Exchange {exchange_id} not found")
+    
+    try:
+        exchange = exchange_instances[exchange_id]
+        markets = exchange.load_markets()
+        
+        result = []
+        for symbol, market in markets.items():
+            if market['active']:
+                result.append(CryptoPair(
+                    symbol=symbol,
+                    base=market['base'],
+                    quote=market['quote'],
+                    type=market['type']
+                ))
+        
+        return result
+    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("/data/{exchange_id}/{symbol}/{timeframe}")
+async def get_market_data(
+    exchange_id: str = Path(..., description="Exchange ID"),
+    symbol: str = Path(..., description="Market symbol (e.g. BTC/USDT)"),
+    timeframe: str = Path(..., description="Timeframe (e.g. 1h, 1d)"),
+    limit: int = Query(100, description="Number of candles to return"),
+    from_timestamp: Optional[int] = Query(None, description="Start timestamp in milliseconds"),
+    use_cache: bool = Query(True, description="Whether to use cached data")
+):
+    """Get OHLCV market data for a specific market"""
+    if exchange_id not in exchange_instances:
+        raise HTTPException(status_code=404, detail=f"Exchange {exchange_id} not found")
+    
+    exchange = exchange_instances[exchange_id]
+    
+    # Check if exchange supports OHLCV
+    if not exchange.has.get('fetchOHLCV', False):
+        raise HTTPException(status_code=400, detail=f"Exchange {exchange_id} does not support OHLCV data")
+    
+    # Check if timeframe is supported
+    if hasattr(exchange, 'timeframes') and timeframe not in exchange.timeframes:
+        raise HTTPException(status_code=400, detail=f"Timeframe {timeframe} not supported by {exchange_id}")
+    
+    try:
+        # Check if we have cached data
+        cache_file = f"data/{exchange_id}_{symbol.replace('/', '_')}_{timeframe}.json"
+        cache_file = cache_file.replace(':', '_')  # Replace colons for Windows compatibility
+        
+        if use_cache and os.path.exists(cache_file):
+            data = load_market_data(cache_file)
+            
+            # Filter by from_timestamp if provided
+            if from_timestamp:
+                data = [candle for candle in data if candle[0] >= from_timestamp]
+                
+            # Limit the number of candles
+            data = data[-limit:]
+        else:
+            # Fetch data from exchange
+            data = exchange.fetch_ohlcv(
+                symbol=symbol,
+                timeframe=timeframe,
+                limit=limit,
+                since=from_timestamp
+            )
+            
+            # Save to cache
+            save_market_data(data, cache_file)
+        
+        # Convert to a more readable format
+        result = []
+        for candle in data:
+            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 result
+    
+    except ccxt.NetworkError as e:
+        logger.error(f"Network error: {str(e)}")
+        raise HTTPException(status_code=503, detail="Network error when connecting to exchange")
+    except ccxt.ExchangeError as e:
+        logger.error(f"Exchange error: {str(e)}")
+        raise HTTPException(status_code=500, detail=str(e))
+    except Exception as e:
+        logger.error(f"Error fetching data: {str(e)}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.get("/indicators/{exchange_id}/{symbol}/{timeframe}")
+async def get_indicators(
+    exchange_id: str = Path(..., description="Exchange ID"),
+    symbol: str = Path(..., description="Market symbol (e.g. BTC/USDT)"),
+    timeframe: str = Path(..., description="Timeframe (e.g. 1h, 1d)"),
+    limit: int = Query(100, description="Number of candles to include"),
+    include_price_data: bool = Query(False, description="Whether to include price data"),
+    indicators: List[str] = Query(
+        ["rsi", "macd", "bollinger", "ema"], 
+        description="Indicators to calculate"
+    )
+):
+    """Get technical indicators for a specific market"""
+    try:
+        # Get market data first
+        market_data = await get_market_data(
+            exchange_id=exchange_id,
+            symbol=symbol,
+            timeframe=timeframe,
+            limit=limit + 100,  # Extra data for accurate indicator calculation
+            use_cache=True
+        )
+        
+        # Convert to pandas DataFrame
+        df = pd.DataFrame(market_data)
+        
+        # Calculate indicators
+        result = calculate_indicators(df, indicators)
+        
+        # Remove extra data used for calculation
+        result = result.iloc[-limit:].reset_index(drop=True)
+        
+        # Include or exclude price data
+        if not include_price_data:
+            for col in ['open', 'high', 'low', 'close', 'volume']:
+                if col in result.columns:
+                    result = result.drop(col, axis=1)
+        
+        # Convert DataFrame to list of records
+        result_list = result.to_dict(orient='records')
+        
+        return result_list
+    
+    except Exception as e:
+        logger.error(f"Error calculating indicators: {str(e)}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.get("/data/available")
+async def get_available_data_files():
+    """Get list of available cached data files"""
+    try:
+        files = get_available_data("data")
+        return {"available_data": files}
+    except Exception as e:
+        logger.error(f"Error listing available data: {str(e)}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+# Add a health check endpoint
+@app.get("/health")
+async def health_check():
+    """Health check endpoint"""
+    return {"status": "healthy", "timestamp": datetime.now().isoformat()}
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run("main:app", host="0.0.0.0", port=int(os.getenv("PORT", 7860)), log_level="info")

requirements.txt

@@ -1,36 +1,15 @@
-# Gradio Application Dependencies
-gradio==4.14.0
-pandas==2.1.4
-plotly==5.18.0
-
-# Task Scheduling
-APScheduler==3.10.4
-
-# API & HTTP
-aiohttp==3.9.1
-requests==2.31.0
-httpx>=0.24
-
-# FastAPI (for API mode)
 fastapi==0.104.1
 uvicorn[standard]==0.24.0
 pydantic==2.5.0
 python-multipart==0.0.6
-websockets==12.0
-
-# Database
-SQLAlchemy==2.0.23
-
-# Configuration
+httpx==0.25.0
 python-dotenv==1.0.0
-
-# HuggingFace Integration (required for HF Spaces deployment)
-transformers>=4.44.0
-datasets>=3.0.0
-huggingface_hub>=0.24.0
-torch>=2.0.0
-sentencepiece>=0.1.99
-protobuf>=3.20.0
-
-# RSS Feed Parsing
-feedparser==6.0.11
+requests==2.31.0
+ccxt==4.0.0
+pandas==2.1.1
+numpy==1.26.0
+matplotlib==3.8.0
+plotly==5.18.0
+ta==0.10.2
+scikit-learn==1.3.1
+joblib==1.3.2