Update app.py

app.py

@@ -2,19 +2,197 @@ import gradio as gr
 import joblib
 import os
 import logging
+import sqlite3
+import hashlib
+import json
+import pandas as pd
 from datetime import datetime
+from collections import Counter
+import re
 
 # Configure logging
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
 class SMSScamDetector:
-    """Enhanced SMS Scam Detection System"""
+    """Enhanced SMS Scam Detection System with Analytics and Reporting"""
     
     def __init__(self):
         self.model = None
         self.vectorizer = None
+        self.db_path = "sms_analytics.db"
+        self.init_database()
         self.load_models()
+        self.scam_patterns = self.load_scam_patterns()
+    
+    def init_database(self):
+        """Initialize SQLite database for analytics"""
+        try:
+            conn = sqlite3.connect(self.db_path)
+            cursor = conn.cursor()
+            cursor.execute('''
+                CREATE TABLE IF NOT EXISTS sms_logs (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    message_hash TEXT UNIQUE,
+                    prediction TEXT,
+                    confidence REAL,
+                    timestamp DATETIME,
+                    message_length INTEGER,
+                    suspicious_keywords INTEGER
+                )
+            ''')
+            conn.commit()
+            conn.close()
+            logger.info("Database initialized successfully")
+        except Exception as e:
+            logger.error(f"Database initialization error: {str(e)}")
+    
+    def load_scam_patterns(self):
+        """Load common scam patterns and keywords"""
+        return {
+            'prize_keywords': ['ushindi', 'zawadi', 'hongera', 'umeshinda', 'pesa', 'dola'],
+            'urgency_keywords': ['haraka', 'sasa hivi', 'urgent', 'muda mchache'],
+            'suspicious_urls': [r'http[s]?://(?:[a-zA-Z]|[0-9]|[$-_@.&+]|[!*\\(\\),]|(?:%[0-9a-fA-F][0-9a-fA-F]))+'],
+            'phone_patterns': [r'\*\d+#', r'\d{10,}'],
+            'money_patterns': [r'tsh?\s*[\d,]+', r'usd?\s*[\d,]+', r'[\d,]+\s*shilling']
+        }
+    
+    def analyze_message_patterns(self, text):
+        """Analyze message for suspicious patterns"""
+        text_lower = text.lower()
+        suspicious_score = 0
+        detected_patterns = []
+        
+        # Check for prize/money keywords
+        for keyword in self.scam_patterns['prize_keywords']:
+            if keyword in text_lower:
+                suspicious_score += 2
+                detected_patterns.append(f"Prize keyword: {keyword}")
+        
+        # Check for urgency keywords
+        for keyword in self.scam_patterns['urgency_keywords']:
+            if keyword in text_lower:
+                suspicious_score += 1
+                detected_patterns.append(f"Urgency keyword: {keyword}")
+        
+        # Check for URLs
+        if re.search(self.scam_patterns['suspicious_urls'][0], text):
+            suspicious_score += 3
+            detected_patterns.append("Contains suspicious URL")
+        
+        # Check for USSD codes
+        if re.search(self.scam_patterns['phone_patterns'][0], text):
+            suspicious_score += 2
+            detected_patterns.append("Contains USSD code")
+        
+        # Check for money mentions
+        for pattern in self.scam_patterns['money_patterns']:
+            if re.search(pattern, text_lower):
+                suspicious_score += 1
+                detected_patterns.append("Contains money amount")
+                break
+        
+        return suspicious_score, detected_patterns
+    
+    def log_prediction(self, text, prediction, confidence, suspicious_score):
+        """Log prediction to database for analytics"""
+        try:
+            conn = sqlite3.connect(self.db_path)
+            cursor = conn.cursor()
+            
+            message_hash = hashlib.md5(text.encode()).hexdigest()
+            
+            cursor.execute('''
+                INSERT OR REPLACE INTO sms_logs 
+                (message_hash, prediction, confidence, timestamp, message_length, suspicious_keywords)
+                VALUES (?, ?, ?, ?, ?, ?)
+            ''', (
+                message_hash,
+                prediction,
+                float(max(confidence)),
+                datetime.now().isoformat(),
+                len(text),
+                suspicious_score
+            ))
+            
+            conn.commit()
+            conn.close()
+        except Exception as e:
+            logger.error(f"Logging error: {str(e)}")
+    
+    def get_analytics(self):
+        """Get analytics data from database"""
+        try:
+            conn = sqlite3.connect(self.db_path)
+            df = pd.read_sql_query("SELECT * FROM sms_logs ORDER BY timestamp DESC LIMIT 100", conn)
+            conn.close()
+            
+            if df.empty:
+                return "Hakuna data ya kutosha kwa takwimu"
+            
+            total_messages = len(df)
+            scam_count = len(df[df['prediction'] == 'scam'])
+            trust_count = len(df[df['prediction'] == 'trust'])
+            avg_confidence = df['confidence'].mean()
+            
+            analytics = f"""
+## 📊 Takwimu za Mfumo
+
+**Jumla ya Ujumbe**: {total_messages}
+**Scam**: {scam_count} ({scam_count/total_messages*100:.1f}%)
+**Trust**: {trust_count} ({trust_count/total_messages*100:.1f}%)
+**Wastani wa Uhakika**: {avg_confidence:.2f}
+
+### Takwimu za Wiki Hii
+- Ujumbe mrefu zaidi: {df['message_length'].max()} herufi
+- Ujumbe mfupi zaidi: {df['message_length'].min()} herufi
+- Wastani wa urefu: {df['message_length'].mean():.0f} herufi
+            """
+            
+            return analytics
+            
+        except Exception as e:
+            return f"Kosa la takwimu: {str(e)}"
+    
+    def export_report(self):
+        """Export detailed report"""
+        try:
+            conn = sqlite3.connect(self.db_path)
+            df = pd.read_sql_query("""
+                SELECT prediction, confidence, timestamp, message_length, suspicious_keywords
+                FROM sms_logs 
+                ORDER BY timestamp DESC LIMIT 1000
+            """, conn)
+            conn.close()
+            
+            if df.empty:
+                return "Hakuna data ya kuexport"
+            
+            # Create summary report
+            report = {
+                'total_analyzed': len(df),
+                'scam_percentage': (df['prediction'] == 'scam').mean() * 100,
+                'average_confidence': df['confidence'].mean(),
+                'date_range': {
+                    'from': df['timestamp'].min(),
+                    'to': df['timestamp'].max()
+                },
+                'message_stats': {
+                    'avg_length': df['message_length'].mean(),
+                    'max_length': df['message_length'].max(),
+                    'min_length': df['message_length'].min()
+                }
+            }
+            
+            # Save to JSON
+            report_file = f"sms_report_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
+            with open(report_file, 'w') as f:
+                json.dump(report, f, indent=2, default=str)
+            
+            return f"Ripoti imehifadhiwa: {report_file}"
+            
+        except Exception as e:
+            return f"Kosa la report: {str(e)}"
     
     def load_models(self):
         """Load machine learning models with error handling"""
@@ -59,7 +237,7 @@ class SMSScamDetector:
             return "Haba (Low)", "🟢"
     
     def predict_sms(self, text):
-        """Enhanced prediction function with detailed output"""
+        """Enhanced prediction function with detailed output and logging"""
         # Input validation
         if not text or len(text.strip()) == 0:
             return "❌ **Kosa**: Tafadhali ingiza ujumbe wa SMS"
@@ -75,6 +253,9 @@ class SMSScamDetector:
             # Preprocess text
             cleaned_text = self.preprocess_text(text)
             
+            # Analyze patterns
+            suspicious_score, detected_patterns = self.analyze_message_patterns(text)
+            
             # Vectorize text
             text_vector = self.vectorizer.transform([cleaned_text])
             
@@ -85,6 +266,9 @@ class SMSScamDetector:
             # Get confidence level
             confidence, emoji = self.get_confidence_level(prediction_proba)
             
+            # Log prediction
+            self.log_prediction(text, prediction, prediction_proba, suspicious_score)
+            
             # Format prediction
             if prediction.lower() == 'scam':
                 result_text = "**SCAM** 🚨"
@@ -95,6 +279,12 @@ class SMSScamDetector:
                 result_color = "success"
                 advice = "Ujumbe huu unaonekana kuwa wa kawaida, lakini bado kuwa makini."
             
+            # Add pattern analysis to output
+            pattern_analysis = ""
+            if detected_patterns:
+                pattern_analysis = f"\n**Dalili Zilizogunduliwa**:\n" + "\n".join([f"• {pattern}" for pattern in detected_patterns])
+                pattern_analysis += f"\n**Alama za Utata**: {suspicious_score}/10"
+            
             # Create detailed output
             output = f"""
 ## Matokeo ya Uchunguzi {emoji}
@@ -106,6 +296,7 @@ class SMSScamDetector:
 **Kiwango cha Uhakika**: {confidence}
 
 **Maoni**: {advice}
+{pattern_analysis}
 
 ---
 *Tarehe*: {datetime.now().strftime("%Y-%m-%d %H:%M:%S")}
@@ -194,6 +385,16 @@ with gr.Blocks(
         value="Matokeo yataonyeshwa hapa baada ya kuchunguza ujumbe..."
     )
     
+    with gr.Row():
+        with gr.Column(scale=1):
+            # Analytics Section
+            gr.Markdown("### 📊 Takwimu za Mfumo")
+            analytics_btn = gr.Button("📈 Ona Takwimu", variant="outline")
+            analytics_output = gr.Markdown("Bonyeza hapo juu kuona takwimu...")
+            
+            export_btn = gr.Button("📄 Export Ripoti", variant="outline")
+            export_output = gr.Markdown("")
+    
     # Information section
     with gr.Accordion("ℹ️ Maelezo ya Ziada", open=False):
         gr.Markdown("""
@@ -209,11 +410,35 @@ with gr.Blocks(
         - 🔗 Ina viungo vya kugusia (links)
         - ⚡ Inadai ni ya dharura
         - 📞 Inaomba taarifa za kibinafsi
+        - 📱 Ina USSD codes (*123#)
+        
+        ### Vipimo Vipya:
+        - **Pattern Analysis**: Mfumo unachunguza maneno na michoro ya kawaida
+        - **Database Logging**: Kila ujumbe unahifadhiwa kwa takwimu
+        - **Confidence Scoring**: Kiwango cha uhakika kinajumuishwa
+        - **Analytics Dashboard**: Takwimu za jumla za matumizi
         
         ### Onyo Muhimu:
         Mfumo huu ni wa kusaidia tu. Daima tumia busara zako na usijibu SMS zisizoeleweka.
         """)
     
+    # Advanced Features Section
+    with gr.Accordion("🔧 Vipengele vya Kina", open=False):
+        gr.Markdown("""
+        ### Uchanganuzi wa Kina:
+        - **Keyword Detection**: Inachunguza maneno yenye hatari
+        - **URL Analysis**: Inaangalia viungo vya web
+        - **USSD Detection**: Inagundua nambari za *123#
+        - **Money Pattern**: Inatambua maelezo ya pesa
+        - **Urgency Detection**: Inagundua maneno ya dharura
+        
+        ### Data Analytics:
+        - Takwimu za ujumbe wote uliochunguzwa
+        - Asilimia ya scam vs trust
+        - Wastani wa uhakika wa mfumo
+        - Export ya ripoti za kina
+        """)
+    
     # Event handlers
     predict_btn.click(
         fn=detector.predict_sms,
@@ -221,6 +446,16 @@ with gr.Blocks(
         outputs=output_result
     )
     
+    analytics_btn.click(
+        fn=detector.get_analytics,
+        outputs=analytics_output
+    )
+    
+    export_btn.click(
+        fn=detector.export_report,
+        outputs=export_output
+    )
+    
     clear_btn.click(
         fn=lambda: ("", "Matokeo yataonyeshwa hapa baada ya kuchunguza ujumbe..."),
         outputs=[sms_input, output_result]