aiwaf 0.1.9.0.2__py3-none-any.whl → 0.1.9.0.4__py3-none-any.whl

aiwaf/__init__.py

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

aiwaf/management/commands/debug_csv.py

@@ -0,0 +1,155 @@
+from django.core.management.base import BaseCommand
+import os
+import csv
+
+class Command(BaseCommand):
+    help = 'Debug and fix AI-WAF CSV functionality'
+
+    def add_arguments(self, parser):
+        parser.add_argument(
+            '--test-ip',
+            type=str,
+            help='Test IP address to add to exemption list',
+            default='127.0.0.1'
+        )
+        parser.add_argument(
+            '--fix',
+            action='store_true',
+            help='Attempt to fix identified issues',
+        )
+
+    def handle(self, *args, **options):
+        self.stdout.write(self.style.HTTP_INFO("🔍 AI-WAF CSV Debug & Fix"))
+        self.stdout.write("")
+        
+        # Check storage mode
+        from django.conf import settings
+        storage_mode = getattr(settings, 'AIWAF_STORAGE_MODE', 'models')
+        csv_dir = getattr(settings, 'AIWAF_CSV_DATA_DIR', 'aiwaf_data')
+        
+        self.stdout.write(f"Storage Mode: {storage_mode}")
+        self.stdout.write(f"CSV Directory: {csv_dir}")
+        self.stdout.write("")
+        
+        # Check middleware logging
+        middleware_logging = getattr(settings, 'AIWAF_MIDDLEWARE_LOGGING', False)
+        middleware_log = getattr(settings, 'AIWAF_MIDDLEWARE_LOG', 'aiwaf_requests.log')
+        
+        self.stdout.write(f"Middleware Logging: {middleware_logging}")
+        self.stdout.write(f"Middleware Log File: {middleware_log}")
+        self.stdout.write("")
+        
+        # Check if CSV directory exists
+        if os.path.exists(csv_dir):
+            self.stdout.write(self.style.SUCCESS(f"✅ CSV directory exists: {csv_dir}"))
+        else:
+            self.stdout.write(self.style.ERROR(f"❌ CSV directory missing: {csv_dir}"))
+            if options['fix']:
+                os.makedirs(csv_dir, exist_ok=True)
+                self.stdout.write(self.style.SUCCESS(f"✅ Created CSV directory: {csv_dir}"))
+        
+        # Check CSV files
+        csv_files = ['blacklist.csv', 'exemptions.csv', 'keywords.csv']
+        for filename in csv_files:
+            filepath = os.path.join(csv_dir, filename)
+            if os.path.exists(filepath):
+                # Count entries
+                try:
+                    with open(filepath, 'r', newline='', encoding='utf-8') as f:
+                        reader = csv.reader(f)
+                        rows = list(reader)
+                        entry_count = len(rows) - 1 if rows else 0  # Subtract header
+                        self.stdout.write(self.style.SUCCESS(f"✅ {filename}: {entry_count} entries"))
+                except Exception as e:
+                    self.stdout.write(self.style.ERROR(f"❌ {filename}: Error reading - {e}"))
+            else:
+                self.stdout.write(self.style.WARNING(f"⚠️  {filename}: Not found"))
+        
+        self.stdout.write("")
+        
+        # Test storage functionality
+        self.stdout.write(self.style.HTTP_INFO("🧪 Testing Storage Functions"))
+        
+        try:
+            from aiwaf.storage import get_exemption_store, get_blacklist_store, get_keyword_store
+            
+            # Test exemption store
+            exemption_store = get_exemption_store()
+            self.stdout.write(f"Exemption Store: {exemption_store.__name__}")
+            
+            # Test blacklist store
+            blacklist_store = get_blacklist_store()
+            self.stdout.write(f"Blacklist Store: {blacklist_store.__name__}")
+            
+            # Test keyword store
+            keyword_store = get_keyword_store()
+            self.stdout.write(f"Keyword Store: {keyword_store.__name__}")
+            
+        except Exception as e:
+            self.stdout.write(self.style.ERROR(f"❌ Storage import failed: {e}"))
+            return
+        
+        self.stdout.write("")
+        
+        # Test exemption functionality
+        test_ip = options['test_ip']
+        self.stdout.write(f"🧪 Testing exemption with IP: {test_ip}")
+        
+        try:
+            # Check if already exempted
+            is_exempted_before = exemption_store.is_exempted(test_ip)
+            self.stdout.write(f"Before: IP {test_ip} exempted = {is_exempted_before}")
+            
+            # Add to exemption
+            exemption_store.add_ip(test_ip, "Test exemption from debug command")
+            self.stdout.write(f"✅ Added {test_ip} to exemption list")
+            
+            # Check if now exempted
+            is_exempted_after = exemption_store.is_exempted(test_ip)
+            self.stdout.write(f"After: IP {test_ip} exempted = {is_exempted_after}")
+            
+            if is_exempted_after:
+                self.stdout.write(self.style.SUCCESS("✅ Exemption functionality working!"))
+            else:
+                self.stdout.write(self.style.ERROR("❌ Exemption functionality not working!"))
+                
+            # List all exemptions
+            all_exemptions = exemption_store.get_all()
+            self.stdout.write(f"Total exemptions: {len(all_exemptions)}")
+            
+            for exemption in all_exemptions:
+                self.stdout.write(f"  - {exemption.get('ip_address', exemption)}")
+                
+        except Exception as e:
+            self.stdout.write(self.style.ERROR(f"❌ Exemption test failed: {e}"))
+        
+        self.stdout.write("")
+        
+        # Check middleware logger file
+        csv_log_file = middleware_log.replace('.log', '.csv')
+        if os.path.exists(csv_log_file):
+            try:
+                with open(csv_log_file, 'r', newline='', encoding='utf-8') as f:
+                    reader = csv.reader(f)
+                    rows = list(reader)
+                    entry_count = len(rows) - 1 if rows else 0
+                    self.stdout.write(self.style.SUCCESS(f"✅ Middleware CSV log: {entry_count} entries"))
+            except Exception as e:
+                self.stdout.write(self.style.ERROR(f"❌ Middleware CSV log error: {e}"))
+        else:
+            self.stdout.write(self.style.WARNING(f"⚠️  Middleware CSV log not found: {csv_log_file}"))
+            self.stdout.write("   Make some requests to generate log entries")
+        
+        # Recommendations
+        self.stdout.write("")
+        self.stdout.write(self.style.HTTP_INFO("💡 Recommendations:"))
+        
+        if storage_mode != 'csv':
+            self.stdout.write("1. Set AIWAF_STORAGE_MODE = 'csv' in settings.py")
+            
+        if not middleware_logging:
+            self.stdout.write("2. Set AIWAF_MIDDLEWARE_LOGGING = True in settings.py")
+            
+        self.stdout.write("3. Add AIWAFLoggerMiddleware to MIDDLEWARE in settings.py")
+        self.stdout.write("4. Make some requests to generate log data")
+        self.stdout.write("5. Run 'python manage.py detect_and_train' to train with data")

aiwaf/management/commands/regenerate_model.py

@@ -0,0 +1,79 @@
+from django.core.management.base import BaseCommand
+import os
+import warnings
+
+class Command(BaseCommand):
+    help = 'Regenerate AI-WAF model with current scikit-learn version'
+
+    def add_arguments(self, parser):
+        parser.add_argument(
+            '--force',
+            action='store_true',
+            help='Force regeneration even if model exists',
+        )
+
+    def handle(self, *args, **options):
+        self.stdout.write(self.style.HTTP_INFO("🔄 AI-WAF Model Regeneration"))
+        self.stdout.write("")
+        
+        # Check current sklearn version
+        try:
+            import sklearn
+            self.stdout.write(f"Current scikit-learn version: {sklearn.__version__}")
+        except ImportError:
+            self.stdout.write(self.style.ERROR("❌ scikit-learn not available"))
+            self.stdout.write("Install with: pip install scikit-learn")
+            return
+        
+        # Check if model exists
+        from aiwaf.trainer import MODEL_PATH
+        model_exists = os.path.exists(MODEL_PATH)
+        
+        if model_exists and not options['force']:
+            self.stdout.write(f"Model exists at: {MODEL_PATH}")
+            
+            # Try to load and check version
+            try:
+                import joblib
+                with warnings.catch_warnings():
+                    warnings.filterwarnings("ignore", category=UserWarning, module="sklearn.base")
+                    model_data = joblib.load(MODEL_PATH)
+                    
+                if isinstance(model_data, dict) and 'sklearn_version' in model_data:
+                    stored_version = model_data['sklearn_version']
+                    if stored_version == sklearn.__version__:
+                        self.stdout.write(self.style.SUCCESS("✅ Model is up-to-date"))
+                        return
+                    else:
+                        self.stdout.write(f"⚠️  Model version mismatch:")
+                        self.stdout.write(f"   Stored: {stored_version}")
+                        self.stdout.write(f"   Current: {sklearn.__version__}")
+                else:
+                    self.stdout.write("⚠️  Legacy model format detected")
+                    
+            except Exception as e:
+                self.stdout.write(f"⚠️  Could not check model: {e}")
+            
+            self.stdout.write("")
+            self.stdout.write("Regenerating model to fix version compatibility...")
+        
+        # Regenerate model
+        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!"))
+            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("")
+            self.stdout.write(self.style.ERROR(f"❌ Model regeneration failed: {e}"))
+            self.stdout.write("")
+            self.stdout.write("Possible solutions:")
+            self.stdout.write("1. Check that you have log data available")
+            self.stdout.write("2. Verify AIWAF_ACCESS_LOG setting")
+            self.stdout.write("3. Run 'python manage.py detect_and_train' for full training")

aiwaf/middleware.py

@@ -25,7 +25,43 @@ MODEL_PATH = getattr(
     "AIWAF_MODEL_PATH",
     os.path.join(os.path.dirname(__file__), "resources", "model.pkl")
 )
-MODEL = joblib.load(MODEL_PATH)
+
+def load_model_safely():
+    """Load the AI model with version compatibility checking."""
+    import warnings
+    import sklearn
+    
+    try:
+        # Suppress sklearn version warnings temporarily
+        with warnings.catch_warnings():
+            warnings.filterwarnings("ignore", category=UserWarning, module="sklearn.base")
+            model_data = joblib.load(MODEL_PATH)
+            
+            # Handle both old format (direct model) and new format (with metadata)
+            if isinstance(model_data, dict) and 'model' in model_data:
+                # New format with metadata
+                model = model_data['model']
+                stored_version = model_data.get('sklearn_version', 'unknown')
+                current_version = sklearn.__version__
+                
+                if stored_version != 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.")
+                return model_data
+                
+    except Exception as e:
+        print(f"Warning: Could not load AI model from {MODEL_PATH}: {e}")
+        print("AI anomaly detection will be disabled until model is retrained.")
+        print("Run 'python manage.py detect_and_train' to regenerate the model.")
+        return None
+
+# Load model with safety checks
+MODEL = load_model_safely()
 
 STATIC_KW = getattr(
     settings,
@@ -130,8 +166,8 @@ class AIAnomalyMiddleware(MiddlewareMixin):
 
     def __init__(self, get_response=None):
         super().__init__(get_response)
-        model_path = os.path.join(os.path.dirname(__file__), "resources", "model.pkl")
-        self.model = joblib.load(model_path)
+        # Use the safely loaded global MODEL instead of loading again
+        self.model = MODEL
 
     def process_request(self, request):
         if is_exempt(request):
@@ -164,7 +200,9 @@ class AIAnomalyMiddleware(MiddlewareMixin):
         total_404 = sum(1 for (_, _, st, _) in data if st == 404)
         feats = [path_len, kw_hits, resp_time, status_idx, burst_count, total_404]
         X = np.array(feats, dtype=float).reshape(1, -1)
-        if self.model.predict(X)[0] == -1:
+        
+        # Only use AI model if it's available
+        if self.model is not None and self.model.predict(X)[0] == -1:
             if not is_ip_exempted(ip):
                 BlacklistManager.block(ip, "AI anomaly")
                 return JsonResponse({"error": "blocked"}, status=403)

aiwaf/middleware_logger.py

@@ -28,7 +28,11 @@ class AIWAFLoggerMiddleware(MiddlewareMixin):
     def _ensure_csv_header(self):
         """Ensure CSV file has proper header row"""
         if not os.path.exists(self.csv_file):
-            os.makedirs(os.path.dirname(self.csv_file), exist_ok=True) if os.path.dirname(self.csv_file) else None
+            # Create directory if it doesn't exist
+            csv_dir = os.path.dirname(self.csv_file)
+            if csv_dir and not os.path.exists(csv_dir):
+                os.makedirs(csv_dir, exist_ok=True)
+            
             with open(self.csv_file, 'w', newline='', encoding='utf-8') as f:
                 writer = csv.writer(f)
                 writer.writerow([
@@ -73,6 +77,11 @@ class AIWAFLoggerMiddleware(MiddlewareMixin):
     def _log_to_csv(self, data):
         """Write log entry to CSV file"""
         try:
+            # Ensure directory exists before writing
+            csv_dir = os.path.dirname(self.csv_file)
+            if csv_dir and not os.path.exists(csv_dir):
+                os.makedirs(csv_dir, exist_ok=True)
+                
             with open(self.csv_file, 'a', newline='', encoding='utf-8') as f:
                 writer = csv.writer(f)
                 writer.writerow([

aiwaf/storage.py

@@ -167,28 +167,39 @@ class CsvExemptionStore:
     @staticmethod
     def add_ip(ip_address, reason=""):
         ensure_csv_directory()
-        # Check if IP already exists
+        
+        # Check if IP already exists to avoid duplicates
         if CsvExemptionStore.is_exempted(ip_address):
             return
         
         # Add new entry
         new_file = not os.path.exists(EXEMPTION_CSV)
-        with open(EXEMPTION_CSV, "a", newline="", encoding="utf-8") as f:
-            writer = csv.writer(f)
-            if new_file:
-                writer.writerow(["ip_address", "reason", "created_at"])
-            writer.writerow([ip_address, reason, timezone.now().isoformat()])
+        try:
+            with open(EXEMPTION_CSV, "a", newline="", encoding="utf-8") as f:
+                writer = csv.writer(f)
+                if new_file:
+                    writer.writerow(["ip_address", "reason", "created_at"])
+                writer.writerow([ip_address, reason, timezone.now().isoformat()])
+        except Exception as e:
+            print(f"Error writing to exemption CSV: {e}")
+            print(f"File path: {EXEMPTION_CSV}")
+            print(f"Directory exists: {os.path.exists(CSV_DATA_DIR)}")
+            raise
     
     @staticmethod
     def is_exempted(ip_address):
         if not os.path.exists(EXEMPTION_CSV):
             return False
         
-        with open(EXEMPTION_CSV, "r", newline="", encoding="utf-8") as f:
-            reader = csv.DictReader(f)
-            for row in reader:
-                if row["ip_address"] == ip_address:
-                    return True
+        try:
+            with open(EXEMPTION_CSV, "r", newline="", encoding="utf-8") as f:
+                reader = csv.DictReader(f)
+                for row in reader:
+                    if row["ip_address"] == ip_address:
+                        return True
+        except Exception as e:
+            print(f"Error reading exemption CSV: {e}")
+            return False
         return False
     
     @staticmethod

aiwaf/trainer.py

@@ -192,11 +192,28 @@ def train() -> None:
         contamination=getattr(settings, "AIWAF_AI_CONTAMINATION", 0.05), 
         random_state=42
     )
-    model.fit(X)
+    
+    # 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)
-    joblib.dump(model, MODEL_PATH)
-    print(f"Model trained on {len(X)} samples → {MODEL_PATH}")
+    
+    # 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)

{aiwaf-0.1.9.0.2.dist-info → aiwaf-0.1.9.0.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aiwaf
-Version: 0.1.9.0.2
+Version: 0.1.9.0.4
 Summary: AI-powered Web Application Firewall
 Home-page: https://github.com/aayushgauba/aiwaf
 Author: Aayush Gauba
@@ -12,7 +12,7 @@ License-File: LICENSE
 Requires-Dist: Django>=3.2
 Requires-Dist: numpy>=1.21
 Requires-Dist: pandas>=1.3
-Requires-Dist: scikit-learn>=1.0
+Requires-Dist: scikit-learn<2.0,>=1.0
 Requires-Dist: joblib>=1.1
 Dynamic: author
 Dynamic: home-page
@@ -371,6 +371,7 @@ MIDDLEWARE = [
 
 **Common Issues:**
 - **AppRegistryNotReady Error**: Fixed in v0.1.9.0.1 - update with `pip install --upgrade aiwaf`
+- **Scikit-learn Version Warnings**: Fixed in v0.1.9.0.3 - regenerate model with `python manage.py regenerate_model`
 - Missing Django: `pip install Django`
 - Old AI-WAF version: `pip install --upgrade aiwaf`
 - Missing migrations: `python manage.py migrate`
@@ -388,6 +389,24 @@ python manage.py detect_and_train
 1. Read access logs (incl. rotated or gzipped) **OR** AI-WAF middleware CSV logs
 2. Auto‑block IPs with ≥ 6 total 404s
 3. Extract features & train IsolationForest
+4. Save `model.pkl` with current scikit-learn version
+
+### Model Regeneration
+
+If you see scikit-learn version warnings, regenerate the model:
+
+```bash
+# Quick model regeneration (recommended)
+python manage.py regenerate_model
+
+# Full retraining with fresh data
+python manage.py detect_and_train
+```
+
+**Benefits:**
+- ✅ Eliminates version compatibility warnings
+- ✅ Uses current scikit-learn optimizations
+- ✅ Maintains same protection level
 4. Save `model.pkl`
 5. Extract top 10 dynamic keywords from 4xx/5xx
 6. Remove any keywords associated with newly exempt paths

{aiwaf-0.1.9.0.2.dist-info → aiwaf-0.1.9.0.4.dist-info}/RECORD

@@ -1,12 +1,12 @@
-aiwaf/__init__.py,sha256=_efEtDv3HT5nHuYd3IpmPDtwhVdKcnrYo4EE9OC_rMU,220
+aiwaf/__init__.py,sha256=w99RK2Yc4N5TICgJLmsEL_DOiNe7LoCy5GZMkf1t_hQ,220
 aiwaf/apps.py,sha256=nCez-Ptlv2kaEk5HenA8b1pATz1VfhrHP1344gwcY1A,142
 aiwaf/blacklist_manager.py,sha256=92ltIrFfv8WOC4CXwvNVZYfivkRZHGNg3E2QAbHQipQ,550
 aiwaf/decorators.py,sha256=IUKOdM_gdroffImRZep1g1wT6gNqD10zGwcp28hsJCs,825
-aiwaf/middleware.py,sha256=1JPrc0npI_a5bnB-thN0ME1ehfTbWBl1j9wTndZwRdQ,9505
-aiwaf/middleware_logger.py,sha256=uTYTvIc4Mv1pjY50aXaqQ5cWAO9qqquijAyVMs1KWlM,6517
+aiwaf/middleware.py,sha256=fajFXsETb2kGQJzHi7cEV3bQA88yqHbZvRDPNR1y2OA,11188
+aiwaf/middleware_logger.py,sha256=v5tsiFhfdFTDBRRsfw-vfmhW2sNJx7EYRem99pgMsP0,6858
 aiwaf/models.py,sha256=XaG1pd_oZu3y-fw66u4wblGlWcUY9gvsTNKGD0kQk7Y,1672
-aiwaf/storage.py,sha256=aaszMkskRO0RZPwD2vsgP35TthI_xQEs5IxsCsxjGcw,13734
-aiwaf/trainer.py,sha256=2-8sUbXTR07fmJ3INHM6LZP_tqqT4zbv5_jrYky7DSU,9262
+aiwaf/storage.py,sha256=Gh92OCE52j9d8vjBQCoJbjA5-fsMQkdbYYypJMuZjtQ,14167
+aiwaf/trainer.py,sha256=Cem-qi1KMjfw7MFDxyxjn7nAJGPrk-I8An4HHniiT00,9877
 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
@@ -14,12 +14,14 @@ aiwaf/management/commands/add_ipexemption.py,sha256=srgdVPDJtF7G9GGIqaZ7L3qTuNhe
 aiwaf/management/commands/aiwaf_diagnose.py,sha256=nXFRhq66N4QC3e4scYJ2sUngJce-0yDxtBO3R2BllRM,6134
 aiwaf/management/commands/aiwaf_logging.py,sha256=FCIqULn2tii2vD9VxL7vk3PV4k4vr7kaA00KyaCExYY,7692
 aiwaf/management/commands/aiwaf_reset.py,sha256=0FIBqpZS8xgFFvAKJ-0zAC_-QNQwRkOHpXb8N-OdFr8,3740
+aiwaf/management/commands/debug_csv.py,sha256=Vp55g1qWAuRUuAHoz56nuPxMrcccFCHKRGeYyui8Pxw,6794
 aiwaf/management/commands/detect_and_train.py,sha256=-o-LZ7QZ5GeJPCekryox1DGXKMmFEkwwrcDsiM166K0,269
+aiwaf/management/commands/regenerate_model.py,sha256=SUy7TCTTDJy4kRZNAbTIVBxSmljUaAC6ms0JTfSO6BE,3445
 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.0.2.dist-info/licenses/LICENSE,sha256=Ir8PX4dxgAcdB0wqNPIkw84fzIIRKE75NoUil9RX0QU,1069
-aiwaf-0.1.9.0.2.dist-info/METADATA,sha256=N5kAt8giKmurCaiXuwBTqSXNvlT77uOTE0a90AnXRr0,13002
-aiwaf-0.1.9.0.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-aiwaf-0.1.9.0.2.dist-info/top_level.txt,sha256=kU6EyjobT6UPCxuWpI_BvcHDG0I2tMgKaPlWzVxe2xI,6
-aiwaf-0.1.9.0.2.dist-info/RECORD,,
+aiwaf-0.1.9.0.4.dist-info/licenses/LICENSE,sha256=Ir8PX4dxgAcdB0wqNPIkw84fzIIRKE75NoUil9RX0QU,1069
+aiwaf-0.1.9.0.4.dist-info/METADATA,sha256=PtBnfHANxkOI4buUl8kQqglCgzXjGR2dtC6IZdJSEKc,13571
+aiwaf-0.1.9.0.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+aiwaf-0.1.9.0.4.dist-info/top_level.txt,sha256=kU6EyjobT6UPCxuWpI_BvcHDG0I2tMgKaPlWzVxe2xI,6
+aiwaf-0.1.9.0.4.dist-info/RECORD,,