aiwaf 0.1.9.1.3__py3-none-any.whl → 0.1.9.1.5__py3-none-any.whl

aiwaf/__init__.py

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

aiwaf/management/commands/check_dependencies.py

@@ -30,6 +30,21 @@ class Command(BaseCommand):
             default=True,
             help='Check for package compatibility issues (default: True)'
         )
+        parser.add_argument(
+            '--upgrade',
+            action='store_true',
+            help='Automatically upgrade packages while maintaining stability'
+        )
+        parser.add_argument(
+            '--dry-run',
+            action='store_true',
+            help='Show what would be upgraded without actually upgrading'
+        )
+        parser.add_argument(
+            '--update-requirements',
+            action='store_true',
+            help='Update requirements.txt with upgraded package versions'
+        )
 
     def handle(self, *args, **options):
         self.stdout.write(self.style.SUCCESS('🔍 Checking project dependencies...\n'))
@@ -50,6 +65,12 @@ class Command(BaseCommand):
             if options['check_compatibility']:
                 self.check_compatibility(results)
             
+            if options['upgrade']:
+                upgraded_packages = self.perform_safe_upgrade(results, options['dry_run'])
+                
+                if options['update_requirements'] and upgraded_packages and not options['dry_run']:
+                    self.update_requirements_file(upgraded_packages)
+            
             if options['check_security']:
                 self.check_security_vulnerabilities(dependencies)
                 
@@ -338,18 +359,6 @@ class Command(BaseCommand):
                         'severity': 'error'
                     }
                 ]
-            },
-            {
-                'package': 'django',
-                'conflicts_with': [
-                    {
-                        'package': 'pandas',
-                        'django_versions': '>=4.0',
-                        'pandas_versions': '<1.3',
-                        'message': 'Django 4.0+ works better with pandas 1.3+',
-                        'severity': 'warning'
-                    }
-                ]
             }
         ]
 
@@ -433,6 +442,359 @@ class Command(BaseCommand):
         
         return conflicts
 
+    def perform_safe_upgrade(self, results, dry_run=False):
+        """Perform safe package upgrades while maintaining AIWAF compatibility"""
+        self.stdout.write(self.style.HTTP_INFO("\n🔄 Planning safe package upgrades..."))
+        
+        # AIWAF compatibility constraints
+        aiwaf_constraints = self.get_aiwaf_compatibility_constraints()
+        
+        # Get packages that can be safely upgraded
+        safe_upgrades = []
+        blocked_upgrades = []
+        upgraded_packages = []  # Track successfully upgraded packages
+        
+        for pkg in results:
+            if pkg['status'] == 'outdated' and pkg['name'].lower() != 'aiwaf':
+                upgrade_plan = self.plan_safe_upgrade(pkg, aiwaf_constraints, results)
+                if upgrade_plan['safe']:
+                    safe_upgrades.append(upgrade_plan)
+                else:
+                    blocked_upgrades.append(upgrade_plan)
+        
+        # Display upgrade plan
+        if safe_upgrades:
+            self.stdout.write(self.style.SUCCESS("\n✅ SAFE UPGRADES PLANNED:"))
+            self.stdout.write("─" * 80)
+            for upgrade in safe_upgrades:
+                pkg = upgrade['package']
+                target_version = upgrade['target_version']
+                self.stdout.write(
+                    f"📦 {pkg['name']:<20} {pkg['installed']:<12} → {target_version:<12} "
+                    f"(Latest: {pkg['latest']})"
+                )
+                if upgrade['reason']:
+                    self.stdout.write(f"   💡 {upgrade['reason']}")
+        
+        if blocked_upgrades:
+            self.stdout.write(self.style.WARNING("\n⚠️  UPGRADES BLOCKED FOR STABILITY:"))
+            self.stdout.write("─" * 80)
+            for upgrade in blocked_upgrades:
+                pkg = upgrade['package']
+                self.stdout.write(
+                    f"❌ {pkg['name']:<20} {pkg['installed']:<12} ✗ {pkg['latest']:<12}"
+                )
+                self.stdout.write(f"   🚨 {upgrade['reason']}")
+        
+        if not safe_upgrades:
+            self.stdout.write(self.style.NOTICE("ℹ️  No safe upgrades available at this time."))
+            return []
+        
+        # Execute upgrades
+        if dry_run:
+            self.stdout.write(self.style.NOTICE("\n🏃 DRY RUN MODE - No packages will be upgraded"))
+            upgrade_cmd = "pip install --upgrade " + " ".join([
+                f"{u['package']['name']}=={u['target_version']}" if u['target_version'] != u['package']['latest'] 
+                else u['package']['name'] 
+                for u in safe_upgrades
+            ])
+            self.stdout.write(f"Command that would be executed:\n   {upgrade_cmd}")
+            return []
+            return []
+        else:
+            self.stdout.write(self.style.HTTP_INFO("\n🚀 Executing safe upgrades..."))
+            success_count = 0
+            
+            for upgrade in safe_upgrades:
+                pkg_name = upgrade['package']['name']
+                target_version = upgrade['target_version']
+                
+                try:
+                    if target_version == upgrade['package']['latest']:
+                        cmd = ['pip', 'install', '--upgrade', pkg_name]
+                    else:
+                        cmd = ['pip', 'install', f"{pkg_name}=={target_version}"]
+                    
+                    self.stdout.write(f"   Upgrading {pkg_name}...")
+                    result = subprocess.run(cmd, capture_output=True, text=True, timeout=300)
+                    
+                    if result.returncode == 0:
+                        self.stdout.write(self.style.SUCCESS(f"   ✅ {pkg_name} upgraded successfully"))
+                        success_count += 1
+                        upgraded_packages.append({
+                            'name': pkg_name,
+                            'old_version': upgrade['package']['installed'],
+                            'new_version': target_version
+                        })
+                    else:
+                        self.stdout.write(self.style.ERROR(f"   ❌ Failed to upgrade {pkg_name}: {result.stderr}"))
+                
+                except subprocess.TimeoutExpired:
+                    self.stdout.write(self.style.ERROR(f"   ❌ Timeout upgrading {pkg_name}"))
+                except Exception as e:
+                    self.stdout.write(self.style.ERROR(f"   ❌ Error upgrading {pkg_name}: {e}"))
+            
+            self.stdout.write(f"\n🎉 Upgrade complete: {success_count}/{len(safe_upgrades)} packages upgraded successfully")
+            
+            if success_count > 0:
+                self.stdout.write(self.style.HTTP_INFO("\n💡 Recommendations after upgrade:"))
+                self.stdout.write("   1. Run tests to ensure everything works correctly")
+                self.stdout.write("   2. Run 'python manage.py check_dependencies' again to verify")
+                self.stdout.write("   3. Consider running 'python manage.py detect_and_train' to retrain with new packages")
+            
+            return upgraded_packages
+
+    def get_aiwaf_compatibility_constraints(self):
+        """Get AIWAF's compatibility constraints to ensure stability"""
+        return {
+            'django': {
+                'min_version': '3.2',
+                'max_version': '99.0',  # AIWAF works with all Django versions
+                'reason': 'AIWAF is compatible with Django 3.2+'
+            },
+            'numpy': {
+                'min_version': '1.21',
+                'max_version': '1.99.99',  # Avoid NumPy 2.0 breaking changes
+                'reason': 'NumPy 2.0+ may cause compatibility issues'
+            },
+            'pandas': {
+                'min_version': '1.3',
+                'max_version': '2.9.99',
+                'reason': 'AIWAF tested with pandas 1.3-2.x series'
+            },
+            'scikit-learn': {
+                'min_version': '1.0',
+                'max_version': '1.99.99',  # Stay in 1.x series
+                'reason': 'AIWAF models trained with scikit-learn 1.x'
+            },
+            'joblib': {
+                'min_version': '1.1',
+                'max_version': '1.99.99',
+                'reason': 'AIWAF compatible with joblib 1.x series'
+            },
+            'packaging': {
+                'min_version': '21.0',
+                'max_version': '99.0',
+                'reason': 'Required for dependency checking'
+            },
+            'requests': {
+                'min_version': '2.25.0',
+                'max_version': '2.99.99',
+                'reason': 'Required for PyPI API access'
+            }
+        }
+
+    def plan_safe_upgrade(self, pkg, aiwaf_constraints, all_results):
+        """Plan a safe upgrade for a package considering AIWAF compatibility"""
+        pkg_name = pkg['name'].lower()
+        current_version = pkg['installed']
+        latest_version = pkg['latest']
+        
+        # Skip AIWAF itself
+        if pkg_name == 'aiwaf':
+            return {
+                'package': pkg,
+                'safe': False,
+                'target_version': None,
+                'reason': 'AIWAF should be upgraded separately using pip install --upgrade aiwaf'
+            }
+        
+        # Check AIWAF constraints
+        if pkg_name in aiwaf_constraints:
+            constraint = aiwaf_constraints[pkg_name]
+            max_version = constraint['max_version']
+            
+            try:
+                if version.parse(latest_version) > version.parse(max_version):
+                    # Find the highest safe version
+                    safe_version = self.find_highest_safe_version(pkg_name, max_version)
+                    if safe_version and version.parse(safe_version) > version.parse(current_version):
+                        return {
+                            'package': pkg,
+                            'safe': True,
+                            'target_version': safe_version,
+                            'reason': f'Upgraded to latest safe version (AIWAF constraint: <={max_version})'
+                        }
+                    else:
+                        return {
+                            'package': pkg,
+                            'safe': False,
+                            'target_version': None,
+                            'reason': f'{constraint["reason"]} (max safe: {max_version})'
+                        }
+                else:
+                    # Latest version is within AIWAF constraints
+                    # Check for other compatibility issues
+                    compatibility_check = self.check_upgrade_compatibility(pkg, latest_version, all_results)
+                    if compatibility_check['safe']:
+                        return {
+                            'package': pkg,
+                            'safe': True,
+                            'target_version': latest_version,
+                            'reason': 'Safe to upgrade to latest version'
+                        }
+                    else:
+                        return {
+                            'package': pkg,
+                            'safe': False,
+                            'target_version': None,
+                            'reason': compatibility_check['reason']
+                        }
+            except Exception as e:
+                return {
+                    'package': pkg,
+                    'safe': False,
+                    'target_version': None,
+                    'reason': f'Version parsing error: {e}'
+                }
+        else:
+            # No specific AIWAF constraints, check general compatibility
+            compatibility_check = self.check_upgrade_compatibility(pkg, latest_version, all_results)
+            return {
+                'package': pkg,
+                'safe': compatibility_check['safe'],
+                'target_version': latest_version if compatibility_check['safe'] else None,
+                'reason': compatibility_check['reason'] if not compatibility_check['safe'] else 'No known compatibility issues'
+            }
+
+    def find_highest_safe_version(self, package_name, max_version):
+        """Find the highest version that's still within constraints"""
+        try:
+            response = requests.get(f'https://pypi.org/pypi/{package_name}/json', timeout=10)
+            if response.status_code == 200:
+                data = response.json()
+                releases = data.get('releases', {})
+                
+                safe_versions = []
+                for ver in releases.keys():
+                    try:
+                        if version.parse(ver) <= version.parse(max_version):
+                            safe_versions.append(ver)
+                    except:
+                        continue
+                
+                if safe_versions:
+                    # Sort and return the highest safe version
+                    safe_versions.sort(key=lambda x: version.parse(x), reverse=True)
+                    return safe_versions[0]
+        except Exception:
+            pass
+        return None
+
+    def check_upgrade_compatibility(self, pkg, target_version, all_results):
+        """Check if upgrading a package to target version would cause conflicts"""
+        pkg_name = pkg['name'].lower()
+        
+        # Known problematic upgrade scenarios
+        if pkg_name == 'numpy' and version.parse(target_version) >= version.parse('2.0.0'):
+            # Check if pandas is compatible with NumPy 2.0
+            pandas_pkg = next((p for p in all_results if p['name'].lower() == 'pandas'), None)
+            if pandas_pkg and pandas_pkg['status'] != 'not_installed':
+                pandas_version = pandas_pkg['installed']
+                if version.parse(pandas_version) < version.parse('2.1.0'):
+                    return {
+                        'safe': False,
+                        'reason': f'NumPy 2.0+ requires pandas 2.1+, but pandas {pandas_version} is installed'
+                    }
+        
+        if pkg_name == 'pandas' and version.parse(target_version) >= version.parse('2.0.0'):
+            # Check if NumPy is compatible
+            numpy_pkg = next((p for p in all_results if p['name'].lower() == 'numpy'), None)
+            if numpy_pkg and numpy_pkg['status'] != 'not_installed':
+                numpy_version = numpy_pkg['installed']
+                if version.parse(numpy_version) < version.parse('1.22.0'):
+                    return {
+                        'safe': False,
+                        'reason': f'pandas 2.0+ requires NumPy 1.22+, but NumPy {numpy_version} is installed'
+                    }
+        
+        return {'safe': True, 'reason': 'No compatibility issues detected'}
+
+    def update_requirements_file(self, upgraded_packages):
+        """Update requirements.txt with new package versions"""
+        self.stdout.write(self.style.HTTP_INFO("\n📝 Updating requirements.txt..."))
+        
+        requirements_path = os.path.join(settings.BASE_DIR, 'requirements.txt')
+        
+        if not os.path.exists(requirements_path):
+            self.stdout.write(self.style.WARNING(f"   ⚠️  requirements.txt not found at {requirements_path}"))
+            self.stdout.write("   💡 You can create one manually with updated versions")
+            return
+        
+        try:
+            # Read current requirements.txt
+            with open(requirements_path, 'r') as f:
+                lines = f.readlines()
+            
+            # Create backup
+            backup_path = requirements_path + '.backup'
+            with open(backup_path, 'w') as f:
+                f.writelines(lines)
+            self.stdout.write(f"   📋 Backup created: {backup_path}")
+            
+            # Update lines with new versions
+            updated_lines = []
+            updated_count = 0
+            
+            for line in lines:
+                original_line = line.strip()
+                updated_line = line
+                
+                if original_line and not original_line.startswith('#'):
+                    # Check if this line contains an upgraded package
+                    for pkg in upgraded_packages:
+                        pkg_name = pkg['name']
+                        new_version = pkg['new_version']
+                        
+                        # Check various formats: package>=version, package==version, etc.
+                        if self.line_contains_package(original_line, pkg_name):
+                            # Update the line with new version
+                            updated_line = self.update_package_line(original_line, pkg_name, new_version)
+                            if updated_line != original_line:
+                                updated_count += 1
+                                self.stdout.write(f"   📦 {pkg_name}: {original_line} → {updated_line.strip()}")
+                            break
+                
+                updated_lines.append(updated_line)
+            
+            # Write updated requirements.txt
+            with open(requirements_path, 'w') as f:
+                f.writelines(updated_lines)
+            
+            if updated_count > 0:
+                self.stdout.write(self.style.SUCCESS(f"\n   ✅ Updated {updated_count} packages in requirements.txt"))
+                self.stdout.write(f"   💾 Original backed up as: {backup_path}")
+            else:
+                self.stdout.write(self.style.NOTICE("   ℹ️  No package lines found to update in requirements.txt"))
+                
+        except Exception as e:
+            self.stdout.write(self.style.ERROR(f"   ❌ Error updating requirements.txt: {e}"))
+
+    def line_contains_package(self, line, package_name):
+        """Check if a requirements line contains the specified package"""
+        # Remove comments and whitespace
+        line = line.split('#')[0].strip()
+        if not line:
+            return False
+        
+        # Check if line starts with package name followed by version specifier
+        return (line.lower().startswith(package_name.lower()) and 
+                len(line) > len(package_name) and 
+                line[len(package_name)] in ['=', '<', '>', '!', '~', ' ', '\t'])
+
+    def update_package_line(self, line, package_name, new_version):
+        """Update a requirements line with new package version"""
+        # Split line into package part and comment part
+        parts = line.split('#', 1)
+        package_part = parts[0].strip()
+        comment_part = f" #{parts[1]}" if len(parts) > 1 else ""
+        
+        # Extract package name and update with new version
+        # Use >= to allow for future compatible versions
+        updated_package = f"{package_name}>={new_version}"
+        
+        return updated_package + comment_part + '\n'
+
     def check_security_vulnerabilities(self, dependencies):
         """Check for known security vulnerabilities using safety"""
         self.stdout.write(self.style.HTTP_INFO("\n🔒 Checking for security vulnerabilities..."))

{aiwaf-0.1.9.1.3.dist-info → aiwaf-0.1.9.1.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aiwaf
-Version: 0.1.9.1.3
+Version: 0.1.9.1.5
 Summary: AI-powered Web Application Firewall
 Home-page: https://github.com/aayushgauba/aiwaf
 Author: Aayush Gauba
@@ -123,6 +123,9 @@ aiwaf/
   - **Missing dependency** detection
   - **Security vulnerability** scanning
   - **Smart upgrade suggestions** with compatibility validation
+  - **Safe automated upgrades** that preserve AIWAF stability
+  - **Dry run mode** for testing upgrade plans
+  - **Cross-package dependency** analysis and conflict resolution
 
 
 **Exempt Path & IP Awareness**
@@ -222,14 +225,51 @@ python manage.py check_dependencies --format json
 
 # Include security vulnerability scanning
 python manage.py check_dependencies --check-security
+
+# Dry run - show what would be upgraded
+python manage.py check_dependencies --upgrade --dry-run
+
+# Actually upgrade packages safely
+python manage.py check_dependencies --upgrade
+
+# Upgrade packages and update requirements.txt
+python manage.py check_dependencies --upgrade --update-requirements
+
+# Full workflow: check, upgrade, and scan for vulnerabilities
+python manage.py check_dependencies --upgrade --check-security --update-requirements
 ```
 
-**Features:**
+**Core Features:**
 - ✅ **Parses pyproject.toml and requirements.txt**
 - ✅ **Shows current vs latest versions** 
 - ✅ **Checks package compatibility** (NumPy 2.0 vs pandas, etc.)
 - ✅ **Detects missing dependencies**
 - ✅ **Security vulnerability scanning** (requires `safety` package)
+- ✅ **Safe package upgrades** (maintains AIWAF stability)
+- ✅ **Dry run mode** for testing upgrade plans
+- ✅ **AIWAF compatibility validation**
+- ✅ **Automatic requirements.txt updates** after successful upgrades
+
+**Safe Upgrade System:**
+
+The upgrade system is designed to maintain AIWAF stability while keeping your packages up to date:
+
+| Protection Level | Description | Example |
+|------------------|-------------|---------|
+| 🛡️ **AIWAF Core** | Never upgrades AIWAF itself | Skips `aiwaf` package |
+| 🔒 **Breaking Changes** | Avoids known problematic versions | Blocks NumPy 2.0+ |
+| 🧠 **Smart Constraints** | Respects AIWAF compatibility matrix | pandas ≤ 2.9.99 |
+| 🔍 **Dependency Analysis** | Checks cross-package compatibility | NumPy vs pandas versions |
+
+**AIWAF Compatibility Matrix:**
+
+| Package | Safe Range | Blocked Versions | Reason |
+|---------|------------|------------------|---------|
+| Django | 3.2+ | None | AIWAF compatible with all Django versions |
+| NumPy | 1.21 - 1.99 | 2.0+ | Avoid breaking changes |
+| pandas | 1.3 - 2.9 | 3.0+ | AIWAF compatibility |
+| scikit-learn | 1.0 - 1.99 | 2.0+ | Model compatibility |
+| joblib | 1.1 - 1.99 | 2.0+ | AIWAF tested range |
 - ✅ **Provides upgrade commands**
 
 **Example Output:**
@@ -249,10 +289,79 @@ python manage.py check_dependencies --check-security
 🔍 Checking package compatibility...
 ✅ All packages appear to be compatible!
 
-💡 To update outdated packages, run:
-   pip install --upgrade pandas numpy
+� Planning safe package upgrades...
+
+✅ SAFE UPGRADES PLANNED:
+────────────────────────────────────────
+📦 pandas              1.3.5        → 1.5.3        (Latest: 2.2.2)
+   💡 Upgraded to latest safe version (AIWAF constraint: <=1.99.99)
+📦 joblib              1.1.0        → 1.4.2        (Latest: 1.4.2)
+   💡 Safe to upgrade to latest version
+
+⚠️  UPGRADES BLOCKED FOR STABILITY:
+────────────────────────────────────────
+❌ numpy               1.21.0       ✗ 2.0.1
+   🚨 NumPy 2.0+ may cause compatibility issues (max safe: 1.99.99)
+
+🎉 Upgrade complete: 2/2 packages upgraded successfully
+
+📝 Updating requirements.txt...
+   📋 Backup created: requirements.txt.backup
+   📦 pandas: pandas>=1.3 → pandas>=1.5.3
+   📦 joblib: joblib>=1.1 → joblib>=1.4.2
+   ✅ Updated 2 packages in requirements.txt
+   💾 Original backed up as: requirements.txt.backup
+
+�💡 To update outdated packages, run:
+   pip install --upgrade pandas==1.5.3 joblib
 ```
 
+**Safe Upgrade System:**
+- 🛡️ **AIWAF Protection**: Never breaks AIWAF functionality
+- 🔍 **Compatibility Validation**: Checks package interdependencies  
+- 📊 **Conservative Constraints**: Avoids known problematic versions
+- 🧪 **Dry Run Mode**: Test upgrade plans before execution
+- ⚠️ **Clear Blocking Reasons**: Explains why upgrades are blocked
+- 📝 **Requirements.txt Updates**: Automatically updates dependency files
+
+**Recommended Upgrade Workflow:**
+
+1. **Check current status:**
+   ```bash
+   python manage.py check_dependencies
+   ```
+
+2. **Preview safe upgrades:**
+   ```bash
+   python manage.py check_dependencies --upgrade --dry-run
+   ```
+
+3. **Execute safe upgrades:**
+   ```bash
+   python manage.py check_dependencies --upgrade --update-requirements
+   ```
+
+4. **Verify after upgrade:**
+   ```bash
+   python manage.py check_dependencies
+   python manage.py detect_and_train  # Retrain with new packages
+   ```
+
+5. **Test your application:**
+   ```bash
+   python manage.py test  # Run your test suite
+   ```
+
+**Upgrade Decision Logic:**
+
+The system uses a multi-layer decision process:
+
+- **Layer 1**: Skip AIWAF itself (manual upgrade recommended)
+- **Layer 2**: Check AIWAF compatibility constraints
+- **Layer 3**: Analyze cross-package dependencies  
+- **Layer 4**: Select highest safe version within constraints
+- **Layer 5**: Execute with error handling and rollback capability
+
 This will ensure the IP is never blocked by AI‑WAF. You can also manage exemptions via the Django admin interface.
 
 - **Daily Retraining**  
@@ -444,6 +553,68 @@ MIDDLEWARE = [
 - Missing migrations: `python manage.py migrate`
 - Import errors: Check `INSTALLED_APPS` includes `'aiwaf'`
 
+### **Dependency Upgrade Troubleshooting**
+
+**Common Upgrade Scenarios:**
+
+1. **NumPy 2.0 Upgrade Blocked:**
+   ```bash
+   # Check pandas compatibility first
+   python manage.py check_dependencies --upgrade --dry-run
+   
+   # If pandas < 2.1, upgrade pandas first
+   pip install 'pandas>=2.1,<3.0'
+   
+   # Then allow NumPy upgrade
+   python manage.py check_dependencies --upgrade
+   ```
+
+2. **All Upgrades Blocked:**
+   ```bash
+   # Check what's blocking upgrades
+   python manage.py check_dependencies --upgrade --dry-run
+   
+   # Manual override (use with caution)
+   pip install --upgrade package-name
+   
+   # Verify AIWAF still works
+   python manage.py detect_and_train
+   ```
+
+3. **Package Conflict After Upgrade:**
+   ```bash
+   # Check current compatibility
+   python manage.py check_dependencies
+   
+   # Downgrade to last known good version
+   pip install package-name==previous-version
+   
+   # Find safe upgrade path
+   python manage.py check_dependencies --upgrade --dry-run
+   ```
+
+4. **AIWAF Model Issues After Upgrade:**
+   ```bash
+   # Regenerate model with new package versions
+   python manage.py regenerate_model
+   
+   # Retrain with current environment
+   python manage.py detect_and_train
+   ```
+
+**Emergency Rollback:**
+If an upgrade breaks your system:
+```bash
+# Reinstall exact previous versions
+pip install package-name==old-version
+
+# Or use requirements.txt backup
+pip install -r requirements.txt.backup
+
+# Verify AIWAF functionality
+python manage.py aiwaf_diagnose
+```
+
 ---
 
 ##  Running Detection & Training

{aiwaf-0.1.9.1.3.dist-info → aiwaf-0.1.9.1.5.dist-info}/RECORD

@@ -1,4 +1,4 @@
-aiwaf/__init__.py,sha256=vIH1m7iiywRvUB5Q4Lj6MFEkqDOZLB1N5nFPgaV4erg,220
+aiwaf/__init__.py,sha256=XpqePdxlyW-5RJkAUTNtlGeSUYFl7vaRQ6JrnHU1W-Y,220
 aiwaf/apps.py,sha256=nCez-Ptlv2kaEk5HenA8b1pATz1VfhrHP1344gwcY1A,142
 aiwaf/blacklist_manager.py,sha256=LYCeKFB-7e_C6Bg2WeFJWFIIQlrfRMPuGp30ivrnhQY,1196
 aiwaf/decorators.py,sha256=IUKOdM_gdroffImRZep1g1wT6gNqD10zGwcp28hsJCs,825
@@ -15,7 +15,7 @@ aiwaf/management/commands/add_ipexemption.py,sha256=sSf3d9hGK9RqqlBYkCrnrd8KZWGT
 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/check_dependencies.py,sha256=3PFQ6ut3-_I8_P6pfCR9EiSu_lkerJEbAomZoIdSJVs,18978
+aiwaf/management/commands/check_dependencies.py,sha256=pxON6cFrBTWtNRzPOzB_S4Jdld1G6q1O_ds3xtbjq8Y,36134
 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
@@ -27,8 +27,8 @@ aiwaf/management/commands/test_exemption_fix.py,sha256=ngyGaHUCmQQ6y--6j4q1viZJt
 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.1.3.dist-info/licenses/LICENSE,sha256=Ir8PX4dxgAcdB0wqNPIkw84fzIIRKE75NoUil9RX0QU,1069
-aiwaf-0.1.9.1.3.dist-info/METADATA,sha256=3ZoV9qFe4ipGDy9GVFueua_-CuXSbHHRD_XXEGksb0c,16044
-aiwaf-0.1.9.1.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-aiwaf-0.1.9.1.3.dist-info/top_level.txt,sha256=kU6EyjobT6UPCxuWpI_BvcHDG0I2tMgKaPlWzVxe2xI,6
-aiwaf-0.1.9.1.3.dist-info/RECORD,,
+aiwaf-0.1.9.1.5.dist-info/licenses/LICENSE,sha256=Ir8PX4dxgAcdB0wqNPIkw84fzIIRKE75NoUil9RX0QU,1069
+aiwaf-0.1.9.1.5.dist-info/METADATA,sha256=7hXUI5PEFAGOTugMBbECEz1SgMHbb8NEnYt_Alg4yFM,21873
+aiwaf-0.1.9.1.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+aiwaf-0.1.9.1.5.dist-info/top_level.txt,sha256=kU6EyjobT6UPCxuWpI_BvcHDG0I2tMgKaPlWzVxe2xI,6
+aiwaf-0.1.9.1.5.dist-info/RECORD,,