Deploy backend

.env.example

@@ -17,7 +17,7 @@ LOG_LEVEL=INFO
 # Cron ($0: internal scheduler + optional free HF Space Scheduler UI)
 CRON_SECRET=generate-a-long-random-string
 ENABLE_INTERNAL_CRON=true
-DAILY_FORECAST_LIMIT_PER_COUNTRY=50
+DAILY_FORECAST_LIMIT_PER_COUNTRY=200
 
 # CORS (comma-separated origins)
 CORS_ORIGINS=https://yourdomain.com,http://localhost:4321

app/main.py

@@ -16,7 +16,7 @@ from app.services.timesfm_service import TimesFMService
 from app.services.data_service import StockDataService
 from app.services.chart_service import ChartService
 from app.services.database_service import DatabaseService
-from app.models.schemas import ForecastResponse, StockInfo, HealthResponse
+from app.models.schemas import ForecastResponse, StockInfo, HealthResponse, BacktestAccuracy, FinancialMetrics
 from app.cron import router as cron_router
 from app.internal_cron import start_internal_cron
 from app.middleware import RateLimitMiddleware, RequestLoggingMiddleware
@@ -140,6 +140,59 @@ async def health_check():
     )
 
 
+async def calculate_backtest_accuracy(
+    historical_prices: list[float],
+    timesfm: TimesFMService
+) -> dict:
+    """
+    Calculate 5-day and 20-day forecast accuracy percentages
+    by slicing historical close prices, running forecasts, and
+    calculating MAPE against actual realized prices.
+    
+    Accuracy = max(0.0, 100.0 - MAPE_percentage)
+    """
+    if len(historical_prices) < 100:
+        return {"accuracy_5d": 0.0, "accuracy_20d": 0.0}
+
+    try:
+        # --- 5-Day Horizon Backtest ---
+        slice_5d = historical_prices[:-5]
+        realized_5d = historical_prices[-5:]
+        
+        forecast_5d = await timesfm.predict(historical_prices=slice_5d, horizon=5)
+        point_5d = forecast_5d.get("point_forecast", [])
+        
+        if len(point_5d) >= 5 and len(realized_5d) == 5:
+            errors = [abs(p - r) / r for p, r in zip(point_5d, realized_5d) if r > 0]
+            mape = sum(errors) / len(errors) if errors else 0.0
+            accuracy_5d = max(0.0, min(100.0, 100.0 - (mape * 100.0)))
+        else:
+            accuracy_5d = 0.0
+
+        # --- 20-Day Horizon Backtest ---
+        slice_20d = historical_prices[:-20]
+        realized_20d = historical_prices[-20:]
+        
+        forecast_20d = await timesfm.predict(historical_prices=slice_20d, horizon=20)
+        point_20d = forecast_20d.get("point_forecast", [])
+        
+        if len(point_20d) >= 20 and len(realized_20d) == 20:
+            errors = [abs(p - r) / r for p, r in zip(point_20d, realized_20d) if r > 0]
+            mape = sum(errors) / len(errors) if errors else 0.0
+            accuracy_20d = max(0.0, min(100.0, 100.0 - (mape * 100.0)))
+        else:
+            accuracy_20d = 0.0
+
+        return {
+            "accuracy_5d": round(accuracy_5d, 2),
+            "accuracy_20d": round(accuracy_20d, 2)
+        }
+
+    except Exception as e:
+        logger.warning(f"Error calculating backtest accuracy: {e}")
+        return {"accuracy_5d": 0.0, "accuracy_20d": 0.0}
+
+
 @app.get("/api/v1/forecast/{symbol}", response_model=ForecastResponse)
 async def get_forecast(
     symbol: str,
@@ -183,6 +236,12 @@ async def get_forecast(
             horizon=horizon
         )
         
+        # Calculate backtesting validation accuracy
+        backtest_acc = await calculate_backtest_accuracy(
+            historical_prices=close_series.tolist(),
+            timesfm=timesfm_service
+        )
+        
         # Generate chart
         chart_svg = chart_service.generate_forecast_chart(
             symbol=symbol,
@@ -191,6 +250,32 @@ async def get_forecast(
             current_price=current_price
         )
         
+        # Last 60 historical close prices, formatted timezone-safely (YYYY-MM-DD)
+        history_subset = close_series[-60:]
+        historical_prices_data = [
+            {
+                'time': date.strftime('%Y-%m-%d'),
+                'value': float(close)
+            }
+            for date, close in zip(history_subset.index, history_subset)
+        ]
+        
+        # Get financial metrics from attributes
+        from app.services.data_service import clean_float
+        pe_ratio = clean_float(stock_df.attrs.get('pe_ratio'))
+        dividend_yield = clean_float(stock_df.attrs.get('dividend_yield'))
+        fifty_two_week_low = clean_float(stock_df.attrs.get('fifty_two_week_low'))
+        fifty_two_week_high = clean_float(stock_df.attrs.get('fifty_two_week_high'))
+        market_cap = clean_float(stock_df.attrs.get('market_cap'))
+
+        financial_metrics = FinancialMetrics(
+            pe_ratio=pe_ratio,
+            dividend_yield=dividend_yield,
+            fifty_two_week_low=fifty_two_week_low,
+            fifty_two_week_high=fifty_two_week_high,
+            market_cap=market_cap,
+        )
+
         # Prepare response
         response = ForecastResponse(
             symbol=symbol,
@@ -210,6 +295,9 @@ async def get_forecast(
                 'p90': [float(x) for x in forecast_result['quantiles']['p90']],
             },
             chart_svg=chart_svg,
+            historical_prices=historical_prices_data,
+            backtest_accuracy=backtest_acc,
+            financial_metrics=financial_metrics,
             methodology_version="timesfm-2.5-200m-v1.0"
         )
         

app/models/schemas.py

@@ -12,6 +12,27 @@ class Quantiles(BaseModel):
     p90: list[float] = Field(..., description="90th percentile (optimistic)")
 
 
+class HistoricalPrice(BaseModel):
+    """Historical price data point for plotting"""
+    time: str = Field(..., description="Date in YYYY-MM-DD format")
+    value: float = Field(..., description="Closing price")
+
+
+class BacktestAccuracy(BaseModel):
+    """Backtesting forecast accuracy metrics"""
+    accuracy_5d: float = Field(..., description="5-day forecast accuracy percentage")
+    accuracy_20d: float = Field(..., description="20-day forecast accuracy percentage")
+
+
+class FinancialMetrics(BaseModel):
+    """Fundamental financial metrics for a stock"""
+    pe_ratio: Optional[float] = Field(default=None, description="Trailing P/E ratio")
+    dividend_yield: Optional[float] = Field(default=None, description="Dividend yield percentage")
+    fifty_two_week_low: Optional[float] = Field(default=None, description="52-week low price")
+    fifty_two_week_high: Optional[float] = Field(default=None, description="52-week high price")
+    market_cap: Optional[float] = Field(default=None, description="Market capitalization")
+
+
 class ForecastResponse(BaseModel):
     """Complete forecast response with all data"""
     symbol: str
@@ -25,6 +46,9 @@ class ForecastResponse(BaseModel):
     percentage_change: float = Field(..., description="Predicted % change from current")
     quantiles: Quantiles
     chart_svg: Optional[str] = Field(default=None, description="SVG chart as string")
+    historical_prices: list[HistoricalPrice] = Field(default=[], description="List of recent historical prices for plotting")
+    backtest_accuracy: Optional[BacktestAccuracy] = Field(default=None, description="TimesFM backtesting validation metrics")
+    financial_metrics: Optional[FinancialMetrics] = Field(default=None, description="Key fundamental statistics")
     methodology_version: str
 
 

app/services/data_service.py

@@ -34,6 +34,20 @@ MAX_WORKERS = 10  # Parallel fetches
 DEFAULT_DELAY = 0.5  # Base delay between batches (seconds)
 
 
+def clean_float(val) -> Optional[float]:
+    """Safely convert value to float, filtering out non-finite values (NaN, Inf) and None."""
+    if val is None:
+        return None
+    try:
+        f_val = float(val)
+        import math
+        if math.isnan(f_val) or math.isinf(f_val):
+            return None
+        return f_val
+    except (ValueError, TypeError):
+        return None
+
+
 class StockDataService:
     """Service for fetching stock data from Yahoo Finance with rate-limit protection"""
 
@@ -88,6 +102,18 @@ class StockDataService:
                     df.index = pd.to_datetime(df.index)
                 else:
                     df = pd.read_parquet(path)
+                
+                # Restore attrs from meta JSON if present
+                meta_path = cache_path.with_suffix(".meta.json")
+                if meta_path.exists():
+                    try:
+                        with open(meta_path, "r") as f:
+                            meta_data = json.load(f)
+                            for k, v in meta_data.items():
+                                df.attrs[k] = v
+                    except Exception as me:
+                        logger.warning(f"Failed to read metadata file: {me}")
+                        
                 logger.debug(f"Disk cache hit for {symbol} ({period})")
                 return df
             except Exception as e:
@@ -103,6 +129,25 @@ class StockDataService:
             except ImportError:
                 json_path = cache_path.with_suffix(".json")
                 df.reset_index().to_json(json_path, orient="records", date_format="iso")
+            
+            # Save attrs to a separate JSON file
+            meta_path = cache_path.with_suffix(".meta.json")
+            meta_data = {
+                'name': df.attrs.get('name'),
+                'exchange': df.attrs.get('exchange'),
+                'currency': df.attrs.get('currency'),
+                'pe_ratio': df.attrs.get('pe_ratio'),
+                'dividend_yield': df.attrs.get('dividend_yield'),
+                'fifty_two_week_low': df.attrs.get('fifty_two_week_low'),
+                'fifty_two_week_high': df.attrs.get('fifty_two_week_high'),
+                'market_cap': df.attrs.get('market_cap'),
+            }
+            try:
+                with open(meta_path, "w") as f:
+                    json.dump(meta_data, f)
+            except Exception as me:
+                logger.warning(f"Failed to write metadata file: {me}")
+                
             logger.debug(f"Cached {symbol} ({period}) to disk")
         except Exception as e:
             logger.debug(f"Skipped disk cache for {symbol}: {e}")
@@ -112,11 +157,12 @@ class StockDataService:
         try:
             now = datetime.now()
             expired = 0
-            for cache_file in CACHE_DIR.glob("*.parquet"):
-                age = now - datetime.fromtimestamp(cache_file.stat().st_mtime)
-                if age > timedelta(hours=CACHE_TTL_HOURS * 2):
-                    cache_file.unlink()
-                    expired += 1
+            for pattern in ("*.parquet", "*.json", "*.meta.json"):
+                for cache_file in CACHE_DIR.glob(pattern):
+                    age = now - datetime.fromtimestamp(cache_file.stat().st_mtime)
+                    if age > timedelta(hours=CACHE_TTL_HOURS * 2):
+                        cache_file.unlink()
+                        expired += 1
             if expired:
                 logger.info(f"Cleared {expired} expired cache files")
         except Exception as e:
@@ -202,9 +248,17 @@ class StockDataService:
             # Add metadata as DataFrame attributes
             try:
                 info = ticker.info
+                if not isinstance(info, dict):
+                    info = {}
                 df.attrs['name'] = info.get('longName', info.get('shortName', symbol))
                 df.attrs['exchange'] = info.get('exchange', 'UNKNOWN')
                 df.attrs['currency'] = info.get('currency', 'USD')
+                # Key fundamentals sanitized
+                df.attrs['pe_ratio'] = clean_float(info.get('trailingPE'))
+                df.attrs['dividend_yield'] = clean_float(info.get('dividendYield'))
+                df.attrs['fifty_two_week_low'] = clean_float(info.get('fiftyTwoWeekLow'))
+                df.attrs['fifty_two_week_high'] = clean_float(info.get('fiftyTwoWeekHigh'))
+                df.attrs['market_cap'] = clean_float(info.get('marketCap'))
             except Exception:
                 df.attrs['name'] = symbol
                 df.attrs['exchange'] = 'UNKNOWN'
@@ -440,9 +494,10 @@ class StockDataService:
 
         try:
             count = 0
-            for cache_file in CACHE_DIR.glob("*.parquet"):
-                cache_file.unlink()
-                count += 1
+            for pattern in ("*.parquet", "*.json", "*.meta.json"):
+                for cache_file in CACHE_DIR.glob(pattern):
+                    cache_file.unlink()
+                    count += 1
             logger.info(f"Cleared disk cache ({count} files)")
         except Exception as e:
             logger.warning(f"Disk cache clear failed: {e}")

app/services/database_service.py

@@ -182,6 +182,15 @@ class DatabaseService:
             # No stocks table exists — rename stocks_v2 to stocks
             await self._execute("ALTER TABLE stocks_v2 RENAME TO stocks")
 
+        # Add new columns for sync tracking (migration)
+        await self._add_column_if_not_exists("stocks", "trading_status", "TEXT DEFAULT 'active'")
+        await self._add_column_if_not_exists("stocks", "last_synced", "INTEGER DEFAULT 0")
+        await self._add_column_if_not_exists("stocks", "market_cap_tier", "TEXT DEFAULT NULL")
+        await self._add_column_if_not_exists("stocks", "data_quality_score", "INTEGER DEFAULT 100")
+        await self._add_column_if_not_exists("stocks", "yfinance_available", "INTEGER DEFAULT 1")
+        await self._add_column_if_not_exists("stocks", "description", "TEXT DEFAULT NULL")
+        await self._add_column_if_not_exists("stocks", "listing_date", "TEXT DEFAULT NULL")
+
         # Create indexes
         await self._execute("""
             CREATE INDEX IF NOT EXISTS idx_stocks_symbol
@@ -213,15 +222,6 @@ class DatabaseService:
             ON forecasts(created_at)
         """)
 
-        # Add new columns for sync tracking (migration)
-        await self._add_column_if_not_exists("stocks", "trading_status", "TEXT DEFAULT 'active'")
-        await self._add_column_if_not_exists("stocks", "last_synced", "INTEGER DEFAULT 0")
-        await self._add_column_if_not_exists("stocks", "market_cap_tier", "TEXT DEFAULT NULL")
-        await self._add_column_if_not_exists("stocks", "data_quality_score", "INTEGER DEFAULT 100")
-        await self._add_column_if_not_exists("stocks", "yfinance_available", "INTEGER DEFAULT 1")
-        await self._add_column_if_not_exists("stocks", "description", "TEXT DEFAULT NULL")
-        await self._add_column_if_not_exists("stocks", "listing_date", "TEXT DEFAULT NULL")
-
         # Create sync log table
         await self._execute("""
             CREATE TABLE IF NOT EXISTS sync_log (
@@ -716,35 +716,35 @@ class DatabaseService:
             logger.error(f"Failed to create sync log: {e}")
             return None
 
-    async def update_sync_log(self, log_id: int, **updates):
+    async def update_sync_log(self, log_id: int, **updates_dict):
         """Update sync log entry"""
         try:
-            updates = []
+            clauses = []
             params = []
             
-            if 'completed_at' in updates:
-                updates.append("completed_at = ?")
-                params.append(updates['completed_at'])
-            if 'stocks_added' in updates:
-                updates.append("stocks_added = ?")
-                params.append(updates['stocks_added'])
-            if 'stocks_removed' in updates:
-                updates.append("stocks_removed = ?")
-                params.append(updates['stocks_removed'])
-            if 'stocks_updated' in updates:
-                updates.append("stocks_updated = ?")
-                params.append(updates['stocks_updated'])
-            if 'errors' in updates:
-                updates.append("errors = ?")
-                params.append(updates['errors'])
-            if 'status' in updates:
-                updates.append("status = ?")
-                params.append(updates['status'])
+            if 'completed_at' in updates_dict:
+                clauses.append("completed_at = ?")
+                params.append(updates_dict['completed_at'])
+            if 'stocks_added' in updates_dict:
+                clauses.append("stocks_added = ?")
+                params.append(updates_dict['stocks_added'])
+            if 'stocks_removed' in updates_dict:
+                clauses.append("stocks_removed = ?")
+                params.append(updates_dict['stocks_removed'])
+            if 'stocks_updated' in updates_dict:
+                clauses.append("stocks_updated = ?")
+                params.append(updates_dict['stocks_updated'])
+            if 'errors' in updates_dict:
+                clauses.append("errors = ?")
+                params.append(updates_dict['errors'])
+            if 'status' in updates_dict:
+                clauses.append("status = ?")
+                params.append(updates_dict['status'])
             
             params.append(log_id)
             
-            if updates:
-                sql = f"UPDATE sync_log SET {', '.join(updates)} WHERE id = ?"
+            if clauses:
+                sql = f"UPDATE sync_log SET {', '.join(clauses)} WHERE id = ?"
                 await self._execute(sql, params)
         except Exception as e:
             logger.error(f"Failed to update sync log: {e}")

requirements.txt

@@ -16,3 +16,5 @@ httpx==0.28.0
 tenacity==9.0.0
 python-multipart==0.0.12
 curl-cffi==0.15.0
+pytest==7.4.3
+pytest-asyncio==0.21.1

scripts/daily_pipeline.py

@@ -29,7 +29,7 @@ logger = logging.getLogger(__name__)
 sys.path.insert(0, str(Path(__file__).parent.parent))
 
 from app.services.database_service import DatabaseService
-from app.services.data_service import StockDataService
+from app.services.data_service import StockDataService, clean_float
 from app.services.timesfm_service import TimesFMService
 from app.services.chart_service import ChartService
 from dotenv import load_dotenv
@@ -47,7 +47,7 @@ HORIZONS = [1, 5, 20, 60]
 MAX_STOCKS_PER_COUNTRY = int(os.getenv("DAILY_FORECAST_LIMIT_PER_COUNTRY", "10000"))
 
 # Delay between individual stock fetches (seconds)
-STOCK_DELAY = 0.3
+STOCK_DELAY = 0.1
 
 # Country names for display (ASCII-safe for Windows)
 COUNTRY_NAMES = {
@@ -79,6 +79,59 @@ def get_yfinance_symbol(symbol: str, db_stocks: list[dict]) -> str:
     return symbol_upper
 
 
+async def calculate_backtest_accuracy(
+    historical_prices: list[float],
+    timesfm: TimesFMService
+) -> dict:
+    """
+    Calculate 5-day and 20-day forecast accuracy percentages
+    by slicing historical close prices, running forecasts, and
+    calculating MAPE against actual realized prices.
+    
+    Accuracy = max(0.0, 100.0 - MAPE_percentage)
+    """
+    if len(historical_prices) < 100:
+        return {"accuracy_5d": 0.0, "accuracy_20d": 0.0}
+
+    try:
+        # --- 5-Day Horizon Backtest ---
+        slice_5d = historical_prices[:-5]
+        realized_5d = historical_prices[-5:]
+        
+        forecast_5d = await timesfm.predict(historical_prices=slice_5d, horizon=5)
+        point_5d = forecast_5d.get("point_forecast", [])
+        
+        if len(point_5d) >= 5 and len(realized_5d) == 5:
+            errors = [abs(p - r) / r for p, r in zip(point_5d, realized_5d) if r > 0]
+            mape = sum(errors) / len(errors) if errors else 0.0
+            accuracy_5d = max(0.0, min(100.0, 100.0 - (mape * 100.0)))
+        else:
+            accuracy_5d = 0.0
+
+        # --- 20-Day Horizon Backtest ---
+        slice_20d = historical_prices[:-20]
+        realized_20d = historical_prices[-20:]
+        
+        forecast_20d = await timesfm.predict(historical_prices=slice_20d, horizon=20)
+        point_20d = forecast_20d.get("point_forecast", [])
+        
+        if len(point_20d) >= 20 and len(realized_20d) == 20:
+            errors = [abs(p - r) / r for p, r in zip(point_20d, realized_20d) if r > 0]
+            mape = sum(errors) / len(errors) if errors else 0.0
+            accuracy_20d = max(0.0, min(100.0, 100.0 - (mape * 100.0)))
+        else:
+            accuracy_20d = 0.0
+
+        return {
+            "accuracy_5d": round(accuracy_5d, 2),
+            "accuracy_20d": round(accuracy_20d, 2)
+        }
+
+    except Exception as e:
+        logger.warning(f"Error calculating backtest accuracy: {e}")
+        return {"accuracy_5d": 0.0, "accuracy_20d": 0.0}
+
+
 async def process_stock(
     stock: dict,
     db: DatabaseService,
@@ -111,29 +164,97 @@ async def process_stock(
             print("[WARN] Insufficient data")
             return False
 
-        # Generate forecasts for each horizon
-        for horizon in HORIZONS:
-            forecast = await timesfm.predict(
+        # Generate forecast once at the maximum horizon
+        max_horizon = max(HORIZONS)
+        full_forecast = await timesfm.predict(
+            historical_prices=stock_data['Close'].tolist(),
+            horizon=max_horizon,
+        )
+
+        if full_forecast is None:
+            print(f"[WARN] Forecast failed (h={max_horizon})")
+            return False
+
+        # Check if we can reuse cached backtest accuracy
+        backtest_acc = None
+        try:
+            cached_forecast = await db.get_cached_forecast(
+                symbol=yf_symbol.upper(),
+                horizon=20,
+                max_age_hours=720,
+            )
+            if cached_forecast and isinstance(cached_forecast, dict):
+                cached_acc = cached_forecast.get("backtest_accuracy")
+                if (
+                    isinstance(cached_acc, dict)
+                    and "accuracy_5d" in cached_acc
+                    and "accuracy_20d" in cached_acc
+                ):
+                    backtest_acc = cached_acc
+        except Exception as e:
+            logger.warning(f"Error checking cached forecast for backtest accuracy reuse: {e}")
+
+        if backtest_acc is None:
+            # Calculate backtesting validation accuracy
+            backtest_acc = await calculate_backtest_accuracy(
                 historical_prices=stock_data['Close'].tolist(),
-                horizon=horizon,
+                timesfm=timesfm
             )
 
-            if forecast is None:
-                print(f"[WARN] Forecast failed (h={horizon})")
-                continue
+        # Generate forecasts and charts for each horizon by slicing
+        for horizon in HORIZONS:
+            # Slice point forecast and quantiles to the current horizon length
+            sliced_point_forecast = full_forecast['point_forecast'][:horizon]
+            sliced_quantiles = {
+                'p10': full_forecast['quantiles']['p10'][:horizon],
+                'p50': full_forecast['quantiles']['p50'][:horizon],
+                'p90': full_forecast['quantiles']['p90'][:horizon],
+            }
+
+            # Reconstruct horizon-specific forecast object for the chart service
+            horizon_forecast = {
+                'point_forecast': sliced_point_forecast,
+                'quantiles': sliced_quantiles,
+                'method': full_forecast.get('method', 'timesfm')
+            }
 
-            # Generate chart for every horizon
+            # Generate chart for every horizon using the sliced data
             chart_svg = None
             try:
                 chart_svg = chart_service.generate_forecast_chart(
                     symbol=clean_symbol,
                     historical_prices=stock_data['Close'].tolist()[-60:],
-                    forecast=forecast,
+                    forecast=horizon_forecast,
                     current_price=float(stock_data['Close'].iloc[-1]),
                 )
             except Exception as ce:
                 logger.warning(f"Chart generation failed for {clean_symbol} h={horizon}: {ce}")
 
+            # Last 60 historical close prices, formatted timezone-safely (YYYY-MM-DD)
+            history_subset = stock_data[-60:]
+            historical_prices = [
+                {
+                    'time': date.strftime('%Y-%m-%d'),
+                    'value': float(close)
+                }
+                for date, close in zip(history_subset.index, history_subset['Close'])
+            ]
+
+            # Get financial metrics
+            pe_ratio = clean_float(stock_data.attrs.get('pe_ratio'))
+            dividend_yield = clean_float(stock_data.attrs.get('dividend_yield'))
+            fifty_two_week_low = clean_float(stock_data.attrs.get('fifty_two_week_low'))
+            fifty_two_week_high = clean_float(stock_data.attrs.get('fifty_two_week_high'))
+            market_cap = clean_float(stock_data.attrs.get('market_cap'))
+
+            financial_metrics = {
+                'pe_ratio': pe_ratio,
+                'dividend_yield': dividend_yield,
+                'fifty_two_week_low': fifty_two_week_low,
+                'fifty_two_week_high': fifty_two_week_high,
+                'market_cap': market_cap,
+            }
+
             # Prepare forecast data
             forecast_data = {
                 'symbol': clean_symbol,
@@ -146,17 +267,20 @@ async def process_stock(
                 'current_price': float(stock_data['Close'].iloc[-1]),
                 'last_updated': stock_data.index[-1].isoformat(),
                 'horizon_days': horizon,
-                'point_forecast': float(forecast['point_forecast'][-1]),
+                'point_forecast': float(sliced_point_forecast[-1]),
                 'percentage_change': float(
-                    ((forecast['point_forecast'][-1] - stock_data['Close'].iloc[-1])
+                    ((sliced_point_forecast[-1] - stock_data['Close'].iloc[-1])
                      / stock_data['Close'].iloc[-1]) * 100
                 ),
                 'quantiles': {
-                    'p10': [float(x) for x in forecast['quantiles']['p10']],
-                    'p50': [float(x) for x in forecast['quantiles']['p50']],
-                    'p90': [float(x) for x in forecast['quantiles']['p90']],
+                    'p10': [float(x) for x in sliced_quantiles['p10']],
+                    'p50': [float(x) for x in sliced_quantiles['p50']],
+                    'p90': [float(x) for x in sliced_quantiles['p90']],
                 },
                 'chart_svg': chart_svg,
+                'historical_prices': historical_prices,
+                'backtest_accuracy': backtest_acc,
+                'financial_metrics': financial_metrics,
                 'methodology_version': 'timesfm-2.5-200m-v1.0',
             }