Update app.py

app.py

@@ -1,6 +1,6 @@
 # ============================================
 # YORK CHILLER OPTIMIZER API
-# Using NumPy 2.0.2 to match your model
+# Compatible with NumPy 2.0.2 and pandas 2.2.3
 # ============================================
 
 import os
@@ -8,11 +8,13 @@ import sys
 import warnings
 warnings.filterwarnings('ignore')
 
-# Import with NumPy 2.0.2
+# Import libraries
 import numpy as np
 print(f"NumPy version: {np.__version__}")
 
 import pandas as pd
+print(f"Pandas version: {pd.__version__}")
+
 from datetime import datetime
 from typing import List, Optional, Dict, Any
 from fastapi import FastAPI, HTTPException
@@ -64,7 +66,7 @@ def load_model_files():
         print(f"   ❌ Missing: production_model.pkl")
         return False
     
-    # Load model with joblib (should work with NumPy 2.0.2)
+    # Load model with joblib
     try:
         model = joblib.load("production_model.pkl")
         print(f"\n✅ Model loaded successfully with joblib")
@@ -78,17 +80,8 @@ def load_model_files():
             print(f"   Max depth: {model.max_depth}")
             
     except Exception as e:
-        print(f"❌ Error loading model with joblib: {e}")
-        
-        # Try with pickle as fallback
-        try:
-            print("   Trying with pickle...")
-            with open("production_model.pkl", 'rb') as f:
-                model = pickle.load(f)
-            print(f"✅ Model loaded successfully with pickle")
-        except Exception as e2:
-            print(f"❌ Pickle also failed: {e2}")
-            return False
+        print(f"⚠️ Error loading model with joblib: {e}")
+        return False
     
     # Load scaler if exists
     if os.path.exists("scaler.pkl"):
@@ -97,34 +90,39 @@ def load_model_files():
             print(f"✅ Scaler loaded")
         except Exception as e:
             print(f"⚠️ Could not load scaler: {e}")
-            try:
-                with open("scaler.pkl", 'rb') as f:
-                    scaler = pickle.load(f)
-                print(f"✅ Scaler loaded with pickle")
-            except:
-                pass
     
     # Load feature names from features.pkl
     if os.path.exists("features.pkl"):
         try:
-            feature_names = joblib.load("features.pkl")
-            if isinstance(feature_names, list):
-                print(f"✅ Features loaded from features.pkl: {len(feature_names)} features")
+            feature_data = joblib.load("features.pkl")
+            # Convert to list if it's a pandas Series or other type
+            if hasattr(feature_data, 'tolist'):
+                feature_names = feature_data.tolist()
+            elif isinstance(feature_data, (list, tuple)):
+                feature_names = list(feature_data)
+            elif hasattr(feature_data, 'values'):
+                feature_names = list(feature_data.values)
+            else:
+                feature_names = list(feature_data)
+            print(f"✅ Features loaded from features.pkl: {len(feature_names)} features")
+            if len(feature_names) > 0:
                 print(f"   First 3 features: {feature_names[:3]}")
         except Exception as e:
             print(f"⚠️ Could not load features.pkl: {e}")
-            try:
-                with open("features.pkl", 'rb') as f:
-                    feature_names = pickle.load(f)
-                print(f"✅ Features loaded with pickle: {len(feature_names)} features")
-            except:
-                pass
+            feature_names = None
     
     # Use default feature names if none loaded
     if feature_names is None:
         feature_names = EXPECTED_FEATURES
         print(f"✅ Using default feature names: {len(feature_names)} features")
     
+    # Ensure feature_names is a list
+    if not isinstance(feature_names, list):
+        if hasattr(feature_names, 'tolist'):
+            feature_names = feature_names.tolist()
+        else:
+            feature_names = list(feature_names)
+    
     return True
 
 # Load model on startup
@@ -133,11 +131,11 @@ load_success = load_model_files()
 if model:
     print(f"\n📊 Model Status: ✅ ONLINE")
     print(f"   NumPy version: {np.__version__}")
-    print(f"   Features: {len(feature_names) if feature_names else 'Unknown'}")
+    print(f"   Pandas version: {pd.__version__}")
+    print(f"   Features: {len(feature_names) if feature_names else 0}")
     print(f"   Scaler: {'✅' if scaler else '❌'}")
 else:
     print(f"\n📊 Model Status: ❌ OFFLINE")
-    print(f"   NumPy version: {np.__version__}")
 
 # ============================================
 # REQUEST MODELS
@@ -189,8 +187,10 @@ class OptimizeResponse(BaseModel):
 # PREDICTION FUNCTIONS
 # ============================================
 
-def prepare_features(input_data: ChillerInput) -> np.ndarray:
-    """Prepare features in the exact order expected by the model"""
+def predict_kw_per_tr(input_data: ChillerInput) -> float:
+    """Predict Combined_Kw_per_TR using the loaded model"""
+    if model is None:
+        raise ValueError("Model not loaded")
     
     # Create feature array with exact order
     features = np.array([[
@@ -206,24 +206,16 @@ def prepare_features(input_data: ChillerInput) -> np.ndarray:
         input_data.day_of_week,
         input_data.month,
         input_data.day_of_year
-    ]])
+    ]], dtype=np.float64)
     
     # Apply scaler if available
     if scaler is not None:
         try:
             features = scaler.transform(features)
-            print(f"   Applied scaler transformation")
         except Exception as e:
             print(f"   ⚠️ Scaler transform failed: {e}")
     
-    return features
-
-def predict_kw_per_tr(input_data: ChillerInput) -> float:
-    """Predict Combined_Kw_per_TR using the loaded model"""
-    if model is None:
-        raise ValueError("Model not loaded")
-    
-    features = prepare_features(input_data)
+    # Predict
     prediction = model.predict(features)[0]
     
     # Clip to realistic range
@@ -253,9 +245,10 @@ def optimize_chw_setpoint(input_data: ChillerInput) -> tuple:
     best_sp = current_sp
     
     for sp in test_setpoints:
-        # Create copy with new setpoint
-        test_input = ChillerInput(**input_data.dict())
-        test_input.current_chw_setpoint_c = sp
+        # Create copy with new setpoint using dict
+        input_dict = input_data.dict()
+        input_dict['current_chw_setpoint_c'] = sp
+        test_input = ChillerInput(**input_dict)
         
         try:
             kw = predict_kw_per_tr(test_input)
@@ -263,7 +256,6 @@ def optimize_chw_setpoint(input_data: ChillerInput) -> tuple:
                 best_kw = kw
                 best_sp = sp
         except Exception as e:
-            print(f"   Error testing setpoint {sp}: {e}")
             continue
     
     return best_sp, best_kw
@@ -275,6 +267,8 @@ def optimize_chw_setpoint(input_data: ChillerInput) -> tuple:
 @app.get("/")
 async def root():
     """Root endpoint with API information"""
+    feature_count = len(feature_names) if feature_names and isinstance(feature_names, list) else len(EXPECTED_FEATURES)
+    
     return {
         "service": "York Chiller Energy Optimizer",
         "model_type": "Random Forest Regressor",
@@ -282,10 +276,10 @@ async def root():
         "status": "online" if model is not None else "model_not_loaded",
         "model_info": {
             "loaded": model is not None,
-            "features": feature_names if feature_names else EXPECTED_FEATURES,
-            "feature_count": len(feature_names) if feature_names else len(EXPECTED_FEATURES),
+            "features": feature_count,
             "scaler_loaded": scaler is not None,
-            "numpy_version": np.__version__
+            "numpy_version": np.__version__,
+            "pandas_version": pd.__version__
         },
         "endpoints": {
             "/": "This information",
@@ -305,13 +299,16 @@ async def root():
 @app.get("/health")
 async def health():
     """Health check endpoint"""
+    feature_count = len(feature_names) if feature_names and isinstance(feature_names, list) else len(EXPECTED_FEATURES)
+    
     return {
         "status": "healthy" if model is not None else "degraded",
         "model_loaded": model is not None,
         "model_type": type(model).__name__ if model else None,
-        "feature_count": len(feature_names) if feature_names else len(EXPECTED_FEATURES),
+        "feature_count": feature_count,
         "scaler_loaded": scaler is not None,
-        "numpy_version": np.__version__
+        "numpy_version": np.__version__,
+        "pandas_version": pd.__version__
     }
 
 @app.post("/predict", response_model=PredictionResponse)
@@ -324,11 +321,13 @@ async def predict_endpoint(input_data: ChillerInput):
         kw_per_tr = predict_kw_per_tr(input_data)
         rating = get_efficiency_rating(kw_per_tr)
         
+        feature_count = len(feature_names) if feature_names and isinstance(feature_names, list) else len(EXPECTED_FEATURES)
+        
         return PredictionResponse(
             status="success",
             kw_per_tr=round(kw_per_tr, 4),
             efficiency_rating=rating,
-            features_used=len(feature_names) if feature_names else len(EXPECTED_FEATURES),
+            features_used=feature_count,
             model_type="RandomForestRegressor",
             timestamp=datetime.now().isoformat()
         )
@@ -364,7 +363,7 @@ async def optimize_endpoint(input_data: ChillerInput):
                 recommended_value=f"{optimal_sp:.1f}°C",
                 expected_savings=f"{savings_pct:.1f}%",
                 priority="HIGH" if savings_pct > 5 else "MEDIUM",
-                operator_action=f"Adjust CHW setpoint from {current_sp:.1f}°C to {optimal_sp:.1f}°C"
+                operator_action=f"Adjust CHW setpoint to {optimal_sp:.1f}°C"
             ))
         
         # Load-based recommendations