Update app.py

app.py

@@ -1,239 +1,161 @@
-import requests
+import pandas as pd
+import numpy as np
+from sklearn.ensemble import RandomForestRegressor
+from sklearn.preprocessing import StandardScaler
+from datetime import datetime, timedelta
+import logging
+from fastapi import FastAPI, HTTPException
+import uvicorn
 import json
 import os
-import logging
-from datetime import datetime
-from dotenv import load_dotenv
-from flask import Flask, jsonify, request, render_template, redirect, url_for, session
 
-logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+# Configure logging
+logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-load_dotenv()
-
-HUGGING_FACE_API_URL = os.getenv("HUGGING_FACE_API_URL", "https://api-inference.huggingface.co/models/distilgpt2")
-HUGGING_FACE_API_TOKEN = os.getenv("HUGGING_FACE_API_TOKEN")
-
-if not HUGGING_FACE_API_TOKEN:
-    logger.error("HUGGING_FACE_API_TOKEN is not set")
-    raise ValueError("HUGGING_FACE_API_TOKEN environment variable is not set")
-if not HUGGING_FACE_API_URL.startswith("https://api-inference.huggingface.co/models/"):
-    logger.error("Invalid HUGGING_FACE_API_URL: %s", HUGGING_FACE_API_URL)
-    raise ValueError("HUGGING_FACE_API_URL must point to a valid Hugging Face model")
-
-app = Flask(__name__)
-app.secret_key = os.getenv("FLASK_SECRET_KEY", "your-secret-key")
-
-def generate_coaching_output(data):
-    logger.info("Generating coaching output for supervisor %s", data['supervisor_id'])
-    milestones_json = json.dumps(data['milestones'], indent=2)
-    prompt = f"""
-You are an AI Coach for construction site supervisors. Based on the following data, generate a daily checklist, three focus tips, and a motivational quote. Ensure outputs are concise, actionable, and tailored to the supervisor's role, project status, and reflection log.
+# Check for Hugging Face API token
+HF_API_TOKEN = os.getenv("HUGGING_FACE_API_TOKEN")
+if not HF_API_TOKEN:
+    logger.warning("HUGGING_FACE_API_TOKEN not set. Some Hugging Face features may be unavailable.")
 
-Supervisor Role: {data['role']}
-Project Milestones: {milestones_json}
-Reflection Log: {data['reflection_log']}
-Weather: {data['weather']}
-
-Format the response as JSON:
-{{
-    "checklist": ["item1", "item2", ...],
-    "tips": ["tip1", "tip2", "tip3"],
-    "quote": "motivational quote"
-}}
-"""
-
-    headers = {
-        "Authorization": f"Bearer {HUGGING_FACE_API_TOKEN}",
-        "Content-Type": "application/json"
-    }
-    payload = {
-        "inputs": prompt,
-        "parameters": {
-            "max_length": 200,
-            "temperature": 0.7,
-            "top_p": 0.9
-        }
-    }
+app = FastAPI()
 
+# Mock data loading function (replace with actual data source in production)
+def load_data():
     try:
-        response = requests.post(HUGGING_FACE_API_URL, headers=headers, json=payload, timeout=5)
-        response.raise_for_status()
-        result = response.json()
-        generated_text = result[0]["generated_text"] if isinstance(result, list) else result["generated_text"]
-
-        start_idx = generated_text.find('{')
-        end_idx = generated_text.rfind('}') + 1
-        if start_idx == -1 or end_idx == 0:
-            logger.error("No valid JSON found in LLM output")
-            raise ValueError("No valid JSON found in LLM output")
-        
-        json_str = generated_text[start_idx:end_idx]
-        output = json.loads(json_str)
-        logger.info("Successfully generated coaching output")
-        return output
-
-    except requests.exceptions.HTTPError as e:
-        logger.error("Hugging Face API HTTP error: %s", e)
-        return None
-    except (json.JSONDecodeError, ValueError) as e:
-        logger.error("Error parsing LLM output: %s", e)
-        return None
+        # Simulated data for project schedule, historical consumption, weather, etc.
+        data = {
+            'date': [datetime.now().date() - timedelta(days=x) for x in range(30)],
+            'project_id': ['PROJ001'] * 30,
+            'task_type': ['Concrete_Pouring'] * 15 + ['Brick_Laying'] * 15,
+            'cement_qty': np.random.uniform(100, 500, 30),
+            'steel_qty': np.random.uniform(50, 200, 30),
+            'brick_qty': np.random.uniform(1000, 5000, 30),
+            'labor_headcount': np.random.randint(10, 50, 30),
+            'temperature': np.random.uniform(15, 35, 30),
+            'absenteeism_rate': np.random.uniform(0, 0.1, 30),
+            'material_lead_time': np.random.uniform(1, 5, 30)
+        }
+        return pd.DataFrame(data)
     except Exception as e:
-        logger.error("Unexpected error in Hugging Face API call: %s", e)
-        return None
-
-def save_to_salesforce(output, supervisor_id, project_id):
-    logger.info("Mock saving to Salesforce for supervisor %s", supervisor_id)
-    return True  # Mocked success
-
-@app.route('/', methods=['GET'])
-def redirect_to_login():
-    if 'user_id' in session or 'is_guest' in session:
-        return redirect(url_for('ui'))
-    return redirect(url_for('login_page'))
-
-@app.route('/login', methods=['GET'])
-def login_page():
-    if 'user_id' in session or 'is_guest' in session:
-        return redirect(url_for('ui'))
-    return render_template('login.html')
-
-@app.route('/login', methods=['POST'])
-def login():
-    data = request.get_json()
-    username = data.get('username')
-    password = data.get('password')
+        logger.error(f"Error loading data: {str(e)}")
+        raise
 
+# Preprocess data for model input
+def preprocess_data(df, is_training=True):
     try:
-        # Mock Salesforce login
-        if username == "testuser" and password == "testpass":
-            supervisor_id = "MOCK_SUP_001"
-            session['user_id'] = supervisor_id
-            session['is_guest'] = False
-            logger.info("Mock user %s logged in successfully", username)
-            return jsonify({"status": "success", "message": "Logged in successfully"}), 200
+        # Feature engineering
+        df['day_of_week'] = df['date'].apply(lambda x: x.weekday())
+        df['is_weekend'] = df['day_of_week'].apply(lambda x: 1 if x >= 5 else 0)
+        
+        # Encode categorical variables
+        df = pd.get_dummies(df, columns=['task_type', 'project_id'])
+        
+        # Define features and targets
+        features = [col for col in df.columns if col not in ['date', 'cement_qty', 'steel_qty', 'brick_qty', 'labor_headcount']]
+        targets = ['cement_qty', 'steel_qty', 'brick_qty', 'labor_headcount']
+        
+        if is_training:
+            X = df[features]
+            y = df[targets]
+            return X, y
         else:
-            logger.error("Mock login failed for user %s: Invalid credentials", username)
-            return jsonify({"status": "error", "message": "Invalid credentials"}), 401
-
+            return df[features]
     except Exception as e:
-        logger.error("Error during mock login for user %s: %s", username, e)
-        return jsonify({"status": "error", "message": str(e)}), 500
-
-@app.route('/signup', methods=['POST'])
-def signup():
-    data = request.get_json()
-    username = data.get('username')
-    password = data.get('password')
-    name = data.get('name', 'New Supervisor')
-
-    try:
-        # Mock Salesforce signup
-        supervisor_id = f"MOCK_SUP_{username}_{datetime.now().strftime('%Y%m%d%H%M%S')}"
-        session['user_id'] = supervisor_id
-        session['is_guest'] = False
-        logger.info("Mock user %s signed up successfully", username)
-        return jsonify({"status": "success", "message": "Signed up successfully"}), 200
-
-    except Exception as e:
-        logger.error("Error during mock signup: %s", e)
-        return jsonify({"status": "error", "message": str(e)}), 500
-
-@app.route('/guest_login', methods=['POST'])
-def guest_login():
-    try:
-        session['is_guest'] = True
-        session['user_id'] = 'GUEST'
-        logger.info("Guest login successful")
-        return jsonify({"status": "success", "message": "Logged in as guest"}), 200
-    except Exception as e:
-        logger.error("Error during guest login: %s", e)
-        return jsonify({"status": "error", "message": "Failed to log in as guest: " + str(e)}), 500
-
-@app.route('/logout', methods=['POST'])
-def logout():
+        logger.error(f"Error preprocessing data: {str(e)}")
+        raise
+
+# Train or load model
+class AIEstimator:
+    def __init__(self):
+        self.models = {}
+        self.scaler = StandardScaler()
+        
+    def train(self, X, y):
+        try:
+            # Scale features
+            X_scaled = self.scaler.fit_transform(X)
+            
+            # Train a RandomForestRegressor for each target
+            for target in y.columns:
+                model = RandomForestRegressor(n_estimators=100, random_state=42)
+                model.fit(X_scaled, y[target])
+                self.models[target] = model
+                logger.info(f"Trained model for {target}")
+        except Exception as e:
+            logger.error(f"Error training model: {str(e)}")
+            raise
+    
+    def predict(self, X):
+        try:
+            # Scale features
+            X_scaled = self.scaler.transform(X)
+            
+            # Predict for each target
+            predictions = {}
+            for target, model in self.models.items():
+                pred = model.predict(X_scaled)
+                predictions[target] = pred.tolist()
+            
+            # Calculate forecast confidence (simplified as model score)
+            confidence = {target: model.score(X_scaled, pred) for target, model in self.models.items()}
+            predictions['forecast_confidence'] = confidence
+            
+            return predictions
+        except Exception as e:
+            logger.error(f"Error making predictions: {str(e)}")
+            raise
+
+# API endpoint for forecast generation
+@app.post("/forecast")
+async def generate_forecast(data: dict):
     try:
-        session.pop('user_id', None)
-        session.pop('is_guest', None)
-        logger.info("User logged out successfully")
-        return jsonify({"status": "success", "message": "Logged out successfully"}), 200
-    except Exception as e:
-        logger.error("Error during logout: %s", e)
-        return jsonify({"status": "error", "message": str(e)}), 500
-
-@app.route('/get_supervisor_data', methods=['GET'])
-def get_supervisor_data():
-    user_id = session.get('user_id', 'GUEST')
-    if user_id == 'GUEST':
-        logger.info("Fetching default data for guest user")
-        return jsonify({
-            "status": "success",
-            "data": {
-                "supervisor_id": "GUEST",
-                "role": "Guest",
-                "project_id": "PRJ_GUEST",
-                "location": "Unknown",
-                "milestones": [],
-                "reflection_log": "",
-                "weather": "Unknown"
-            }
-        }), 200
-
-    # Mock Salesforce data
-    logger.info("Fetching mock Salesforce data for user %s", user_id)
-    return jsonify({
-        "status": "success",
-        "data": {
-            "supervisor_id": user_id,
-            "role": "Site Supervisor",
-            "project_id": "PRJ_DEFAULT",
-            "location": "Construction Site A",
-            "milestones": [
-                {"task": "Foundation Work", "status": "In Progress"},
-                {"task": "Framing", "status": "Not Started"}
-            ],
-            "reflection_log": "Mock reflection log",
-            "weather": "Sunny, 25°C"
+        # Validate input
+        required_fields = ['project_id', 'date', 'task_type', 'temperature', 'absenteeism_rate', 'material_lead_time']
+        if not all(field in data for field in required_fields):
+            raise HTTPException(status_code=400, detail="Missing required fields")
+        
+        # Convert input to DataFrame
+        input_df = pd.DataFrame([data])
+        input_df['date'] = pd.to_datetime(input_df['date']).dt.date
+        
+        # Load historical data and append new input
+        historical_data = load_data()
+        combined_data = pd.concat([historical_data, input_df], ignore_index=True)
+        
+        # Preprocess data
+        X = preprocess_data(combined_data, is_training=False)
+        X_new = X.tail(1)  # Get features for the new input
+        
+        # Load or train model
+        estimator = AIEstimator()
+        if not estimator.models:
+            X_train, y_train = preprocess_data(historical_data, is_training=True)
+            estimator.train(X_train, y_train)
+        
+        # Generate forecast
+        forecast = estimator.predict(X_new)
+        
+        # Format response
+        response = {
+            'project_id': data['project_id'],
+            'date': data['date'],
+            'material_needed': {
+                'cement_qty': forecast['cement_qty'][0],
+                'steel_qty': forecast['steel_qty'][0],
+                'brick_qty': forecast['brick_qty'][0]
+            },
+            'labor_needed': forecast['labor_headcount'][0],
+            'forecast_confidence': forecast['forecast_confidence'],
+            'alert_flag': any(conf < 0.85 for conf in forecast['forecast_confidence'].values())
         }
-    }), 200
-
-@app.route('/ui', methods=['GET'])
-def ui():
-    if 'user_id' not in session and 'is_guest' not in session:
-        logger.info("No session found, redirecting to login")
-        return redirect(url_for('login_page'))
-    logger.info("Rendering UI for user %s", session.get('user_id', 'GUEST'))
-    return render_template('index.html')
-
-@app.route('/generate', methods=['POST'])
-def generate_endpoint():
-    try:
-        data = request.get_json()
-        if not data or not all(key in data for key in ['supervisor_id', 'role', 'project_id', 'milestones', 'reflection_log', 'weather']):
-            logger.error("Invalid or missing supervisor data in generate request")
-            return jsonify({"status": "error", "message": "Invalid or missing supervisor data"}), 400
-
-        coaching_output = generate_coaching_output(data)
-        if coaching_output:
-            success = save_to_salesforce(coaching_output, data["supervisor_id"], data["project_id"])
-            if success:
-                logger.info("Successfully generated and saved coaching output for %s", data["supervisor_id"])
-                return jsonify({"status": "success", "output": coaching_output}), 200
-            else:
-                logger.error("Failed to save coaching output to Salesforce for %s", data["supervisor_id"])
-                return jsonify({"status": "error", "message": "Failed to save to Salesforce"}), 500
-        else:
-            logger.error("Failed to generate coaching output for %s", data["supervisor_id"])
-            return jsonify({"status": "error", "message": "Failed to generate coaching output"}), 500
+        
+        logger.info(f"Forecast generated for project {data['project_id']}")
+        return response
     except Exception as e:
-        logger.error("Error in generate endpoint: %s", e)
-        return jsonify({"status": "error", "message": str(e)}), 500
-
-@app.route('/health', methods=['GET'])
-def health_check():
-    logger.info("Health check requested")
-    return jsonify({"status": "healthy", "message": "Application is running"}), 200
+        logger.error(f"Error in forecast endpoint: {str(e)}")
+        raise HTTPException(status_code=500, detail=str(e))
 
+# Run the application (for local testing)
 if __name__ == "__main__":
-    app.run(host="0.0.0.0", port=int(os.getenv("PORT", 7860)))
+    uvicorn.run(app, host="0.0.0.0", port=8000)