Sync from GitHub

app/inference.py

@@ -40,22 +40,49 @@ def get_current_price(session: Session, symbol: str) -> Optional[float]:
     """
     Get the current price for a symbol.
     
-    Tries yfinance live data first (15-min delayed), then falls back to DB.
+    Priority:
+    1. Twelve Data API (most reliable, no rate limit issues)
+    2. yfinance live data (15-min delayed)
+    3. Database fallback
     """
+    import httpx
     import yfinance as yf
+    from app.settings import get_settings
     
-    # Try live yfinance data first
+    settings = get_settings()
+    
+    # Try Twelve Data first (for XCU/USD copper)
+    if settings.twelvedata_api_key:
+        try:
+            with httpx.Client(timeout=10.0) as client:
+                response = client.get(
+                    "https://api.twelvedata.com/price",
+                    params={
+                        "symbol": "XCU/USD",
+                        "apikey": settings.twelvedata_api_key,
+                    }
+                )
+                if response.status_code == 200:
+                    data = response.json()
+                    price = data.get("price")
+                    if price:
+                        logger.info(f"Using Twelve Data price for copper: ${float(price):.4f}")
+                        return float(price)
+        except Exception as e:
+            logger.debug(f"Twelve Data price fetch failed: {e}")
+    
+    # Try yfinance as fallback
     try:
         ticker = yf.Ticker(symbol)
         info = ticker.info
         live_price = info.get('regularMarketPrice') or info.get('currentPrice')
         if live_price is not None:
-            logger.info(f"Using live price for {symbol}: ${live_price:.4f}")
+            logger.info(f"Using yfinance price for {symbol}: ${live_price:.4f}")
             return float(live_price)
     except Exception as e:
-        logger.debug(f"Could not get live price for {symbol}: {e}")
+        logger.debug(f"yfinance price fetch failed for {symbol}: {e}")
     
-    # Fallback to database
+    # Final fallback to database
     latest = session.query(PriceBar).filter(
         PriceBar.symbol == symbol
     ).order_by(PriceBar.date.desc()).first()

app/main.py

@@ -175,19 +175,25 @@ async def get_analysis(
                             predicted_return = float(model.predict(dmatrix)[0])
                             
                             # Update with live prediction
-                            # Use DB close as prediction base (model trained on closes)
+                            # Apply futures-spot adjustment (HG=F is ~1.5% higher than XCU/USD)
+                            adjustment = settings.futures_spot_adjustment
+                            adjusted_base = float(prediction_base) * adjustment
+                            
                             cached['predicted_return'] = round(predicted_return, 6)
                             cached['predicted_price'] = round(
-                                float(prediction_base) * (1 + predicted_return),
+                                adjusted_base * (1 + predicted_return),
                                 4
                             )
                             
-                            # Update confidence bounds (based on prediction base)
+                            # Also adjust current_price for consistency
+                            cached['current_price'] = round(adjusted_base, 4)
+                            
+                            # Update confidence bounds (based on adjusted base)
                             std_mult = 1.0  # 1 standard deviation
-                            cached['confidence_lower'] = round(float(prediction_base) * (1 - std_mult * abs(predicted_return)), 4)
-                            cached['confidence_upper'] = round(float(prediction_base) * (1 + std_mult * abs(predicted_return) * 2), 4)
+                            cached['confidence_lower'] = round(adjusted_base * (1 - std_mult * abs(predicted_return)), 4)
+                            cached['confidence_upper'] = round(adjusted_base * (1 + std_mult * abs(predicted_return) * 2), 4)
                             
-                            logger.info(f"LIVE prediction: close=${prediction_base:.4f}, predicted=${cached['predicted_price']:.4f} ({predicted_return*100:.2f}%)")
+                            logger.info(f"LIVE prediction: HG=F=${prediction_base:.4f} -> XCU/USD≈${adjusted_base:.4f}, predicted=${cached['predicted_price']:.4f} ({predicted_return*100:.2f}%)")
                     
             except Exception as e:
                 logger.error(f"Live prediction failed, using cached: {e}")

app/settings.py

@@ -51,6 +51,10 @@ class Settings(BaseSettings):
     analysis_ttl_minutes: int = 30
     log_level: str = "INFO"
     
+    # Futures vs Spot adjustment factor
+    # HG=F (futures) is ~1.5% higher than XCU/USD (spot)
+    futures_spot_adjustment: float = 0.985  # Multiply HG=F by this to get XCU/USD
+    
     # Scheduler
     schedule_time: str = "02:00"
     tz: str = "Europe/Istanbul"