Upload 9 files

.gitattributes

@@ -1,35 +1,35 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,8 @@
+FROM python:3.11-slim
+WORKDIR /app
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+COPY . .
+EXPOSE 7860
+ENV PYTHONUNBUFFERED=1
+CMD ["python", "ml_api.py"]

README.md

@@ -1,10 +1,10 @@
----
-title: Swat Ml Api
-emoji: 💻
-colorFrom: green
-colorTo: yellow
-sdk: docker
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+---
+title: Swat Ml Api
+emoji: 💻
+colorFrom: green
+colorTo: yellow
+sdk: docker
+pinned: false
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

alert_config.py

@@ -0,0 +1,177 @@
+"""
+Alert System Configuration
+==========================
+Store all alert settings and credentials here.
+
+SECURITY: Never commit this file to Git!
+Add to .gitignore: alert_config.py
+"""
+
+# ============================================================================
+# EMAIL CONFIGURATION (Gmail)
+# ============================================================================
+
+EMAIL_CONFIG = {
+    'enabled': False,  # Set to False to disable email alerts
+
+    # Gmail SMTP settings
+    'smtp_server': 'smtp.gmail.com',
+    'smtp_port': 587,
+
+    # Your Gmail account
+    'sender_email': 'fypmlalerts@gmail.com',  # CHANGE THIS
+    'sender_password': 'ahgm aryb wzbk opib',  # CHANGE THIS (16-char app password)
+
+    # Who receives alerts
+    'recipient_emails': [
+        'ariadaikalam1234@gmail.com',
+    ]
+}
+
+# ============================================================================
+# SMS CONFIGURATION (Twilio)
+# ============================================================================
+
+SMS_CONFIG = {
+    'enabled': False,  # Set to False to disable SMS alerts
+
+    # Twilio credentials (from https://console.twilio.com)
+    'twilio_account_sid': 'AC4392144e5e0fe6133a36928d5e8032db',  # CHANGE THIS
+    'twilio_auth_token': 'dc97b81a11fc876f38ee3e61c2522ca1',  # CHANGE THIS
+    'twilio_phone_number': '+14234583614',  # CHANGE THIS
+
+    # Who receives SMS (must be verified on free tier)
+    'recipient_phones': [
+        '+916382043877',  # CHANGE THIS
+    ]
+}
+
+# ============================================================================
+# PHONE CALL CONFIGURATION (Twilio)
+# ============================================================================
+
+CALL_CONFIG = {
+    'enabled': False,  # Set to False to disable phone calls
+
+    # Twilio credentials (same as SMS)
+    'twilio_account_sid': SMS_CONFIG['twilio_account_sid'],
+    'twilio_auth_token': SMS_CONFIG['twilio_auth_token'],
+    'twilio_phone_number': SMS_CONFIG['twilio_phone_number'],
+
+    # Who receives calls (emergency contact only)
+    'recipient_phones': [
+        '+916382043877',  # CHANGE THIS
+    ],
+
+    # Only call if confidence is this high
+    'confidence_threshold': 0.90  # 90%
+}
+
+# ============================================================================
+# ALERT BEHAVIOR
+# ============================================================================
+
+ALERT_BEHAVIOR = {
+    # Cooldown period (seconds) - prevents alert spam
+    # If alert sent at 10:00:00, next alert won't send until 10:05:00
+    'cooldown_seconds': 180,  # 5 minutes
+    'degrading_persist_seconds': 30,
+    'faulted_persist_seconds': 15,
+
+    # Send alerts for these states
+    'alert_on_degrading': True,  # Email only
+    'alert_on_faulted': True,  # Email + SMS + Call (if high confidence)
+
+    # Test mode: Print instead of actually sending
+    'test_mode': False,  # Set to False for production
+}
+
+# ============================================================================
+# ALERT TEMPLATES
+# ============================================================================
+
+EMAIL_TEMPLATES = {
+    'subject': "⚠️ SWAT Alert: {component} - {state}",
+
+    'body_html': """
+    <html>
+    <head>
+        <style>
+            body {{ font-family: Arial, sans-serif; }}
+            .header {{ background: {color}; color: white; padding: 20px; border-radius: 8px; }}
+            .content {{ padding: 20px; }}
+            .metric {{ margin: 10px 0; }}
+            .label {{ font-weight: bold; }}
+            .footer {{ margin-top: 30px; color: #666; font-size: 12px; }}
+        </style>
+    </head>
+    <body>
+        <div class="header">
+            <h2>{icon} {alert_title}</h2>
+        </div>
+        <div class="content">
+            <div class="metric">
+                <span class="label">Component:</span> {component}
+            </div>
+            <div class="metric">
+                <span class="label">State:</span> {state}
+            </div>
+            <div class="metric">
+                <span class="label">Confidence:</span> {confidence}%
+            </div>
+            <div class="metric">
+                <span class="label">Timestamp:</span> {timestamp}
+            </div>
+
+            <h3>Top 3 Suspect Components:</h3>
+            <ul>
+                {top3_list}
+            </ul>
+
+            <h3>Recommended Actions:</h3>
+            <ol>
+                {actions_list}
+            </ol>
+        </div>
+        <div class="footer">
+            <em>This is an automated alert from SWAT Predictive Maintenance System</em>
+        </div>
+    </body>
+    </html>
+    """
+}
+
+SMS_TEMPLATE = """
+🚨 SWAT CRITICAL FAULT 🚨
+
+Component: {component}
+State: {state}
+Confidence: {confidence}%
+Time: {time}
+
+IMMEDIATE ACTION REQUIRED
+Check dashboard for details.
+"""
+
+CALL_SCRIPT = """
+<Response>
+    <Say voice="alice">
+        Critical fault detected in SWAT system.
+        Component {component} has failed.
+        Confidence level: {confidence} percent.
+        Immediate maintenance required.
+        Please check the dashboard for details.
+    </Say>
+    <Pause length="2"/>
+    <Say voice="alice">
+        Repeating: Critical fault in component {component}.
+        Check the dashboard immediately.
+    </Say>
+</Response>
+"""
+
+# ============================================================================
+# SECURITY NOTE
+# ============================================================================
+# Add this file to .gitignore:
+# echo "alert_config.py" >> .gitignore

alerts.py

@@ -0,0 +1,417 @@
+"""
+Alert System Implementation
+===========================
+Handles email, SMS, and phone call alerts.
+"""
+
+import smtplib
+from email.mime.text import MIMEText
+from email.mime.multipart import MIMEMultipart
+from datetime import datetime
+import time
+
+# Import configuration
+from alert_config import (
+    EMAIL_CONFIG, SMS_CONFIG, CALL_CONFIG,
+    ALERT_BEHAVIOR, EMAIL_TEMPLATES, SMS_TEMPLATE, CALL_SCRIPT
+)
+
+# Try to import Twilio
+try:
+    from twilio.rest import Client
+
+    TWILIO_AVAILABLE = True
+except ImportError:
+    TWILIO_AVAILABLE = False
+    print("⚠️  Twilio not installed. SMS/Calls disabled. Install: pip install twilio")
+
+# ============================================================================
+# COOLDOWN TRACKING
+# ============================================================================
+
+_last_alert_time = {}  # Track last alert time per component
+_state_started_at = {}  # key: f"{component}_{state}" -> epoch seconds
+
+def state_persisted_long_enough(component, state):
+    """
+    Returns True only if the current state has been continuous long enough.
+    Resets other state timers for that component automatically.
+    """
+    if not component or state in (None, "NORMAL", "UNKNOWN", "ERROR"):
+        return False
+
+    now = time.time()
+
+    # Reset timers for this component for other states (prevents stale timers)
+    for key in list(_state_started_at.keys()):
+        if key.startswith(component + "_") and key != f"{component}_{state}":
+            _state_started_at.pop(key, None)
+
+    k = f"{component}_{state}"
+    if k not in _state_started_at:
+        _state_started_at[k] = now
+        #print(f"🧪 {state} started: {component}")
+        return False
+
+    elapsed = now - _state_started_at[k]
+
+    if state == "DEGRADING":
+        required = ALERT_BEHAVIOR.get("degrading_persist_seconds", 60)
+    elif state == "FAULTED":
+        required = ALERT_BEHAVIOR.get("faulted_persist_seconds", 0)
+    else:
+        required = 0
+
+    if elapsed < required:
+        #print(f"🧪 Waiting persistence: {component} {state} {int(elapsed)}/{required}s")
+        return False
+
+    return True
+
+def reset_component_timers(component):
+    if not component:
+        return
+    for key in list(_state_started_at.keys()):
+        if key.startswith(component + "_"):
+            _state_started_at.pop(key, None)
+
+def check_cooldown(component, alert_type, state):
+    key = f"{component}_{state}_{alert_type}"
+    current_time = time.time()
+
+    if key in _last_alert_time:
+        elapsed = current_time - _last_alert_time[key]
+        if elapsed < ALERT_BEHAVIOR['cooldown_seconds']:
+            #print(f"⏳ Cooldown: {component} {state} ({alert_type}) - {int(elapsed)}s ago")
+            return False
+
+    _last_alert_time[key] = current_time
+    return True
+
+
+# ============================================================================
+# EMAIL ALERTS
+# ============================================================================
+
+def send_email_alert(prediction):
+    """
+    Send email alert for DEGRADING or FAULTED state.
+
+    Args:
+        prediction (dict): ML prediction result
+
+    Returns:
+        bool: True if sent successfully
+    """
+    if not EMAIL_CONFIG['enabled']:
+        #print("📧 Email alerts disabled in config")
+        return False
+
+    state = prediction['stage2']['state']
+    component = prediction['stage3']['component']
+    confidence = prediction['stage3']['confidence']
+
+    if not component:
+        return False
+
+    # Check cooldown
+    if not check_cooldown(component, 'EMAIL', state):
+        return False
+
+    # Test mode: Just print
+    if ALERT_BEHAVIOR['test_mode']:
+        print(f"📧 [TEST MODE] Would send email: {component} - {state} ({confidence * 100:.0f}%)")
+        return True
+
+    try:
+        # Create message
+        msg = MIMEMultipart('alternative')
+
+        # Subject
+        subject = EMAIL_TEMPLATES['subject'].format(
+            component=component,
+            state=state
+        )
+        msg['Subject'] = subject
+        msg['From'] = EMAIL_CONFIG['sender_email']
+        msg['To'] = ', '.join(EMAIL_CONFIG['recipient_emails'])
+
+        # Determine color and icon
+        if state == "FAULTED":
+            color = "#dc3545"
+            icon = "🔴"
+            alert_title = "CRITICAL FAULT DETECTED"
+        else:
+            color = "#ffc107"
+            icon = "🟡"
+            alert_title = "DEGRADATION WARNING"
+
+        # Build top 3 list
+        top3 = prediction['stage3'].get('top3', [])
+        top3_html = ''.join([
+            f"<li>{comp}: {conf * 100:.1f}%</li>"
+            for comp, conf in top3
+        ])
+
+        # Build actions list
+        actions = prediction.get('actions', [])[:5]  # Top 5 actions
+        actions_html = ''.join([
+            f"<li>{action}</li>"
+            for action in actions
+        ])
+
+        # Format HTML body
+        html = EMAIL_TEMPLATES['body_html'].format(
+            color=color,
+            icon=icon,
+            alert_title=alert_title,
+            component=component,
+            state=state,
+            confidence=confidence * 100,
+            timestamp=prediction['timestamp'].strftime('%Y-%m-%d %H:%M:%S'),
+            top3_list=top3_html,
+            actions_list=actions_html
+        )
+
+        msg.attach(MIMEText(html, 'html'))
+
+        # Send email
+        with smtplib.SMTP(EMAIL_CONFIG['smtp_server'], EMAIL_CONFIG['smtp_port']) as server:
+            server.starttls()
+            server.login(EMAIL_CONFIG['sender_email'], EMAIL_CONFIG['sender_password'])
+            server.send_message(msg)
+
+        print(f"✅ Email sent: {component} - {state}")
+        return True
+
+    except Exception as e:
+        print(f"❌ Email failed: {e}")
+        return False
+
+
+# ============================================================================
+# SMS ALERTS
+# ============================================================================
+
+def send_sms_alert(prediction):
+    """
+    Send SMS alert for FAULTED state.
+
+    Args:
+        prediction (dict): ML prediction result
+
+    Returns:
+        bool: True if sent successfully
+    """
+    if not SMS_CONFIG['enabled']:
+        #print("📱 SMS alerts disabled in config")
+        return False
+
+    if not TWILIO_AVAILABLE:
+        print("❌ SMS failed: Twilio not installed")
+        return False
+
+    state = prediction['stage2']['state']
+
+    if state != 'FAULTED':
+        return False  # Only SMS for faults
+
+    component = prediction['stage3']['component']
+    confidence = prediction['stage3']['confidence']
+
+    if not component:
+        return False
+
+    # Check cooldown
+    if not check_cooldown(component, 'SMS', state):
+        return False
+
+    # Test mode: Just print
+    if ALERT_BEHAVIOR['test_mode']:
+        print(f"📱 [TEST MODE] Would send SMS: {component} - FAULTED ({confidence * 100:.0f}%)")
+        return True
+
+    try:
+        client = Client(
+            SMS_CONFIG['twilio_account_sid'],
+            SMS_CONFIG['twilio_auth_token']
+        )
+
+        message_body = SMS_TEMPLATE.format(
+            component=component,
+            state=state,
+            confidence=confidence * 100,
+            time=prediction['timestamp'].strftime('%H:%M:%S')
+        )
+
+        for phone in SMS_CONFIG['recipient_phones']:
+            message = client.messages.create(
+                body=message_body,
+                from_=SMS_CONFIG['twilio_phone_number'],
+                to=phone
+            )
+            print(f"✅ SMS sent to {phone}: {message.sid}")
+
+        return True
+
+    except Exception as e:
+        print(f"❌ SMS failed: {e}")
+        return False
+
+
+# ============================================================================
+# PHONE CALL ALERTS
+# ============================================================================
+
+def send_phone_alert(prediction):
+    """
+    Send phone call for FAULTED state with high confidence.
+
+    Args:
+        prediction (dict): ML prediction result
+
+    Returns:
+        bool: True if sent successfully
+    """
+    if not CALL_CONFIG['enabled']:
+        #print("☎️  Phone alerts disabled in config")
+        return False
+
+    if not TWILIO_AVAILABLE:
+        print("❌ Call failed: Twilio not installed")
+        return False
+
+    state = prediction['stage2']['state']
+    confidence = prediction['stage3']['confidence']
+
+    if state != 'FAULTED' or confidence < CALL_CONFIG['confidence_threshold']:
+        return False
+
+    component = prediction['stage3']['component']
+
+    if not component:
+        return False
+
+    # Check cooldown
+    if not check_cooldown(component, 'CALL', state):
+        return False
+
+    # Test mode: Just print
+    if ALERT_BEHAVIOR['test_mode']:
+        print(f"☎️  [TEST MODE] Would call: {component} - FAULTED ({confidence * 100:.0f}%)")
+        return True
+
+    try:
+        client = Client(
+            CALL_CONFIG['twilio_account_sid'],
+            CALL_CONFIG['twilio_auth_token']
+        )
+
+        twiml = CALL_SCRIPT.format(
+            component=component,
+            confidence=int(confidence * 100)
+        )
+
+        for phone in CALL_CONFIG['recipient_phones']:
+            call = client.calls.create(
+                twiml=twiml,
+                from_=CALL_CONFIG['twilio_phone_number'],
+                to=phone
+            )
+            print(f"✅ Call initiated to {phone}: {call.sid}")
+
+        return True
+
+    except Exception as e:
+        print(f"❌ Call failed: {e}")
+        return False
+
+
+# ============================================================================
+# TRIGGER ALERTS
+# ============================================================================
+
+def trigger_alerts(prediction):
+    state = prediction['stage2']['state']
+    component = prediction['stage3'].get('component')
+
+    # If normal, reset timers and exit
+    if state in ('NORMAL', 'UNKNOWN', 'ERROR'):
+        if not component:
+            _state_started_at.clear()
+            # optionally also clear _last_alert_time for state keys if desired
+        else:
+            reset_component_timers(component)
+
+        return {'email': False, 'sms': False, 'call': False}
+
+    results = {'email': False, 'sms': False, 'call': False}
+
+    # ✅ Persistence gates for both DEGRADING and FAULTED
+    if state in ("DEGRADING", "FAULTED"):
+        if not state_persisted_long_enough(component, state):
+            return results  # don't alert yet
+
+    # Email for DEGRADING or FAULTED
+    if state in ['DEGRADING', 'FAULTED']:
+        if ALERT_BEHAVIOR['alert_on_degrading'] or state == 'FAULTED':
+            results['email'] = send_email_alert(prediction)
+
+    # SMS for FAULTED only (after persistence gate)
+    if state == 'FAULTED' and ALERT_BEHAVIOR['alert_on_faulted']:
+        results['sms'] = send_sms_alert(prediction)
+
+    # Phone call for FAULTED only (after persistence gate + your confidence threshold)
+    if state == 'FAULTED' and ALERT_BEHAVIOR['alert_on_faulted']:
+        results['call'] = send_phone_alert(prediction)
+
+    return results
+
+
+# ============================================================================
+# TESTING
+# ============================================================================
+
+if __name__ == "__main__":
+    print("=" * 60)
+    print("ALERT SYSTEM TEST")
+    print("=" * 60)
+
+    # Mock prediction
+    test_prediction = {
+        'timestamp': datetime.now(),
+        'stage2': {
+            'state': 'FAULTED',
+            'confidence': 0.95
+        },
+        'stage3': {
+            'component': 'P302',
+            'confidence': 0.93,
+            'top3': [
+                ('P302', 0.93),
+                ('P402', 0.04),
+                ('P501', 0.02)
+            ]
+        },
+        'actions': [
+            '🔧 Inspect UF feed pump P302',
+            '📋 Check UF membrane differential pressure',
+            '💧 Consider membrane backwash or cleaning'
+        ]
+    }
+
+    print("\n📧 Testing Email Alert...")
+    email_result = send_email_alert(test_prediction)
+
+    print("\n📱 Testing SMS Alert...")
+    sms_result = send_sms_alert(test_prediction)
+
+    print("\n☎️  Testing Phone Alert...")
+    call_result = send_phone_alert(test_prediction)
+
+    print("\n" + "=" * 60)
+    print("RESULTS:")
+    print("=" * 60)
+    print(f"Email: {'✅ Sent' if email_result else '❌ Failed'}")
+    print(f"SMS:   {'✅ Sent' if sms_result else '❌ Failed'}")
+    print(f"Call:  {'✅ Sent' if call_result else '❌ Failed'}")

ml_api.py

@@ -0,0 +1,185 @@
+"""
+SWaT ML Inference API Service
+Directly calls ml_inference.run_pipeline() and returns dashboard-friendly JSON
+"""
+
+from flask import Flask, request, jsonify
+from flask_cors import CORS
+import os
+import sys
+import time
+import traceback
+
+# Import from current folder
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+
+app = Flask(__name__)
+CORS(app)
+
+ML_AVAILABLE = False
+ML_IMPORT_ERROR = None
+ML_API_FILE = os.path.abspath(__file__)
+ML_PID = os.getpid()
+
+sensor_buffer = None
+MODELS = None  # cached models (already cached in your ml_inference too)
+
+
+# -----------------------------------------------------------------------------
+# Startup: load models ONCE + create one shared buffer
+# -----------------------------------------------------------------------------
+try:
+    from sensor_buffer import SensorBuffer
+    import ml_inference
+
+    t0 = time.perf_counter()
+    MODELS = ml_inference.load_models()
+    t1 = time.perf_counter()
+
+    if not MODELS or not MODELS.get("loaded"):
+        raise RuntimeError(MODELS.get("error", "Models not loaded"))
+
+    sensor_buffer = SensorBuffer(window_size=60, n_features=40)
+    ML_AVAILABLE = True
+
+    print(f"✅ Models loaded successfully in {(t1 - t0)*1000:.1f} ms")
+    print("ML Available: True")
+
+except Exception as e:
+    ML_IMPORT_ERROR = f"{e}\n{traceback.format_exc()}"
+    ML_AVAILABLE = False
+    print(f"ML Import Error: {e}")
+    print(traceback.format_exc())
+    print("ML Available: False")
+
+
+# -----------------------------------------------------------------------------
+# Map ml_inference output -> what your web app expects
+# -----------------------------------------------------------------------------
+def to_dashboard_schema(result: dict):
+    stage1 = result.get("stage1", {}) or {}
+    stage2 = result.get("stage2", {}) or {}
+    stage3 = result.get("stage3", {}) or {}
+
+    bs = result.get("buffer_status", {}) or {}
+    buffer_status = {
+        "ready": bool(bs.get("ready", sensor_buffer.is_ready() if sensor_buffer else False)),
+        "size": int(bs.get("size", len(sensor_buffer) if sensor_buffer else 0)),
+        "capacity": int(getattr(sensor_buffer, "window_size", 60)) if sensor_buffer else 60,
+        "usingBuffer": bool(bs.get("using_buffer", False)),
+    }
+
+    return {
+        "success": True,
+        "stage1": {
+            "isAnomaly": bool(stage1.get("is_anomaly", False)),
+            "confidence": float(stage1.get("confidence", 0.0)),
+            "score": stage1.get("score", None),
+            "modelType": stage1.get("model_type", None),
+        },
+        "stage2": {
+            "state": stage2.get("state", "UNKNOWN"),
+            "confidence": float(stage2.get("confidence", 0.0)),
+            "modelType": stage2.get("model_type", None),
+        },
+        "stage3": {
+            "component": stage3.get("component", None),
+            "confidence": float(stage3.get("confidence", 0.0)),
+            "top3": [
+                {"component": c, "confidence": float(p)}
+                for (c, p) in (stage3.get("top3") or [])
+            ],
+            "modelType": stage3.get("model_type", None),
+        },
+        "componentHealth": result.get("component_health", {}) or {},
+        "recommendedActions": result.get("actions", []) or [],
+        "alertsSent": result.get("alerts_sent", {}) or {},
+        "bufferStatus": buffer_status,
+    }
+
+
+# -----------------------------------------------------------------------------
+# Routes
+# -----------------------------------------------------------------------------
+@app.route("/health", methods=["GET"])
+def health():
+    return jsonify({
+        "status": "ok",
+        "ml_available": bool(ML_AVAILABLE),
+        "pid": ML_PID,
+        "file": ML_API_FILE,
+        "import_error": ML_IMPORT_ERROR,
+        "buffer_size": len(sensor_buffer) if sensor_buffer else 0,
+        "buffer_ready": sensor_buffer.is_ready() if sensor_buffer else False,
+    })
+
+
+@app.route("/api/inference", methods=["POST"])
+def run_inference():
+    if not ML_AVAILABLE:
+        return jsonify({
+            "success": False,
+            "error": "ML components not available",
+            "import_error": ML_IMPORT_ERROR
+        }), 503
+
+    try:
+        data = request.get_json(silent=True) or {}
+        payload = data.get("payload")
+
+        if not isinstance(payload, dict):
+            return jsonify({"success": False, "error": "Missing payload in request"}), 400
+
+        # ✅ Directly call YOUR working pipeline
+        result = ml_inference.run_pipeline(payload, sensor_buffer=sensor_buffer)
+
+        if not result.get("success", False):
+            return jsonify({
+                "success": False,
+                "error": result.get("error", "Pipeline failed"),
+                "bufferStatus": {
+                    "ready": sensor_buffer.is_ready() if sensor_buffer else False,
+                    "size": len(sensor_buffer) if sensor_buffer else 0,
+                    "capacity": getattr(sensor_buffer, "window_size", 60) if sensor_buffer else 60,
+                    "usingBuffer": False,
+                }
+            }), 200
+
+        return jsonify(to_dashboard_schema(result)), 200
+
+    except Exception as e:
+        traceback.print_exc()
+        return jsonify({"success": False, "error": str(e)}), 500
+
+
+@app.route("/api/buffer/reset", methods=["POST"])
+def reset_buffer():
+    global sensor_buffer
+    if not ML_AVAILABLE:
+        return jsonify({"success": False, "error": "ML not available"}), 503
+
+    from sensor_buffer import SensorBuffer
+    sensor_buffer = SensorBuffer(window_size=60, n_features=40)
+    return jsonify({"success": True, "message": "Buffer reset"}), 200
+
+
+@app.route("/api/buffer/status", methods=["GET"])
+def buffer_status():
+    if not sensor_buffer:
+        return jsonify({"ready": False, "size": 0, "capacity": 60})
+    return jsonify({
+        "ready": sensor_buffer.is_ready(),
+        "size": len(sensor_buffer),
+        "capacity": sensor_buffer.window_size
+    })
+
+
+if __name__ == "__main__":
+    print("=" * 60)
+    print("SWaT ML Inference API Service")
+    print("=" * 60)
+    print(f"ML Available: {ML_AVAILABLE}")
+    print("Starting server on http://localhost:5000")
+    print("=" * 60)
+
+    app.run(host="0.0.0.0", port=int(os.environ.get("PORT", 7860)))

ml_inference.py

@@ -0,0 +1,813 @@
+"""
+ML INFERENCE ENGINE FOR SWAT DASHBOARD
+======================================
+Real-time predictive maintenance inference using trained models.
+
+Implements 3-stage pipeline:
+- Stage 1: Anomaly Detection (ANY model from training)
+- Stage 2: State Classification (ANY model from training)
+- Stage 3: Component Identification (ANY model from training)
+
+Models are automatically loaded based on final_config.json from each stage.
+Models are cached for fast inference.
+"""
+
+import numpy as np
+import pandas as pd
+import pickle
+import json
+import warnings
+from sensor_buffer import SensorBuffer
+from alerts import trigger_alerts
+warnings.filterwarnings('ignore')
+
+try:
+    import tensorflow as tf
+    from tensorflow import keras
+    TF_AVAILABLE = True
+except ImportError:
+    TF_AVAILABLE = False
+    print("⚠️  TensorFlow not available. Install: pip install tensorflow")
+
+try:
+    import streamlit as st
+    STREAMLIT_AVAILABLE = False
+except ImportError:
+    STREAMLIT_AVAILABLE = False
+
+
+# ============================================================================
+# CONFIGURATION
+# ============================================================================
+
+# Model paths (adjust these to your local paths)
+MODEL_DIR = r"D:\FYP - FINAL\SwatDashboard\PythonMlService\models"
+DATA_DIR = r"D:\FYP - FINAL\SwatDashboard\PythonMlService\ml_data"
+
+# Component names (must match training)
+COMPONENTS = ['P101', 'P201', 'P203', 'P205', 'P302', 'P402', 'P403', 'P501', 'MV101', 'MV304']
+STATE_NAMES = ['ANOMALY', 'DEGRADING', 'FAULTED']
+
+# ============================================================================
+# MODEL LOADING (CACHED & GENERAL)
+# ============================================================================
+
+if STREAMLIT_AVAILABLE:
+    @st.cache_resource
+    def load_models():
+        """Load all trained models (cached for performance)"""
+        return _load_models_internal()
+else:
+    _cached_models = None
+    def load_models():
+        global _cached_models
+        if _cached_models is None:
+            _cached_models = _load_models_internal()
+        return _cached_models
+
+
+def _load_models_internal():
+    """Internal model loading function - GENERAL VERSION"""
+    models = {}
+
+    try:
+        # Load scaler
+        scaler_path = f"{DATA_DIR}/scaler.pkl"
+        with open(scaler_path, 'rb') as f:
+            models['scaler'] = pickle.load(f)
+
+        # ====================================================================
+        # STAGE 1: Load best model based on config
+        # ====================================================================
+        stage1_dir = f"{MODEL_DIR}/stage1"
+        with open(f"{stage1_dir}/final_config.json", "r") as f:
+            config1 = json.load(f)
+
+        models['stage1_type'] = config1['best_model_type']
+
+        if models['stage1_type'] in ['autoencoder', 'dae']:
+            # Autoencoder or Denoising Autoencoder
+            if not TF_AVAILABLE:
+                raise ImportError("TensorFlow required for autoencoder models")
+
+            model_file = 'autoencoder.keras' if models['stage1_type'] == 'autoencoder' else 'denoising_autoencoder.keras'
+            threshold_file = 'autoencoder_threshold.pkl' if models['stage1_type'] == 'autoencoder' else 'dae_threshold.pkl'
+
+            models['stage1'] = keras.models.load_model(f"{stage1_dir}/{model_file}", compile=False)
+            with open(f"{stage1_dir}/{threshold_file}", 'rb') as f:
+                models['stage1_threshold'] = pickle.load(f)
+
+        elif models['stage1_type'] == 'lof':
+            # Local Outlier Factor
+            with open(f"{stage1_dir}/lof.pkl", 'rb') as f:
+                models['stage1'] = pickle.load(f)
+            with open(f"{stage1_dir}/lof_threshold.pkl", 'rb') as f:
+                models['stage1_threshold'] = pickle.load(f)
+
+        elif models['stage1_type'] == 'iforest':
+            # Isolation Forest
+            with open(f"{stage1_dir}/isolation_forest.pkl", 'rb') as f:
+                models['stage1'] = pickle.load(f)
+            models['stage1_threshold'] = None  # Uses built-in threshold
+
+        else:  # xgboost
+            with open(f"{stage1_dir}/xgboost.pkl", 'rb') as f:
+                models['stage1'] = pickle.load(f)
+
+            # ===== FORCE CPU (XGBoost 3.1.0 SAFE) =====
+            m = models['stage1']
+
+            # sklearn wrapper params
+            try:
+                m.set_params(
+                    device="cpu",  # 🔥 key line
+                    tree_method="hist",  # CPU-friendly
+                    n_jobs=1  # avoid OpenMP fights
+                )
+            except Exception:
+                pass
+
+            # booster-level safety
+            try:
+                m.get_booster().set_param({"device": "cpu"})
+            except Exception:
+                pass
+
+            models['stage1_threshold'] = None
+            #print("   ✅ Stage 1 XGBoost loaded (CPU forced)")
+
+        # ====================================================================
+        # STAGE 2: Load best model based on config
+        # ====================================================================
+        stage2_dir = f"{MODEL_DIR}/stage2"
+        with open(f"{stage2_dir}/final_config.json", "r") as f:
+            config2 = json.load(f)
+
+        models['stage2_type'] = config2['best_model_type']
+        models['stage2_seq_length'] = config2.get('sequence_length', None)
+
+        if models['stage2_type'] in ['lstm', 'cnn']:
+            # Sequential models (LSTM or CNN)
+            if not TF_AVAILABLE:
+                raise ImportError("TensorFlow required for LSTM/CNN models")
+
+            models['stage2'] = keras.models.load_model(f"{stage2_dir}/{models['stage2_type']}.keras")
+
+        else:  # xgboost
+            with open(f"{stage2_dir}/xgboost.pkl", 'rb') as f:
+                models['stage2'] = pickle.load(f)
+
+        # ====================================================================
+        # STAGE 3: Load best model based on config
+        # ====================================================================
+        stage3_dir = f"{MODEL_DIR}/stage3"
+        with open(f"{stage3_dir}/final_config.json", "r") as f:
+            config3 = json.load(f)
+
+        models['stage3_type'] = config3['best_model_type']
+
+        if models['stage3_type'] == 'mlp':
+            # Multi-Layer Perceptron
+            if not TF_AVAILABLE:
+                raise ImportError("TensorFlow required for MLP models")
+
+            models['stage3'] = keras.models.load_model(f"{stage3_dir}/mlp.keras")
+
+        elif models['stage3_type'] == 'lightgbm':
+            # LightGBM
+            with open(f"{stage3_dir}/lightgbm.pkl", 'rb') as f:
+                models['stage3'] = pickle.load(f)
+
+        else:  # xgboost
+            with open(f"{stage3_dir}/xgboost.pkl", 'rb') as f:
+                models['stage3'] = pickle.load(f)
+
+        models['loaded'] = True
+        print(f"✅ Models loaded successfully!")
+        print(f"   Stage 1: {config1['best_model']} ({models['stage1_type']})")
+        print(f"   Stage 2: {config2['best_model']} ({models['stage2_type']})")
+        print(f"   Stage 3: {config3['best_model']} ({models['stage3_type']})")
+
+        return models
+
+    except Exception as e:
+        print(f"⚠️  Error loading models: {e}")
+        models['loaded'] = False
+        models['error'] = str(e)
+        return models
+
+
+# ============================================================================
+# FEATURE EXTRACTION
+# ============================================================================
+
+def extract_features(payload):
+    """
+    Extract 40 features from payload (matches training format).
+
+    Returns:
+        np.array: (1, 40) feature array
+    """
+    features = []
+
+    # ========================================================================
+    # 16 SENSOR READINGS
+    # ========================================================================
+    sensors = [
+        'true_FIT101', 'true_FIT201', 'true_FIT301', 'true_FIT401', 'true_FIT501',
+    'true_LIT101', 'true_LIT301', 'true_LIT401',
+    'true_AIT201', 'true_AIT202', 'true_AIT203', 'true_AIT401', 'true_AIT402', 'true_AIT501',
+    'true_DPIT301', 'true_PIT501'
+]
+
+    for sensor in sensors:
+        val = payload.get(sensor, 0)
+        try:
+            features.append(float(val))
+        except:
+            features.append(0.0)
+
+    # ========================================================================
+    # 24 MOTOR PHYSICS FEATURES
+    # ========================================================================
+    # These should match the motor physics features used in training
+    # Format: motor_temp, current, vibration for each component
+    components = ['P101', 'P201', 'P203', 'P205', 'P302', 'P402', 'P403', 'P501']
+
+    for comp in components:
+        # Get motor physics features from payload
+        temp_key = f'true_{comp}_motor_temp'
+        current_key = f'true_{comp}_current'
+        vib_key = f'true_{comp}_vibration'
+
+        # Extract values (use defaults if not present)
+        temp = payload.get(temp_key, 0.0)
+        current = payload.get(current_key, 0.0)
+        vib = payload.get(vib_key, 0.0)
+
+        try:
+            features.extend([float(temp), float(current), float(vib)])
+        except:
+            features.extend([0.0, 0.0, 0.0])
+
+    # Convert to numpy array
+    return np.array(features).reshape(1, -1)
+
+
+# ============================================================================
+# STAGE 1: ANOMALY DETECTION (GENERAL)
+# ============================================================================
+
+def predict_anomaly(features_scaled, models):
+    """
+    Stage 1: Binary anomaly detection using ANY model type.
+
+    Returns:
+        tuple: (is_anomaly, confidence, score)
+    """
+    if not models.get('loaded'):
+        return False, 0.0, 0.0
+
+    try:
+        model_type = models['stage1_type']
+
+        # ====================================================================
+        # AUTOENCODER / DENOISING AUTOENCODER
+        # ====================================================================
+        if model_type in ['autoencoder', 'dae']:
+            # Reconstruct input
+            reconstructed = models['stage1'].predict(features_scaled, verbose=0)
+
+            # Compute reconstruction error (MSE)
+            error = np.mean((features_scaled - reconstructed) ** 2)
+
+            # Compare to threshold
+            threshold = models['stage1_threshold']
+            is_anomaly = (error > threshold)
+
+            # Compute confidence
+            if is_anomaly:
+                confidence = min(1.0, (error / threshold - 1.0) * 2 + 0.5)
+            else:
+                confidence = min(1.0, (1.0 - error / threshold) + 0.5)
+
+            return bool(is_anomaly), float(confidence), float(error)
+
+        # ====================================================================
+        # LOCAL OUTLIER FACTOR
+        # ====================================================================
+        elif model_type == 'lof':
+            # Get anomaly score (higher = more anomalous)
+            score = -models['stage1'].decision_function(features_scaled)[0]
+            threshold = models['stage1_threshold']
+
+            is_anomaly = (score > threshold)
+
+            # Confidence based on distance from threshold
+            if is_anomaly:
+                confidence = min(1.0, (score / threshold - 1.0) + 0.5)
+            else:
+                confidence = min(1.0, (1.0 - score / threshold) + 0.5)
+
+            return bool(is_anomaly), float(confidence), float(score)
+
+        # ====================================================================
+        # ISOLATION FOREST
+        # ====================================================================
+        elif model_type == 'iforest':
+            # Predict (-1 = anomaly, 1 = normal)
+            pred = models['stage1'].predict(features_scaled)[0]
+            is_anomaly = (pred == -1)
+
+            # Get anomaly score for confidence
+            score = -models['stage1'].score_samples(features_scaled)[0]
+            confidence = min(1.0, abs(score) / 2.0)
+
+            return bool(is_anomaly), float(confidence), float(score)
+
+        # ====================================================================
+        # XGBOOST
+        # ====================================================================
+        else:  # xgboost
+            import xgboost as xgb
+            import numpy as np
+
+            # force CPU
+            try:
+                models["stage1"].set_params(device="cpu", tree_method="hist", n_jobs=1)
+            except Exception:
+                pass
+            try:
+                models["stage1"].get_booster().set_param({"device": "cpu"})
+            except Exception:
+                pass
+
+            x = np.ascontiguousarray(features_scaled.astype(np.float32))
+            dm = xgb.DMatrix(x)
+
+            p1 = float(models["stage1"].get_booster().predict(dm)[0])  # binary:logistic => P(class=1)
+            is_anomaly = p1 > 0.5
+            confidence = p1 if is_anomaly else (1.0 - p1)
+
+            return bool(is_anomaly), float(confidence), float(p1)
+
+    except Exception as e:
+        print(f"Stage 1 error: {e}")
+        return False, 0.0, 0.0
+
+
+# ============================================================================
+# STAGE 2: STATE CLASSIFICATION (GENERAL)
+# ============================================================================
+
+def predict_state(features_scaled, models, is_anomaly, sensor_buffer=None):
+    """
+    Stage 2: Multi-class state classification using ANY model type.
+    Only runs if Stage 1 detected anomaly.
+
+    Args:
+        features_scaled: Current sample features (scaled)
+        models: Loaded models dict
+        is_anomaly: Whether Stage 1 detected anomaly
+        sensor_buffer: Optional SensorBuffer for LSTM/CNN
+
+    Returns:
+        tuple: (state_name, confidence, state_probs)
+    """
+    if not is_anomaly:
+        return "NORMAL", 1.0, [0.0, 0.0, 0.0]
+
+    if not models.get('loaded'):
+        return "UNKNOWN", 0.0, [0.0, 0.0, 0.0]
+
+    try:
+        model_type = models['stage2_type']
+
+        # ====================================================================
+        # LSTM / CNN (Sequential models)
+        # ====================================================================
+        if model_type in ['lstm', 'cnn']:
+            seq_length = models['stage2_seq_length']
+
+            # NEW: Try to use buffer if available
+            if sensor_buffer is not None and sensor_buffer.is_ready():
+                # Use real sequence from buffer
+                seq = sensor_buffer.get_sequence()
+                seq = seq.reshape(1, seq_length, -1)
+                use_buffer = True
+            else:
+                # Fallback: Repeat current sample (old hack)
+                seq = np.repeat(features_scaled, seq_length, axis=0)
+                seq = seq.reshape(1, seq_length, -1)
+                use_buffer = False
+
+            # Predict
+            probs = models['stage2'].predict(seq, verbose=0)[0]
+
+            # Get predicted class
+            state_idx = int(np.argmax(probs))
+            state_name = STATE_NAMES[state_idx]
+            confidence = float(probs[state_idx])
+
+            # Reduce confidence if using fallback hack
+            if not use_buffer:
+                confidence *= 0.85  # Penalty for not having real sequence
+
+            return state_name, confidence, probs.tolist()
+
+        # ====================================================================
+        # XGBOOST (Tabular model - doesn't need buffer)
+        # ====================================================================
+        else:  # xgboost
+            # Predict probabilities
+            probs = models['stage2'].predict_proba(features_scaled)[0]
+
+            # Get predicted class
+            state_idx = int(np.argmax(probs))
+            state_name = STATE_NAMES[state_idx]
+            confidence = float(probs[state_idx])
+
+            return state_name, confidence, probs.tolist()
+
+    except Exception as e:
+        print(f"Stage 2 error: {e}")
+        return "UNKNOWN", 0.0, [0.0, 0.0, 0.0]
+
+# ============================================================================
+# STAGE 3: COMPONENT IDENTIFICATION (GENERAL)
+# ============================================================================
+
+def predict_component(features_scaled, models, state_name):
+    """
+    Stage 3: Component identification using ANY model type.
+    Only runs if state is DEGRADING or FAULTED.
+
+    Returns:
+        tuple: (component, confidence, top3_components)
+    """
+    if state_name == "NORMAL":
+        return None, 0.0, []
+
+    if not models.get('loaded'):
+        return None, 0.0, []
+
+    try:
+        model_type = models['stage3_type']
+
+        # ====================================================================
+        # MLP (Neural Network)
+        # ====================================================================
+        if model_type == 'mlp':
+            # Predict probabilities
+            probs = models['stage3'].predict(features_scaled, verbose=0)[0]
+
+            # Get top prediction
+            comp_idx = int(np.argmax(probs))
+            component = COMPONENTS[comp_idx]
+            confidence = float(probs[comp_idx])
+
+            # Get top 3
+            top3_idx = np.argsort(probs)[-3:][::-1]
+            top3 = [(COMPONENTS[i], float(probs[i])) for i in top3_idx]
+
+            return component, confidence, top3
+
+        # ====================================================================
+        # LIGHTGBM or XGBOOST
+        # ====================================================================
+        else:  # lightgbm or xgboost
+            # Predict probabilities
+            probs = models['stage3'].predict_proba(features_scaled)[0]
+
+            # Get top prediction
+            comp_idx = int(np.argmax(probs))
+            component = COMPONENTS[comp_idx]
+            confidence = float(probs[comp_idx])
+
+            # Get top 3
+            top3_idx = np.argsort(probs)[-3:][::-1]
+            top3 = [(COMPONENTS[i], float(probs[i])) for i in top3_idx]
+
+            return component, confidence, top3
+
+    except Exception as e:
+        print(f"Stage 3 error: {e}")
+        return None, 0.0, []
+
+
+# ============================================================================
+# FULL PIPELINE
+# ============================================================================
+
+def run_pipeline(payload, sensor_buffer=None):
+    """
+    Run complete 3-stage ML pipeline on payload.
+
+    Args:
+        payload (dict): Raw sensor/actuator data from dashboard
+        sensor_buffer (SensorBuffer): Optional buffer for LSTM/CNN models
+
+    Returns:
+        dict: Prediction results with all stages
+    """
+    # Load models (cached)
+    models = load_models()
+
+    # Check if models loaded successfully
+    if not models.get('loaded'):
+        return {
+            'success': False,
+            'error': models.get('error', 'Models not loaded'),
+            'stage1': {'is_anomaly': False, 'confidence': 0.0},
+            'stage2': {'state': 'UNKNOWN', 'confidence': 0.0},
+            'stage3': {'component': None, 'confidence': 0.0}
+        }
+
+    try:
+        # Extract features
+        features = extract_features(payload)
+
+        # Scale features
+        features_scaled = models['scaler'].transform(features)
+
+        # NEW: Add to buffer if provided
+        if sensor_buffer is not None:
+            sensor_buffer.add_sample(features_scaled[0])  # Add 1D array
+
+        # Stage 1: Anomaly Detection
+        is_anomaly, s1_conf, score = predict_anomaly(features_scaled, models)
+
+        # Stage 2: State Classification (NOW WITH BUFFER)
+        state, s2_conf, state_probs = predict_state(
+            features_scaled,
+            models,
+            is_anomaly,
+            sensor_buffer=sensor_buffer  # PASS BUFFER
+        )
+
+        # Stage 3: Component Identification
+        component, s3_conf, top3 = predict_component(features_scaled, models, state)
+
+        # Compile results
+        result = {
+            'success': True,
+            'timestamp': pd.Timestamp.now(),
+            'stage1': {
+                'is_anomaly': is_anomaly,
+                'confidence': s1_conf,
+                'score': score,
+                'model_type': models['stage1_type']
+            },
+            'stage2': {
+                'state': state,
+                'confidence': s2_conf,
+                'probabilities': {
+                    'ANOMALY': state_probs[0] if len(state_probs) > 0 else 0.0,
+                    'DEGRADING': state_probs[1] if len(state_probs) > 1 else 0.0,
+                    'FAULTED': state_probs[2] if len(state_probs) > 2 else 0.0
+                },
+                'model_type': models['stage2_type']
+            },
+            'stage3': {
+                'component': component,
+                'confidence': s3_conf,
+                'top3': top3,
+                'model_type': models['stage3_type']
+            }
+        }
+
+        # NEW: Add buffer status to result
+        if sensor_buffer is not None:
+            result['buffer_status'] = {
+                'size': sensor_buffer.size(),
+                'ready': sensor_buffer.is_ready(),
+                'using_buffer': sensor_buffer.is_ready() and models['stage2_type'] in ['lstm', 'cnn']
+            }
+        # Build component health + recommended actions
+        component_health = get_component_health(result)
+        result['component_health'] = component_health  # optional (for dashboard)
+
+        result['actions'] = get_recommended_actions(result, component_health)
+
+        # Now trigger alerts (email uses result['actions'])
+        alert_status = trigger_alerts(result)
+        result['alerts_sent'] = alert_status
+        return result
+
+    except Exception as e:
+        return {
+            'success': False,
+            'error': str(e),
+            'stage1': {'is_anomaly': False, 'confidence': 0.0},
+            'stage2': {'state': 'ERROR', 'confidence': 0.0},
+            'stage3': {'component': None, 'confidence': 0.0}
+        }
+
+# ============================================================================
+# COMPONENT HEALTH SUMMARY
+# ============================================================================
+
+def get_component_health(prediction):
+    """
+    Generate health status for all components.
+
+    Returns:
+        dict: {component_name: status_dict}
+    """
+    health = {}
+
+    state = prediction['stage2']['state']
+    identified_comp = prediction['stage3']['component']
+    top3 = prediction['stage3'].get('top3', [])
+
+    for comp in COMPONENTS:
+        if state == "NORMAL":
+            health[comp] = {
+                'status': 'NORMAL',
+                'icon': '🟢',
+                'confidence': 1.0,
+                'message': 'Operating normally'
+            }
+        elif comp == identified_comp:
+            # Primary suspect
+            conf = prediction['stage3']['confidence']
+            if state == "FAULTED":
+                health[comp] = {
+                    'status': 'FAULTED',
+                    'icon': '🔴',
+                    'confidence': conf,
+                    'message': f'FAULTED - Immediate action required'
+                }
+            elif state == "DEGRADING":
+                health[comp] = {
+                    'status': 'DEGRADING',
+                    'icon': '🟡',
+                    'confidence': conf,
+                    'message': f'Degrading - Schedule maintenance'
+                }
+            elif state == "ANOMALY":
+                health[comp] = {
+                    'status': 'MONITOR',
+                    'icon': '🟠',
+                    'confidence': conf,
+                    'message': 'Anomaly detected - Monitor closely'
+                }
+        elif any(comp == t[0] for t in top3):
+            # In top 3 - possible suspect
+            conf = next(t[1] for t in top3 if t[0] == comp)
+            health[comp] = {
+                'status': 'MONITOR',
+                'icon': '🟠',
+                'confidence': conf,
+                'message': f'Check (Top-3: {conf*100:.0f}%)'
+            }
+        else:
+            # Not identified
+            health[comp] = {
+                'status': 'NORMAL',
+                'icon': '🟢',
+                'confidence': 0.0,
+                'message': 'Operating normally'
+            }
+
+    return health
+
+
+# ============================================================================
+# RECOMMENDED ACTIONS
+# ============================================================================
+
+def get_recommended_actions(prediction, component_health):
+    """
+    Generate maintenance recommendations based on predictions.
+
+    Returns:
+        list: List of action strings
+    """
+    actions = []
+
+    state = prediction['stage2']['state']
+    component = prediction['stage3']['component']
+
+    if state == "NORMAL":
+        actions.append("✅ System operating normally - No action required")
+        return actions
+    else:
+        if state != "FAULTED" and state != "DEGRADING":
+            actions.append(f"⚠️  Suspected component: {component}")
+
+    if component:
+        # Component-specific actions
+        comp_actions = {
+            'P101': [
+                '🔧 Inspect intake pump P101 for wear',
+                '📋 Check pump vibration and bearing temperature',
+                '💧 Verify intake flow rate and pressure'
+            ],
+            'P201': [
+                '🔧 Inspect NaCl dosing pump P201',
+                '📋 Check chemical feed lines for blockages',
+                '⚗️ Verify NaCl concentration and flow rate'
+            ],
+            'P203': [
+                '🔧 Inspect HCl dosing pump P203',
+                '📋 Check acid feed system for leaks',
+                '⚗️ Calibrate pH sensor AIT202'
+            ],
+            'P205': [
+                '🔧 Inspect NaOCl dosing pump P205',
+                '📋 Check chlorine feed system',
+                '⚗️ Verify ORP readings (AIT203)'
+            ],
+            'P302': [
+                '🔧 Inspect UF feed pump P302',
+                '📋 Check UF membrane differential pressure',
+                '💧 Consider membrane backwash or cleaning'
+            ],
+            'P402': [
+                '🔧 Inspect dechlorination feed pump P402',
+                '📋 Check UV system operation',
+                '⚗️ Verify ORP levels post-UV'
+            ],
+            'P403': [
+                '🔧 Inspect NaHSO₄ dosing pump P403',
+                '📋 Check dechlorination efficiency',
+                '⚗️ Verify residual chlorine levels'
+            ],
+            'P501': [
+                '🔧 Inspect RO feed pump P501',
+                '📋 Check RO membrane pressure and flow',
+                '💧 Monitor permeate quality (TDS)'
+            ],
+            'MV101': [
+                '🔧 Inspect motorized valve MV101',
+                '📋 Check valve position and response',
+                '⚙️ Lubricate valve actuator'
+            ],
+            'MV304': [
+                '🔧 Inspect motorized valve MV304',
+                '📋 Check UF backwash valve operation',
+                '⚙️ Verify valve seating'
+            ]
+        }
+        if state == "FAULTED":
+            actions.append(f"🚨 URGENT: {component} has FAULTED")
+            actions.append("📞 Alert maintenance team")
+            actions.append(f"⏸️  Consider stopping {component} immediately")
+        # General actions based on state
+        if state == "DEGRADING":
+            actions.append(f"🚨 URGENT: {component} is DEGRADING")
+            actions.append("📅 Schedule maintenance within next 24-48 hours")
+            actions.append("📊 Increase monitoring frequency")
+
+        if component in comp_actions:
+            actions.extend(comp_actions[component][:3])  # Top 3 actions
+
+
+    return actions
+
+
+# ============================================================================
+# TESTING
+# ============================================================================
+
+if __name__ == "__main__":
+    print("\n" + "=" * 60)
+    print("TEST 1: Without Buffer (Old Way)")
+    print("=" * 60)
+
+    test_payload = {
+        'true_FIT101': 2.5, 'true_LIT101': 800.0,
+        'true_FIT201': 2.3, 'true_AIT201': 150.0, 'true_AIT202': 7.2, 'true_AIT203': 350.0,
+        'true_FIT301': 2.1, 'true_LIT301': 750.0, 'true_DPIT301': 0.15,
+        'true_FIT401': 2.0, 'true_LIT401': 700.0, 'true_AIT401': 85.0, 'true_AIT402': 280.0,
+        'true_FIT501': 1.8, 'true_PIT501': 5.2, 'true_AIT501': 6.8,
+        # Motor physics features
+        'true_P101_motor_temp': 45.0, 'true_P101_current': 3.5, 'true_P101_vibration': 1.2,
+        'true_P201_motor_temp': 42.0, 'true_P201_current': 2.8, 'true_P201_vibration': 0.9,
+        'true_P203_motor_temp': 40.0, 'true_P203_current': 2.5, 'true_P203_vibration': 0.8,
+        'true_P205_motor_temp': 43.0, 'true_P205_current': 3.0, 'true_P205_vibration': 1.0,
+        'true_P302_motor_temp': 46.0, 'true_P302_current': 3.8, 'true_P302_vibration': 1.3,
+        'true_P402_motor_temp': 44.0, 'true_P402_current': 3.2, 'true_P402_vibration': 1.1,
+        'true_P403_motor_temp': 41.0, 'true_P403_current': 2.7, 'true_P403_vibration': 0.9,
+        'true_P501_motor_temp': 48.0, 'true_P501_current': 4.0, 'true_P501_vibration': 1.4,
+        'true_MV101_motor_temp': 38.0, 'true_MV101_current': 1.5, 'true_MV101_vibration': 0.5,
+        'true_MV304_motor_temp': 39.0, 'true_MV304_current': 1.6, 'true_MV304_vibration': 0.6,
+    }
+
+    # Create buffer and add 60 samples
+    buffer = SensorBuffer(window_size=60, n_features=40)
+
+    for i in range(60):
+        result1 = run_pipeline(test_payload, sensor_buffer=buffer)
+
+    if result1['success']:
+        print(f"✅ Stage 1: {result1['stage1']['is_anomaly']}")
+        print(f"✅ Stage 2: {result1['stage2']['state']} (conf: {result1['stage2']['confidence']:.2f})")
+        print(f"✅ Stage 3: {result1['stage3']['component']}")
+        print(f"\n📊 Buffer Status:")
+        print(f"   Size: {result1['buffer_status']['size']}/60")
+        print(f"   Ready: {result1['buffer_status']['ready']}")
+        print(f"   Using Buffer: {result1['buffer_status']['using_buffer']}")
+    else:
+        print(f"\n❌ Pipeline Error: {result1['error']}")

requirements.txt

@@ -0,0 +1,2 @@
+flask==3.0.0
+flask-cors==4.0.0

sensor_buffer.py

@@ -0,0 +1,97 @@
+"""
+Sensor Buffer for Rolling Window
+=================================
+Maintains last 60 samples for LSTM/CNN inference.
+"""
+
+import numpy as np
+from collections import deque
+
+
+class SensorBuffer:
+    """
+    Rolling buffer that stores last N sensor readings.
+
+    Usage:
+        buffer = SensorBuffer(window_size=60, n_features=40)
+
+        # Add new sample
+        buffer.add_sample(features_scaled)
+
+        # Check if ready
+        if buffer.is_ready():
+            sequence = buffer.get_sequence()
+            # Use sequence for LSTM/CNN
+    """
+
+    def __init__(self, window_size=60, n_features=40):
+        """
+        Initialize buffer.
+
+        Args:
+            window_size (int): Number of samples to store (default: 60)
+            n_features (int): Number of features per sample (default: 40)
+        """
+        self.window_size = window_size
+        self.n_features = n_features
+
+        # Use deque for efficient FIFO operations
+        self.buffer = deque(maxlen=window_size)
+
+        #print(f"✅ SensorBuffer initialized: window={window_size}, features={n_features}")
+
+    def add_sample(self, features):
+        """
+        Add new sample to buffer.
+
+        Args:
+            features (np.array): (40,) array of scaled features
+        """
+        # Convert to 1D array if needed
+        if features.ndim == 2:
+            features = features.flatten()
+
+        # Add to buffer (automatically removes oldest if full)
+        self.buffer.append(features)
+
+    def get_sequence(self):
+        """
+        Get sequence for LSTM/CNN (60 x 40 array).
+
+        Returns:
+            np.array: (window_size, n_features) array
+        """
+        # If buffer not full yet, pad with zeros
+        if len(self.buffer) < self.window_size:
+            # Pad beginning with zeros
+            padding_needed = self.window_size - len(self.buffer)
+            padding = [np.zeros(self.n_features)] * padding_needed
+            return np.array(padding + list(self.buffer))
+
+        # Buffer is full - return as numpy array
+        return np.array(list(self.buffer))
+
+    def is_ready(self):
+        """
+        Check if buffer has enough samples for reliable prediction.
+
+        Returns:
+            bool: True if buffer has at least window_size samples
+        """
+        return len(self.buffer) >= self.window_size
+
+    def size(self):
+        """Current number of samples in buffer"""
+        return len(self.buffer)
+
+    def clear(self):
+        """Clear all samples from buffer"""
+        self.buffer.clear()
+
+    def __len__(self):
+        return len(self.buffer)
+
+    def __repr__(self):
+        return f"SensorBuffer(size={len(self.buffer)}/{self.window_size}, features={self.n_features})"
+
+