Upload folder using huggingface_hub

app.py

@@ -168,24 +168,24 @@ async def preview_portfolio(req: PortfolioRequest, x_access_key: Optional[str] =
         raise HTTPException(status_code=401, detail="Unauthorized")
         
     try:
-        overrides = {
-            'tickers': req.tickers,
-            'capital': req.capital,
-            'risk_input': req.risk_input,
-            'risk_factor': {1:0.1, 2:0.5, 3:1.0, 4:2.0, 5:3.0, 6:5.0, 7:7.5, 8:10.0, 9:15.0, 10:25.0}.get(req.risk_input, 3.0),
-            'model': req.model,
-            'allocation_engine': req.allocation_engine,
-            'single_asset_min': -1.0 if req.allow_shorting else 0.0,
-            'tax_enabled': req.tax_enabled,
-            'garch_enabled': req.garch_enabled,
-            'custom_constraints': req.custom_constraints
+        import requests
+        HF_URL = os.environ.get("HF_MATH_URL", "https://engineportf-math-backend.hf.space")
+        HF_SECRET = os.environ.get("HF_SECRET_KEY", "EngineSecret2026")
+        
+        headers = {
+            "X-API-Key": HF_SECRET,
+            "Content-Type": "application/json"
         }
         
+        # Send request to Hugging Face backend
         loop = asyncio.get_running_loop()
-        result = await loop.run_in_executor(
-            engine_executor, 
-            lambda: core_engine.run_engine(overrides=overrides, serve=False, preview_only=True)
-        )
+        def _call_hf_preview():
+            res = requests.post(f"{HF_URL}/api/preview", json=req.model_dump() if hasattr(req, "model_dump") else req.dict(), headers=headers, timeout=60)
+            if res.status_code != 200:
+                raise Exception(f"HF Engine Error: {res.text}")
+            return res.json()
+            
+        result = await loop.run_in_executor(engine_executor, _call_hf_preview)
         
         return {
             "status": "success", 
@@ -209,26 +209,59 @@ async def generate_portfolio(req: PortfolioRequest, request: Request, x_access_k
     task_id = str(uuid.uuid4())
     BACKGROUND_TASKS[task_id] = {"status": "running", "message": "Initializing...", "target_weights": {}}
 
-    def _run_optimization(tid, request):
+    def _run_optimization(tid, request_obj):
         try:
-            overrides = {
-                'tickers': request.tickers,
-                'capital': request.capital,
-                'risk_input': request.risk_input,
-                'risk_factor': {1:0.1, 2:0.5, 3:1.0, 4:2.0, 5:3.0, 6:5.0, 7:7.5, 8:10.0, 9:15.0, 10:25.0}.get(request.risk_input, 3.0),
-                'model': request.model,
-                'allocation_engine': request.allocation_engine,
-                'single_asset_min': -1.0 if request.allow_shorting else 0.0,
-                'tax_enabled': request.tax_enabled,
-                'garch_enabled': request.garch_enabled,
-                'custom_constraints': request.custom_constraints
+            import requests
+            import time
+            HF_URL = os.environ.get("HF_MATH_URL", "https://engineportf-math-backend.hf.space")
+            HF_SECRET = os.environ.get("HF_SECRET_KEY", "EngineSecret2026")
+            
+            headers = {
+                "X-API-Key": HF_SECRET,
+                "Content-Type": "application/json"
             }
             
-            result = core_engine.run_engine(overrides=overrides, serve=False)
+            BACKGROUND_TASKS[tid]["message"] = "Initializing on Hugging Face..."
+            
+            payload = request_obj.model_dump() if hasattr(request_obj, "model_dump") else request_obj.dict()
+            response = requests.post(f"{HF_URL}/api/generate", json=payload, headers=headers, timeout=60)
+            
+            if response.status_code != 200:
+                raise Exception(f"HF Engine Error: {response.text}")
+                
+            init_data = response.json()
+            if init_data.get("status") != "queued":
+                raise Exception("Failed to queue task on Hugging Face.")
+                
+            hf_task_id = init_data.get("task_id")
             
-            BACKGROUND_TASKS[tid]["status"] = "completed"
-            BACKGROUND_TASKS[tid]["message"] = "Report generated."
-            BACKGROUND_TASKS[tid]["target_weights"] = result.get("target_weights", {})
+            # Poll Hugging Face
+            while True:
+                time.sleep(2.0)
+                status_res = requests.get(f"{HF_URL}/api/status/{hf_task_id}", headers=headers, timeout=20)
+                if status_res.status_code != 200:
+                    continue # Network blip, retry
+                    
+                status_data = status_res.json()
+                if status_data.get("status") == "completed":
+                    # Task finished, retrieve HTML
+                    report_html = status_data.get("report_html", "")
+                    if report_html:
+                        report_path = os.path.join(OUTPUT_DIR, "portfolio_report.html")
+                        os.makedirs(OUTPUT_DIR, exist_ok=True)
+                        with open(report_path, "w", encoding="utf-8") as f:
+                            f.write(report_html)
+                            
+                    BACKGROUND_TASKS[tid]["status"] = "completed"
+                    BACKGROUND_TASKS[tid]["message"] = "Report generated."
+                    BACKGROUND_TASKS[tid]["target_weights"] = status_data.get("target_weights", {})
+                    break
+                elif status_data.get("status") == "error":
+                    raise Exception(status_data.get("message", "Unknown error on HF backend."))
+                else:
+                    # Still running
+                    BACKGROUND_TASKS[tid]["message"] = "Calculating (Running on HF 16GB Cluster)..."
+                    
         except Exception as e:
             BACKGROUND_TASKS[tid]["status"] = "error"
             BACKGROUND_TASKS[tid]["message"] = str(e)
@@ -260,23 +293,35 @@ async def get_report():
     raise HTTPException(status_code=404, detail="Report not generated yet.")
 
 def _alert_daemon():
-    """Background daemon to check for market drops."""
+    """Background daemon to check for market drops and ping HF."""
     import time
+    import requests
+    
+    HF_URL = os.environ.get("HF_MATH_URL", "https://engineportf-math-backend.hf.space")
+    loops = 0
     while True:
         try:
-            # Wake up every 1 hour (3600 seconds)
-            time.sleep(3600)
+            # Wake up every 15 minutes (900 seconds)
+            time.sleep(900)
+            loops += 1
             
-            # Simple check for SPY drops
-            ticker = yf.Ticker("SPY")
-            hist = ticker.history(period="2d")
-            if len(hist) >= 2:
-                current = float(hist['Close'].iloc[-1])
-                prev = float(hist['Close'].iloc[-2])
-                pct_change = ((current - prev) / prev) * 100
-                
-                if pct_change <= -5.0:
-                    access_manager.send_telegram_alert(f"🚨 **MARKET ALERT**\nSPY has dropped by {pct_change:.2f}%!\nCheck the portfolio engine.")
+            # 1. Ping Hugging Face to keep the 16GB math cluster awake
+            try:
+                requests.get(HF_URL, timeout=10)
+            except Exception:
+                pass
+            
+            # 2. Every 4th loop (1 hour), check for SPY drops
+            if loops % 4 == 0:
+                ticker = yf.Ticker("SPY")
+                hist = ticker.history(period="2d")
+                if len(hist) >= 2:
+                    current = float(hist['Close'].iloc[-1])
+                    prev = float(hist['Close'].iloc[-2])
+                    pct_change = ((current - prev) / prev) * 100
+                    
+                    if pct_change <= -5.0:
+                        access_manager.send_telegram_alert(f"🚨 **MARKET ALERT**\nSPY has dropped by {pct_change:.2f}%!\nCheck the portfolio engine.")
         except Exception as e:
             pass # Suppress daemon errors
 

hf_app.py

@@ -7,12 +7,16 @@ from fastapi.security import APIKeyHeader
 from pydantic import BaseModel
 import concurrent.futures
 import base64
+import time
 
 import core_engine
 from config import OUTPUT_DIR
 
 app = FastAPI(title="Portfolio Engine Math Backend")
 
+BACKGROUND_TASKS = {}
+engine_executor = concurrent.futures.ThreadPoolExecutor(max_workers=3)
+
 # Security configuration
 api_key_header = APIKeyHeader(name="X-API-Key")
 SECRET_KEY = os.environ.get("HF_SECRET_KEY", "default-unsafe-key")
@@ -57,34 +61,56 @@ def preview_portfolio(req: PortfolioRequest, api_key: str = Security(get_api_key
 
 @app.post("/api/generate")
 def generate_portfolio(req: PortfolioRequest, api_key: str = Security(get_api_key)):
-    overrides = {
-        'tickers': req.tickers,
-        'capital': req.capital,
-        'risk_input': req.risk_input,
-        'risk_factor': {1:0.1, 2:0.5, 3:1.0, 4:2.0, 5:3.0, 6:5.0, 7:7.5, 8:10.0, 9:15.0, 10:25.0}.get(req.risk_input, 3.0),
-        'model': req.model,
-        'allocation_engine': req.allocation_engine,
-        'single_asset_min': -1.0 if req.allow_shorting else 0.0,
-        'tax_enabled': req.tax_enabled,
-        'garch_enabled': req.garch_enabled,
-        'custom_constraints': req.custom_constraints
-    }
-    
-    # Run the engine. This generates output/portfolio_report.html
-    result = core_engine.run_engine(overrides=overrides, serve=False)
-    
-    report_path = os.path.join(OUTPUT_DIR, "portfolio_report.html")
-    html_content = ""
-    if os.path.exists(report_path):
-        with open(report_path, "r", encoding="utf-8") as f:
-            html_content = f.read()
+    task_id = str(uuid.uuid4())
+    BACKGROUND_TASKS[task_id] = {"status": "running", "message": "Starting...", "target_weights": {}, "report_html": ""}
+
+    def _run_optimization(tid, request_obj):
+        try:
+            overrides = {
+                'tickers': request_obj.tickers,
+                'capital': request_obj.capital,
+                'risk_input': request_obj.risk_input,
+                'risk_factor': {1:0.1, 2:0.5, 3:1.0, 4:2.0, 5:3.0, 6:5.0, 7:7.5, 8:10.0, 9:15.0, 10:25.0}.get(request_obj.risk_input, 3.0),
+                'model': request_obj.model,
+                'allocation_engine': request_obj.allocation_engine,
+                'single_asset_min': -1.0 if request_obj.allow_shorting else 0.0,
+                'tax_enabled': request_obj.tax_enabled,
+                'garch_enabled': request_obj.garch_enabled,
+                'custom_constraints': request_obj.custom_constraints
+            }
             
+            result = core_engine.run_engine(overrides=overrides, serve=False)
+            
+            report_path = os.path.join(OUTPUT_DIR, "portfolio_report.html")
+            html_content = ""
+            if os.path.exists(report_path):
+                with open(report_path, "r", encoding="utf-8") as f:
+                    html_content = f.read()
+                    
+            BACKGROUND_TASKS[tid]["status"] = "completed"
+            BACKGROUND_TASKS[tid]["target_weights"] = result.get("target_weights", {})
+            BACKGROUND_TASKS[tid]["report_html"] = html_content
+        except Exception as e:
+            BACKGROUND_TASKS[tid]["status"] = "error"
+            BACKGROUND_TASKS[tid]["message"] = str(e)
+
+    engine_executor.submit(_run_optimization, task_id, req)
+
     return {
-        "status": "success",
-        "target_weights": result.get("target_weights", {}),
-        "report_html": html_content
+        "status": "queued",
+        "task_id": task_id,
+        "message": "Optimization started on HF."
     }
 
+@app.get("/api/status/{task_id}")
+def get_task_status(task_id: str, api_key: str = Security(get_api_key)):
+    task = BACKGROUND_TASKS.get(task_id)
+    if not task:
+        raise HTTPException(status_code=404, detail="Task not found")
+    # To save bandwidth, don't send massive HTML if it's not completed yet
+    # Or send it, but the client will handle it
+    return task
+
 @app.get("/")
 def health_check():
     return {"status": "HF Engine is running. Use X-API-Key to authenticate."}

static/app.js

@@ -299,24 +299,40 @@ async function generateFullReport() {
         "Compiling institutional HTML report matrix..."
     ];
     
+    const infiniteSteps = [
+        "Calculating gradients...",
+        "Rebalancing tensors...",
+        "Analyzing tail risks...",
+        "Synchronizing with Hugging Face ML Cluster...",
+        "Backpropagating loss function...",
+        "Filtering noise from alpha signals...",
+        "Executing stochastic bounds check...",
+        "Optimizing L2 regularization weights..."
+    ];
+    
     let logIdx = 0;
+    let infiniteIdx = 0;
     const interval = setInterval(() => {
+        const el = document.createElement('div');
         if(logIdx < steps.length) {
-            const el = document.createElement('div');
             el.innerHTML = `<span style="color: #fff">></span> ${steps[logIdx]}`;
-            matrixLogs.appendChild(el);
-            
-            // Auto scroll
-            const maxScroll = matrixLogs.scrollHeight;
-            if (logIdx > 5) {
-                matrixLogs.style.transform = `translateY(-${(logIdx - 5) * 20}px)`;
-            }
-            
-            // Progress bar
             matrixProgress.style.width = `${((logIdx + 1) / steps.length) * 100}%`;
             logIdx++;
+        } else {
+            // Infinite loading loop
+            el.innerHTML = `<span style="color: #3b82f6">></span> <span style="opacity: 0.8;">[ML CLUSTER]</span> ${infiniteSteps[infiniteIdx % infiniteSteps.length]} <span class="spinner-anim">◓</span>`;
+            infiniteIdx++;
+            // Keep progress bar pulsing
+            matrixProgress.style.opacity = (Math.sin(infiniteIdx) * 0.5 + 0.5).toString();
+        }
+        matrixLogs.appendChild(el);
+        
+        // Auto scroll
+        const scrollAmt = Math.max(0, matrixLogs.children.length - 6);
+        if (scrollAmt > 0) {
+            matrixLogs.style.transform = `translateY(-${scrollAmt * 20}px)`;
         }
-    }, 600); // Fast cinematic log streaming
+    }, 800); // Cinematic log streaming
 
     try {
         const res = await fetch('/api/generate', {

static/index.html

@@ -18,10 +18,12 @@
         .glass-panel:hover { transform: translateY(-5px) scale(1.02); }
     </style>
 </head>
-<body id="vanta-bg">
+<body class="theme-dark">
+    <!-- Vanta JS Fixed Background Container -->
+    <div id="vanta-bg" style="position: fixed; top: 0; left: 0; width: 100vw; height: 100vh; z-index: -2;"></div>
 
     <!-- Cinematic Matrix Loading Overlay -->
-    <div id="matrix-loader" style="display: none; position: fixed; top: 0; left: 0; width: 100vw; height: 100vh; background: #050814; z-index: 9999; flex-direction: column; justify-content: center; align-items: center; color: #3b82f6; font-family: monospace; overflow: hidden;">
+    <div id="matrix-loader" style="display: none; position: fixed; top: 0; left: 0; width: 100vw; height: 100vh; background: rgba(5, 8, 20, 0.65); backdrop-filter: blur(12px); -webkit-backdrop-filter: blur(12px); z-index: 9999; flex-direction: column; justify-content: center; align-items: center; color: #3b82f6; font-family: monospace; overflow: hidden;">
         <div class="noise-overlay" style="opacity: 0.05;"></div>
         <div style="position: absolute; top: 50%; left: 50%; transform: translate(-50%, -50%); text-align: center; z-index: 2;">
             <div style="font-size: 2rem; font-weight: bold; letter-spacing: 2px; margin-bottom: 2rem; text-shadow: 0 0 20px rgba(59,130,246,0.5);">ENGINE OPTIMIZING</div>