Upload app.py

app.py

@@ -8,44 +8,44 @@ from contextlib import asynccontextmanager
 import os
 import requests
 from pathlib import Path
+from typing import List, Dict, Any
 
-# Define the data schema for Window 7 Conductor requests (Virus Analysis)
+# Define the data schema for virus-based requests (legacy)
 class EconRequest(BaseModel):
     virus_name: str
     econ_buffer: float  # Value from 0.1 to 1.0 (IMF-WEO)
     population_exposure: float # Value from 100 to 100,000 (WorldPop)
 
-# Define the data schema for Window 4 Conductor Economic Analysis
+# Define the data schema for conductor-based requests (v2.0.0)
 class ConductorEconRequest(BaseModel):
     conductor_prompt: str
     year: int
-    stress_factors: list = []
+    stress_factors: List[Dict[str, Any]] = []
     singularity_detected: bool = False
     timestamp: int
     market_shock_index: float = 0.0
     impact_classification: str = "Unknown"
-    regional_vulnerabilities: dict = {}
-    contagion_metrics: dict = {}
-    tech_analysis_id: str = None
+    regional_vulnerabilities: Dict[str, float] = {}
+    contagion_metrics: Dict[str, float] = {}
+    tech_analysis_id: str = ""
 
-# Global container for the model
+# Global container for the model - PRODUCTION MODE (no fallbacks)
 aegis_brain = {}
 
 def download_model():
-    """Download the model from Hugging Face with authentication"""
+    """Download the model from Hugging Face with authentication - REQUIRED"""
     model_path = "aegis_window2_econ_v1.zip"
     model_url = "https://huggingface.co/gsstec/aegis_window2_econ_v1/resolve/main/aegis_window2_econ_v1.zip"
     
-    # Get HF token from environment variable
+    # Get HF token from environment variable - REQUIRED
     hf_token = os.getenv("HF_TOKEN")
     if not hf_token:
-        print("⚠️ No HF_TOKEN environment variable found. Using public access only.")
-        return False
+        raise Exception("❌ PRODUCTION ERROR: HF_TOKEN environment variable is required for model access")
     
     headers = {"Authorization": f"Bearer {hf_token}"}
     
     if not os.path.exists(model_path):
-        print("📥 Downloading model from Hugging Face...")
+        print("📥 Downloading production model from Hugging Face...")
         try:
             response = requests.get(model_url, headers=headers, stream=True)
             response.raise_for_status()
@@ -53,115 +53,104 @@ def download_model():
             with open(model_path, 'wb') as f:
                 for chunk in response.iter_content(chunk_size=8192):
                     f.write(chunk)
-            print("✅ Model downloaded successfully!")
+            print("✅ Production model downloaded successfully!")
             return True
         except Exception as e:
-            print(f"❌ Failed to download model: {e}")
-            return False
+            raise Exception(f"❌ PRODUCTION ERROR: Failed to download model: {e}")
     else:
-        print("✅ Model file already exists")
+        print("✅ Production model file already exists")
         return True
 
+def load_rankings_data():
+    """Load rankings data from HuggingFace - REQUIRED"""
+    rankings_url = "https://huggingface.co/gsstec/aegis_window2_econ_v1/resolve/main/Rankings.csv"
+    hf_token = os.getenv("HF_TOKEN")
+    
+    if not hf_token:
+        raise Exception("❌ PRODUCTION ERROR: HF_TOKEN required for rankings data access")
+    
+    headers = {"Authorization": f"Bearer {hf_token}"}
+    response = requests.get(rankings_url, headers=headers)
+    
+    if response.status_code != 200:
+        raise Exception(f"❌ PRODUCTION ERROR: Failed to load rankings data: {response.status_code}")
+    
+    from io import StringIO
+    rankings_df = pd.read_csv(StringIO(response.text))
+    print("✅ Production rankings data loaded from Hugging Face")
+    return rankings_df
+
 @asynccontextmanager
 async def lifespan(app: FastAPI):
-    # Download and load model on startup
-    model_loaded = False
+    # PRODUCTION MODE: Require real model and data - NO FALLBACKS
+    print("🚀 Starting AEGIS Economic Analysis API v2.0.0 - PRODUCTION MODE")
+    print("⚠️ PRODUCTION MODE: No fallbacks, simulations, or mock data allowed")
     
-    if download_model():
-        try:
-            model_path = "aegis_window2_econ_v1.zip"
-            regressor = TabNetRegressor()
-            regressor.load_model(model_path)
-            aegis_brain["model"] = regressor
-            model_loaded = True
-            print("✅ TabNet Model Loaded Successfully!")
-        except Exception as e:
-            print(f"⚠️ Failed to load TabNet model: {e}")
-            print("🔄 Falling back to simulation mode...")
+    # Download and load model - REQUIRED
+    if not download_model():
+        raise Exception("❌ PRODUCTION ERROR: Model download failed")
     
-    # Load risk data for cross-referencing
     try:
-        rankings_url = "https://huggingface.co/gsstec/aegis_window2_econ_v1/resolve/main/Rankings.csv"
-        hf_token = os.getenv("HF_TOKEN")
-        
-        if hf_token:
-            headers = {"Authorization": f"Bearer {hf_token}"}
-            response = requests.get(rankings_url, headers=headers)
-            if response.status_code == 200:
-                from io import StringIO
-                aegis_brain["rankings"] = pd.read_csv(StringIO(response.text))
-                print("✅ Rankings data loaded from Hugging Face")
-            else:
-                raise Exception(f"Rankings CSV request failed: {response.status_code}")
-        else:
-            raise Exception("No HF token available")
+        model_path = "aegis_window2_econ_v1.zip"
+        regressor = TabNetRegressor()
+        regressor.load_model(model_path)
+        aegis_brain["model"] = regressor
+        print("✅ Production TabNet Model Loaded Successfully!")
     except Exception as e:
-        print(f"⚠️ Could not load rankings from HF: {e}")
-        # Create comprehensive mock rankings data
-        aegis_brain["rankings"] = pd.DataFrame({
-            'Virus Name': [
-                'COVID-19', 'H1N1', 'SARS', 'MERS', 'Ebola', 'Zika', 
-                'Influenza A', 'RSV', 'Marburg', 'Lassa', 'Nipah', 'Hendra'
-            ],
-            'Original Score': [
-                0.85, 0.65, 0.75, 0.55, 0.95, 0.45, 
-                0.60, 0.40, 0.90, 0.70, 0.80, 0.75
-            ]
-        })
-        print("✅ Comprehensive Mock Rankings Data Loaded")
-    
-    aegis_brain["model_loaded"] = model_loaded
+        raise Exception(f"❌ PRODUCTION ERROR: Failed to load TabNet model: {e}")
+    
+    # Load rankings data - REQUIRED
+    try:
+        aegis_brain["rankings"] = load_rankings_data()
+    except Exception as e:
+        raise Exception(f"❌ PRODUCTION ERROR: Failed to load rankings data: {e}")
+    
+    aegis_brain["model_loaded"] = True
+    print("🎯 PRODUCTION MODE: All systems operational with real model and data")
+    
     yield
+    
+    # Cleanup
     aegis_brain.clear()
+    print("🔄 PRODUCTION MODE: Cleanup completed")
 
-app = FastAPI(lifespan=lifespan, title="Aegis Econ API")
+app = FastAPI(
+    lifespan=lifespan, 
+    title="AEGIS Economic Analysis API v2.0.0 - PRODUCTION",
+    description="Production-grade economic analysis with real TabNet model - No fallbacks or simulations",
+    version="2.0.0"
+)
 
 @app.post("/predict")
 async def get_stability_score(data: EconRequest):
-    """Original virus-based economic stability prediction"""
+    """Legacy virus-based economic stability prediction - PRODUCTION MODE ONLY"""
     model = aegis_brain.get("model")
     df_rankings = aegis_brain.get("rankings")
-    model_loaded = aegis_brain.get("model_loaded", False)
+    
+    # PRODUCTION MODE: Require model and data
+    if not model:
+        raise HTTPException(status_code=503, detail="PRODUCTION ERROR: TabNet model not loaded")
     
     if df_rankings is None:
-        raise HTTPException(status_code=500, detail="Rankings data not initialized.")
+        raise HTTPException(status_code=503, detail="PRODUCTION ERROR: Rankings data not initialized")
 
-    # 1. Fetch risk score from Rankings.csv
+    # Get risk score from Rankings.csv
     virus_row = df_rankings[df_rankings['Virus Name'] == data.virus_name]
     if virus_row.empty:
-        # If virus not found, use a default moderate risk score
-        base_score = 0.7
-        print(f"⚠️ Virus '{data.virus_name}' not found in database. Using default risk score.")
-    else:
-        base_score = virus_row.iloc[0]['Original Score']
+        raise HTTPException(
+            status_code=404, 
+            detail=f"PRODUCTION ERROR: Virus '{data.virus_name}' not found in production database"
+        )
     
+    base_score = virus_row.iloc[0]['Original Score']
     risk_impact = base_score * 0.7
     
-    # 2. Predict Continental Stability
-    if model_loaded and model is not None:
-        # Use actual TabNet model
-        input_vector = np.array([[base_score, risk_impact, data.econ_buffer, data.population_exposure]])
-        prediction = model.predict(input_vector)
-        stability_score = float(prediction[0][0])
-        model_status = "trained_model"
-    else:
-        # Enhanced mathematical simulation
-        econ_factor = data.econ_buffer * 0.35
-        population_factor = min(data.population_exposure / 100000, 1.0) * 0.35
-        virus_factor = (1 - base_score) * 0.30
-        
-        # More sophisticated calculation
-        stability_score = max(0.0, min(1.0, 
-            econ_factor + (1 - population_factor) + (1 - virus_factor)
-        ))
-        
-        # Add realistic variance based on input parameters
-        variance = 0.03 + (data.population_exposure / 1000000) * 0.02
-        stability_score += np.random.normal(0, variance)
-        stability_score = max(0.0, min(1.0, stability_score))
-        model_status = "enhanced_simulation"
-    
-    # Determine alert level with more nuanced thresholds
+    # Use ONLY the real TabNet model - NO SIMULATIONS
+    input_vector = np.array([[base_score, risk_impact, data.econ_buffer, data.population_exposure]])
+    prediction = model.predict(input_vector)
+    stability_score = float(prediction[0][0])
+    
+    # Determine alert level
     if stability_score < 0.25:
         alert_level = "CRITICAL"
     elif stability_score < 0.45:
@@ -175,20 +164,27 @@ async def get_stability_score(data: EconRequest):
         "virus": data.virus_name,
         "stability_score": round(stability_score, 4),
         "alert_level": alert_level,
-        "model_status": model_status,
+        "model_status": "production_tabnet_model",
         "base_risk_score": round(base_score, 3),
         "economic_buffer_impact": round(data.econ_buffer * 0.35, 3),
-        "population_risk_factor": round(min(data.population_exposure / 100000, 1.0), 3)
+        "population_risk_factor": round(min(data.population_exposure / 100000, 1.0), 3),
+        "production_mode": True
     }
 
 @app.post("/conductor-predict")
 async def get_conductor_economic_analysis(data: ConductorEconRequest):
-    """New conductor-based economic analysis for Window 4 → War → Disease pipeline"""
+    """Production conductor-based economic analysis for Window 4 → War → Disease pipeline"""
     model = aegis_brain.get("model")
     df_rankings = aegis_brain.get("rankings")
-    model_loaded = aegis_brain.get("model_loaded", False)
     
-    # Extract economic factors from conductor data
+    # PRODUCTION MODE: Require model and data
+    if not model:
+        raise HTTPException(status_code=503, detail="PRODUCTION ERROR: TabNet model not loaded")
+    
+    if df_rankings is None:
+        raise HTTPException(status_code=503, detail="PRODUCTION ERROR: Rankings data not initialized")
+    
+    # Extract base risk from conductor data
     base_risk_score = data.market_shock_index if data.market_shock_index > 0 else 0.5
     
     # Calculate stress factor impact
@@ -196,149 +192,131 @@ async def get_conductor_economic_analysis(data: ConductorEconRequest):
     if data.stress_factors:
         stress_impact = sum(factor.get('impact_level', 0.5) for factor in data.stress_factors) / len(data.stress_factors)
     
-    # Regional vulnerability assessment
-    regional_risk = 0.5
+    # Calculate regional vulnerability impact
+    regional_impact = 0.0
     if data.regional_vulnerabilities:
-        regional_risk = sum(data.regional_vulnerabilities.values()) / len(data.regional_vulnerabilities)
+        regional_impact = sum(data.regional_vulnerabilities.values()) / len(data.regional_vulnerabilities)
     
-    # Contagion metrics assessment
-    contagion_risk = 0.5
+    # Calculate contagion impact
+    contagion_impact = 0.0
     if data.contagion_metrics:
-        spread_rate = data.contagion_metrics.get('spread_rate', 0.5)
-        containment_difficulty = data.contagion_metrics.get('containment_difficulty', 0.5)
-        contagion_risk = (spread_rate + containment_difficulty) / 2
-    
-    # Singularity detection impact
-    singularity_multiplier = 1.5 if data.singularity_detected else 1.0
-    
-    # Calculate comprehensive economic stability
-    if model_loaded and model is not None:
-        # Use actual TabNet model with conductor data
-        input_vector = np.array([[base_risk_score, stress_impact, regional_risk, contagion_risk]])
-        prediction = model.predict(input_vector)
-        stability_score = float(prediction[0][0]) * singularity_multiplier
-        model_status = "trained_model_conductor"
-    else:
-        # Enhanced mathematical simulation for conductor data
-        economic_stability = (
-            (1 - base_risk_score) * 0.30 +           # Market shock impact
-            (1 - stress_impact) * 0.25 +             # Stress factors
-            (1 - regional_risk) * 0.25 +             # Regional vulnerabilities
-            (1 - contagion_risk) * 0.20              # Contagion metrics
-        ) * singularity_multiplier
-        
-        # Year-based adjustment (future years have more uncertainty)
-        year_factor = max(0.8, 1.0 - (data.year - 2024) * 0.02)
-        stability_score = economic_stability * year_factor
-        
-        # Add realistic variance
-        variance = 0.05 + (stress_impact * 0.03)
-        stability_score += np.random.normal(0, variance)
-        stability_score = max(0.0, min(1.0, stability_score))
-        model_status = "enhanced_simulation_conductor"
-    
-    # Calculate market cap estimate (in billions)
-    market_cap_estimate = max(50.0, 500.0 * stability_score * (2.0 - base_risk_score))
-    
-    # Generate key metrics
+        contagion_impact = sum(data.contagion_metrics.values()) / len(data.contagion_metrics)
+    
+    # Use ONLY the real TabNet model - NO SIMULATIONS
+    input_vector = np.array([[
+        base_risk_score,
+        stress_impact,
+        regional_impact,
+        contagion_impact
+    ]])
+    
+    prediction = model.predict(input_vector)
+    stability_score = float(prediction[0][0])
+    
+    # Calculate market cap estimate (in billions) based on model prediction
+    market_cap_estimate = max(10, min(500, (1 - stability_score) * 200 + 50))
+    
+    # Generate key metrics based on model prediction
     key_metrics = [
         {
             "name": "Market Shock Index",
-            "value": base_risk_score,
-            "change": -15.2 if data.singularity_detected else -5.1,
+            "value": data.market_shock_index,
+            "change": -5.1 if stability_score < 0.5 else 2.3,
             "unit": "index",
-            "risk_level": "CRITICAL" if base_risk_score > 0.8 else "HIGH" if base_risk_score > 0.6 else "MEDIUM",
+            "risk_level": "HIGH" if data.market_shock_index > 0.7 else "MEDIUM",
             "description": "Overall market disruption indicator"
         },
         {
-            "name": "Regional Stability",
-            "value": 1 - regional_risk,
-            "change": -8.3 if regional_risk > 0.7 else 2.1,
+            "name": "Economic Stability",
+            "value": stability_score,
+            "change": -3.2 if stability_score < 0.4 else 1.8,
             "unit": "stability",
-            "risk_level": "HIGH" if regional_risk > 0.7 else "MEDIUM" if regional_risk > 0.5 else "LOW",
-            "description": "Cross-regional economic stability"
+            "risk_level": "CRITICAL" if stability_score < 0.3 else "MEDIUM",
+            "description": "TabNet model economic stability prediction"
         },
         {
-            "name": "Contagion Risk",
-            "value": contagion_risk,
-            "change": 12.5 if contagion_risk > 0.6 else -3.2,
-            "unit": "risk",
-            "risk_level": "CRITICAL" if contagion_risk > 0.8 else "HIGH" if contagion_risk > 0.6 else "MEDIUM",
-            "description": "Economic contagion spread potential"
+            "name": "Stress Factor Impact",
+            "value": stress_impact,
+            "change": -2.1 if stress_impact > 0.6 else 0.5,
+            "unit": "impact",
+            "risk_level": "HIGH" if stress_impact > 0.7 else "LOW",
+            "description": "Aggregated stress factor analysis"
         }
     ]
     
-    # Determine alert level
-    if stability_score < 0.25:
-        alert_level = "CRITICAL"
+    # Determine status based on model prediction
+    if stability_score < 0.2:
         status = f"CRITICAL ECONOMIC INSTABILITY DETECTED ({data.year})"
-    elif stability_score < 0.45:
-        alert_level = "HIGH_RISK"
+    elif stability_score < 0.4:
         status = f"HIGH ECONOMIC RISK IDENTIFIED ({data.year})"
-    elif stability_score < 0.65:
-        alert_level = "MONITOR"
-        status = f"ECONOMIC MONITORING REQUIRED ({data.year})"
+    elif stability_score < 0.6:
+        status = f"MODERATE ECONOMIC CONCERNS ({data.year})"
     else:
-        alert_level = "STABLE"
         status = f"ECONOMIC STABILITY MAINTAINED ({data.year})"
     
-    if data.singularity_detected:
-        status = f"SINGULARITY EVENT - {status}"
-    
-    # Generate BRICS+ impact analysis
-    brics_impact = {
-        "inflation_pressure": min(15.0, base_risk_score * 20.0),
-        "market_disruption": f"{'Severe' if base_risk_score > 0.7 else 'Moderate' if base_risk_score > 0.4 else 'Limited'} disruption expected across BRICS+ economies",
-        "competitive_dynamics": f"{'Accelerated' if data.singularity_detected else 'Standard'} competitive realignment in emerging markets"
-    }
-    
-    # Generate strategic recommendations
-    recommendations = [
-        f"Implement {'emergency' if alert_level == 'CRITICAL' else 'enhanced'} economic monitoring protocols",
-        f"Activate {'Tier 1' if stability_score < 0.4 else 'Tier 2'} risk mitigation strategies",
-        f"Coordinate with {'all' if data.singularity_detected else 'key'} international economic partners"
-    ]
-    
-    if data.stress_factors:
-        recommendations.append(f"Address {len(data.stress_factors)} identified stress factors immediately")
+    # Generate market analysis based on model prediction
+    severity = "critical" if stability_score < 0.3 else "moderate" if stability_score < 0.6 else "manageable"
+    market_analysis = f"Production TabNet model analysis for {data.year} indicates {severity} economic conditions. " \
+                     f"Conductor analysis reveals {data.impact_classification.lower()} implications with " \
+                     f"{len(data.stress_factors)} stress factors identified. " \
+                     f"Economic stability score: {stability_score:.3f}"
     
     return {
         "status": status,
-        "market_analysis": f"Comprehensive economic analysis for {data.year} indicates {alert_level.lower()} conditions. Conductor analysis reveals {data.impact_classification.lower()} implications with {len(data.stress_factors)} stress factors identified. {'Singularity event detected - ' if data.singularity_detected else ''}Economic stability score: {stability_score:.3f}",
+        "market_analysis": market_analysis,
         "key_metrics": key_metrics,
         "market_cap_estimate": round(market_cap_estimate, 1),
-        "operational_risk": f"{'Extreme' if alert_level == 'CRITICAL' else 'High' if alert_level == 'HIGH_RISK' else 'Moderate'} operational risk across {len(data.regional_vulnerabilities) if data.regional_vulnerabilities else 'multiple'} regions",
-        "sovereign_advantage": f"{'Minimal' if stability_score < 0.3 else 'Limited' if stability_score < 0.6 else 'Moderate'} sovereign economic advantage maintained",
-        "recommendations": recommendations,
-        "brics_impact": brics_impact,
-        "processing_time": 1200 + int(len(data.stress_factors) * 150),
-        "confidence_score": max(0.6, min(0.95, stability_score + 0.1)),
-        "conductor_metadata": {
-            "tech_analysis_id": data.tech_analysis_id,
-            "year": data.year,
-            "singularity_detected": data.singularity_detected,
-            "stress_factors_count": len(data.stress_factors),
-            "regional_coverage": len(data.regional_vulnerabilities) if data.regional_vulnerabilities else 0,
-            "model_status": model_status
-        }
+        "operational_risk": f"Model-predicted risk level: {severity.upper()}",
+        "sovereign_advantage": f"Stability score indicates {('limited' if stability_score < 0.5 else 'moderate')} sovereign resilience",
+        "recommendations": [
+            f"Monitor economic indicators closely given {severity} stability prediction",
+            f"Implement risk mitigation strategies for {data.impact_classification.lower()}",
+            "Enhance economic monitoring systems based on model predictions"
+        ],
+        "brics_impact": {
+            "inflation_pressure": round(max(0, (1 - stability_score) * 10), 1),
+            "market_disruption": f"Model predicts {severity} market disruption potential",
+            "competitive_dynamics": f"Economic competitiveness {'severely impacted' if stability_score < 0.3 else 'moderately affected'}"
+        },
+        "processing_time": 1500,  # Model inference time
+        "confidence_score": round(min(0.95, max(0.6, stability_score + 0.2)), 2),
+        "model_status": "production_tabnet_conductor",
+        "production_mode": True,
+        "model_prediction": round(stability_score, 4)
     }
 
 @app.get("/health")
 async def health():
+    """Production health check - requires real model and data"""
+    model_loaded = aegis_brain.get("model_loaded", False)
+    rankings_available = aegis_brain.get("rankings") is not None
+    
+    if not model_loaded:
+        raise HTTPException(status_code=503, detail="PRODUCTION ERROR: TabNet model not loaded")
+    
+    if not rankings_available:
+        raise HTTPException(status_code=503, detail="PRODUCTION ERROR: Rankings data not available")
+    
     return {
-        "status": "operational", 
+        "status": "production_operational", 
         "hardware": "T4 GPU Active" if torch.cuda.is_available() else "CPU Mode",
-        "model_loaded": aegis_brain.get("model_loaded", False),
-        "available_viruses": aegis_brain.get("rankings", pd.DataFrame())['Virus Name'].tolist() if aegis_brain.get("rankings") is not None else [],
+        "model_loaded": True,
+        "model_type": "TabNet Production Model",
+        "available_viruses": aegis_brain.get("rankings", pd.DataFrame())['Virus Name'].tolist(),
         "total_virus_database": len(aegis_brain.get("rankings", pd.DataFrame())),
-        "hf_token_available": bool(os.getenv("HF_TOKEN"))
+        "hf_token_available": bool(os.getenv("HF_TOKEN")),
+        "production_mode": True,
+        "fallbacks_disabled": True,
+        "simulations_disabled": True
     }
 
 @app.get("/")
 async def root():
+    """Production API information"""
     return {
         "message": "AEGIS Economic Stability Analysis API",
         "version": "2.0.0",
+        "mode": "PRODUCTION",
         "model_source": "https://huggingface.co/gsstec/aegis_window2_econ_v1",
         "features": [
             "Economic stability prediction",
@@ -354,5 +332,12 @@ async def root():
             "health": "GET /health - System status",
             "root": "GET / - API information"
         },
-        "data_flow": "Conductor → Economic → War → Disease Analysis Pipeline"
+        "data_flow": "Conductor → Economic → War → Disease Analysis Pipeline",
+        "production_features": {
+            "real_tabnet_model": True,
+            "no_fallbacks": True,
+            "no_simulations": True,
+            "no_mock_data": True,
+            "requires_hf_token": True
+        }
     }