Update hf_demo.py

hf_demo.py

@@ -1,51 +1,40 @@
 """
-ARF OSS v3.3.9 - Enterprise Lead Generation Engine
-Compatible with Gradio 4.44.1 and Pydantic V2
+ARF OSS v3.3.9 - Enterprise Lead Generation Engine (API Only)
+Compatible with Pydantic V2
 """
 
 import os
-# 🔥 CRITICAL: Force Gradio to use port 7860 for Hugging Face Spaces
-os.environ['GRADIO_SERVER_PORT'] = '7860'
-os.environ['GRADIO_SERVER_NAME'] = '0.0.0.0'
-# 🔥 Prevent Gradio from auto-launching its own server
-os.environ['GRADIO_ANALYTICS_ENABLED'] = 'False'
-
+# 🔥 CRITICAL: Ensure we use the correct port from environment
+import sys
 import json
 import uuid
-import hmac
 import hashlib
 import logging
-import asyncio
 import sqlite3
 import requests
-import fcntl  # <-- NEW: for file locking
-import sys
-from datetime import datetime, timedelta
+import fcntl
+from datetime import datetime
 from typing import Dict, List, Optional, Any, Tuple
 from contextlib import contextmanager
-from dataclasses import dataclass, asdict
 from enum import Enum
 
-import gradio as gr
-# 🔥 Close any existing Gradio instances immediately after import
-gr.close_all()
-
+# FastAPI and Pydantic
 from fastapi import FastAPI, HTTPException, Depends, status
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
-from pydantic import BaseModel, Field, field_validator, ConfigDict  # <-- NEW: ConfigDict
-from pydantic_settings import BaseSettings, SettingsConfigDict  # <-- NEW: SettingsConfigDict
-from gradio import mount_gradio_app
+from pydantic import BaseModel, Field, field_validator
+from pydantic_settings import BaseSettings, SettingsConfigDict
 
-# ============== SINGLE INSTANCE LOCK ==============
-LOCK_FILE = '/tmp/arf_app.lock'
+# ============== SINGLE INSTANCE LOCK (per port) ==============
+PORT = int(os.environ.get('PORT', 7860))
+LOCK_FILE = f'/tmp/arf_app_{PORT}.lock'
 try:
     lock_fd = open(LOCK_FILE, 'w')
     fcntl.flock(lock_fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
 except (IOError, OSError):
-    print("Another instance is already running. Exiting.")
+    print(f"Another instance is already running on port {PORT}. Exiting.")
     sys.exit(1)
-# ==================================================
+# ==============================================================
 
 # ============== CONFIGURATION (Pydantic V2) ==============
 class Settings(BaseSettings):
@@ -61,7 +50,7 @@ class Settings(BaseSettings):
         alias='DATA_DIR'
     )
     
-    # Lead generation
+    # Lead generation (kept for reference, but UI removed)
     lead_email: str = "petter2025us@outlook.com"
     calendly_url: str = "https://calendly.com/petter2025us/arf-demo"
     
@@ -81,15 +70,14 @@ class Settings(BaseSettings):
     
     # Pydantic V2 configuration
     model_config = SettingsConfigDict(
-        populate_by_name=True,   # allows use of field names or aliases
-        extra='ignore',           # ignore extra env vars
-        env_prefix='',            # no prefix
-        case_sensitive=False      # case-insensitive matching
+        populate_by_name=True,
+        extra='ignore',
+        env_prefix='',
+        case_sensitive=False
     )
 
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
-        # Ensure data directory exists
         os.makedirs(self.data_dir, exist_ok=True)
 
 settings = Settings()
@@ -125,18 +113,12 @@ class LeadSignal(str, Enum):
     CONFIDENCE_LOW = "confidence_low"
     REPEATED_FAILURE = "repeated_failure"
 
-# ============== REAL ARF BAYESIAN ENGINE ==============
+# ============== BAYESIAN ENGINE (unchanged) ==============
 class BayesianRiskEngine:
-    """
-    True Bayesian inference with conjugate priors
-    Matches ARF OSS production implementation
-    """
-    
+    # ... (keep the full class as before) ...
     def __init__(self):
-        # Beta-Binomial conjugate prior
         self.prior_alpha = 2.0
         self.prior_beta = 5.0
-        
         self.action_priors = {
             'database': {'alpha': 1.5, 'beta': 8.0},
             'network': {'alpha': 3.0, 'beta': 4.0},
@@ -144,12 +126,10 @@ class BayesianRiskEngine:
             'security': {'alpha': 2.0, 'beta': 6.0},
             'default': {'alpha': 2.0, 'beta': 5.0}
         }
-        
         self.evidence_db = f"{settings.data_dir}/evidence.db"
         self._init_db()
     
     def _init_db(self):
-        """Initialize SQLite DB for evidence storage"""
         try:
             with self._get_db() as conn:
                 conn.execute('''
@@ -163,10 +143,7 @@ class BayesianRiskEngine:
                         metadata TEXT
                     )
                 ''')
-                conn.execute('''
-                    CREATE INDEX IF NOT EXISTS idx_action_hash 
-                    ON evidence(action_hash)
-                ''')
+                conn.execute('CREATE INDEX IF NOT EXISTS idx_action_hash ON evidence(action_hash)')
         except sqlite3.Error as e:
             logger.error(f"Failed to initialize evidence database: {e}")
             raise RuntimeError("Could not initialize evidence storage") from e
@@ -214,24 +191,17 @@ class BayesianRiskEngine:
             logger.error(f"Failed to retrieve evidence: {e}")
             return (0, 0)
     
-    def calculate_posterior(self, 
-                           action_text: str,
-                           context: Dict[str, Any]) -> Dict[str, Any]:
+    def calculate_posterior(self, action_text: str, context: Dict[str, Any]) -> Dict[str, Any]:
         action_type = self.classify_action(action_text)
         alpha0, beta0 = self.get_prior(action_type)
-        
         action_hash = hashlib.sha256(action_text.encode()).hexdigest()
         successes, trials = self.get_evidence(action_hash)
-        
         alpha_n = alpha0 + successes
         beta_n = beta0 + (trials - successes)
-        
         posterior_mean = alpha_n / (alpha_n + beta_n)
         context_multiplier = self._context_likelihood(context)
-        
         risk_score = posterior_mean * context_multiplier
         risk_score = min(0.99, max(0.01, risk_score))
-        
         variance = (alpha_n * beta_n) / ((alpha_n + beta_n)**2 * (alpha_n + beta_n + 1))
         std_dev = variance ** 0.5
         ci_lower = max(0.01, posterior_mean - 1.96 * std_dev)
@@ -299,7 +269,7 @@ class BayesianRiskEngine:
         except sqlite3.Error as e:
             logger.error(f"Failed to record outcome: {e}")
 
-# ============== POLICY ENGINE ==============
+# ============== POLICY ENGINE (unchanged) ==============
 class PolicyEngine:
     def __init__(self):
         self.config = {
@@ -325,10 +295,8 @@ class PolicyEngine:
             "require_rollback": True
         }
     
-    def evaluate(self,
-                action: str,
-                risk: Dict[str, Any],
-                confidence: float) -> Dict[str, Any]:
+    def evaluate(self, action: str, risk: Dict[str, Any], confidence: float) -> Dict[str, Any]:
+        import re
         gates = []
         
         # Gate 1: Confidence threshold
@@ -347,7 +315,6 @@ class PolicyEngine:
         max_idx = risk_levels.index(RiskLevel(self.config["max_autonomous_risk"]))
         action_idx = risk_levels.index(risk["level"])
         risk_passed = action_idx <= max_idx
-        
         gates.append({
             "gate": "risk_assessment",
             "passed": risk_passed,
@@ -355,19 +322,11 @@ class PolicyEngine:
             "actual": risk["level"].value,
             "reason": f"Risk level {risk['level'].value} {'≤' if risk_passed else '>'} max autonomous {self.config['max_autonomous_risk']}",
             "type": "categorical",
-            "metadata": {
-                "risk_score": risk["score"],
-                "credible_interval": risk["credible_interval"]
-            }
+            "metadata": {"risk_score": risk["score"], "credible_interval": risk["credible_interval"]}
         })
         
         # Gate 3: Destructive check
-        import re
-        is_destructive = any(
-            re.search(pattern, action.lower()) 
-            for pattern in self.config["destructive_patterns"]
-        )
-        
+        is_destructive = any(re.search(pattern, action.lower()) for pattern in self.config["destructive_patterns"])
         gates.append({
             "gate": "destructive_check",
             "passed": not is_destructive,
@@ -379,7 +338,6 @@ class PolicyEngine:
         
         # Gate 4: Human review requirement
         requires_human = risk["level"] in self.config["require_human"]
-        
         gates.append({
             "gate": "human_review",
             "passed": not requires_human,
@@ -388,7 +346,7 @@ class PolicyEngine:
             "type": "boolean"
         })
         
-        # Gate 5: OSS license (always passes in OSS)
+        # Gate 5: OSS license (always passes)
         gates.append({
             "gate": "license_check",
             "passed": True,
@@ -423,7 +381,7 @@ class PolicyEngine:
             return True
         return False
 
-# ============== RAG MEMORY WITH PERSISTENCE ==============
+# ============== RAG MEMORY (unchanged) ==============
 class RAGMemory:
     def __init__(self):
         self.db_path = f"{settings.data_dir}/memory.db"
@@ -482,13 +440,11 @@ class RAGMemory:
     def _simple_embedding(self, text: str) -> List[float]:
         if text in self.embedding_cache:
             return self.embedding_cache[text]
-        
         words = text.lower().split()
         trigrams = set()
         for word in words:
             for i in range(len(word) - 2):
                 trigrams.add(word[i:i+3])
-        
         vector = [hash(t) % 1000 / 1000.0 for t in sorted(trigrams)[:100]]
         while len(vector) < 100:
             vector.append(0.0)
@@ -496,13 +452,8 @@ class RAGMemory:
         self.embedding_cache[text] = vector
         return vector
     
-    def store_incident(self, 
-                      action: str,
-                      risk_score: float,
-                      risk_level: RiskLevel,
-                      confidence: float,
-                      allowed: bool,
-                      gates: List[Dict]):
+    def store_incident(self, action: str, risk_score: float, risk_level: RiskLevel,
+                       confidence: float, allowed: bool, gates: List[Dict]):
         action_hash = hashlib.sha256(action.encode()).hexdigest()[:50]
         embedding = json.dumps(self._simple_embedding(action))
         try:
@@ -531,11 +482,7 @@ class RAGMemory:
         query_embedding = self._simple_embedding(action)
         try:
             with self._get_db() as conn:
-                cursor = conn.execute('''
-                    SELECT * FROM incidents 
-                    ORDER BY timestamp DESC 
-                    LIMIT 100
-                ''')
+                cursor = conn.execute('SELECT * FROM incidents ORDER BY timestamp DESC LIMIT 100')
                 incidents = []
                 for row in cursor.fetchall():
                     stored_embedding = json.loads(row['embedding'])
@@ -559,11 +506,8 @@ class RAGMemory:
             logger.error(f"Failed to find similar incidents: {e}")
             return []
     
-    def track_enterprise_signal(self, 
-                               signal_type: LeadSignal,
-                               action: str,
-                               risk_score: float,
-                               metadata: Dict = None):
+    def track_enterprise_signal(self, signal_type: LeadSignal, action: str,
+                                risk_score: float, metadata: Dict = None):
         signal = {
             'id': str(uuid.uuid4()),
             'signal_type': signal_type.value,
@@ -615,11 +559,7 @@ class RAGMemory:
     def get_uncontacted_signals(self) -> List[Dict]:
         try:
             with self._get_db() as conn:
-                cursor = conn.execute('''
-                    SELECT * FROM signals 
-                    WHERE contacted = 0 
-                    ORDER BY timestamp DESC
-                ''')
+                cursor = conn.execute('SELECT * FROM signals WHERE contacted = 0 ORDER BY timestamp DESC')
                 signals = []
                 for row in cursor.fetchall():
                     signals.append({
@@ -704,9 +644,9 @@ class LeadSignalResponse(BaseModel):
 
 # ============== FASTAPI SETUP ==============
 app = FastAPI(
-    title="ARF OSS Real Engine",
+    title="ARF OSS Real Engine (API Only)",
     version="3.3.9",
-    description="Real ARF OSS components for enterprise lead generation",
+    description="Real ARF OSS components for enterprise lead generation - API only",
     contact={
         "name": "ARF Sales",
         "email": settings.lead_email,
@@ -726,11 +666,11 @@ risk_engine = BayesianRiskEngine()
 policy_engine = PolicyEngine()
 memory = RAGMemory()
 
-# ============== API ENDPOINTS (with authentication) ==============
+# ============== API ENDPOINTS ==============
 
 @app.get("/health")
 async def health_check():
-    """Public health check endpoint (no auth required)"""
+    """Public health check endpoint"""
     return {
         "status": "healthy",
         "version": "3.3.9",
@@ -741,7 +681,7 @@ async def health_check():
 
 @app.get("/api/v1/config", dependencies=[Depends(verify_api_key)])
 async def get_config():
-    """Get current ARF configuration (protected)"""
+    """Get current ARF configuration"""
     return {
         "confidenceThreshold": policy_engine.config["confidence_threshold"],
         "maxAutonomousRisk": policy_engine.config["max_autonomous_risk"],
@@ -752,7 +692,7 @@ async def get_config():
 
 @app.post("/api/v1/config", dependencies=[Depends(verify_api_key)])
 async def update_config(config: ConfigUpdateRequest):
-    """Update ARF configuration (protected)"""
+    """Update ARF configuration"""
     if config.confidenceThreshold:
         policy_engine.update_config("confidence_threshold", config.confidenceThreshold)
     if config.maxAutonomousRisk:
@@ -762,7 +702,7 @@ async def update_config(config: ConfigUpdateRequest):
 @app.post("/api/v1/evaluate", dependencies=[Depends(verify_api_key)], response_model=EvaluationResponse)
 async def evaluate_action(request: ActionRequest):
     """
-    Real ARF OSS evaluation pipeline (protected)
+    Real ARF OSS evaluation pipeline
     """
     try:
         context = {
@@ -855,7 +795,7 @@ async def evaluate_action(request: ActionRequest):
 @app.get("/api/v1/enterprise/signals", dependencies=[Depends(verify_api_key)])
 async def get_enterprise_signals(contacted: bool = False):
     """
-    Get enterprise lead signals (protected endpoint)
+    Get enterprise lead signals
     """
     try:
         if contacted:
@@ -898,143 +838,18 @@ async def record_outcome(action: str, success: bool):
     risk_engine.record_outcome(action, success)
     return {"status": "success", "message": "Outcome recorded"}
 
-# ============== GRADIO LEAD GENERATION UI ==============
-def create_lead_gen_ui():
-    """Professional lead generation interface (no auth needed for UI)"""
-    with gr.Blocks(title="ARF OSS - Enterprise Reliability Intelligence") as ui:
-        
-        gr.HTML(f"""
-        <div style="padding: 2rem; border-radius: 1rem; background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); color: white; text-align: center;">
-            <h1 style="font-size: 3em; margin-bottom: 0.5rem;">🤖 ARF OSS v3.3.9</h1>
-            <h2 style="font-size: 1.5em; font-weight: 300; margin-bottom: 2rem;">
-                Real Bayesian Reliability Intelligence
-            </h2>
-            <div style="display: inline-block; background: rgba(255,255,255,0.2); padding: 0.5rem 1rem; 
-                        border-radius: 2rem; margin-bottom: 2rem;">
-                ⚡ Running REAL ARF OSS Components • No Simulation
-            </div>
-        </div>
-        """)
-        
-        with gr.Row():
-            with gr.Column():
-                gr.HTML("""
-                <div style="text-align: center; padding: 2rem;">
-                    <h3 style="color: #333; font-size: 2em;">From Bayesian Analysis to Autonomous Execution</h3>
-                    <p style="color: #666; font-size: 1.2em; max-width: 800px; margin: 1rem auto;">
-                        This demo uses real ARF OSS components for risk assessment. 
-                        Enterprise adds mechanical gates, learning loops, and governed execution.
-                    </p>
-                </div>
-                """)
-        
-        with gr.Row():
-            with gr.Column():
-                gr.HTML("""
-                <div style="padding: 1.5rem; border-radius: 0.5rem; background: #f8f9fa; border-left: 4px solid #667eea; height: 100%;">
-                    <h4>🧮 True Bayesian Inference</h4>
-                    <p>Beta-Binomial conjugate priors with evidence updates</p>
-                </div>
-                """)
-            with gr.Column():
-                gr.HTML("""
-                <div style="padding: 1.5rem; border-radius: 0.5rem; background: #f8f9fa; border-left: 4px solid #667eea; height: 100%;">
-                    <h4>🛡️ Deterministic Policies</h4>
-                    <p>5 mechanical gates with live configuration</p>
-                </div>
-                """)
-        
-        with gr.Row():
-            with gr.Column():
-                gr.HTML("""
-                <div style="padding: 1.5rem; border-radius: 0.5rem; background: #f8f9fa; border-left: 4px solid #667eea; height: 100%;">
-                    <h4>💾 Persistent RAG Memory</h4>
-                    <p>SQLite + vector embeddings for incident recall</p>
-                </div>
-                """)
-            with gr.Column():
-                gr.HTML("""
-                <div style="padding: 1.5rem; border-radius: 0.5rem; background: #f8f9fa; border-left: 4px solid #667eea; height: 100%;">
-                    <h4>📊 Lead Intelligence</h4>
-                    <p>Automatic enterprise signal detection</p>
-                </div>
-                """)
-        
-        demo_stats = gr.JSON(
-            label="📊 Live Demo Statistics",
-            value={
-                "active_since": datetime.utcnow().strftime("%Y-%m-%d %H:%M"),
-                "bayesian_prior": "Beta(2.0, 5.0)",
-                "memory_size": len(memory.get_uncontacted_signals()),
-                "enterprise_signals": len(memory.get_uncontacted_signals())
-            }
-        )
-        
-        gr.HTML(f"""
-        <div style="margin: 3rem 0; padding: 3rem; background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
-                    border-radius: 1rem; text-align: center; color: white;">
-            <h2 style="font-size: 2.5em; margin-bottom: 1rem;">🚀 Ready for Autonomous Operations?</h2>
-            <p style="font-size: 1.3em; margin-bottom: 2rem;">
-                See ARF Enterprise with mechanical gates and execution
-            </p>
-            
-            <div style="display: flex; gap: 1rem; justify-content: center; flex-wrap: wrap;">
-                <a href="mailto:{settings.lead_email}?subject=ARF%20Enterprise%20Demo%20Request&body=I%20saw%20the%20real%20ARF%20OSS%20demo%20and%20would%20like%20to%20discuss%20Enterprise%20capabilities." 
-                   style="background: white; color: #667eea; padding: 1rem 2rem; border-radius: 2rem; font-weight: bold; text-decoration: none; display: inline-block; margin: 0.5rem;">
-                    📧 {settings.lead_email}
-                </a>
-                <a href="{settings.calendly_url}" target="_blank" 
-                   style="background: #FFD700; color: #333; padding: 1rem 2rem; border-radius: 2rem; font-weight: bold; text-decoration: none; display: inline-block; margin: 0.5rem;">
-                    📅 Schedule Technical Demo
-                </a>
-            </div>
-            
-            <p style="margin-top: 2rem; font-size: 0.9em; opacity: 0.9;">
-                ⚡ 30-min technical deep-dive • Live autonomous execution • Enterprise pricing<br>
-                🔒 All demos confidential and tailored to your infrastructure
-            </p>
-        </div>
-        """)
-        
-        gr.HTML(f"""
-        <div style="text-align: center; padding: 2rem; color: #666; border-top: 1px solid #eee;">
-            <p>
-                📧 <a href="mailto:{settings.lead_email}" style="color: #667eea;">{settings.lead_email}</a> • 
-                🐙 <a href="https://github.com/petterjuan/agentic-reliability-framework" style="color: #667eea;">GitHub</a>
-            </p>
-            <p style="font-size: 0.9rem;">
-                © 2026 ARF - Open Source Intelligence, Enterprise Execution<br>
-                <span style="font-size: 0.8rem; color: #999;">
-                    v3.3.9 • Real Bayesian Inference • Persistent RAG • Lead Intelligence
-                </span>
-            </p>
-        </div>
-        """)
-    
-    return ui
-
-# ============== MOUNT GRADIO ON FASTAPI ==============
-gradio_ui = create_lead_gen_ui()
-app = mount_gradio_app(app, gradio_ui, path="/")
-
 # ============== MAIN ENTRY POINT ==============
 if __name__ == "__main__":
     import uvicorn
     
     port = int(os.environ.get('PORT', 7860))
     
-    # 🔥 Ensure any lingering Gradio servers are closed before starting
-    try:
-        gr.close_all()
-    except:
-        pass
-    
     logger.info("="*60)
-    logger.info("🚀 ARF OSS v3.3.9 Starting")
+    logger.info("🚀 ARF OSS v3.3.9 (API Only) Starting")
     logger.info(f"📊 Data directory: {settings.data_dir}")
     logger.info(f"📧 Lead email: {settings.lead_email}")
     logger.info(f"🔑 API Key: {settings.api_key[:8]}... (set in HF secrets)")
-    logger.info(f"🌐 Serving at: http://0.0.0.0:{port}")
+    logger.info(f"🌐 Serving API at: http://0.0.0.0:{port}")
     logger.info("="*60)
     
     uvicorn.run(