aiwaf 0.1.9.2.7__py3-none-any.whl → 0.1.9.2.9__py3-none-any.whl

aiwaf/__init__.py

@@ -1,6 +1,6 @@
 default_app_config = "aiwaf.apps.AiwafConfig"
 
-__version__ = "0.1.9.2.7"
+__version__ = "0.1.9.2.9"
 
 # Note: Middleware classes are available from aiwaf.middleware
 # Import them only when needed to avoid circular imports during Django app loading

aiwaf/management/commands/detect_and_train.py

@@ -4,7 +4,19 @@ from aiwaf.trainer import train
 class Command(BaseCommand):
     help = "Run AI‑WAF detect & retrain"
 
+    def add_arguments(self, parser):
+        parser.add_argument(
+            '--disable-ai',
+            action='store_true',
+            help='Disable AI model training, only perform keyword learning'
+        )
+
     def handle(self, *args, **options):
-        train()
+        disable_ai = options.get('disable_ai', False)
+        
+        if disable_ai:
+            self.stdout.write(self.style.WARNING("AI model training disabled - keyword learning only"))
+        
+        train(disable_ai=disable_ai)
         self.stdout.write(self.style.SUCCESS("Done."))
 

aiwaf/management/commands/regenerate_model.py

@@ -11,6 +11,11 @@ class Command(BaseCommand):
             action='store_true',
             help='Force regeneration even if model exists',
         )
+        parser.add_argument(
+            '--disable-ai',
+            action='store_true',
+            help='Disable AI model training, only perform keyword learning'
+        )
 
     def handle(self, *args, **options):
         self.stdout.write(self.style.HTTP_INFO("🔄 AI-WAF Model Regeneration"))
@@ -58,16 +63,28 @@ class Command(BaseCommand):
             self.stdout.write("Regenerating model to fix version compatibility...")
         
         # Regenerate model
-        self.stdout.write("🚀 Starting model training...")
+        disable_ai = options.get('disable_ai', False)
+        
+        if disable_ai:
+            self.stdout.write("� AI model training disabled - keyword learning only")
+            self.stdout.write("🚀 Starting keyword training...")
+        else:
+            self.stdout.write("�🚀 Starting model training...")
         
         try:
             from aiwaf.trainer import train
-            train()
-            self.stdout.write("")
-            self.stdout.write(self.style.SUCCESS("✅ Model regenerated successfully!"))
+            train(disable_ai=disable_ai)
             self.stdout.write("")
-            self.stdout.write("The model is now compatible with your current scikit-learn version.")
-            self.stdout.write("Version warnings should no longer appear.")
+            
+            if disable_ai:
+                self.stdout.write(self.style.SUCCESS("✅ Keyword training completed successfully!"))
+                self.stdout.write("")
+                self.stdout.write("Keyword-based protection is now active.")
+            else:
+                self.stdout.write(self.style.SUCCESS("✅ Model regenerated successfully!"))
+                self.stdout.write("")
+                self.stdout.write("The model is now compatible with your current scikit-learn version.")
+                self.stdout.write("Version warnings should no longer appear.")
             
         except Exception as e:
             self.stdout.write("")

aiwaf/middleware.py

@@ -32,6 +32,12 @@ def load_model_safely():
     import warnings
     import sklearn
     
+    # Check if AI is disabled globally
+    ai_disabled = getattr(settings, "AIWAF_DISABLE_AI", False)
+    if ai_disabled:
+        print("AI functionality disabled via AIWAF_DISABLE_AI setting")
+        return None
+    
     try:
         # Suppress sklearn version warnings temporarily
         with warnings.catch_warnings():
@@ -46,13 +52,13 @@ def load_model_safely():
                 current_version = sklearn.__version__
                 
                 if stored_version != current_version:
-                    print(f"ℹ️  Model was trained with sklearn v{stored_version}, current v{current_version}")
+                    print(f"Model was trained with sklearn v{stored_version}, current v{current_version}")
                     print("   Run 'python manage.py detect_and_train' to update model if needed.")
                 
                 return model
             else:
                 # Old format - direct model object
-                print("ℹ️  Using legacy model format. Consider retraining for better compatibility.")
+                print("Using legacy model format. Consider retraining for better compatibility.")
                 return model_data
                 
     except Exception as e:

aiwaf/storage.py

@@ -2,22 +2,43 @@ import numpy as np
 import pandas as pd
 from django.conf import settings
 from django.utils import timezone
+import os
+import json
+from collections import defaultdict
 
 # Defer model imports to avoid AppRegistryNotReady during Django app loading
 FeatureSample = BlacklistEntry = IPExemption = DynamicKeyword = None
 
+# Fallback storage for when Django models are unavailable
+_fallback_keywords = defaultdict(int)
+_fallback_storage_path = os.path.join(os.path.dirname(__file__), 'fallback_keywords.json')
+
 def _import_models():
     """Import Django models only when needed and apps are ready."""
     global FeatureSample, BlacklistEntry, IPExemption, DynamicKeyword
     
     if FeatureSample is not None:
         return  # Already imported
-    
     try:
         from django.apps import apps
-        if apps.ready and apps.is_installed('aiwaf'):
-            from .models import FeatureSample, BlacklistEntry, IPExemption, DynamicKeyword
-    except (ImportError, RuntimeError, Exception):
+        if apps.ready:
+            # Try multiple ways to import models
+            try:
+                # First try: direct import (most reliable)
+                from .models import FeatureSample, BlacklistEntry, IPExemption, DynamicKeyword
+            except ImportError:
+                # Second try: check if aiwaf app is installed under different name
+                for app_config in apps.get_app_configs():
+                    if 'aiwaf' in app_config.name.lower() or 'aiwaf' in app_config.label.lower():
+                        try:
+                            from .models import FeatureSample, BlacklistEntry, IPExemption, DynamicKeyword
+                            break
+                        except ImportError:
+                            continue
+    except (ImportError, RuntimeError, Exception) as e:
+        # Log the error for debugging but don't fail silently
+        import sys
+        print(f"Warning: Could not import AIWAF models: {e}", file=sys.stderr)
         # Keep models as None if can't import
         pass
 
@@ -62,7 +83,6 @@ class ModelFeatureStore:
             if df.empty:
                 return df
             
-            # Ensure proper column order and types
             feature_cols = ['path_len', 'kw_hits', 'resp_time', 'status_idx', 'burst_count', 'total_404']
             for col in feature_cols:
                 if col in df.columns:
@@ -242,11 +262,40 @@ class ModelExemptionStore:
             return 0
 
 class ModelKeywordStore:
+    @staticmethod
+    def _load_fallback_keywords():
+        """Load keywords from fallback JSON file"""
+        global _fallback_keywords
+        try:
+            if os.path.exists(_fallback_storage_path):
+                with open(_fallback_storage_path, 'r') as f:
+                    data = json.load(f)
+                    _fallback_keywords = defaultdict(int, data)
+        except Exception as e:
+            import sys
+            print(f"Warning: Could not load fallback keywords: {e}", file=sys.stderr)
+    
+    @staticmethod
+    def _save_fallback_keywords():
+        """Save keywords to fallback JSON file"""
+        try:
+            with open(_fallback_storage_path, 'w') as f:
+                json.dump(dict(_fallback_keywords), f, indent=2)
+        except Exception as e:
+            import sys
+            print(f"Warning: Could not save fallback keywords: {e}", file=sys.stderr)
+    
     @staticmethod
     def add_keyword(keyword, count=1):
         """Add a keyword to the dynamic keyword list"""
         _import_models()
         if DynamicKeyword is None:
+            # Use fallback storage when Django models not available
+            ModelKeywordStore._load_fallback_keywords()
+            _fallback_keywords[keyword] += count
+            ModelKeywordStore._save_fallback_keywords()
+            import sys
+            print(f"Info: Using fallback storage for keyword '{keyword}' - Django models not available.", file=sys.stderr)
             return
         try:
             obj, created = DynamicKeyword.objects.get_or_create(keyword=keyword)
@@ -257,7 +306,12 @@ class ModelKeywordStore:
                 obj.count = count
                 obj.save()
         except Exception as e:
-            print(f"Error adding keyword {keyword}: {e}")
+            # Fallback to file storage on database error
+            ModelKeywordStore._load_fallback_keywords()
+            _fallback_keywords[keyword] += count
+            ModelKeywordStore._save_fallback_keywords()
+            import sys
+            print(f"Database error adding keyword {keyword}, using fallback storage: {e}", file=sys.stderr)
 
     @staticmethod
     def remove_keyword(keyword):
@@ -275,14 +329,22 @@ class ModelKeywordStore:
         """Get top N keywords by count"""
         _import_models()
         if DynamicKeyword is None:
-            return []
+            # Use fallback storage
+            ModelKeywordStore._load_fallback_keywords()
+            sorted_keywords = sorted(_fallback_keywords.items(), key=lambda x: x[1], reverse=True)
+            return [keyword for keyword, count in sorted_keywords[:n]]
         try:
             return list(
                 DynamicKeyword.objects.order_by('-count')[:n]
                 .values_list('keyword', flat=True)
             )
-        except Exception:
-            return []
+        except Exception as e:
+            # Fallback to file storage on database error
+            ModelKeywordStore._load_fallback_keywords()
+            sorted_keywords = sorted(_fallback_keywords.items(), key=lambda x: x[1], reverse=True)
+            import sys
+            print(f"Database error getting top keywords, using fallback storage: {e}", file=sys.stderr)
+            return [keyword for keyword, count in sorted_keywords[:n]]
 
     @staticmethod
     def get_all_keywords():
@@ -308,6 +370,18 @@ class ModelKeywordStore:
         except Exception as e:
             print(f"Error resetting keywords: {e}")
 
+    def add_keyword_for_route(self, route, keyword, count=1):
+        """Add a keyword for a specific route (fallback method)"""
+        # For now, just use the general add_keyword method
+        # In a full implementation, this would handle route-specific storage
+        return ModelKeywordStore.add_keyword(keyword, count)
+    
+    def get_keywords_for_route(self, route):
+        """Get keywords for a specific route (fallback method)"""
+        # For now, return all keywords
+        # In a full implementation, this would return route-specific keywords
+        return ModelKeywordStore.get_all_keywords()
+
 # Factory functions that only return Django model stores
 def get_feature_store():
     """Get the feature store (Django models only)"""

aiwaf/trainer.py

@@ -3,13 +3,10 @@ import glob
 import gzip
 import re
 import joblib
-
 from datetime import datetime
 from collections import defaultdict, Counter
-
 import pandas as pd
 from sklearn.ensemble import IsolationForest
-
 from django.conf import settings
 from django.apps import apps
 from django.db.models import F
@@ -409,9 +406,16 @@ def _is_malicious_context_trainer(path: str, keyword: str, status: str = "404")
     return any(malicious_indicators)
 
 
-def train() -> None:
-    """Enhanced training with improved keyword filtering and exemption handling"""
-    print("🚀 Starting AIWAF enhanced training...")
+def train(disable_ai=False) -> None:
+    """Enhanced training with improved keyword filtering and exemption handling
+    
+    Args:
+        disable_ai (bool): If True, skip AI model training and only do keyword learning
+    """
+    print("Starting AIWAF enhanced training...")
+    
+    if disable_ai:
+        print("AI model training disabled - keyword learning only")
     
     # Remove exempt keywords first
     remove_exempt_keywords()
@@ -421,7 +425,7 @@ def train() -> None:
     
     exempted_ips = [entry['ip_address'] for entry in exemption_store.get_all()]
     if exempted_ips:
-        print(f"🛡️  Found {len(exempted_ips)} exempted IPs - clearing from blacklist")
+        print(f"Found {len(exempted_ips)} exempted IPs - clearing from blacklist")
         for ip in exempted_ips:
             BlacklistManager.unblock(ip)
     
@@ -484,85 +488,100 @@ def train() -> None:
         })
 
     if not feature_dicts:
-        print("⚠️ Nothing to train on – no valid log entries.")
+        print(" Nothing to train on – no valid log entries.")
         return
 
-    df = pd.DataFrame(feature_dicts)
-    feature_cols = [c for c in df.columns if c != "ip"]
-    X = df[feature_cols].astype(float).values
-    model = IsolationForest(
-        contamination=getattr(settings, "AIWAF_AI_CONTAMINATION", 0.05), 
-        random_state=42
-    )
-    
-    # Suppress sklearn warnings during training
-    import warnings
-    with warnings.catch_warnings():
-        warnings.filterwarnings("ignore", category=UserWarning, module="sklearn")
-        model.fit(X)
-
-    os.makedirs(os.path.dirname(MODEL_PATH), exist_ok=True)
-    
-    # Save model with version metadata
-    import sklearn
-    from django.utils import timezone as django_timezone
-    model_data = {
-        'model': model,
-        'sklearn_version': sklearn.__version__,
-        'created_at': str(django_timezone.now()),
-        'feature_count': len(feature_cols),
-        'samples_count': len(X)
-    }
-    joblib.dump(model_data, MODEL_PATH)
-    print(f"✅ Model trained on {len(X)} samples → {MODEL_PATH}")
-    print(f"📦 Created with scikit-learn v{sklearn.__version__}")
-    
-    # Check for anomalies and intelligently decide which IPs to block
-    preds = model.predict(X)
-    anomalous_ips = set(df.loc[preds == -1, "ip"])
-    
-    if anomalous_ips:
-        print(f"⚠️  Detected {len(anomalous_ips)} potentially anomalous IPs during training")
-        
-        exemption_store = get_exemption_store()
-        blacklist_store = get_blacklist_store()
-        blocked_count = 0
+    # AI Model Training (optional)
+    blocked_count = 0
+    if not disable_ai:
+        print(" Training AI anomaly detection model...")
         
-        for ip in anomalous_ips:
-            # Skip if IP is exempted
-            if exemption_store.is_exempted(ip):
-                continue
+        try:
+            df = pd.DataFrame(feature_dicts)
+            feature_cols = [c for c in df.columns if c != "ip"]
+            X = df[feature_cols].astype(float).values
+            model = IsolationForest(
+                contamination=getattr(settings, "AIWAF_AI_CONTAMINATION", 0.05), 
+                random_state=42
+            )
             
-            # Get this IP's behavior from the data
-            ip_data = df[df["ip"] == ip]
+            # Suppress sklearn warnings during training
+            import warnings
+            with warnings.catch_warnings():
+                warnings.filterwarnings("ignore", category=UserWarning, module="sklearn")
+                model.fit(X)
+
+            os.makedirs(os.path.dirname(MODEL_PATH), exist_ok=True)
             
-            # Criteria to determine if this is likely a legitimate user vs threat:
-            avg_kw_hits = ip_data["kw_hits"].mean()
-            max_404s = ip_data["total_404"].max()
-            avg_burst = ip_data["burst_count"].mean()
-            total_requests = len(ip_data)
+            # Save model with version metadata
+            import sklearn
+            from django.utils import timezone as django_timezone
+            model_data = {
+                'model': model,
+                'sklearn_version': sklearn.__version__,
+                'created_at': str(django_timezone.now()),
+                'feature_count': len(feature_cols),
+                'samples_count': len(X)
+            }
+            joblib.dump(model_data, MODEL_PATH)
+            print(f"Model trained on {len(X)} samples → {MODEL_PATH}")
+            print(f"Created with scikit-learn v{sklearn.__version__}")
             
-            # Don't block if it looks like legitimate behavior:
-            if (
-                avg_kw_hits < 2 and           # Not hitting many malicious keywords
-                max_404s < 10 and            # Not excessive 404s
-                avg_burst < 15 and           # Not excessive burst activity
-                total_requests < 100         # Not excessive total requests
-            ):
-                print(f"   - {ip}: Anomalous but looks legitimate (kw:{avg_kw_hits:.1f}, 404s:{max_404s}, burst:{avg_burst:.1f}) - NOT blocking")
-                continue
+            # Check for anomalies and intelligently decide which IPs to block
+            preds = model.predict(X)
+            anomalous_ips = set(df.loc[preds == -1, "ip"])
             
-            # Block if it shows clear signs of malicious behavior
-            BlacklistManager.block(ip, f"AI anomaly + suspicious patterns (kw:{avg_kw_hits:.1f}, 404s:{max_404s}, burst:{avg_burst:.1f})")
-            blocked_count += 1
-            print(f"   - {ip}: Blocked for suspicious behavior (kw:{avg_kw_hits:.1f}, 404s:{max_404s}, burst:{avg_burst:.1f})")
+            if anomalous_ips:
+                print(f"Detected {len(anomalous_ips)} potentially anomalous IPs during training")
+                
+                exemption_store = get_exemption_store()
+                blacklist_store = get_blacklist_store()
+                
+                for ip in anomalous_ips:
+                    # Skip if IP is exempted
+                    if exemption_store.is_exempted(ip):
+                        continue
+                    
+                    # Get this IP's behavior from the data
+                    ip_data = df[df["ip"] == ip]
+                    
+                    # Criteria to determine if this is likely a legitimate user vs threat:
+                    avg_kw_hits = ip_data["kw_hits"].mean()
+                    max_404s = ip_data["total_404"].max()
+                    avg_burst = ip_data["burst_count"].mean()
+                    total_requests = len(ip_data)
+                    
+                    # Don't block if it looks like legitimate behavior:
+                    if (
+                        avg_kw_hits < 2 and           # Not hitting many malicious keywords
+                        max_404s < 10 and            # Not excessive 404s
+                        avg_burst < 15 and           # Not excessive burst activity
+                        total_requests < 100         # Not excessive total requests
+                    ):
+                        print(f"   - {ip}: Anomalous but looks legitimate (kw:{avg_kw_hits:.1f}, 404s:{max_404s}, burst:{avg_burst:.1f}) - NOT blocking")
+                        continue
+                    
+                    # Block if it shows clear signs of malicious behavior
+                    BlacklistManager.block(ip, f"AI anomaly + suspicious patterns (kw:{avg_kw_hits:.1f}, 404s:{max_404s}, burst:{avg_burst:.1f})")
+                    blocked_count += 1
+                    print(f"   - {ip}: Blocked for suspicious behavior (kw:{avg_kw_hits:.1f}, 404s:{max_404s}, burst:{avg_burst:.1f})")
+                
+                print(f"   → Blocked {blocked_count}/{len(anomalous_ips)} anomalous IPs (others looked legitimate)")
         
-        print(f"   → Blocked {blocked_count}/{len(anomalous_ips)} anomalous IPs (others looked legitimate)")
+        except ImportError as e:
+            print(f"AI model training failed - missing dependencies: {e}")
+            print("   Continuing with keyword learning only...")
+        except Exception as e:
+            print(f"AI model training failed: {e}")
+            print("   Continuing with keyword learning only...")
+    else:
+        print("AI model training skipped (disabled)")
+        df = pd.DataFrame(feature_dicts)  # Still need df for some operations
 
     tokens = Counter()
     legitimate_keywords = get_legitimate_keywords()
     
-    print(f"🔍 Learning keywords from {len(parsed)} parsed requests...")
+    print(f"Learning keywords from {len(parsed)} parsed requests...")
     
     for r in parsed:
         # Only learn from suspicious requests (errors on non-existent paths)
@@ -603,22 +622,35 @@ def train() -> None:
             learned_from_paths.extend(example_paths[:2])  # Track first 2 example paths
     
     if filtered_tokens:
-        print(f"📝 Added {len(filtered_tokens)} suspicious keywords: {[kw for kw, _ in filtered_tokens]}")
-        print(f"🎯 Example malicious paths learned from: {learned_from_paths[:5]}")  # Show first 5
+        print(f"Added {len(filtered_tokens)} suspicious keywords: {[kw for kw, _ in filtered_tokens]}")
+        print(f"Example malicious paths learned from: {learned_from_paths[:5]}")  # Show first 5
     else:
-        print("✅ No new suspicious keywords learned (good sign!)")
+        print("No new suspicious keywords learned (good sign!)")
     
-    print(f"🎯 Smart keyword learning complete. Excluded {len(legitimate_keywords)} legitimate keywords.")
-    print(f"🔒 Used malicious context analysis to filter out false positives.")
+    print(f"Smart keyword learning complete. Excluded {len(legitimate_keywords)} legitimate keywords.")
+    print(f"Used malicious context analysis to filter out false positives.")
     
     # Training summary
     print("\n" + "="*60)
-    print("🎉 AIWAF ENHANCED TRAINING COMPLETE")
+    if disable_ai:
+        print("AIWAF KEYWORD-ONLY TRAINING COMPLETE")
+    else:
+        print("AIWAF ENHANCED TRAINING COMPLETE")
     print("="*60)
-    print(f"📊 Training Data: {len(parsed)} log entries processed")
-    print(f"🤖 AI Model: Trained with {len(feature_cols)} features")
-    print(f"🚫 Blocked IPs: {blocked_count if 'blocked_count' in locals() else 0} suspicious IPs blocked")
-    print(f"🔑 Keywords: {len(filtered_tokens)} new suspicious keywords learned")
-    print(f"🛡️  Exemptions: {len(exempted_ips)} IPs protected from blocking")
-    print(f"✅ Enhanced protection now active with context-aware filtering!")
+    print(f"Training Data: {len(parsed)} log entries processed")
+    
+    if not disable_ai:
+        print(f"AI Model: Trained with {len(feature_cols) if 'feature_cols' in locals() else 'N/A'} features")
+        print(f"Blocked IPs: {blocked_count} suspicious IPs blocked")
+    else:
+        print(f"AI Model: Disabled (keyword learning only)")
+        print(f"Blocked IPs: 0 (AI blocking disabled)")
+        
+    print(f"Keywords: {len(filtered_tokens)} new suspicious keywords learned")
+    print(f"Exemptions: {len(exempted_ips)} IPs protected from blocking")
+    
+    if disable_ai:
+        print(f"Keyword-based protection now active with context-aware filtering!")
+    else:
+        print(f"Enhanced protection now active with context-aware filtering!")
     print("="*60)

{aiwaf-0.1.9.2.7.dist-info → aiwaf-0.1.9.2.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aiwaf
-Version: 0.1.9.2.7
+Version: 0.1.9.2.9
 Summary: AI-powered Web Application Firewall
 Home-page: https://github.com/aayushgauba/aiwaf
 Author: Aayush Gauba
@@ -806,13 +806,25 @@ python manage.py aiwaf_reset --blacklist --confirm
 
 ---
 
-## 📄 License
+## Sponsors
+
+This project is proudly supported by:
+
+<a href="https://www.digitalocean.com/">
+  <img src="https://opensource.nyc3.cdn.digitaloceanspaces.com/attribution/assets/SVG/DO_Logo_horizontal_blue.svg" width="201px">
+</a>
+
+[DigitalOcean](https://www.digitalocean.com/) provides the cloud infrastructure that powers AIWAF development.
+
+---
+
+## License
 
 This project is licensed under the **MIT License**. See the [LICENSE](LICENSE) file for details.
 
 ---
 
-## 👤 Credits
+## Credits
 
 **AI‑WAF** by [Aayush Gauba](https://github.com/aayushgauba)  
-> “Let your firewall learn and evolve — keep your site a fortress.”
+> "Let your firewall learn and evolve — keep your site a fortress." your Django `INSTALLED_APPS` to avoid setup errors.

{aiwaf-0.1.9.2.7.dist-info → aiwaf-0.1.9.2.9.dist-info}/RECORD

@@ -1,12 +1,12 @@
-aiwaf/__init__.py,sha256=TCY7zgvfazGCir552LTRiAfLBZcCfJGYpVD1eAuN9Pk,220
+aiwaf/__init__.py,sha256=WYEirEwV6DFp3jOUp4bh0HowpXax-5yA30mS_cQb1Tk,220
 aiwaf/apps.py,sha256=nCez-Ptlv2kaEk5HenA8b1pATz1VfhrHP1344gwcY1A,142
 aiwaf/blacklist_manager.py,sha256=LYCeKFB-7e_C6Bg2WeFJWFIIQlrfRMPuGp30ivrnhQY,1196
 aiwaf/decorators.py,sha256=IUKOdM_gdroffImRZep1g1wT6gNqD10zGwcp28hsJCs,825
-aiwaf/middleware.py,sha256=ThR0Bxw_VbGcOsRMIXMmQ5OMOIAy19z4SulsK7rZ_NM,32053
+aiwaf/middleware.py,sha256=Bo8xcrRugp9audWNKp2nkrfYC34E4523tgWarEdlb2A,32256
 aiwaf/middleware_logger.py,sha256=LWZVDAnjh6CGESirA8eMbhGgJKB7lVDGRQqVroH95Lo,4742
 aiwaf/models.py,sha256=vQxgY19BDVMjoO903UNrTZC1pNoLltMU6wbyWPoAEns,2719
-aiwaf/storage.py,sha256=5ImrZMRn3u7HNsPH0fDjWhDrD2tgG2IHVnOXtLz0fk4,10253
-aiwaf/trainer.py,sha256=hswkopOnEQHNkSn79AIk-OWw6zatP2EDhsBBEHQeFYw,26410
+aiwaf/storage.py,sha256=pUXE3bm7aRrABh_B6jTOBUQOYK67oQmHaR9EqyOasis,14038
+aiwaf/trainer.py,sha256=RYtSEnRKKzfwzFRX_XODbWgIqvedf4Y271DlDh5qsJE,28060
 aiwaf/utils.py,sha256=BJk5vJCYdGPl_4QQiknjhCbkzv5HZCXgFcBJDMJpHok,3390
 aiwaf/management/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 aiwaf/management/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -20,17 +20,17 @@ aiwaf/management/commands/check_dependencies.py,sha256=GOZl00pDwW2cJjDvIaCeB3yWx
 aiwaf/management/commands/clear_blacklist.py,sha256=Tisedg0EVlc3E01mA3hBZQorwMzc5j1cns-oYshja0g,2770
 aiwaf/management/commands/clear_cache.py,sha256=cdnuTgxkhKLqT_6k6yTcEBlREovNRQxAE51ceXlGYMA,647
 aiwaf/management/commands/debug_csv.py,sha256=Lddqp37mIn0zdvHf4GbuNTWYyJ5h8bumDcGmFSAioi0,6801
-aiwaf/management/commands/detect_and_train.py,sha256=-o-LZ7QZ5GeJPCekryox1DGXKMmFEkwwrcDsiM166K0,269
+aiwaf/management/commands/detect_and_train.py,sha256=ai8mUq-n9SW4_SX59Q9hE6eUvmBgb6i-IiTkCvaBe84,703
 aiwaf/management/commands/diagnose_blocking.py,sha256=HKb_FdN4b6QdyqNDf54B08I5jyWfrv9Mh-SFBrr3LbU,4140
-aiwaf/management/commands/regenerate_model.py,sha256=SUy7TCTTDJy4kRZNAbTIVBxSmljUaAC6ms0JTfSO6BE,3445
+aiwaf/management/commands/regenerate_model.py,sha256=teguV17TlkE5IiefIDOx-ow4KfKvh35vYdhsdcfMpwg,4195
 aiwaf/management/commands/setup_models.py,sha256=JzuxwAqO3e-8L4PdFlXkyEQmOA8EGCXBfaOwfCNv1Gg,1678
 aiwaf/management/commands/test_exemption.py,sha256=ENmWFMJE8iQyzJGAPdw_5PUPknLajE8JjwHgH8DCFsE,5518
 aiwaf/management/commands/test_exemption_fix.py,sha256=ngyGaHUCmQQ6y--6j4q1viZJtR-RvI526yDqvEaEXPs,2553
 aiwaf/resources/model.pkl,sha256=5t6h9BX8yoh2xct85MXOO60jdlWyg1APskUOW0jZE1Y,1288265
 aiwaf/templatetags/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 aiwaf/templatetags/aiwaf_tags.py,sha256=XXfb7Tl4DjU3Sc40GbqdaqOEtKTUKELBEk58u83wBNw,357
-aiwaf-0.1.9.2.7.dist-info/licenses/LICENSE,sha256=Ir8PX4dxgAcdB0wqNPIkw84fzIIRKE75NoUil9RX0QU,1069
-aiwaf-0.1.9.2.7.dist-info/METADATA,sha256=tT2a7bhytbNJ5nvi1X7R6-9Xef7liJYQL-G8RMM3Oa8,26824
-aiwaf-0.1.9.2.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-aiwaf-0.1.9.2.7.dist-info/top_level.txt,sha256=kU6EyjobT6UPCxuWpI_BvcHDG0I2tMgKaPlWzVxe2xI,6
-aiwaf-0.1.9.2.7.dist-info/RECORD,,
+aiwaf-0.1.9.2.9.dist-info/licenses/LICENSE,sha256=Ir8PX4dxgAcdB0wqNPIkw84fzIIRKE75NoUil9RX0QU,1069
+aiwaf-0.1.9.2.9.dist-info/METADATA,sha256=nUd5bp6VMsOJcDRK6qXQy6cO5eYGJ_arEdZhrrHft6M,27208
+aiwaf-0.1.9.2.9.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+aiwaf-0.1.9.2.9.dist-info/top_level.txt,sha256=kU6EyjobT6UPCxuWpI_BvcHDG0I2tMgKaPlWzVxe2xI,6
+aiwaf-0.1.9.2.9.dist-info/RECORD,,