gitflow-analytics 1.0.3__py3-none-any.whl → 1.3.11__py3-none-any.whl

gitflow_analytics/qualitative/classifiers/risk_analyzer.py

@@ -1,95 +1,120 @@
 """Risk analyzer for assessing commit risk levels."""
 
+import importlib.util
 import logging
 import re
-from typing import Dict, List, Any, Set
-from pathlib import Path
+from typing import Any
 
 from ..models.schemas import RiskConfig
 
-try:
-    import spacy
+# Check if spacy is available without importing it
+SPACY_AVAILABLE = importlib.util.find_spec("spacy") is not None
+
+if SPACY_AVAILABLE:
     from spacy.tokens import Doc
-    SPACY_AVAILABLE = True
-except ImportError:
-    SPACY_AVAILABLE = False
+else:
     Doc = Any
 
 
 class RiskAnalyzer:
     """Analyze commits to assess risk level and identify risk factors.
-    
+
     This analyzer evaluates multiple dimensions of risk:
     - Content risk: Security-sensitive keywords, critical system changes
     - Size risk: Large commits affecting many files/lines
     - Context risk: Production deployments, emergency fixes
     - Pattern risk: File patterns indicating high-risk areas
-    
+
     Risk levels: low, medium, high, critical
     """
-    
+
     def __init__(self, config: RiskConfig):
         """Initialize risk analyzer.
-        
+
         Args:
             config: Configuration for risk analysis
         """
         self.config = config
         self.logger = logging.getLogger(__name__)
-        
+
         # Compile file risk patterns for efficiency
         self._compile_file_patterns()
-        
+
         # Additional risk patterns not in config
         self.critical_keywords = {
-            'password', 'secret', 'key', 'token', 'credential', 'auth',
-            'admin', 'root', 'sudo', 'permission', 'access', 'security'
+            "password",
+            "secret",
+            "key",
+            "token",
+            "credential",
+            "auth",
+            "admin",
+            "root",
+            "sudo",
+            "permission",
+            "access",
+            "security",
         }
-        
+
         self.production_keywords = {
-            'production', 'prod', 'live', 'release', 'deploy', 'deployment',
-            'critical', 'urgent', 'emergency', 'hotfix', 'immediate'
+            "production",
+            "prod",
+            "live",
+            "release",
+            "deploy",
+            "deployment",
+            "critical",
+            "urgent",
+            "emergency",
+            "hotfix",
+            "immediate",
         }
-        
+
         self.database_keywords = {
-            'database', 'db', 'migration', 'schema', 'table', 'column',
-            'index', 'constraint', 'trigger', 'procedure'
+            "database",
+            "db",
+            "migration",
+            "schema",
+            "table",
+            "column",
+            "index",
+            "constraint",
+            "trigger",
+            "procedure",
         }
-        
+
         # File extension risk mapping
         self.extension_risk = {
             # High risk extensions
-            '.sql': 'high',
-            '.py': 'medium',  # Could be config or critical logic
-            '.js': 'medium',
-            '.php': 'medium',
-            '.java': 'medium',
-            '.cs': 'medium',
-            '.go': 'medium',
-            '.rb': 'medium',
-            
+            ".sql": "high",
+            ".py": "medium",  # Could be config or critical logic
+            ".js": "medium",
+            ".php": "medium",
+            ".java": "medium",
+            ".cs": "medium",
+            ".go": "medium",
+            ".rb": "medium",
             # Configuration files
-            '.yml': 'medium',
-            '.yaml': 'medium', 
-            '.json': 'medium',
-            '.toml': 'medium',
-            '.ini': 'medium',
-            '.conf': 'medium',
-            '.config': 'medium',
-            
+            ".yml": "medium",
+            ".yaml": "medium",
+            ".json": "medium",
+            ".toml": "medium",
+            ".ini": "medium",
+            ".conf": "medium",
+            ".config": "medium",
             # Low risk extensions
-            '.md': 'low',
-            '.txt': 'low',
-            '.rst': 'low',
-            '.css': 'low',
-            '.scss': 'low',
-            '.less': 'low',
+            ".md": "low",
+            ".txt": "low",
+            ".rst": "low",
+            ".css": "low",
+            ".scss": "low",
+            ".less": "low",
         }
-        
+
     def _compile_file_patterns(self) -> None:
         """Compile file risk patterns for efficient matching."""
         self.compiled_file_patterns = {}
-        
+
         for pattern, risk_level in self.config.file_risk_patterns.items():
             try:
                 # Convert glob pattern to regex
@@ -97,316 +122,317 @@ class RiskAnalyzer:
                 self.compiled_file_patterns[re.compile(regex_pattern, re.IGNORECASE)] = risk_level
             except re.error as e:
                 self.logger.warning(f"Invalid risk pattern '{pattern}': {e}")
-                
+
     def _glob_to_regex(self, pattern: str) -> str:
         """Convert glob pattern to regex."""
-        pattern = pattern.replace('.', r'\.')
-        pattern = pattern.replace('*', '.*')
-        pattern = pattern.replace('?', '.')
-        pattern = f'^{pattern}$'
+        pattern = pattern.replace(".", r"\.")
+        pattern = pattern.replace("*", ".*")
+        pattern = pattern.replace("?", ".")
+        pattern = f"^{pattern}$"
         return pattern
-        
-    def assess(self, commit: Dict[str, Any], doc: Doc) -> Dict[str, Any]:
+
+    def assess(self, commit: dict[str, Any], doc: Doc) -> dict[str, Any]:
         """Assess risk level and identify risk factors for a commit.
-        
+
         Args:
             commit: Commit dictionary with message, files, stats, etc.
             doc: spaCy processed document (may be None)
-            
-        Returns:     
+
+        Returns:
             Dictionary with 'level' and 'factors' keys
         """
         risk_factors = []
         risk_scores = []
-        
+
         # Analyze message content for risk keywords
-        message_risk = self._analyze_message_risk(commit.get('message', ''), doc)
-        risk_factors.extend(message_risk['factors'])
-        risk_scores.append(message_risk['score'])
-        
+        message_risk = self._analyze_message_risk(commit.get("message", ""), doc)
+        risk_factors.extend(message_risk["factors"])
+        risk_scores.append(message_risk["score"])
+
         # Analyze file patterns for risk
-        file_risk = self._analyze_file_risk(commit.get('files_changed', []))
-        risk_factors.extend(file_risk['factors'])
-        risk_scores.append(file_risk['score'])
-        
+        file_risk = self._analyze_file_risk(commit.get("files_changed", []))
+        risk_factors.extend(file_risk["factors"])
+        risk_scores.append(file_risk["score"])
+
         # Analyze commit size for risk
         size_risk = self._analyze_size_risk(commit)
-        risk_factors.extend(size_risk['factors'])
-        risk_scores.append(size_risk['score'])
-        
+        risk_factors.extend(size_risk["factors"])
+        risk_scores.append(size_risk["score"])
+
         # Analyze timing and context
         context_risk = self._analyze_context_risk(commit)
-        risk_factors.extend(context_risk['factors'])
-        risk_scores.append(context_risk['score'])
-        
+        risk_factors.extend(context_risk["factors"])
+        risk_scores.append(context_risk["score"])
+
         # Calculate overall risk level
         max_risk_score = max(risk_scores) if risk_scores else 0.0
         risk_level = self._score_to_level(max_risk_score)
-        
+
         return {
-            'level': risk_level,
-            'factors': list(set(risk_factors)),  # Remove duplicates
-            'score': max_risk_score,
-            'breakdown': {
-                'message_risk': message_risk['score'],
-                'file_risk': file_risk['score'], 
-                'size_risk': size_risk['score'],
-                'context_risk': context_risk['score']
-            }
+            "level": risk_level,
+            "factors": list(set(risk_factors)),  # Remove duplicates
+            "score": max_risk_score,
+            "breakdown": {
+                "message_risk": message_risk["score"],
+                "file_risk": file_risk["score"],
+                "size_risk": size_risk["score"],
+                "context_risk": context_risk["score"],
+            },
         }
-        
-    def _analyze_message_risk(self, message: str, doc: Doc) -> Dict[str, Any]:
+
+    def _analyze_message_risk(self, message: str, doc: Doc) -> dict[str, Any]:
         """Analyze commit message for risk indicators.
-        
+
         Args:
             message: Commit message
             doc: spaCy processed document
-            
+
         Returns:
             Dictionary with score and factors
         """
         if not message:
-            return {'score': 0.0, 'factors': []}
-            
+            return {"score": 0.0, "factors": []}
+
         message_lower = message.lower()
         factors = []
         risk_score = 0.0
-        
+
         # Check for high-risk patterns
         for pattern in self.config.high_risk_patterns:
             if pattern.lower() in message_lower:
                 factors.append(f"high_risk_keyword:{pattern}")
                 risk_score = max(risk_score, 0.8)  # High risk
-                
+
         # Check for medium-risk patterns
         for pattern in self.config.medium_risk_patterns:
             if pattern.lower() in message_lower:
                 factors.append(f"medium_risk_keyword:{pattern}")
                 risk_score = max(risk_score, 0.5)  # Medium risk
-                
+
         # Check for critical security keywords
         for keyword in self.critical_keywords:
             if keyword in message_lower:
                 factors.append(f"security_keyword:{keyword}")
                 risk_score = max(risk_score, 0.9)  # Critical risk
-                
+
         # Check for production-related keywords
         for keyword in self.production_keywords:
             if keyword in message_lower:
                 factors.append(f"production_keyword:{keyword}")
                 risk_score = max(risk_score, 0.7)  # High risk
-                
+
         # Check for database-related keywords
         for keyword in self.database_keywords:
             if keyword in message_lower:
                 factors.append(f"database_keyword:{keyword}")
                 risk_score = max(risk_score, 0.6)  # Medium-high risk
-                
+
         # Check for urgency indicators
         urgency_patterns = [
-            r'\b(urgent|critical|emergency|asap|immediate)\b',
-            r'\b(hotfix|quickfix|patch)\b',
-            r'\b(breaking|major)\b'
+            r"\b(urgent|critical|emergency|asap|immediate)\b",
+            r"\b(hotfix|quickfix|patch)\b",
+            r"\b(breaking|major)\b",
         ]
-        
+
         for pattern in urgency_patterns:
             if re.search(pattern, message_lower):
                 factors.append(f"urgency_indicator:{pattern}")
                 risk_score = max(risk_score, 0.6)
-                
-        return {'score': risk_score, 'factors': factors}
-        
-    def _analyze_file_risk(self, files: List[str]) -> Dict[str, Any]:
+
+        return {"score": risk_score, "factors": factors}
+
+    def _analyze_file_risk(self, files: list[str]) -> dict[str, Any]:
         """Analyze changed files for risk indicators.
-        
+
         Args:
             files: List of file paths
-            
+
         Returns:
             Dictionary with score and factors
         """
         if not files:
-            return {'score': 0.0, 'factors': []}
-            
+            return {"score": 0.0, "factors": []}
+
         factors = []
         risk_score = 0.0
-        
+
         for file_path in files:
             file_lower = file_path.lower()
-            
+
             # Check compiled file risk patterns
             for pattern, risk_level in self.compiled_file_patterns.items():
                 if pattern.search(file_path):
                     factors.append(f"file_pattern:{risk_level}:{file_path}")
-                    if risk_level == 'critical':
+                    if risk_level == "critical":
                         risk_score = max(risk_score, 1.0)
-                    elif risk_level == 'high':
+                    elif risk_level == "high":
                         risk_score = max(risk_score, 0.8)
-                    elif risk_level == 'medium':
+                    elif risk_level == "medium":
                         risk_score = max(risk_score, 0.5)
-                        
+
             # Check file extensions
-            if '.' in file_path:
-                ext = '.' + file_path.split('.')[-1].lower()
+            if "." in file_path:
+                ext = "." + file_path.split(".")[-1].lower()
                 if ext in self.extension_risk:
                     ext_risk = self.extension_risk[ext]
                     factors.append(f"file_extension:{ext_risk}:{ext}")
-                    if ext_risk == 'high':
+                    if ext_risk == "high":
                         risk_score = max(risk_score, 0.7)
-                    elif ext_risk == 'medium':
+                    elif ext_risk == "medium":
                         risk_score = max(risk_score, 0.4)
-                        
+
             # Check for sensitive file names
             sensitive_patterns = [
-                r'.*password.*', r'.*secret.*', r'.*key.*', r'.*token.*',
-                r'.*config.*', r'.*env.*', r'.*credential.*'
+                r".*password.*",
+                r".*secret.*",
+                r".*key.*",
+                r".*token.*",
+                r".*config.*",
+                r".*env.*",
+                r".*credential.*",
             ]
-            
+
             for pattern in sensitive_patterns:
                 if re.search(pattern, file_lower):
                     factors.append(f"sensitive_filename:{file_path}")
                     risk_score = max(risk_score, 0.8)
                     break
-                    
-        return {'score': risk_score, 'factors': factors}
-        
-    def _analyze_size_risk(self, commit: Dict[str, Any]) -> Dict[str, Any]:
+
+        return {"score": risk_score, "factors": factors}
+
+    def _analyze_size_risk(self, commit: dict[str, Any]) -> dict[str, Any]:
         """Analyze commit size for risk indicators.
-        
+
         Args:
             commit: Commit dictionary
-            
+
         Returns:
             Dictionary with score and factors
         """
         factors = []
         risk_score = 0.0
-        
-        files_changed = len(commit.get('files_changed', []))
-        insertions = commit.get('insertions', 0)
-        deletions = commit.get('deletions', 0)
+
+        files_changed = len(commit.get("files_changed", []))
+        insertions = commit.get("insertions", 0)
+        deletions = commit.get("deletions", 0)
         total_changes = insertions + deletions
-        
+
         # Check file count thresholds
-        if files_changed >= self.config.size_thresholds['large_commit_files']:
+        if files_changed >= self.config.size_thresholds["large_commit_files"]:
             factors.append(f"large_file_count:{files_changed}")
-            if files_changed >= 50:  # Very large
-                risk_score = max(risk_score, 0.8)
-            else:
-                risk_score = max(risk_score, 0.6)
-                
+            # Very large commits get higher risk score
+            risk_score = max(risk_score, 0.8) if files_changed >= 50 else max(risk_score, 0.6)
+
         # Check line change thresholds
-        if total_changes >= self.config.size_thresholds['massive_commit_lines']:
+        if total_changes >= self.config.size_thresholds["massive_commit_lines"]:
             factors.append(f"massive_changes:{total_changes}")
             risk_score = max(risk_score, 0.9)
-        elif total_changes >= self.config.size_thresholds['large_commit_lines']:
+        elif total_changes >= self.config.size_thresholds["large_commit_lines"]:
             factors.append(f"large_changes:{total_changes}")
             risk_score = max(risk_score, 0.6)
-            
+
         # Check deletion ratio (high deletion ratio can be risky)
         if total_changes > 0:
             deletion_ratio = deletions / total_changes
             if deletion_ratio > 0.7:  # More than 70% deletions
                 factors.append(f"high_deletion_ratio:{deletion_ratio:.2f}")
                 risk_score = max(risk_score, 0.5)
-                
-        return {'score': risk_score, 'factors': factors}
-        
-    def _analyze_context_risk(self, commit: Dict[str, Any]) -> Dict[str, Any]:
+
+        return {"score": risk_score, "factors": factors}
+
+    def _analyze_context_risk(self, commit: dict[str, Any]) -> dict[str, Any]:
         """Analyze commit context for risk indicators.
-        
+
         Args:
             commit: Commit dictionary
-            
+
         Returns:
             Dictionary with score and factors
         """
         factors = []
         risk_score = 0.0
-        
+
         # Check branch context if available
-        branch = commit.get('branch', '').lower()
+        branch = commit.get("branch", "").lower()
         if branch:
-            if any(term in branch for term in ['main', 'master', 'prod', 'production']):
+            if any(term in branch for term in ["main", "master", "prod", "production"]):
                 factors.append(f"main_branch:{branch}")
                 risk_score = max(risk_score, 0.6)
-            elif 'hotfix' in branch:
+            elif "hotfix" in branch:
                 factors.append(f"hotfix_branch:{branch}")
                 risk_score = max(risk_score, 0.8)
-                
+
         # Check commit timing (if timestamp available)
         # Weekend/night commits might be higher risk
-        timestamp = commit.get('timestamp')
+        timestamp = commit.get("timestamp")
         if timestamp:
             # This would require datetime analysis
             # For now, skip this check
             pass
-            
+
         # Check for merge commits
-        if commit.get('is_merge', False):
+        if commit.get("is_merge", False):
             factors.append("merge_commit")
             # Merges can be risky depending on what's being merged
             risk_score = max(risk_score, 0.3)
-            
-        return {'score': risk_score, 'factors': factors}
-        
+
+        return {"score": risk_score, "factors": factors}
+
     def _score_to_level(self, score: float) -> str:
         """Convert risk score to risk level.
-        
+
         Args:
             score: Risk score (0.0 to 1.0)
-            
+
         Returns:
             Risk level string
         """
         if score >= 0.9:
-            return 'critical'
+            return "critical"
         elif score >= 0.7:
-            return 'high'
+            return "high"
         elif score >= 0.4:
-            return 'medium'
+            return "medium"
         else:
-            return 'low'
-            
-    def get_risk_statistics(self, commits: List[Dict[str, Any]]) -> Dict[str, Any]:
+            return "low"
+
+    def get_risk_statistics(self, commits: list[dict[str, Any]]) -> dict[str, Any]:
         """Get risk analysis statistics for a set of commits.
-        
+
         Args:
             commits: List of commit dictionaries
-            
+
         Returns:
             Dictionary with risk statistics
         """
         if not commits:
-            return {'total_commits': 0}
-            
-        risk_levels = {'low': 0, 'medium': 0, 'high': 0, 'critical': 0}
+            return {"total_commits": 0}
+
+        risk_levels = {"low": 0, "medium": 0, "high": 0, "critical": 0}
         all_factors = []
-        
+
         for commit in commits:
             # Quick risk assessment without full doc processing
             risk_result = self.assess(commit, None)
-            risk_levels[risk_result['level']] += 1
-            all_factors.extend(risk_result['factors'])
-            
+            risk_levels[risk_result["level"]] += 1
+            all_factors.extend(risk_result["factors"])
+
         # Count factor frequencies
         factor_counts = {}
         for factor in all_factors:
-            factor_type = factor.split(':')[0] if ':' in factor else factor
+            factor_type = factor.split(":")[0] if ":" in factor else factor
             factor_counts[factor_type] = factor_counts.get(factor_type, 0) + 1
-            
+
         return {
-            'total_commits': len(commits),
-            'risk_distribution': risk_levels,
-            'risk_percentages': {
-                level: (count / len(commits)) * 100 
-                for level, count in risk_levels.items()
+            "total_commits": len(commits),
+            "risk_distribution": risk_levels,
+            "risk_percentages": {
+                level: (count / len(commits)) * 100 for level, count in risk_levels.items()
             },
-            'common_risk_factors': sorted(
-                factor_counts.items(), 
-                key=lambda x: x[1], 
-                reverse=True
-            )[:10],
-            'high_risk_commits': risk_levels['high'] + risk_levels['critical'],
-            'high_risk_percentage': ((risk_levels['high'] + risk_levels['critical']) / len(commits)) * 100
-        }
+            "common_risk_factors": sorted(factor_counts.items(), key=lambda x: x[1], reverse=True)[
+                :10
+            ],
+            "high_risk_commits": risk_levels["high"] + risk_levels["critical"],
+            "high_risk_percentage": ((risk_levels["high"] + risk_levels["critical"]) / len(commits))
+            * 100,
+        }

gitflow_analytics/qualitative/core/__init__.py

@@ -1,13 +1,13 @@
 """Core processing components for qualitative analysis."""
 
-from .processor import QualitativeProcessor
-from .nlp_engine import NLPEngine
 from .llm_fallback import LLMFallback
+from .nlp_engine import NLPEngine
 from .pattern_cache import PatternCache
+from .processor import QualitativeProcessor
 
 __all__ = [
     "QualitativeProcessor",
-    "NLPEngine", 
+    "NLPEngine",
     "LLMFallback",
     "PatternCache",
-]
+]