Upload 10 files

.dockerignore

@@ -2,30 +2,15 @@ __pycache__/
 *.py[cod]
 *$py.class
 *.so
-.Python
-env/
-build/
-develop-eggs/
-dist/
-downloads/
-eggs/
-.eggs/
-lib/
-lib64/
-parts/
-sdist/
-var/
-*.egg-info/
-.installed.cfg
-*.egg
 .env
 .venv
+env/
 venv/
 ENV/
-.idea/
-.vscode/
-*.swp
-*.bak
 .DS_Store
 .git
 .gitignore
+*.log
+*.sqlite
+.idea/
+.vscode/

Dockerfile

@@ -11,6 +11,9 @@ RUN apt-get update && \
     && apt-get clean \
     && rm -rf /var/lib/apt/lists/*
 
+# Create necessary directories
+RUN mkdir -p /code/data /code/logs
+
 # Copy requirements first to leverage Docker cache
 COPY requirements.txt .
 
@@ -18,13 +21,11 @@ COPY requirements.txt .
 RUN pip install --no-cache-dir --upgrade pip && \
     pip install --no-cache-dir -r requirements.txt
 
-# Create necessary directories with correct permissions
-RUN mkdir -p /code/data /code/logs && \
-    chmod -R 755 /code/data /code/logs
-
 # Copy application code
-COPY app /code/app
-COPY main.py /code/
+COPY . .
+
+# Ensure directories have correct permissions
+RUN chmod -R 755 /code/data /code/logs
 
 # Set environment variables
 ENV PYTHONPATH=/code

README.md

@@ -10,36 +10,33 @@ pinned: false
 
 # Cryptocurrency Data Source API
 
-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.
+This API provides cryptocurrency market data from various exchanges using the CCXT library.
 
 ## Features
 
-- 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
+- Access to multiple cryptocurrency exchanges
+- OHLCV (Open, High, Low, Close, Volume) data
+- Easy integration with trading systems
 
 ## API 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
-- `GET /data/available` - Get list of available cached data files
+- `GET /` - API status and version
+- `GET /exchanges` - List all available exchanges
+- `GET /markets/{exchange_id}` - Get markets for a specific exchange
+- `GET /ohlcv/{exchange_id}/{symbol}` - Get OHLCV data for a specific market
 - `GET /health` - Health check endpoint
 
 ## Usage
 
-The API documentation is available at `/docs` once the service is running.
+Once deployed, visit the `/docs` endpoint to see the interactive API documentation.
 
 ## Development
 
-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
+Built with:
+- FastAPI - Modern, fast web framework
+- CCXT - Cryptocurrency exchange trading library
+- Docker - Containerization
 
-## Deployment
+## Deployment on Hugging Face Spaces
 
-This application is designed for deployment on Hugging Face Spaces using Docker.
+This project is designed to be deployed as a Docker space on Hugging Face.

main.py

@@ -1,23 +1,19 @@
-from fastapi import FastAPI, HTTPException, Query, Depends, Path
+from fastapi import FastAPI, HTTPException, Depends
 from fastapi.middleware.cors import CORSMiddleware
-from fastapi.responses import JSONResponse
+import ccxt
 import os
 import logging
-from datetime import datetime, timedelta
-from typing import List, Dict, Any, Optional
-import json
-import ccxt
+from datetime import datetime
 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")
+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(
@@ -35,128 +31,104 @@ app.add_middleware(
     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)
+@app.get("/")
 async def root():
-    """Root endpoint returning API information"""
+    """Root endpoint showing API status"""
     return {
-        "message": "Cryptocurrency Data Source API is running",
+        "status": "online",
         "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",
-        }
+        "timestamp": datetime.now().isoformat(),
+        "ccxt_version": ccxt.__version__
     }
 
-@app.get("/exchanges", response_model=List[ExchangeInfo])
+@app.get("/exchanges")
 async def get_exchanges():
-    """Get list of available exchanges"""
-    result = []
-    for exchange_id, exchange in exchange_instances.items():
+    """List available exchanges"""
+    # Get list of exchanges that support OHLCV data
+    exchanges = []
+    for exchange_id in ccxt.exchanges:
         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)}")
+            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
     
-    return result
+    return {"total": len(exchanges), "exchanges": exchanges}
 
-@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")
-    
+@app.get("/markets/{exchange_id}")
+async def get_markets(exchange_id: str):
+    """Get markets for a specific exchange"""
     try:
-        exchange = exchange_instances[exchange_id]
+        # 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['active']:
-                result.append(CryptoPair(
-                    symbol=symbol,
-                    base=market['base'],
-                    quote=market['quote'],
-                    type=market['type']
-                ))
+            if market.get('active', False):
+                result.append({
+                    "symbol": symbol,
+                    "base": market.get('base', ''),
+                    "quote": market.get('quote', ''),
+                    "type": market.get('type', 'spot')
+                })
         
-        return result
+        return {"exchange": exchange_id, "total": len(result), "markets": result[:100]}
+    
+    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("/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}")
-    
+@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 we have cached data
-        cache_file = f"data/{exchange_id}_{symbol.replace('/', '_')}_{timeframe}.json"
-        cache_file = cache_file.replace(':', '_')  # Replace colons for Windows compatibility
+        # 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
+        })
         
-        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
+        # 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"
             )
-            
-            # Save to cache
-            save_market_data(data, cache_file)
         
-        # Convert to a more readable format
+        # 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 data:
+        for candle in ohlcv:
             timestamp, open_price, high, low, close, volume = candle
             result.append({
                 "timestamp": timestamp,
@@ -168,81 +140,29 @@ async def get_market_data(
                 "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
+        return {
+            "exchange": exchange_id,
+            "symbol": symbol,
+            "timeframe": timeframe,
+            "data": result
+        }
     
-    except Exception as e:
-        logger.error(f"Error calculating indicators: {str(e)}")
+    except ccxt.BaseError as 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)}")
+        logger.error(f"Error fetching OHLCV 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()}
+    return {
+        "status": "healthy",
+        "timestamp": datetime.now().isoformat(),
+        "version": "1.0.0"
+    }
 
 if __name__ == "__main__":
     import uvicorn
-    uvicorn.run("main:app", host="0.0.0.0", port=int(os.getenv("PORT", 7860)), log_level="info")
+    port = int(os.getenv("PORT", 7860))
+    uvicorn.run("main:app", host="0.0.0.0", port=port, log_level="info")