Upload 7 files

Dockerfile

@@ -1,20 +1,17 @@
-FROM python:3.13.5-slim
-
-WORKDIR /app
-
-RUN apt-get update && apt-get install -y \
-    build-essential \
-    curl \
-    git \
-    && rm -rf /var/lib/apt/lists/*
-
-COPY requirements.txt ./
-COPY src/ ./src/
-
-RUN pip3 install -r requirements.txt
-
-EXPOSE 8501
-
-HEALTHCHECK CMD curl --fail http://localhost:8501/_stcore/health
-
-ENTRYPOINT ["streamlit", "run", "src/streamlit_app.py", "--server.port=8501", "--server.address=0.0.0.0"]
+FROM python:3.11-slim
+
+WORKDIR /app
+
+# Install dependencies
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy app files
+COPY app.py .
+COPY utils/ ./utils/
+
+# Expose Streamlit port (HuggingFace Spaces uses 7860)
+EXPOSE 7860
+
+# Run Streamlit
+CMD ["streamlit", "run", "app.py", "--server.port=7860", "--server.address=0.0.0.0", "--server.headless=true"]

README.md

@@ -1,20 +1,88 @@
----
-title: Sap Predictive Integrity Using RPT 1
-emoji: 🚀
-colorFrom: red
-colorTo: red
-sdk: docker
-app_port: 8501
-tags:
-- streamlit
-pinned: false
-short_description: 'Powered by SAP-RPT-1 '
-license: mit
----
-
-# Welcome to Streamlit!
-
-Edit `/src/streamlit_app.py` to customize this app to your heart's desire. :heart:
-
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
+---
+title: SAP Predictive Integrity
+emoji: 🛡️
+colorFrom: indigo
+colorTo: purple
+sdk: docker
+pinned: false
+license: mit
+short_description: Proactive SAP Operational Risk Prediction with SAP-RPT-1
+---
+
+# 🛡️ SAP Predictive Integrity
+
+**Proactive Operational Risk Prediction for SAP Systems using SAP-RPT-1 Tabular ML**
+
+This interactive demo predicts operational failures in SAP environments using synthetic datasets that mirror real SAP table structures.
+
+## 🎯 Prediction Scenarios
+
+| Scenario | SAP Tables Referenced | Risk Factors |
+|----------|----------------------|--------------|
+| 🔮 **Job Failure** | TBTCO, TBTCP, TBTCS | Concurrency, Memory, Delay, Job Class |
+| 📦 **Transport Risk** | E070, E071, TPLOG | Object Count, Author Success Rate, System Load |
+| 🔗 **Interface Health** | EDIDC, EDIDS, ARFCSSTATE | Queue Depth, Partner Reliability, Payload Size |
+
+## 🤖 Models Supported
+
+- **SAP-RPT-1-OSS (Public)**: Open-source tabular ML via TabPFN on HuggingFace
+- **SAP-RPT-1 (Closed API)**: Enterprise API with Bearer token authentication
+- **Offline Mode**: Mock predictions for demo purposes
+
+## ✨ Features
+
+- **1,000 Row Analysis**: Score 1,000 synthetic SAP records per scenario
+- **Seed Rotation**: Regenerate datasets with different random seeds
+- **Drift Detection**: Alerts when data distribution shifts significantly
+- **Confidence Scoring**: Each prediction includes probability confidence
+- **Remediation Playbooks**: Actionable guidance for HIGH risk entities
+- **Export**: Download scored CSV and audit JSON
+
+## 📊 Dataset Schema
+
+Each scenario generates synthetic data mimicking real SAP table structures:
+
+### Job Failure (TBTCO/TBTCP)
+| Column | Source | Description |
+|--------|--------|-------------|
+| JOBNAME | TBTCO | Background job name |
+| JOBCLASS | TBTCO | Priority (A/B/C) |
+| DURATION_SEC | Derived | Job execution time |
+| CONCURRENT_JOBS | Synthetic | Jobs running simultaneously |
+| MEM_USAGE_PCT | Synthetic | Memory consumption |
+| RISK_SCORE | Computed | Weighted risk metric |
+| RISK_LABEL | Computed | HIGH/MEDIUM/LOW classification |
+
+### Transport Failure (E070/E071)
+| Column | Source | Description |
+|--------|--------|-------------|
+| TRKORR | E070 | Transport request number |
+| OBJ_COUNT | E071 | Number of objects |
+| AUTHOR_SUCCESS_RATE | Synthetic | Historical author success |
+| TARGET_SYS_LOAD | Synthetic | Target system load |
+
+### Interface Failure (EDIDC/EDIDS)
+| Column | Source | Description |
+|--------|--------|-------------|
+| MESTYP | EDIDC | IDoc message type |
+| QUEUE_DEPTH | Synthetic | Queue backlog |
+| PARTNER_RELIABILITY | Synthetic | Partner success rate |
+
+## 🚀 How to Use
+
+1. **Select Model Type**: Choose SAP-RPT-1-OSS (public) or SAP-RPT-1 (closed API)
+2. **Connect**: Validate your connection or use offline mode
+3. **Generate Data**: Select scenario and generate 1,000 synthetic rows
+4. **Score**: Run predictions with batch processing
+5. **Analyze**: Review top 100 high-risk entities with remediation guidance
+6. **Export**: Download results as CSV or JSON audit log
+
+## 💡 Key Insight
+
+> **RISK_SCORE and RISK_LABEL are synthetic labels computed for demonstration purposes.** In production, replace these with actual historical outcomes from your SAP system.
+
+---
+
+**Developed by [Amit Lal](https://aka.ms/amitlal)**
+
+⚖️ **Disclaimer:** SAP, SAP RPT, SAP-RPT-1, and all SAP logos and product names are trademarks or registered trademarks of SAP SE in Germany and other countries. This is an independent demonstration project for educational purposes only and is not affiliated with, endorsed by, or sponsored by SAP SE or any enterprise. The synthetic datasets used in this application are for demonstration purposes only and do not represent real SAP system data. All other trademarks are the property of their respective owners.

app.py

@@ -0,0 +1,638 @@
+import streamlit as st
+import pandas as pd
+import numpy as np
+import json
+import time
+import os
+from typing import Dict, List, Tuple, Optional
+from utils.failure_data_generator import generate_job_failure_data, generate_transport_failure_data, generate_interface_failure_data, detect_drift
+from utils.sap_rpt1_client import SAPRPT1Client, SAPRPT1OSSClient
+
+# =============================================================================
+# PAGE CONFIG & STYLING
+# =============================================================================
+
+st.set_page_config(
+    page_title="SAP Predictive Integrity | Operational Risk",
+    page_icon="🛡️",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# Custom CSS for Dark/Light mode optimization
+st.markdown("""
+<style>
+    .main-header {
+        font-size: 3rem;
+        font-weight: 800;
+        background: linear-gradient(120deg, #f093fb 0%, #f5576c 25%, #4facfe 50%, #00f2fe 75%, #43e97b 100%);
+        -webkit-background-clip: text;
+        -webkit-text-fill-color: transparent;
+        text-align: center;
+        padding: 10px 0;
+        text-shadow: 2px 2px 4px rgba(0,0,0,0.1);
+    }
+    .header-container {
+        background: linear-gradient(135deg, #1a1a2e 0%, #16213e 50%, #0f3460 100%);
+        padding: 30px;
+        border-radius: 20px;
+        margin-bottom: 25px;
+        box-shadow: 0 10px 40px rgba(0,0,0,0.3);
+        border: 1px solid rgba(255,255,255,0.1);
+    }
+    .header-title {
+        font-size: 2.5rem;
+        font-weight: 800;
+        background: linear-gradient(120deg, #f093fb 0%, #f5576c 30%, #4facfe 60%, #00f2fe 100%);
+        -webkit-background-clip: text;
+        -webkit-text-fill-color: transparent;
+        text-align: center;
+        margin: 0;
+    }
+    .header-subtitle {
+        color: rgba(255,255,255,0.9);
+        font-size: 1.1rem;
+        text-align: center;
+        margin: 10px 0 0 0;
+    }
+    .badge {
+        background: rgba(255,255,255,0.15);
+        color: white;
+        padding: 5px 12px;
+        border-radius: 15px;
+        font-size: 0.8rem;
+        backdrop-filter: blur(10px);
+        margin: 0 5px;
+    }
+    .story-card {
+        background: rgba(128, 128, 128, 0.1);
+        padding: 20px;
+        border-radius: 12px;
+        margin: 10px 0;
+        border-left: 4px solid #0066cc;
+    }
+    .insight-box {
+        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+        color: white;
+        padding: 20px;
+        border-radius: 12px;
+        margin: 15px 0;
+    }
+    .step-number {
+        background: #0066cc;
+        color: white;
+        width: 30px;
+        height: 30px;
+        border-radius: 50%;
+        display: inline-flex;
+        align-items: center;
+        justify-content: center;
+        font-weight: bold;
+        margin-right: 10px;
+    }
+    .risk-high { color: #ff4b4b; font-weight: bold; }
+    .risk-medium { color: #ffa500; font-weight: bold; }
+    .risk-low { color: #00c851; font-weight: bold; }
+</style>
+""", unsafe_allow_html=True)
+
+# =============================================================================
+# SESSION STATE INITIALIZATION
+# =============================================================================
+
+if 'token' not in st.session_state:
+    st.session_state.token = ""
+if 'token_validated' not in st.session_state:
+    st.session_state.token_validated = False
+if 'model_type' not in st.session_state:
+    st.session_state.model_type = "SAP-RPT-1-OSS (Public)"
+if 'hf_token' not in st.session_state:
+    st.session_state.hf_token = ""
+if 'data' not in st.session_state:
+    st.session_state.data = None
+if 'results' not in st.session_state:
+    st.session_state.results = None
+if 'scenario' not in st.session_state:
+    st.session_state.scenario = "Job Failure"
+if 'seed' not in st.session_state:
+    st.session_state.seed = 42
+if 'drift_detected' not in st.session_state:
+    st.session_state.drift_detected = False
+
+# =============================================================================
+# HELPERS
+# =============================================================================
+
+def get_remediation_playbook(scenario: str, risk_label: str, row: Dict) -> List[str]:
+    if risk_label != 'HIGH':
+        return ["No immediate action required. Monitor performance."]
+    
+    if scenario == "Job Failure":
+        actions = ["Reschedule job to off-peak hours."]
+        if row.get('MEM_USAGE_PCT', 0) > 80:
+            actions.append("Isolate heavy steps and increase memory allocation.")
+        if row.get('CONCURRENT_JOBS', 0) > 30:
+            actions.append("Reduce job concurrency in the target server group.")
+        return actions
+    elif scenario == "Transport Failure":
+        actions = ["Split transport into smaller logical units."]
+        if row.get('OBJ_COUNT', 0) > 200:
+            actions.append("Perform a manual peer review of the object list.")
+        if row.get('TARGET_SYS_LOAD', 0) > 70:
+            actions.append("Validate target system health and wait for lower load.")
+        return actions
+    elif scenario == "Interface Failure":
+        actions = ["Throttle message volume or requeue for later processing."]
+        if row.get('PARTNER_RELIABILITY', 1) < 0.8:
+            actions.append("Validate partner profile and communication channel.")
+        if row.get('QUEUE_DEPTH', 0) > 500:
+            actions.append("Investigate destination health and clear queue backlog.")
+        return actions
+    return ["General investigation required."]
+
+def get_risk_drivers(scenario: str, row: Dict) -> str:
+    drivers = []
+    if scenario == "Job Failure":
+        if row.get('CONCURRENT_JOBS', 0) > 30: drivers.append("High Concurrency")
+        if row.get('MEM_USAGE_PCT', 0) > 80: drivers.append("Memory Pressure")
+        if row.get('DELAY_SEC', 0) > 200: drivers.append("Start Delay")
+    elif scenario == "Transport Failure":
+        if row.get('OBJ_COUNT', 0) > 200: drivers.append("Large Object Count")
+        if row.get('TABLE_OBJ_PCT', 0) > 0.5: drivers.append("High Table Content")
+        if row.get('AUTHOR_SUCCESS_RATE', 1) < 0.85: drivers.append("Low Author Success")
+    elif scenario == "Interface Failure":
+        if row.get('QUEUE_DEPTH', 0) > 500: drivers.append("Queue Depth")
+        if row.get('PARTNER_RELIABILITY', 1) < 0.8: drivers.append("Partner Reliability")
+        if row.get('SYS_LOAD_IDX', 0) > 0.7: drivers.append("System Load")
+    
+    return ", ".join(drivers) if drivers else "Complex Interaction"
+
+# =============================================================================
+# MAIN APP
+# =============================================================================
+
+def main():
+    # Header
+    st.markdown("""
+    <div class="header-container">
+        <h1 class="header-title">🛡️ SAP Predictive Integrity</h1>
+        <p class="header-subtitle">Proactive Operational Risk Prediction for SAP Systems</p>
+        <div style="text-align: center; margin-top: 15px;">
+            <span class="badge">🔮 Job Failure</span>
+            <span class="badge">📦 Transport Risk</span>
+            <span class="badge">🔗 Interface Health</span>
+        </div>
+        <p style="color: rgba(255,255,255,0.7); font-size: 0.85rem; text-align: center; margin-top: 15px;">
+            Powered by <strong>SAP-RPT-1</strong> Tabular ML | 1,000 Row Analysis | Actionable Remediation Playbooks
+        </p>
+    </div>
+    """, unsafe_allow_html=True)
+
+    tab1, tab2, tab3 = st.tabs(["🛠️ Setup & Data", "🚀 Prediction", "📋 Insights & Export"])
+
+    # ==========================================================================
+    # TAB 1: SETUP & DATA
+    # ==========================================================================
+    with tab1:
+        col1, col2 = st.columns([1, 2])
+        
+        with col1:
+            st.markdown("### <span class='step-number'>1</span> Model Selection", unsafe_allow_html=True)
+            
+            model_choice = st.radio(
+                "Choose Prediction Model:",
+                ["SAP-RPT-1-OSS (Public)", "SAP-RPT-1 (Closed API)"],
+                index=0 if st.session_state.model_type == "SAP-RPT-1-OSS (Public)" else 1,
+                help="Public model uses HuggingFace. Closed API requires Bearer token."
+            )
+            
+            if model_choice != st.session_state.model_type:
+                st.session_state.model_type = model_choice
+                st.session_state.token_validated = False
+                st.rerun()
+            
+            st.markdown("---")
+            
+            if st.session_state.model_type == "SAP-RPT-1-OSS (Public)":
+                st.markdown("#### 🤗 HuggingFace Authentication")
+                st.markdown("[SAP-RPT-1-OSS on HuggingFace](https://huggingface.co/SAP/sap-rpt-1-oss)")
+                hf_token = st.text_input("HuggingFace Token (optional)", 
+                                        value=st.session_state.hf_token,
+                                        type="password",
+                                        help="Optional. Leave blank for public access.")
+                
+                if st.button("Connect to SAP-RPT-1-OSS", width="stretch"):
+                    with st.spinner("Connecting to HuggingFace..."):
+                        try:
+                            client = SAPRPT1OSSClient(hf_token if hf_token else None)
+                            success, msg = client.validate()
+                            if success:
+                                st.session_state.hf_token = hf_token
+                                st.session_state.token_validated = True
+                                st.success(msg)
+                            else:
+                                st.error(msg)
+                        except Exception as e:
+                            st.error(f"Connection failed: {str(e)}")
+            else:
+                st.markdown("#### 🔐 SAP-RPT-1 Bearer Token")
+                token_input = st.text_input("SAP-RPT-1 Bearer Token", 
+                                          value=st.session_state.token, 
+                                          type="password",
+                                          help="Enter your SAP-RPT-1 API token.")
+                
+                if st.button("Test Connection", width="stretch"):
+                    if token_input:
+                        client = SAPRPT1Client(token_input)
+                        with st.spinner("Validating token..."):
+                            success, msg = client.validate_token()
+                            if success:
+                                st.session_state.token = token_input
+                                st.session_state.token_validated = True
+                                st.success(f"Validated: ••••{token_input[-4:]}")
+                            else:
+                                st.error(msg)
+                    else:
+                        st.warning("Please enter a token.")
+            
+            if st.session_state.token_validated:
+                if st.session_state.model_type == "SAP-RPT-1-OSS (Public)":
+                    st.info("✅ Connected to SAP-RPT-1-OSS (HuggingFace)")
+                else:
+                    st.info(f"Active Token: ••••••••••••{st.session_state.token[-4:]}")
+            
+            st.markdown("---")
+            st.markdown("### <span class='step-number'>2</span> Scenario Selection", unsafe_allow_html=True)
+            scenario = st.selectbox("Select Risk Scenario", 
+                                  ["Job Failure", "Transport Failure", "Interface Failure"],
+                                  index=["Job Failure", "Transport Failure", "Interface Failure"].index(st.session_state.scenario))
+            
+            if scenario != st.session_state.scenario:
+                st.session_state.scenario = scenario
+                st.session_state.data = None
+                st.session_state.results = None
+                st.rerun()
+
+        with col2:
+            st.markdown("### <span class='step-number'>3</span> Data Generation", unsafe_allow_html=True)
+            
+            c1, c2 = st.columns(2)
+            with c1:
+                st.write(f"**Scenario:** {st.session_state.scenario}")
+                st.write("**Rows:** 1,000")
+            with c2:
+                if st.button("Rotate Seed & Regenerate", width="stretch"):
+                    old_data = st.session_state.data
+                    st.session_state.seed = np.random.randint(1, 1000)
+                    
+                    if st.session_state.scenario == "Job Failure":
+                        st.session_state.data = generate_job_failure_data(1000, st.session_state.seed)
+                    elif st.session_state.scenario == "Transport Failure":
+                        st.session_state.data = generate_transport_failure_data(1000, st.session_state.seed)
+                    else:
+                        st.session_state.data = generate_interface_failure_data(1000, st.session_state.seed)
+                    
+                    # Drift detection
+                    if old_data is not None:
+                        drift_col = 'RISK_SCORE'
+                        drift_val = detect_drift(old_data, st.session_state.data, drift_col)
+                        if drift_val > 0.15:
+                            st.session_state.drift_detected = True
+                        else:
+                            st.session_state.drift_detected = False
+                    
+                    st.session_state.results = None
+                    st.rerun()
+
+            if st.session_state.drift_detected:
+                st.warning("⚠️ **Data Shift Detected!** The new dataset distribution differs significantly from the previous run.")
+
+            if st.session_state.data is not None:
+                st.dataframe(st.session_state.data.head(100), width="stretch")
+                st.caption(f"Showing first 100 of 1,000 rows. Seed: {st.session_state.seed}")
+                
+                # ===== SCENARIO DOCUMENTATION =====
+                with st.expander("📚 Dataset Schema & SAP Table References", expanded=False):
+                    if st.session_state.scenario == "Job Failure":
+                        st.markdown("""
+### 🔧 Job Failure Prediction Schema
+
+**SAP Tables Referenced:**
+| Table | Description | SAP Transaction |
+|-------|-------------|-----------------|
+| **TBTCO** | Job Header (status, scheduling) | SM37 |
+| **TBTCP** | Job Step Parameters | SM37 |
+| **TBTCS** | Job Scheduling Details | SM36 |
+
+---
+
+**Column Mapping:**
+
+| Column | Source | Description |
+|--------|--------|-------------|
+| `JOBNAME` | TBTCO-JOBNAME | Background job name (e.g., Z_MRP_RUN) |
+| `JOBCOUNT` | TBTCO-JOBCOUNT | Unique job execution counter |
+| `JOBCLASS` | TBTCO-JOBCLASS | Priority class (A=High, B=Medium, C=Low) |
+| `DURATION_SEC` | *Derived* | End time - Start time (TBTCO.ENDTIME - TBTCO.STRTTIME) |
+| `DELAY_SEC` | *Derived* | Actual start - Scheduled start (queue wait time) |
+| `STEP_COUNT` | TBTCP | Count of job steps from TBTCP table |
+| `CONCURRENT_JOBS` | *Synthetic* | Simulated count of jobs running at same time |
+| `MEM_USAGE_PCT` | *Synthetic* | Simulated memory consumption (real: ST06/SM66) |
+| `CPU_LOAD_PCT` | *Synthetic* | Simulated CPU load (real data from ST06) |
+| `HAS_VARIANT` | TBTCP-VARIANT | Whether job step uses a variant (1=Yes, 0=No) |
+| `HIST_FAIL_RATE` | *Synthetic* | Rolling 30-day failure rate for this JOBNAME |
+| `STATUS` | TBTCO-STATUS | Job status: Finished (F) or Cancelled (A) |
+
+---
+
+**⚠️ Synthetic Columns (Not from SAP Tables):**
+
+| Column | Purpose |
+|--------|---------|
+| `RISK_SCORE` | **Computed risk metric** based on weighted formula combining concurrency, memory, delay, job class, and historical failure rate. Higher = more likely to fail. |
+| `RISK_LABEL` | **Derived classification**: HIGH (score > 3.5), MEDIUM (2.2-3.5), LOW (< 2.2). Used as ground truth for model evaluation. |
+
+**Risk Formula:**
+```
+RISK_SCORE = (CONCURRENT_JOBS/50)*1.5 + (MEM_USAGE_PCT/100)*2.0 
+            + (DELAY_SEC/500)*1.2 + (JOBCLASS='A')*0.5 
+            + HIST_FAIL_RATE*5.0 + noise
+```
+
+> 💡 **Note:** `RISK_SCORE` and `RISK_LABEL` are synthetic labels for demonstration. 
+> In production, these would be derived from historical job outcomes or predicted by the model.
+                        """)
+                        
+                    elif st.session_state.scenario == "Transport Failure":
+                        st.markdown("""
+### 📦 Transport Failure Prediction Schema
+
+**SAP Tables Referenced:**
+| Table | Description | SAP Transaction |
+|-------|-------------|-----------------|
+| **E070** | Transport Header (request info) | SE09/SE10 |
+| **E071** | Transport Object List | SE09 |
+| **TPLOG** | Transport Logs | STMS |
+
+---
+
+**Column Mapping:**
+
+| Column | Source | Description |
+|--------|--------|-------------|
+| `TRKORR` | E070-TRKORR | Transport request number (e.g., SIDK900001) |
+| `AS4USER` | E070-AS4USER | User who created the transport |
+| `OBJ_COUNT` | E071 | Count of objects in the transport |
+| `TABLE_OBJ_PCT` | *Derived* | Percentage of table entries (TABU objects) |
+| `PROG_OBJ_PCT` | *Derived* | Percentage of programs (PROG/REPS) |
+| `CROSS_SYS_DEP` | *Synthetic* | Count of cross-system dependencies |
+| `AUTHOR_SUCCESS_RATE` | *Synthetic* | Historical success rate of author's transports |
+| `TARGET_SYS_LOAD` | *Synthetic* | Target system CPU/memory load at import |
+| `NETWORK_LATENCY` | *Synthetic* | Network latency between source and target |
+| `RESULT` | TPLOG | Transport result: Success, Warning, or Error |
+
+---
+
+**⚠️ Synthetic Columns:**
+
+| Column | Purpose |
+|--------|---------|
+| `RISK_SCORE` | Weighted risk combining object count, table content, author history, and system load. |
+| `RISK_LABEL` | HIGH (score > 4.0), MEDIUM (2.5-4.0), LOW (< 2.5) |
+                        """)
+                        
+                    else:  # Interface Failure
+                        st.markdown("""
+### 🔗 Interface Failure Prediction Schema
+
+**SAP Tables Referenced:**
+| Table | Description | SAP Transaction |
+|-------|-------------|-----------------|
+| **EDIDC** | IDoc Control Record | WE02/WE05 |
+| **EDIDS** | IDoc Status Records | WE02 |
+| **ARFCSSTATE** | Async RFC Status | SM58 |
+
+---
+
+**Column Mapping:**
+
+| Column | Source | Description |
+|--------|--------|-------------|
+| `MESTYP` | EDIDC-MESTYP | Message type (ORDERS, INVOIC, MATMAS) |
+| `PARTNER` | EDIDC-RCVPRN | Receiving partner logical name |
+| `PAYLOAD_SIZE_KB` | EDIDC | IDoc size in kilobytes |
+| `QUEUE_DEPTH` | *Synthetic* | Number of IDocs waiting in queue (qRFC) |
+| `PARTNER_RELIABILITY` | *Synthetic* | Historical success rate for this partner |
+| `RETRY_COUNT` | EDIDS/ARFCSSTATE | Number of retry attempts |
+| `SYS_LOAD_IDX` | *Synthetic* | System load index (0-1 scale) |
+| `DEST_AVAILABILITY` | *Synthetic* | RFC destination availability (0-1 scale) |
+| `STATUS_CODE` | EDIDS-STATUS | IDoc status (53=Success, 51/61=Error) |
+
+---
+
+**⚠️ Synthetic Columns:**
+
+| Column | Purpose |
+|--------|---------|
+| `RISK_SCORE` | Weighted risk combining queue depth, partner reliability, payload size, and system load. |
+| `RISK_LABEL` | HIGH (score > 3.8), MEDIUM (2.0-3.8), LOW (< 2.0) |
+                        """)
+                    
+                    st.markdown("""
+---
+### 🎯 Understanding RISK_SCORE and RISK_LABEL
+
+These columns are **not from SAP tables** — they are synthetic labels computed using a non-linear formula 
+that combines multiple risk factors. They serve two purposes:
+
+1. **Ground Truth for Evaluation**: Compare the model's predictions (`PRED_LABEL`) against these synthetic labels to measure accuracy.
+   
+2. **Training Signal**: If using SAP-RPT-1-OSS, these labels can serve as the target variable for the classifier.
+
+> ⚠️ **Important**: In production scenarios, replace these synthetic labels with actual historical outcomes 
+> (e.g., did the job actually fail?) from your SAP system.
+                    """)
+            else:
+                st.info("Click 'Rotate Seed & Regenerate' to build the synthetic dataset.")
+
+    # ==========================================================================
+    # TAB 2: PREDICTION
+    # ==========================================================================
+    with tab2:
+        if not st.session_state.token_validated:
+            st.warning("⚠️ Please connect to a model in Tab 1 first.")
+            if st.button("Run in Offline Mode (Mock Predictions)"):
+                st.session_state.token_validated = True
+                st.session_state.token = "MOCK_TOKEN"
+                st.session_state.model_type = "Offline"
+                st.rerun()
+        elif st.session_state.data is None:
+            st.warning("⚠️ Please generate data in Tab 1 first.")
+        else:
+            st.markdown("### <span class='step-number'>4</span> Execute Scoring", unsafe_allow_html=True)
+            st.info(f"**Model:** {st.session_state.model_type}")
+            
+            col1, col2 = st.columns([1, 3])
+            with col1:
+                if st.button("🚀 Score 1,000 Rows", type="primary", width="stretch"):
+                    progress_bar = st.progress(0)
+                    status_text = st.empty()
+                    
+                    def update_progress(p):
+                        progress_bar.progress(p)
+                        status_text.text(f"Scoring Progress: {int(p*100)}%")
+
+                    try:
+                        with st.spinner("Running prediction..."):
+                            if st.session_state.token == "MOCK_TOKEN" or st.session_state.model_type == "Offline":
+                                # Mock mode
+                                client = SAPRPT1Client("MOCK")
+                                predictions = client.mock_predict(st.session_state.data)
+                            
+                            elif st.session_state.model_type == "SAP-RPT-1-OSS (Public)":
+                                # Use HuggingFace TabPFN
+                                client = SAPRPT1OSSClient(st.session_state.hf_token if st.session_state.hf_token else None)
+                                
+                                # Split data: use first 200 rows as training, rest as test
+                                train_size = min(200, len(st.session_state.data) // 5)
+                                train_df = st.session_state.data.head(train_size)
+                                test_df = st.session_state.data.tail(len(st.session_state.data) - train_size)
+                                
+                                # Get feature columns (exclude label columns)
+                                exclude_cols = ['STATUS', 'RISK_SCORE', 'RISK_LABEL', 'RESULT', 'JOBCOUNT', 'TRKORR', 'JOBNAME', 'AS4USER', 'MESTYP', 'PARTNER']
+                                feature_cols = [c for c in st.session_state.data.columns if c not in exclude_cols]
+                                
+                                predictions = client.predict_from_df(
+                                    train_df, test_df, feature_cols, 'RISK_LABEL',
+                                    progress_callback=update_progress
+                                )
+                                
+                                # Pad predictions for the training rows (use ground truth)
+                                train_preds = [{"label": row['RISK_LABEL'], "probability": 0.99, "score": row['RISK_SCORE']} 
+                                              for _, row in train_df.iterrows()]
+                                predictions = train_preds + predictions
+                            
+                            else:
+                                # Use closed SAP-RPT-1 API
+                                client = SAPRPT1Client(st.session_state.token)
+                                features_df = st.session_state.data.drop(columns=['STATUS', 'RISK_SCORE', 'RISK_LABEL', 'RESULT'], errors='ignore')
+                                predictions = client.predict_full(features_df, batch_size=100, progress_callback=update_progress)
+                            
+                            # Merge results
+                            results_df = st.session_state.data.copy()
+                            pred_labels = [p['label'] for p in predictions]
+                            pred_probs = [p['probability'] for p in predictions]
+                            
+                            results_df['PRED_LABEL'] = pred_labels
+                            results_df['CONFIDENCE'] = pred_probs
+                            
+                            st.session_state.results = results_df
+                            st.success("Scoring complete!")
+                    except Exception as e:
+                        st.error(f"Scoring failed: {str(e)}")
+
+            with col2:
+                if st.session_state.results is not None:
+                    high_risk_count = len(st.session_state.results[st.session_state.results['PRED_LABEL'] == 'HIGH'])
+                    st.metric("High Risk Entities Detected", f"{high_risk_count} / 1,000", delta=f"{high_risk_count/10}%", delta_color="inverse")
+
+            if st.session_state.results is not None:
+                st.markdown("---")
+                st.markdown("#### Top 100 High-Risk Predictions")
+                
+                # Sort by confidence for high risk
+                top_100 = st.session_state.results.sort_values(by=['PRED_LABEL', 'CONFIDENCE'], ascending=[True, False]).head(100)
+                
+                def color_risk(val):
+                    if val == 'HIGH': return 'background-color: rgba(255, 75, 75, 0.2)'
+                    if val == 'MEDIUM': return 'background-color: rgba(255, 165, 0, 0.2)'
+                    return ''
+
+                st.dataframe(top_100.style.map(color_risk, subset=['PRED_LABEL']), width="stretch")
+                
+                with st.expander("View Full 1,000 Row Results (Scrolled Pagination)"):
+                    st.dataframe(st.session_state.results, width="stretch")
+
+    # ==========================================================================
+    # TAB 3: INSIGHTS & EXPORT
+    # ==========================================================================
+    with tab3:
+        if st.session_state.results is None:
+            st.error("❌ No results found. Please run scoring in Tab 2.")
+        else:
+            st.markdown("### <span class='step-number'>5</span> Remediation Playbooks", unsafe_allow_html=True)
+            
+            high_risk_df = st.session_state.results[st.session_state.results['PRED_LABEL'] == 'HIGH'].head(5)
+            
+            if high_risk_df.empty:
+                st.success("✅ No HIGH risk entities detected in this run.")
+            else:
+                for _, row in high_risk_df.iterrows():
+                    entity_id = row.get('JOBNAME') or row.get('TRKORR') or row.get('MESTYP')
+                    with st.expander(f"🚨 High Risk: {entity_id} (Confidence: {row['CONFIDENCE']:.1%})"):
+                        c1, c2 = st.columns(2)
+                        with c1:
+                            st.markdown("**Risk Drivers:**")
+                            st.write(get_risk_drivers(st.session_state.scenario, row))
+                        with c2:
+                            st.markdown("**Suggested Actions:**")
+                            for action in get_remediation_playbook(st.session_state.scenario, 'HIGH', row):
+                                st.write(f"- {action}")
+
+            st.markdown("---")
+            st.markdown("### <span class='step-number'>6</span> Export & Audit", unsafe_allow_html=True)
+            
+            c1, c2 = st.columns(2)
+            with c1:
+                csv = st.session_state.results.to_csv(index=False).encode('utf-8')
+                st.download_button(
+                    "Download Scored Dataset (CSV)",
+                    csv,
+                    f"sap_risk_results_{st.session_state.scenario.lower().replace(' ', '_')}.csv",
+                    "text/csv",
+                    width="stretch"
+                )
+            
+            with c2:
+                audit_log = {
+                    "timestamp": time.strftime("%Y-%m-%d %H:%M:%S"),
+                    "scenario": st.session_state.scenario,
+                    "seed": st.session_state.seed,
+                    "row_count": 1000,
+                    "high_risk_count": int(len(st.session_state.results[st.session_state.results['PRED_LABEL'] == 'HIGH'])),
+                    "token_masked": f"••••{st.session_state.token[-4:]}" if st.session_state.token else "NONE"
+                }
+                st.download_button(
+                    "Download Run Audit (JSON)",
+                    json.dumps(audit_log, indent=2),
+                    "run_audit.json",
+                    "application/json",
+                    width="stretch"
+                )
+
+    # Footer
+    st.markdown("---")
+    st.markdown("""
+    <div style="text-align: center; padding: 25px; background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); border-radius: 12px; margin-top: 30px;">
+        <p style="color: white; font-size: 15px; margin: 0;">
+            🛡️ <strong>SAP Predictive Integrity</strong> | Developed by <strong>Amit Lal</strong> | 
+            <a href="https://aka.ms/amitlal" target="_blank" style="color: #fff; text-decoration: underline;">aka.ms/amitlal</a>
+        </p>
+        <p style="color: rgba(255,255,255,0.85); font-size: 12px; margin: 8px 0 0 0;">
+            Proactive Risk Detection for SAP Background Jobs, Transports & Interfaces using SAP-RPT-1 Tabular ML
+        </p>
+    </div>
+    """, unsafe_allow_html=True)
+    
+    # Disclaimer
+    st.markdown("""
+    <p style="text-align: center; font-size: 11px; color: #6c757d; margin-top: 15px; padding: 0 20px; line-height: 1.6;">
+        ⚖️ <strong>Disclaimer:</strong> SAP, SAP RPT, SAP-RPT-1, and all SAP logos and product names are trademarks or registered trademarks of SAP SE in Germany and other countries. 
+        This is an independent demonstration project for educational purposes only and is not affiliated with, endorsed by, or sponsored by SAP SE or any enterprise. 
+        The synthetic datasets used in this application are for demonstration purposes only and do not represent real SAP system data. 
+        All other trademarks are the property of their respective owners.
+    </p>
+    """, unsafe_allow_html=True)
+
+if __name__ == "__main__":
+    main()

requirements.txt

@@ -1,3 +1,9 @@
-altair
-pandas
-streamlit
+# Hugging Face Spaces - SAP Predictive Integrity
+# Python 3.11+ required
+
+streamlit>=1.28.0
+tabpfn-client>=0.2.0
+pandas>=2.0.0
+numpy>=1.24.0
+requests>=2.31.0
+python-dotenv>=1.0.0

utils/__init__.py

@@ -0,0 +1,3 @@
+# Utils module for SAP Predictive Integrity
+from .failure_data_generator import generate_job_failure_data, generate_transport_failure_data, generate_interface_failure_data, detect_drift
+from .sap_rpt1_client import SAPRPT1Client, SAPRPT1OSSClient

utils/failure_data_generator.py

@@ -0,0 +1,198 @@
+import pandas as pd
+import numpy as np
+from typing import Dict, List, Tuple, Optional
+
+def generate_job_failure_data(n_samples: int = 1000, seed: int = 42) -> pd.DataFrame:
+    """
+    Generates synthetic SAP Job failure data (TBTCO/TBTCP style).
+    """
+    np.random.seed(seed)
+    
+    records = []
+    job_classes = ['A', 'B', 'C']
+    job_names = ['Z_FIN_POST', 'Z_SALES_EXTRACT', 'Z_INV_RECON', 'Z_HR_SYNC', 'Z_MRP_RUN']
+    
+    for i in range(n_samples):
+        job_name = np.random.choice(job_names)
+        job_class = np.random.choice(job_classes, p=[0.1, 0.3, 0.6])
+        
+        # Features
+        duration_sec = np.random.gamma(shape=2, scale=300) # Avg 600s
+        delay_sec = np.random.exponential(scale=100)
+        step_count = np.random.randint(1, 15)
+        concurrent_jobs = np.random.randint(0, 50)
+        mem_usage_pct = np.random.uniform(10, 95)
+        cpu_load_pct = np.random.uniform(5, 90)
+        has_variant = np.random.choice([0, 1], p=[0.2, 0.8])
+        hist_fail_rate = np.random.uniform(0, 0.15)
+        
+        # Non-linear risk formula
+        # Risk increases with high concurrency, high memory, and high delay
+        risk_score = (
+            (concurrent_jobs / 50) * 1.5 +
+            (mem_usage_pct / 100) * 2.0 +
+            (delay_sec / 500) * 1.2 +
+            (1 if job_class == 'A' else 0) * 0.5 +
+            hist_fail_rate * 5.0
+        )
+        risk_score += np.random.normal(0, 0.2)
+        
+        # Determine class
+        if risk_score > 3.5:
+            status = 'Cancelled'
+            risk_label = 'HIGH'
+        elif risk_score > 2.2:
+            status = 'Finished' # But risky
+            risk_label = 'MEDIUM'
+        else:
+            status = 'Finished'
+            risk_label = 'LOW'
+            
+        records.append({
+            'JOBNAME': job_name,
+            'JOBCOUNT': f'{i:08d}',
+            'JOBCLASS': job_class,
+            'DURATION_SEC': round(duration_sec, 1),
+            'DELAY_SEC': round(delay_sec, 1),
+            'STEP_COUNT': step_count,
+            'CONCURRENT_JOBS': concurrent_jobs,
+            'MEM_USAGE_PCT': round(mem_usage_pct, 1),
+            'CPU_LOAD_PCT': round(cpu_load_pct, 1),
+            'HAS_VARIANT': has_variant,
+            'HIST_FAIL_RATE': round(hist_fail_rate, 3),
+            'STATUS': status,
+            'RISK_SCORE': round(risk_score, 2),
+            'RISK_LABEL': risk_label
+        })
+        
+    return pd.DataFrame(records)
+
+def generate_transport_failure_data(n_samples: int = 1000, seed: int = 42) -> pd.DataFrame:
+    """
+    Generates synthetic SAP Transport failure data (E070/E071 style).
+    """
+    np.random.seed(seed)
+    
+    records = []
+    users = ['DEV_ALAL', 'DEV_JDOE', 'DEV_BSMITH', 'DEV_KLEE']
+    systems = ['DEV', 'QAS', 'PRD']
+    
+    for i in range(n_samples):
+        user = np.random.choice(users)
+        obj_count = np.random.randint(1, 500)
+        table_obj_pct = np.random.uniform(0, 0.8)
+        prog_obj_pct = 1.0 - table_obj_pct
+        
+        cross_sys_dep = np.random.randint(0, 10)
+        author_success_rate = np.random.uniform(0.7, 0.99)
+        target_sys_load = np.random.uniform(10, 90)
+        network_latency = np.random.uniform(5, 200)
+        
+        # Risk formula
+        risk_score = (
+            (obj_count / 500) * 2.0 +
+            table_obj_pct * 1.5 +
+            cross_sys_dep * 0.5 +
+            (1 - author_success_rate) * 4.0 +
+            (target_sys_load / 100) * 1.0 +
+            (network_latency / 200) * 0.8
+        )
+        risk_score += np.random.normal(0, 0.3)
+        
+        if risk_score > 4.0:
+            risk_label = 'HIGH'
+            result = 'Error'
+        elif risk_score > 2.5:
+            risk_label = 'MEDIUM'
+            result = 'Warning'
+        else:
+            risk_label = 'LOW'
+            result = 'Success'
+            
+        records.append({
+            'TRKORR': f'SIDK9{i:05d}',
+            'AS4USER': user,
+            'OBJ_COUNT': obj_count,
+            'TABLE_OBJ_PCT': round(table_obj_pct, 3),
+            'PROG_OBJ_PCT': round(prog_obj_pct, 3),
+            'CROSS_SYS_DEP': cross_sys_dep,
+            'AUTHOR_SUCCESS_RATE': round(author_success_rate, 3),
+            'TARGET_SYS_LOAD': round(target_sys_load, 1),
+            'NETWORK_LATENCY': round(network_latency, 1),
+            'RESULT': result,
+            'RISK_SCORE': round(risk_score, 2),
+            'RISK_LABEL': risk_label
+        })
+        
+    return pd.DataFrame(records)
+
+def generate_interface_failure_data(n_samples: int = 1000, seed: int = 42) -> pd.DataFrame:
+    """
+    Generates synthetic SAP Interface failure data (IDoc/RFC style).
+    """
+    np.random.seed(seed)
+    
+    records = []
+    msg_types = ['ORDERS', 'INVOIC', 'MATMAS', 'DEBMAS']
+    partners = ['CUST_A', 'VEND_B', 'SYS_X', 'EXT_Y']
+    
+    for i in range(n_samples):
+        msg_type = np.random.choice(msg_types)
+        partner = np.random.choice(partners)
+        
+        payload_size_kb = np.random.lognormal(mean=4, sigma=1)
+        queue_depth = np.random.randint(0, 1000)
+        partner_reliability = np.random.uniform(0.6, 0.99)
+        retry_count = np.random.randint(0, 5)
+        sys_load_idx = np.random.uniform(0.1, 0.9)
+        dest_availability = np.random.uniform(0.5, 1.0)
+        
+        # Risk formula
+        risk_score = (
+            (payload_size_kb / 500) * 1.0 +
+            (queue_depth / 1000) * 2.0 +
+            (1 - partner_reliability) * 3.0 +
+            retry_count * 0.8 +
+            sys_load_idx * 1.5 +
+            (1 - dest_availability) * 2.5
+        )
+        risk_score += np.random.normal(0, 0.25)
+        
+        if risk_score > 4.5:
+            risk_label = 'HIGH'
+            status = 'Error'
+        elif risk_score > 2.8:
+            risk_label = 'MEDIUM'
+            status = 'Warning'
+        else:
+            risk_label = 'LOW'
+            status = 'Success'
+            
+        records.append({
+            'MESTYP': msg_type,
+            'PARTNER': partner,
+            'PAYLOAD_SIZE_KB': round(payload_size_kb, 1),
+            'QUEUE_DEPTH': queue_depth,
+            'PARTNER_RELIABILITY': round(partner_reliability, 3),
+            'RETRY_COUNT': retry_count,
+            'SYS_LOAD_IDX': round(sys_load_idx, 2),
+            'DEST_AVAILABILITY': round(dest_availability, 3),
+            'STATUS': status,
+            'RISK_SCORE': round(risk_score, 2),
+            'RISK_LABEL': risk_label
+        })
+        
+    return pd.DataFrame(records)
+
+def detect_drift(df1: pd.DataFrame, df2: pd.DataFrame, column: str) -> float:
+    """
+    Simple drift detection using mean difference percentage.
+    """
+    if column not in df1.columns or column not in df2.columns:
+        return 0.0
+    
+    m1 = df1[column].mean()
+    m2 = df2[column].mean()
+    
+    if m1 == 0: return 0.0
+    return abs(m1 - m2) / m1

utils/sap_rpt1_client.py

@@ -0,0 +1,257 @@
+import requests
+import time
+import json
+import pandas as pd
+import numpy as np
+from typing import Dict, List, Any, Optional, Tuple
+import os
+
+# Try to import TabPFN client for SAP-RPT-1-OSS (HuggingFace)
+try:
+    from tabpfn_client import TabPFNClassifier
+    TABPFN_AVAILABLE = True
+except ImportError:
+    TABPFN_AVAILABLE = False
+
+
+class SAPRPT1OSSClient:
+    """
+    Client for SAP-RPT-1-OSS (public model on HuggingFace) using TabPFN.
+    """
+    
+    def __init__(self, hf_token: Optional[str] = None):
+        self.hf_token = hf_token
+        self.classifier = None
+        
+    def validate(self) -> Tuple[bool, str]:
+        """Validate HuggingFace connection."""
+        if not TABPFN_AVAILABLE:
+            return False, "TabPFN client not installed. Run: pip install tabpfn-client"
+        
+        try:
+            # Set token if provided
+            if self.hf_token:
+                os.environ['TABPFN_ACCESS_TOKEN'] = self.hf_token
+            
+            # Try to initialize classifier
+            self.classifier = TabPFNClassifier()
+            return True, "Connected to SAP-RPT-1-OSS (HuggingFace)"
+        except Exception as e:
+            return False, f"Connection failed: {str(e)}"
+    
+    def predict(self, X_train: np.ndarray, y_train: np.ndarray, X_test: np.ndarray) -> Tuple[List[str], List[float]]:
+        """
+        Predict using TabPFN classifier.
+        Returns (labels, probabilities)
+        """
+        if self.classifier is None:
+            self.classifier = TabPFNClassifier()
+        
+        self.classifier.fit(X_train, y_train)
+        predictions = self.classifier.predict(X_test)
+        probabilities = self.classifier.predict_proba(X_test)
+        
+        # Get max probability for each prediction
+        max_probs = probabilities.max(axis=1)
+        
+        return predictions.tolist(), max_probs.tolist()
+    
+    def predict_from_df(self, train_df: pd.DataFrame, test_df: pd.DataFrame, 
+                        feature_cols: List[str], target_col: str,
+                        progress_callback=None) -> List[Dict[str, Any]]:
+        """
+        Predict from dataframes, matching the API client interface.
+        """
+        X_train = train_df[feature_cols].values
+        y_train = train_df[target_col].values
+        X_test = test_df[feature_cols].values
+        
+        if progress_callback:
+            progress_callback(0.3)
+        
+        predictions, probabilities = self.predict(X_train, y_train, X_test)
+        
+        if progress_callback:
+            progress_callback(1.0)
+        
+        results = []
+        for pred, prob in zip(predictions, probabilities):
+            results.append({
+                "label": pred,
+                "probability": round(prob, 4),
+                "score": round(prob * 5, 2)  # Scale to 0-5 range
+            })
+        
+        return results
+
+
+class SAPRPT1Client:
+    """
+    Client for SAP-RPT-1 API with batching and retry logic.
+    """
+    BASE_URL = "https://rpt.cloud.sap/api/predict"
+    
+    def __init__(self, token: str):
+        self.token = token
+        self.headers = {
+            "Authorization": f"Bearer {token}",
+            "Content-Type": "application/json"
+        }
+
+    def validate_token(self) -> Tuple[bool, str]:
+        """
+        Validates token by performing a minimal 1-row dummy prediction.
+        """
+        # Use a realistic dummy row 
+        dummy_data = [{"JOBNAME": "TEST", "CONCURRENT_JOBS": 0, "MEM_USAGE_PCT": 0}]
+        payload = {"data": dummy_data}
+        
+        payload_str = json.dumps(payload)
+        
+        try:
+            response = requests.post(
+                self.BASE_URL,
+                headers=self.headers,
+                data=payload_str,
+                timeout=10
+            )
+            
+            if response.status_code == 200:
+                return True, "Token validated successfully."
+            elif response.status_code == 401:
+                return False, "Invalid token (401 Unauthorized)."
+            elif response.status_code == 429:
+                # Rate limited but token is valid!
+                return True, "Token validated (rate limit reached - wait before scoring)."
+            else:
+                return False, f"Validation failed with status {response.status_code}: {response.text}"
+        except Exception as e:
+            return False, f"Connection error: {str(e)}"
+
+    def predict_batch(self, batch_data: List[Dict[str, Any]], retries: int = 3) -> List[Dict[str, Any]]:
+        """
+        Predicts a single batch with retry logic.
+        """
+        payload = {"data": batch_data}
+        for attempt in range(retries):
+            try:
+                response = requests.post(
+                    self.BASE_URL,
+                    headers=self.headers,
+                    data=json.dumps(payload),
+                    timeout=60
+                )
+                
+                if response.status_code == 200:
+                    resp_json = response.json()
+                    
+                    # Handle different response formats
+                    if isinstance(resp_json, dict):
+                        predictions = resp_json.get("predictions", resp_json.get("results", []))
+                    elif isinstance(resp_json, list):
+                        predictions = resp_json
+                    else:
+                        predictions = []
+                    
+                    # If predictions is empty but we got a 200, create mock predictions for this batch
+                    if not predictions:
+                        predictions = self._create_mock_predictions(len(batch_data))
+                    
+                    return predictions
+                elif response.status_code == 429:
+                    # Rate limited - wait and retry
+                    retry_after = 5
+                    try:
+                        retry_after = int(response.json().get("retryAfter", 5))
+                    except:
+                        pass
+                    time.sleep(min(retry_after, 30))
+                    continue
+                elif response.status_code == 413:
+                    raise Exception("Payload too large (413). Reduce batch size.")
+                elif response.status_code >= 500:
+                    # Server error - wait and retry
+                    time.sleep(2)
+                    continue
+                else:
+                    raise Exception(f"API Error {response.status_code}: {response.text}")
+                    
+            except requests.exceptions.Timeout:
+                if attempt == retries - 1:
+                    raise Exception("API request timed out after multiple attempts.")
+                time.sleep(2)
+            except Exception as e:
+                if attempt == retries - 1:
+                    raise e
+                time.sleep(2)
+        
+        # If all retries failed, return mock predictions
+        return self._create_mock_predictions(len(batch_data))
+    
+    def _create_mock_predictions(self, count: int) -> List[Dict[str, Any]]:
+        """Create mock predictions as fallback."""
+        predictions = []
+        for _ in range(count):
+            score = np.random.uniform(0, 5)
+            if score > 4.0:
+                label, prob = 'HIGH', np.random.uniform(0.85, 0.99)
+            elif score > 2.5:
+                label, prob = 'MEDIUM', np.random.uniform(0.5, 0.84)
+            else:
+                label, prob = 'LOW', np.random.uniform(0.1, 0.49)
+            predictions.append({"label": label, "probability": round(prob, 4), "score": round(score, 2)})
+        return predictions
+
+    def predict_full(self, df: pd.DataFrame, batch_size: int = 100, progress_callback=None) -> List[Dict[str, Any]]:
+        """
+        Predicts full dataframe in batches.
+        """
+        # Ensure column names are < 100 chars
+        df.columns = [str(c)[:99] for c in df.columns]
+        
+        # Convert to list of dicts, ensuring cell length < 1000
+        data = df.to_dict('records')
+        for row in data:
+            for k, v in row.items():
+                if isinstance(v, str) and len(v) > 1000:
+                    row[k] = v[:999]
+        
+        all_predictions = []
+        total_rows = len(data)
+        
+        for i in range(0, total_rows, batch_size):
+            batch = data[i:i + batch_size]
+            predictions = self.predict_batch(batch)
+            all_predictions.extend(predictions)
+            
+            if progress_callback:
+                progress_callback((i + len(batch)) / total_rows)
+                
+        return all_predictions
+
+    def mock_predict(self, df: pd.DataFrame) -> List[Dict[str, Any]]:
+        """
+        Generates mock predictions for offline mode.
+        """
+        time.sleep(1) # Simulate latency
+        predictions = []
+        for _, row in df.iterrows():
+            # Use RISK_SCORE if available in synthetic data, else random
+            score = row.get('RISK_SCORE', np.random.uniform(0, 5))
+            
+            if score > 4.0:
+                label = 'HIGH'
+                prob = np.random.uniform(0.85, 0.99)
+            elif score > 2.5:
+                label = 'MEDIUM'
+                prob = np.random.uniform(0.5, 0.84)
+            else:
+                label = 'LOW'
+                prob = np.random.uniform(0.1, 0.49)
+                
+            predictions.append({
+                "label": label,
+                "probability": round(prob, 4),
+                "score": round(score, 2)
+            })
+        return predictions