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

gitflow_analytics/extractors/story_points.py

@@ -1,30 +1,31 @@
 """Story point extraction from commits and pull requests."""
+
 import re
-from typing import Any, Dict, List, Optional
+from typing import Any, Optional
 
 
 class StoryPointExtractor:
     """Extract story points from text using configurable patterns."""
-    
-    def __init__(self, patterns: Optional[List[str]] = None):
+
+    def __init__(self, patterns: Optional[list[str]] = None):
         """Initialize with extraction patterns."""
         if patterns is None:
             patterns = [
-                r'(?:story\s*points?|sp|pts?)\s*[:=]\s*(\d+)',  # SP: 5, story points = 3
-                r'\[(\d+)\s*(?:sp|pts?)\]',                     # [3sp], [5 pts]
-                r'#(\d+)sp',                                     # #3sp
-                r'estimate:\s*(\d+)',                            # estimate: 5
-                r'\bSP(\d+)\b',                                  # SP5, SP13
-                r'points?:\s*(\d+)',                             # points: 8
+                r"(?:story\s*points?|sp|pts?)\s*[:=]\s*(\d+)",  # SP: 5, story points = 3
+                r"\[(\d+)\s*(?:sp|pts?)\]",  # [3sp], [5 pts]
+                r"#(\d+)sp",  # #3sp
+                r"estimate:\s*(\d+)",  # estimate: 5
+                r"\bSP(\d+)\b",  # SP5, SP13
+                r"points?:\s*(\d+)",  # points: 8
             ]
-        
+
         self.patterns = [re.compile(pattern, re.IGNORECASE) for pattern in patterns]
-    
+
     def extract_from_text(self, text: str) -> Optional[int]:
         """Extract story points from text."""
         if not text:
             return None
-        
+
         for pattern in self.patterns:
             match = pattern.search(text)
             if match:
@@ -35,28 +36,29 @@ class StoryPointExtractor:
                         return points
                 except (ValueError, IndexError):
                     continue
-        
+
         return None
-    
-    def extract_from_pr(self, pr_data: Dict[str, Any], 
-                       commit_messages: Optional[List[str]] = None) -> Optional[int]:
+
+    def extract_from_pr(
+        self, pr_data: dict[str, Any], commit_messages: Optional[list[str]] = None
+    ) -> Optional[int]:
         """Extract story points from PR with fallback to commits."""
         # Try PR description first (most authoritative)
-        points = self.extract_from_text(pr_data.get('description', ''))
+        points = self.extract_from_text(pr_data.get("description", ""))
         if points:
             return points
-        
+
         # Try PR title
-        points = self.extract_from_text(pr_data.get('title', ''))
+        points = self.extract_from_text(pr_data.get("title", ""))
         if points:
             return points
-        
+
         # Try PR body (if different from description)
-        if 'body' in pr_data:
-            points = self.extract_from_text(pr_data['body'])
+        if "body" in pr_data:
+            points = self.extract_from_text(pr_data["body"])
             if points:
                 return points
-        
+
         # Fallback to commit messages
         if commit_messages:
             commit_points = []
@@ -64,65 +66,74 @@ class StoryPointExtractor:
                 points = self.extract_from_text(message)
                 if points:
                     commit_points.append(points)
-            
+
             if commit_points:
                 # Use the most common value or max if no consensus
                 from collections import Counter
+
                 point_counts = Counter(commit_points)
                 most_common = point_counts.most_common(1)
                 if most_common:
                     return most_common[0][0]
-        
+
         return None
-    
-    def aggregate_story_points(self, prs: List[Dict[str, Any]], 
-                             commits: List[Dict[str, Any]]) -> Dict[str, Any]:
+
+    def aggregate_story_points(
+        self, prs: list[dict[str, Any]], commits: list[dict[str, Any]]
+    ) -> dict[str, Any]:
         """Aggregate story points from PRs and commits."""
         # Map commits to PRs
         pr_by_commit = {}
         for pr in prs:
-            for commit_hash in pr.get('commit_hashes', []):
+            for commit_hash in pr.get("commit_hashes", []):
                 pr_by_commit[commit_hash] = pr
-        
+
         # Track which commits are associated with PRs
         pr_commits = set(pr_by_commit.keys())
-        
+
         # Aggregate results
+        orphan_commits: list[dict[str, Any]] = []
+        unestimated_prs: list[dict[str, Any]] = []
+
         results = {
-            'total_story_points': 0,
-            'pr_story_points': 0,
-            'commit_story_points': 0,
-            'orphan_commits': [],  # Commits without PRs
-            'unestimated_prs': []  # PRs without story points
+            "total_story_points": 0,
+            "pr_story_points": 0,
+            "commit_story_points": 0,
+            "orphan_commits": orphan_commits,  # Commits without PRs
+            "unestimated_prs": unestimated_prs,  # PRs without story points
         }
-        
+
         # Process PRs
         for pr in prs:
-            pr_points = pr.get('story_points', 0)
+            pr_points = pr.get("story_points", 0)
             if pr_points:
-                results['pr_story_points'] += pr_points
-                results['total_story_points'] += pr_points
+                results["pr_story_points"] += pr_points
+                results["total_story_points"] += pr_points
             else:
-                results['unestimated_prs'].append({
-                    'number': pr['number'],
-                    'title': pr['title']
-                })
-        
+                unestimated_prs.append(
+                    {"number": pr.get("number", 0), "title": pr.get("title", "")}
+                )
+
         # Process commits not in PRs
         for commit in commits:
-            if commit['hash'] not in pr_commits:
-                commit_points = commit.get('story_points', 0)
+            commit_hash = commit.get("hash", "")
+            if commit_hash not in pr_commits:
+                commit_points = commit.get("story_points", 0)
                 if commit_points:
-                    results['commit_story_points'] += commit_points
-                    results['total_story_points'] += commit_points
-                
+                    results["commit_story_points"] += commit_points
+                    results["total_story_points"] += commit_points
+
                 # Track significant orphan commits
-                if commit['files_changed'] > 5 or commit['insertions'] > 100:
-                    results['orphan_commits'].append({
-                        'hash': commit['hash'][:7],
-                        'message': commit['message'].split('\n')[0][:80],
-                        'story_points': commit_points,
-                        'files_changed': commit['files_changed']
-                    })
-        
-        return results
+                files_changed = commit.get("files_changed", 0)
+                insertions = commit.get("insertions", 0)
+                if files_changed > 5 or insertions > 100:
+                    orphan_commits.append(
+                        {
+                            "hash": commit.get("hash", "")[:7],
+                            "message": commit.get("message", "").split("\n")[0][:80],
+                            "story_points": commit_points,
+                            "files_changed": files_changed,
+                        }
+                    )
+
+        return results

gitflow_analytics/extractors/tickets.py

@@ -1,39 +1,40 @@
 """Ticket reference extraction for multiple platforms."""
+
 import re
 from collections import defaultdict
-from typing import Any, Dict, List
+from typing import Any, Optional, cast
 
 
 class TicketExtractor:
     """Extract ticket references from various issue tracking systems."""
-    
-    def __init__(self, allowed_platforms=None):
+
+    def __init__(self, allowed_platforms: Optional[list[str]] = None) -> None:
         """Initialize with patterns for different platforms.
-        
+
         Args:
             allowed_platforms: List of platforms to extract tickets from.
                               If None, all platforms are allowed.
         """
         self.allowed_platforms = allowed_platforms
         self.patterns = {
-            'jira': [
-                r'([A-Z]{2,10}-\d+)',  # Standard JIRA format: PROJ-123
+            "jira": [
+                r"([A-Z]{2,10}-\d+)",  # Standard JIRA format: PROJ-123
             ],
-            'github': [
-                r'#(\d+)',              # GitHub issues: #123
-                r'GH-(\d+)',            # Alternative format: GH-123
-                r'(?:fix|fixes|fixed|close|closes|closed|resolve|resolves|resolved)\s+#(\d+)',
+            "github": [
+                r"#(\d+)",  # GitHub issues: #123
+                r"GH-(\d+)",  # Alternative format: GH-123
+                r"(?:fix|fixes|fixed|close|closes|closed|resolve|resolves|resolved)\s+#(\d+)",
             ],
-            'clickup': [
-                r'CU-([a-z0-9]+)',      # ClickUp: CU-abc123
-                r'#([a-z0-9]{6,})',     # ClickUp short format
+            "clickup": [
+                r"CU-([a-z0-9]+)",  # ClickUp: CU-abc123
+                r"#([a-z0-9]{6,})",  # ClickUp short format
+            ],
+            "linear": [
+                r"([A-Z]{2,5}-\d+)",  # Linear: ENG-123, similar to JIRA
+                r"LIN-(\d+)",  # Alternative: LIN-123
             ],
-            'linear': [
-                r'([A-Z]{2,5}-\d+)',    # Linear: ENG-123, similar to JIRA
-                r'LIN-(\d+)',           # Alternative: LIN-123
-            ]
         }
-        
+
         # Compile patterns only for allowed platforms
         self.compiled_patterns = {}
         for platform, patterns in self.patterns.items():
@@ -41,126 +42,139 @@ class TicketExtractor:
             if self.allowed_platforms and platform not in self.allowed_platforms:
                 continue
             self.compiled_patterns[platform] = [
-                re.compile(pattern, re.IGNORECASE if platform != 'jira' else 0) 
+                re.compile(pattern, re.IGNORECASE if platform != "jira" else 0)
                 for pattern in patterns
             ]
-    
-    def extract_from_text(self, text: str) -> List[Dict[str, str]]:
+
+    def extract_from_text(self, text: str) -> list[dict[str, str]]:
         """Extract all ticket references from text."""
         if not text:
             return []
-        
+
         tickets = []
         seen = set()  # Avoid duplicates
-        
+
         for platform, patterns in self.compiled_patterns.items():
             for pattern in patterns:
                 matches = pattern.findall(text)
                 for match in matches:
                     ticket_id = match if isinstance(match, str) else match[0]
-                    
+
                     # Normalize ticket ID
-                    if platform == 'jira' or platform == 'linear':
+                    if platform == "jira" or platform == "linear":
                         ticket_id = ticket_id.upper()
-                    
+
                     # Create unique key
                     key = f"{platform}:{ticket_id}"
                     if key not in seen:
                         seen.add(key)
-                        tickets.append({
-                            'platform': platform,
-                            'id': ticket_id,
-                            'full_id': self._format_ticket_id(platform, ticket_id)
-                        })
-        
+                        tickets.append(
+                            {
+                                "platform": platform,
+                                "id": ticket_id,
+                                "full_id": self._format_ticket_id(platform, ticket_id),
+                            }
+                        )
+
         return tickets
-    
-    def extract_by_platform(self, text: str) -> Dict[str, List[str]]:
+
+    def extract_by_platform(self, text: str) -> dict[str, list[str]]:
         """Extract tickets grouped by platform."""
         tickets = self.extract_from_text(text)
-        
+
         by_platform = defaultdict(list)
         for ticket in tickets:
-            by_platform[ticket['platform']].append(ticket['id'])
-        
+            by_platform[ticket["platform"]].append(ticket["id"])
+
         return dict(by_platform)
-    
-    def analyze_ticket_coverage(self, commits: List[Dict[str, Any]], 
-                               prs: List[Dict[str, Any]]) -> Dict[str, Any]:
+
+    def analyze_ticket_coverage(
+        self, commits: list[dict[str, Any]], prs: list[dict[str, Any]]
+    ) -> dict[str, Any]:
         """Analyze ticket reference coverage across commits and PRs."""
+        ticket_platforms: defaultdict[str, int] = defaultdict(int)
+        untracked_commits: list[dict[str, Any]] = []
+        ticket_summary: defaultdict[str, set[str]] = defaultdict(set)
+
         results = {
-            'total_commits': len(commits),
-            'total_prs': len(prs),
-            'commits_with_tickets': 0,
-            'prs_with_tickets': 0,
-            'ticket_platforms': defaultdict(int),
-            'untracked_commits': [],
-            'ticket_summary': defaultdict(set)
+            "total_commits": len(commits),
+            "total_prs": len(prs),
+            "commits_with_tickets": 0,
+            "prs_with_tickets": 0,
+            "ticket_platforms": ticket_platforms,
+            "untracked_commits": untracked_commits,
+            "ticket_summary": ticket_summary,
         }
-        
+
         # Analyze commits
         for commit in commits:
-            ticket_refs = commit.get('ticket_references', [])
+            ticket_refs = commit.get("ticket_references", [])
             if ticket_refs:
-                results['commits_with_tickets'] += 1
+                commits_with_tickets = cast(int, results["commits_with_tickets"])
+                results["commits_with_tickets"] = commits_with_tickets + 1
                 for ticket in ticket_refs:
                     if isinstance(ticket, dict):
-                        platform = ticket.get('platform', 'unknown')
-                        ticket_id = ticket.get('id', '')
+                        platform = ticket.get("platform", "unknown")
+                        ticket_id = ticket.get("id", "")
                     else:
                         # Legacy format - assume JIRA
-                        platform = 'jira'
+                        platform = "jira"
                         ticket_id = ticket
-                    
-                    results['ticket_platforms'][platform] += 1
-                    results['ticket_summary'][platform].add(ticket_id)
+
+                    platform_count = ticket_platforms[platform]
+                    ticket_platforms[platform] = platform_count + 1
+                    ticket_summary[platform].add(ticket_id)
             else:
                 # Track significant untracked commits
-                if (not commit.get('is_merge') and 
-                    commit.get('files_changed', 0) > 3):
-                    results['untracked_commits'].append({
-                        'hash': commit['hash'][:7],
-                        'message': commit['message'].split('\n')[0][:60],
-                        'files_changed': commit.get('files_changed', 0)
-                    })
-        
+                if not commit.get("is_merge") and commit.get("files_changed", 0) > 3:
+                    untracked_commits.append(
+                        {
+                            "hash": commit.get("hash", "")[:7],
+                            "message": commit.get("message", "").split("\n")[0][:60],
+                            "files_changed": commit.get("files_changed", 0),
+                        }
+                    )
+
         # Analyze PRs
         for pr in prs:
             # Extract tickets from PR title and description
             pr_text = f"{pr.get('title', '')} {pr.get('description', '')}"
             tickets = self.extract_from_text(pr_text)
-            
+
             if tickets:
-                results['prs_with_tickets'] += 1
+                prs_with_tickets = cast(int, results["prs_with_tickets"])
+                results["prs_with_tickets"] = prs_with_tickets + 1
                 for ticket in tickets:
-                    platform = ticket['platform']
-                    results['ticket_platforms'][platform] += 1
-                    results['ticket_summary'][platform].add(ticket['id'])
-        
+                    platform = ticket["platform"]
+                    platform_count = ticket_platforms[platform]
+                    ticket_platforms[platform] = platform_count + 1
+                    ticket_summary[platform].add(ticket["id"])
+
         # Calculate coverage percentages
-        results['commit_coverage_pct'] = (
-            results['commits_with_tickets'] / results['total_commits'] * 100
-            if results['total_commits'] > 0 else 0
+        total_commits = cast(int, results["total_commits"])
+        commits_with_tickets_count = cast(int, results["commits_with_tickets"])
+        results["commit_coverage_pct"] = (
+            commits_with_tickets_count / total_commits * 100 if total_commits > 0 else 0
         )
-        
-        results['pr_coverage_pct'] = (
-            results['prs_with_tickets'] / results['total_prs'] * 100
-            if results['total_prs'] > 0 else 0
+
+        total_prs = cast(int, results["total_prs"])
+        prs_with_tickets_count = cast(int, results["prs_with_tickets"])
+        results["pr_coverage_pct"] = (
+            prs_with_tickets_count / total_prs * 100 if total_prs > 0 else 0
         )
-        
+
         # Convert sets to counts for summary
-        results['ticket_summary'] = {
-            platform: len(tickets) 
-            for platform, tickets in results['ticket_summary'].items()
+        results["ticket_summary"] = {
+            platform: len(tickets) for platform, tickets in ticket_summary.items()
         }
-        
+
         return results
-    
+
     def _format_ticket_id(self, platform: str, ticket_id: str) -> str:
         """Format ticket ID for display."""
-        if platform == 'github':
+        if platform == "github":
             return f"#{ticket_id}"
-        elif platform == 'clickup':
-            return f"CU-{ticket_id}" if not ticket_id.startswith('CU-') else ticket_id
+        elif platform == "clickup":
+            return f"CU-{ticket_id}" if not ticket_id.startswith("CU-") else ticket_id
         else:
-            return ticket_id
+            return ticket_id