Update app.py

app.py

@@ -134,6 +134,80 @@ class GradioScamDetector:
         
         return result_text, confidence, details, prob_chart
     
+    def predict_api(self, message):
+        """API-friendly prediction function for webhooks"""
+        if not message or not message.strip():
+            return {
+                "status": "error",
+                "message": "Empty message",
+                "prediction": "unknown",
+                "confidence": 0.0
+            }
+        
+        message = message.strip()
+        
+        try:
+            # Tokenize message
+            encoding = self.tokenizer(
+                message,
+                truncation=True,
+                padding='max_length',
+                max_length=self.max_length,
+                return_tensors='pt'
+            )
+            
+            input_ids = encoding['input_ids'].to(self.device)
+            attention_mask = encoding['attention_mask'].to(self.device)
+            
+            with torch.no_grad():
+                outputs = self.model(input_ids, attention_mask)
+                probabilities = torch.nn.functional.softmax(outputs, dim=1)
+                _, prediction = torch.max(outputs, dim=1)
+            
+            predicted_label = self.id2label[prediction.item()]
+            confidence = probabilities[0][prediction.item()].item()
+            trust_prob = probabilities[0][0].item()
+            scam_prob = probabilities[0][1].item()
+            
+            # Format result
+            if predicted_label == 'scam':
+                result_text = "🚫 SCAM DETECTED"
+                alert_level = "HIGH"
+            else:
+                result_text = "✅ TRUSTED MESSAGE"
+                alert_level = "LOW"
+            
+            # Store prediction history
+            self.prediction_history.append({
+                'timestamp': datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+                'message': message[:50] + "..." if len(message) > 50 else message,
+                'prediction': predicted_label,
+                'confidence': confidence,
+                'trust_prob': trust_prob,
+                'scam_prob': scam_prob,
+                'source': 'API'
+            })
+            
+            return {
+                "status": "success",
+                "message": message[:100] + "..." if len(message) > 100 else message,
+                "prediction": predicted_label,
+                "result_text": result_text,
+                "confidence": round(confidence, 4),
+                "trust_probability": round(trust_prob, 4),
+                "scam_probability": round(scam_prob, 4),
+                "alert_level": alert_level,
+                "timestamp": datetime.now().isoformat()
+            }
+            
+        except Exception as e:
+            return {
+                "status": "error",
+                "message": f"Prediction failed: {str(e)}",
+                "prediction": "unknown",
+                "confidence": 0.0
+            }
+    
     def create_probability_chart(self, trust_prob, scam_prob):
         """Create probability visualization"""
         fig = go.Figure(data=[
@@ -215,8 +289,9 @@ class GradioScamDetector:
         df = pd.DataFrame(self.prediction_history[-20:])  # Last 20 predictions
         df['Confidence'] = df['confidence'].apply(lambda x: f"{x:.1%}")
         df['Prediction'] = df['prediction'].apply(lambda x: f"🚫 {x.upper()}" if x == 'scam' else f"✅ {x.upper()}")
+        df['Source'] = df.get('source', 'Manual')
         
-        return df[['timestamp', 'message', 'Prediction', 'Confidence']].rename(columns={
+        return df[['timestamp', 'message', 'Prediction', 'Confidence', 'Source']].rename(columns={
             'timestamp': 'Time',
             'message': 'Message',
         })
@@ -237,9 +312,13 @@ class GradioScamDetector:
             "Suspicious": "URGENT: Your account will be suspended. Click link to verify now!"
         }
 
+# Global detector instance for API endpoints
+detector = None
+
 def create_gradio_app():
     """Create and configure Gradio interface"""
     
+    global detector
     # Initialize detector
     detector = GradioScamDetector()
     
@@ -279,6 +358,64 @@ def create_gradio_app():
         Simply enter a message below to check if it's legitimate or potentially fraudulent.
         """)
         
+        # API Information Tab
+        with gr.Tab("🔌 API Integration"):
+            gr.Markdown("""
+            ## 📡 API Endpoints for IFTTT/Zapier Integration
+            
+            ### For IFTTT Webhook:
+            ```
+            URL: https://jacksonwambali-bert.hf.space/api/predict
+            Method: POST
+            Content-Type: application/json
+            Body: {"data": ["Your SMS message here"]}
+            ```
+            
+            ### For Zapier Webhook:
+            ```
+            URL: https://jacksonwambali-bert.hf.space/api/predict
+            Method: POST
+            Content-Type: application/json
+            Payload: {"data": ["{{sms_text}}"]}
+            ```
+            
+            ### Response Format:
+            ```json
+            {
+                "data": [
+                    {
+                        "status": "success",
+                        "prediction": "scam" or "trust",
+                        "result_text": "🚫 SCAM DETECTED" or "✅ TRUSTED MESSAGE",
+                        "confidence": 0.95,
+                        "alert_level": "HIGH" or "LOW"
+                    }
+                ]
+            }
+            ```
+            
+            ### Quick Test:
+            Use the form below to test your API integration:
+            """)
+            
+            with gr.Row():
+                with gr.Column():
+                    api_test_input = gr.Textbox(
+                        label="📱 Test SMS Message",
+                        placeholder="Enter SMS to test API response...",
+                        lines=3
+                    )
+                    api_test_btn = gr.Button("🧪 Test API Response", variant="primary")
+                
+                with gr.Column():
+                    api_response = gr.JSON(label="📊 API Response")
+            
+            api_test_btn.click(
+                fn=lambda msg: detector.predict_api(msg) if detector else {"error": "Model not loaded"},
+                inputs=api_test_input,
+                outputs=api_response
+            )
+        
         # Main prediction interface
         with gr.Tab("🔍 Single Message Detection"):
             with gr.Row():
@@ -381,6 +518,12 @@ def create_gradio_app():
             - 📊 Confidence scoring
             - 📁 Batch processing
             - 📚 Prediction history
+            - 🔌 API integration for IFTTT/Zapier
+            
+            ### SMS Integration
+            - Connect with IFTTT for automatic SMS scanning
+            - Webhook support for real-time alerts
+            - Batch processing for multiple messages
             
             ### Usage Tips
             - Enter complete SMS messages for best results