Comprehensive comparison for API Integration technology in Software Development applications

import os
import requests
import time
from typing import Dict, List, Optional
from datetime import datetime, timedelta
import logging

# Configure logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

class FinnhubStockDataService:
    """
    Production-ready service for integrating Finnhub Stock API
    into a financial dashboard application.
    """
    
    BASE_URL = "https://finnhub.io/api/v1"
    
    def __init__(self, api_key: Optional[str] = None):
        self.api_key = api_key or os.getenv("FINNHUB_API_KEY")
        if not self.api_key:
            raise ValueError("Finnhub API key is required")
        
        self.session = requests.Session()
        self.session.headers.update({"X-Finnhub-Token": self.api_key})
        self.rate_limit_delay = 1.0  # Seconds between requests
        self.last_request_time = 0
    
    def _rate_limit(self):
        """Implement rate limiting to avoid API throttling"""
        elapsed = time.time() - self.last_request_time
        if elapsed < self.rate_limit_delay:
            time.sleep(self.rate_limit_delay - elapsed)
        self.last_request_time = time.time()
    
    def _make_request(self, endpoint: str, params: Dict = None) -> Dict:
        """Make HTTP request with error handling and retries"""
        self._rate_limit()
        url = f"{self.BASE_URL}/{endpoint}"
        
        try:
            response = self.session.get(url, params=params, timeout=10)
            response.raise_for_status()
            return response.json()
        except requests.exceptions.HTTPError as e:
            if e.response.status_code == 429:
                logger.warning("Rate limit exceeded, waiting 60 seconds")
                time.sleep(60)
                return self._make_request(endpoint, params)
            elif e.response.status_code == 401:
                logger.error("Invalid API key")
                raise ValueError("Authentication failed")
            else:
                logger.error(f"HTTP error: {e}")
                raise
        except requests.exceptions.RequestException as e:
            logger.error(f"Request failed: {e}")
            raise
    
    def get_stock_quote(self, symbol: str) -> Dict:
        """Fetch real-time quote for a stock symbol"""
        logger.info(f"Fetching quote for {symbol}")
        data = self._make_request("quote", {"symbol": symbol})
        
        if not data or data.get("c") == 0:
            raise ValueError(f"No data available for symbol {symbol}")
        
        return {
            "symbol": symbol,
            "current_price": data.get("c"),
            "change": data.get("d"),
            "percent_change": data.get("dp"),
            "high": data.get("h"),
            "low": data.get("l"),
            "open": data.get("o"),
            "previous_close": data.get("pc"),
            "timestamp": datetime.fromtimestamp(data.get("t", 0)).isoformat()
        }
    
    def get_company_profile(self, symbol: str) -> Dict:
        """Retrieve company profile information"""
        logger.info(f"Fetching company profile for {symbol}")
        data = self._make_request("stock/profile2", {"symbol": symbol})
        
        if not data:
            raise ValueError(f"Company profile not found for {symbol}")
        
        return data
    
    def get_market_news(self, category: str = "general", limit: int = 10) -> List[Dict]:
        """Fetch latest market news"""
        logger.info(f"Fetching market news for category: {category}")
        data = self._make_request("news", {"category": category})
        return data[:limit] if data else []

# Example usage in a Flask API endpoint
def create_stock_api_endpoint():
    """
    Example Flask endpoint integrating Finnhub service
    """
    from flask import Flask, jsonify, request
    
    app = Flask(__name__)
    finnhub_service = FinnhubStockDataService()
    
    @app.route("/api/stocks/<symbol>", methods=["GET"])
    def get_stock_data(symbol: str):
        try:
            quote = finnhub_service.get_stock_quote(symbol.upper())
            profile = finnhub_service.get_company_profile(symbol.upper())
            
            return jsonify({
                "success": True,
                "data": {
                    "quote": quote,
                    "profile": profile
                }
            }), 200
        except ValueError as e:
            return jsonify({"success": False, "error": str(e)}), 404
        except Exception as e:
            logger.exception("Unexpected error")
            return jsonify({"success": False, "error": "Internal server error"}), 500
    
    return app