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

gitflow_analytics/integrations/github_integration.py

@@ -1,7 +1,8 @@
 """GitHub API integration for PR and issue enrichment."""
+
 import time
 from datetime import datetime, timezone
-from typing import Any, Dict, List, Optional
+from typing import Any, Optional
 
 from github import Github
 from github.GithubException import RateLimitExceededException, UnknownObjectException
@@ -11,157 +12,163 @@ from ..core.cache import GitAnalysisCache
 
 class GitHubIntegration:
     """Integrate with GitHub API for PR and issue data."""
-    
-    def __init__(self, token: str, cache: GitAnalysisCache, 
-                 rate_limit_retries: int = 3, backoff_factor: int = 2,
-                 allowed_ticket_platforms: Optional[List[str]] = None):
+
+    def __init__(
+        self,
+        token: str,
+        cache: GitAnalysisCache,
+        rate_limit_retries: int = 3,
+        backoff_factor: int = 2,
+        allowed_ticket_platforms: Optional[list[str]] = None,
+    ):
         """Initialize GitHub integration."""
         self.github = Github(token)
         self.cache = cache
         self.rate_limit_retries = rate_limit_retries
         self.backoff_factor = backoff_factor
         self.allowed_ticket_platforms = allowed_ticket_platforms
-    
-    def enrich_repository_with_prs(self, repo_name: str, commits: List[Dict[str, Any]], 
-                                  since: datetime) -> List[Dict[str, Any]]:
+
+    def enrich_repository_with_prs(
+        self, repo_name: str, commits: list[dict[str, Any]], since: datetime
+    ) -> list[dict[str, Any]]:
         """Enrich repository commits with PR data."""
         try:
             repo = self.github.get_repo(repo_name)
         except UnknownObjectException:
             print(f"   ⚠️  GitHub repo not found: {repo_name}")
             return []
-        
+
         # Get PRs for the time period
         prs = self._get_pull_requests(repo, since)
-        
+
         # Build commit to PR mapping
         commit_to_pr = {}
         for pr in prs:
             pr_data = self._extract_pr_data(pr)
-            
+
             # Cache PR data
             self.cache.cache_pr(repo_name, pr_data)
-            
+
             # Map commits to this PR
             for commit in pr.get_commits():
                 commit_to_pr[commit.sha] = pr_data
-        
+
         # Enrich commits with PR data
         enriched_prs = []
         for commit in commits:
-            if commit['hash'] in commit_to_pr:
-                pr_data = commit_to_pr[commit['hash']]
-                
+            if commit["hash"] in commit_to_pr:
+                pr_data = commit_to_pr[commit["hash"]]
+
                 # Use PR story points if commit doesn't have them
-                if not commit.get('story_points') and pr_data.get('story_points'):
-                    commit['story_points'] = pr_data['story_points']
-                
+                if not commit.get("story_points") and pr_data.get("story_points"):
+                    commit["story_points"] = pr_data["story_points"]
+
                 # Add PR reference
-                commit['pr_number'] = pr_data['number']
-                commit['pr_title'] = pr_data['title']
-                
+                commit["pr_number"] = pr_data["number"]
+                commit["pr_title"] = pr_data["title"]
+
                 # Add to PR list if not already there
                 if pr_data not in enriched_prs:
                     enriched_prs.append(pr_data)
-        
+
         return enriched_prs
-    
-    def _get_pull_requests(self, repo, since: datetime) -> List[Any]:
+
+    def _get_pull_requests(self, repo, since: datetime) -> list[Any]:
         """Get pull requests with rate limit handling."""
         prs = []
-        
+
         # Ensure since is timezone-aware for comparison with GitHub's timezone-aware datetimes
         if since.tzinfo is None:
             since = since.replace(tzinfo=timezone.utc)
-        
+
         for attempt in range(self.rate_limit_retries):
             try:
                 # Get all PRs updated since the date
-                for pr in repo.get_pulls(state='all', sort='updated', direction='desc'):
+                for pr in repo.get_pulls(state="all", sort="updated", direction="desc"):
                     if pr.updated_at < since:
                         break
-                    
+
                     # Only include PRs that were merged in our time period
                     if pr.merged and pr.merged_at >= since:
                         prs.append(pr)
-                
+
                 return prs
-                
+
             except RateLimitExceededException:
                 if attempt < self.rate_limit_retries - 1:
-                    wait_time = self.backoff_factor ** attempt
+                    wait_time = self.backoff_factor**attempt
                     print(f"   ⏳ GitHub rate limit hit, waiting {wait_time}s...")
                     time.sleep(wait_time)
                 else:
                     print("   ❌ GitHub rate limit exceeded, skipping PR enrichment")
                     return []
-        
+
         return prs
-    
-    def _extract_pr_data(self, pr) -> Dict[str, Any]:
+
+    def _extract_pr_data(self, pr) -> dict[str, Any]:
         """Extract relevant data from a GitHub PR object."""
         from ..extractors.story_points import StoryPointExtractor
         from ..extractors.tickets import TicketExtractor
-        
+
         sp_extractor = StoryPointExtractor()
         ticket_extractor = TicketExtractor(allowed_platforms=self.allowed_ticket_platforms)
-        
+
         # Extract story points from PR title and body
         pr_text = f"{pr.title} {pr.body or ''}"
         story_points = sp_extractor.extract_from_text(pr_text)
-        
+
         # Extract ticket references
         tickets = ticket_extractor.extract_from_text(pr_text)
-        
+
         # Get commit SHAs
         commit_hashes = [c.sha for c in pr.get_commits()]
-        
+
         return {
-            'number': pr.number,
-            'title': pr.title,
-            'description': pr.body,
-            'author': pr.user.login,
-            'created_at': pr.created_at,
-            'merged_at': pr.merged_at,
-            'story_points': story_points,
-            'labels': [label.name for label in pr.labels],
-            'commit_hashes': commit_hashes,
-            'ticket_references': tickets,
-            'review_comments': pr.review_comments,
-            'changed_files': pr.changed_files,
-            'additions': pr.additions,
-            'deletions': pr.deletions
+            "number": pr.number,
+            "title": pr.title,
+            "description": pr.body,
+            "author": pr.user.login,
+            "created_at": pr.created_at,
+            "merged_at": pr.merged_at,
+            "story_points": story_points,
+            "labels": [label.name for label in pr.labels],
+            "commit_hashes": commit_hashes,
+            "ticket_references": tickets,
+            "review_comments": pr.review_comments,
+            "changed_files": pr.changed_files,
+            "additions": pr.additions,
+            "deletions": pr.deletions,
         }
-    
-    def calculate_pr_metrics(self, prs: List[Dict[str, Any]]) -> Dict[str, Any]:
+
+    def calculate_pr_metrics(self, prs: list[dict[str, Any]]) -> dict[str, Any]:
         """Calculate PR-level metrics."""
         if not prs:
             return {
-                'avg_pr_size': 0,
-                'avg_pr_lifetime_hours': 0,
-                'avg_files_per_pr': 0,
-                'total_review_comments': 0
+                "avg_pr_size": 0,
+                "avg_pr_lifetime_hours": 0,
+                "avg_files_per_pr": 0,
+                "total_review_comments": 0,
             }
-        
-        total_size = sum(pr['additions'] + pr['deletions'] for pr in prs)
-        total_files = sum(pr.get('changed_files', 0) for pr in prs)
-        total_comments = sum(pr.get('review_comments', 0) for pr in prs)
-        
+
+        total_size = sum(pr["additions"] + pr["deletions"] for pr in prs)
+        total_files = sum(pr.get("changed_files", 0) for pr in prs)
+        total_comments = sum(pr.get("review_comments", 0) for pr in prs)
+
         # Calculate average PR lifetime
         lifetimes = []
         for pr in prs:
-            if pr.get('merged_at') and pr.get('created_at'):
-                lifetime = (pr['merged_at'] - pr['created_at']).total_seconds() / 3600
+            if pr.get("merged_at") and pr.get("created_at"):
+                lifetime = (pr["merged_at"] - pr["created_at"]).total_seconds() / 3600
                 lifetimes.append(lifetime)
-        
+
         avg_lifetime = sum(lifetimes) / len(lifetimes) if lifetimes else 0
-        
+
         return {
-            'total_prs': len(prs),
-            'avg_pr_size': total_size / len(prs),
-            'avg_pr_lifetime_hours': avg_lifetime,
-            'avg_files_per_pr': total_files / len(prs),
-            'total_review_comments': total_comments,
-            'prs_with_story_points': sum(1 for pr in prs if pr.get('story_points')),
-            'story_point_coverage': sum(1 for pr in prs if pr.get('story_points')) / len(prs) * 100
-        }
+            "total_prs": len(prs),
+            "avg_pr_size": total_size / len(prs),
+            "avg_pr_lifetime_hours": avg_lifetime,
+            "avg_files_per_pr": total_files / len(prs),
+            "total_review_comments": total_comments,
+            "prs_with_story_points": sum(1 for pr in prs if pr.get("story_points")),
+            "story_point_coverage": sum(1 for pr in prs if pr.get("story_points")) / len(prs) * 100,
+        }

gitflow_analytics/integrations/jira_integration.py

@@ -1,6 +1,7 @@
 """JIRA API integration for story point and ticket enrichment."""
+
 import base64
-from typing import Any, Dict, List, Optional, Set
+from typing import Any, Optional
 
 import requests
 from requests.exceptions import RequestException
@@ -10,12 +11,17 @@ from ..core.cache import GitAnalysisCache
 
 class JIRAIntegration:
     """Integrate with JIRA API for ticket and story point data."""
-    
-    def __init__(self, base_url: str, username: str, api_token: str, 
-                 cache: GitAnalysisCache,
-                 story_point_fields: Optional[List[str]] = None):
+
+    def __init__(
+        self,
+        base_url: str,
+        username: str,
+        api_token: str,
+        cache: GitAnalysisCache,
+        story_point_fields: Optional[list[str]] = None,
+    ):
         """Initialize JIRA integration.
-        
+
         Args:
             base_url: JIRA instance base URL (e.g., https://company.atlassian.net)
             username: JIRA username/email
@@ -23,74 +29,74 @@ class JIRAIntegration:
             cache: Git analysis cache for storing JIRA data
             story_point_fields: List of custom field IDs for story points
         """
-        self.base_url = base_url.rstrip('/')
+        self.base_url = base_url.rstrip("/")
         self.cache = cache
-        
+
         # Set up authentication
         credentials = base64.b64encode(f"{username}:{api_token}".encode()).decode()
         self.headers = {
             "Authorization": f"Basic {credentials}",
             "Accept": "application/json",
-            "Content-Type": "application/json"
+            "Content-Type": "application/json",
         }
-        
+
         # Default story point field names/IDs
         self.story_point_fields = story_point_fields or [
             "customfield_10016",  # Common story points field
             "customfield_10021",  # Alternative field
-            "Story Points",       # Field name
-            "storypoints",        # Alternative name
+            "Story Points",  # Field name
+            "storypoints",  # Alternative name
             "customfield_10002",  # Another common ID
         ]
-        
+
         # Cache for field mapping
         self._field_mapping = None
-    
-    def enrich_commits_with_jira_data(self, commits: List[Dict[str, Any]]) -> None:
+
+    def enrich_commits_with_jira_data(self, commits: list[dict[str, Any]]) -> None:
         """Enrich commits with JIRA story points by looking up ticket references.
-        
+
         Args:
             commits: List of commit dictionaries to enrich
         """
         # Collect all unique JIRA tickets from commits
         jira_tickets = set()
         for commit in commits:
-            ticket_refs = commit.get('ticket_references', [])
+            ticket_refs = commit.get("ticket_references", [])
             for ref in ticket_refs:
-                if isinstance(ref, dict) and ref.get('platform') == 'jira':
-                    jira_tickets.add(ref['id'])
+                if isinstance(ref, dict) and ref.get("platform") == "jira":
+                    jira_tickets.add(ref["id"])
                 elif isinstance(ref, str) and self._is_jira_ticket(ref):
                     jira_tickets.add(ref)
-        
+
         if not jira_tickets:
             return
-        
+
         # Fetch ticket data from JIRA
         ticket_data = self._fetch_tickets_batch(list(jira_tickets))
-        
+
         # Enrich commits with story points
         for commit in commits:
             commit_story_points = 0
-            ticket_refs = commit.get('ticket_references', [])
-            
+            ticket_refs = commit.get("ticket_references", [])
+
             for ref in ticket_refs:
                 ticket_id = None
-                if isinstance(ref, dict) and ref.get('platform') == 'jira':
-                    ticket_id = ref['id']
+                if isinstance(ref, dict) and ref.get("platform") == "jira":
+                    ticket_id = ref["id"]
                 elif isinstance(ref, str) and self._is_jira_ticket(ref):
                     ticket_id = ref
-                
+
                 if ticket_id and ticket_id in ticket_data:
-                    points = ticket_data[ticket_id].get('story_points', 0)
+                    points = ticket_data[ticket_id].get("story_points", 0)
                     if points:
                         commit_story_points = max(commit_story_points, points)
-            
+
             if commit_story_points > 0:
-                commit['story_points'] = commit_story_points
-    
-    def enrich_prs_with_jira_data(self, prs: List[Dict[str, Any]]) -> None:
+                commit["story_points"] = commit_story_points
+
+    def enrich_prs_with_jira_data(self, prs: list[dict[str, Any]]) -> None:
         """Enrich PRs with JIRA story points.
-        
+
         Args:
             prs: List of PR dictionaries to enrich
         """
@@ -98,51 +104,51 @@ class JIRAIntegration:
         for pr in prs:
             pr_text = f"{pr.get('title', '')} {pr.get('description', '')}"
             jira_tickets = self._extract_jira_tickets(pr_text)
-            
+
             if jira_tickets:
                 ticket_data = self._fetch_tickets_batch(list(jira_tickets))
-                
+
                 # Use the highest story point value found
                 max_points = 0
                 for ticket_id in jira_tickets:
                     if ticket_id in ticket_data:
-                        points = ticket_data[ticket_id].get('story_points', 0)
+                        points = ticket_data[ticket_id].get("story_points", 0)
                         max_points = max(max_points, points)
-                
+
                 if max_points > 0:
-                    pr['story_points'] = max_points
-    
-    def _fetch_tickets_batch(self, ticket_ids: List[str]) -> Dict[str, Dict[str, Any]]:
+                    pr["story_points"] = max_points
+
+    def _fetch_tickets_batch(self, ticket_ids: list[str]) -> dict[str, dict[str, Any]]:
         """Fetch multiple tickets from JIRA API.
-        
+
         Args:
             ticket_ids: List of JIRA ticket IDs
-            
+
         Returns:
             Dictionary mapping ticket ID to ticket data
         """
         if not ticket_ids:
             return {}
-        
+
         # Check cache first
         cached_tickets = {}
         tickets_to_fetch = []
-        
+
         for ticket_id in ticket_ids:
             cached = self._get_cached_ticket(ticket_id)
             if cached:
                 cached_tickets[ticket_id] = cached
             else:
                 tickets_to_fetch.append(ticket_id)
-        
+
         # Fetch missing tickets from JIRA
         if tickets_to_fetch:
             # JIRA JQL has a limit, so batch the requests
             batch_size = 50
             for i in range(0, len(tickets_to_fetch), batch_size):
-                batch = tickets_to_fetch[i:i + batch_size]
+                batch = tickets_to_fetch[i : i + batch_size]
                 jql = f"key in ({','.join(batch)})"
-                
+
                 try:
                     response = requests.get(
                         f"{self.base_url}/rest/api/3/search",
@@ -150,33 +156,33 @@ class JIRAIntegration:
                         params={
                             "jql": jql,
                             "fields": "*all",  # Get all fields to find story points
-                            "maxResults": batch_size
-                        }
+                            "maxResults": batch_size,
+                        },
                     )
                     response.raise_for_status()
-                    
+
                     data = response.json()
-                    for issue in data.get('issues', []):
+                    for issue in data.get("issues", []):
                         ticket_data = self._extract_ticket_data(issue)
-                        cached_tickets[ticket_data['id']] = ticket_data
-                        self._cache_ticket(ticket_data['id'], ticket_data)
-                        
+                        cached_tickets[ticket_data["id"]] = ticket_data
+                        self._cache_ticket(ticket_data["id"], ticket_data)
+
                 except RequestException as e:
                     print(f"   ⚠️  Failed to fetch JIRA tickets: {e}")
-        
+
         return cached_tickets
-    
-    def _extract_ticket_data(self, issue: Dict[str, Any]) -> Dict[str, Any]:
+
+    def _extract_ticket_data(self, issue: dict[str, Any]) -> dict[str, Any]:
         """Extract relevant data from JIRA issue.
-        
+
         Args:
             issue: JIRA issue data from API
-            
+
         Returns:
             Dictionary with extracted ticket data
         """
-        fields = issue.get('fields', {})
-        
+        fields = issue.get("fields", {})
+
         # Extract story points from various possible fields
         story_points = 0
         for field_id in self.story_point_fields:
@@ -186,87 +192,93 @@ class JIRAIntegration:
                     break
                 except (ValueError, TypeError):
                     continue
-        
+
         return {
-            'id': issue['key'],
-            'summary': fields.get('summary', ''),
-            'status': fields.get('status', {}).get('name', ''),
-            'story_points': int(story_points) if story_points else 0,
-            'assignee': fields.get('assignee', {}).get('displayName', '') if fields.get('assignee') else '',
-            'created': fields.get('created', ''),
-            'updated': fields.get('updated', '')
+            "id": issue["key"],
+            "summary": fields.get("summary", ""),
+            "status": fields.get("status", {}).get("name", ""),
+            "story_points": int(story_points) if story_points else 0,
+            "assignee": (
+                fields.get("assignee", {}).get("displayName", "") if fields.get("assignee") else ""
+            ),
+            "created": fields.get("created", ""),
+            "updated": fields.get("updated", ""),
         }
-    
+
     def _is_jira_ticket(self, text: str) -> bool:
         """Check if text matches JIRA ticket pattern."""
         import re
-        return bool(re.match(r'^[A-Z]{2,10}-\d+$', text))
-    
-    def _extract_jira_tickets(self, text: str) -> Set[str]:
+
+        return bool(re.match(r"^[A-Z]{2,10}-\d+$", text))
+
+    def _extract_jira_tickets(self, text: str) -> set[str]:
         """Extract JIRA ticket IDs from text."""
         import re
-        pattern = r'([A-Z]{2,10}-\d+)'
+
+        pattern = r"([A-Z]{2,10}-\d+)"
         matches = re.findall(pattern, text)
         return set(matches)
-    
-    def _get_cached_ticket(self, ticket_id: str) -> Optional[Dict[str, Any]]:
+
+    def _get_cached_ticket(self, ticket_id: str) -> Optional[dict[str, Any]]:
         """Get ticket data from cache."""
         # TODO: Implement cache lookup using self.cache
         # For now, return None to always fetch from API
         return None
-    
-    def _cache_ticket(self, ticket_id: str, ticket_data: Dict[str, Any]) -> None:
+
+    def _cache_ticket(self, ticket_id: str, ticket_data: dict[str, Any]) -> None:
         """Cache ticket data."""
         # TODO: Implement cache storage using self.cache
         pass
-    
+
     def validate_connection(self) -> bool:
         """Validate JIRA connection and credentials.
-        
+
         Returns:
             True if connection is valid
         """
         try:
-            response = requests.get(
-                f"{self.base_url}/rest/api/3/myself",
-                headers=self.headers
-            )
+            response = requests.get(f"{self.base_url}/rest/api/3/myself", headers=self.headers)
             response.raise_for_status()
             return True
         except RequestException as e:
             print(f"   ❌ JIRA connection failed: {e}")
             return False
-    
-    def discover_fields(self) -> Dict[str, Dict[str, str]]:
+
+    def discover_fields(self) -> dict[str, dict[str, str]]:
         """Discover all available fields in JIRA instance.
-        
+
         Returns:
             Dictionary mapping field IDs to their names and types
         """
         try:
-            response = requests.get(
-                f"{self.base_url}/rest/api/3/field",
-                headers=self.headers
-            )
+            response = requests.get(f"{self.base_url}/rest/api/3/field", headers=self.headers)
             response.raise_for_status()
-            
+
             fields = {}
             for field in response.json():
-                field_id = field.get('id', '')
-                field_name = field.get('name', '')
-                field_type = field.get('schema', {}).get('type', 'unknown') if field.get('schema') else 'unknown'
-                
+                field_id = field.get("id", "")
+                field_name = field.get("name", "")
+                field_type = (
+                    field.get("schema", {}).get("type", "unknown")
+                    if field.get("schema")
+                    else "unknown"
+                )
+
                 # Look for potential story point fields
-                if any(term in field_name.lower() for term in ['story', 'point', 'estimate', 'size']):
+                if any(
+                    term in field_name.lower() for term in ["story", "point", "estimate", "size"]
+                ):
                     fields[field_id] = {
-                        'name': field_name,
-                        'type': field_type,
-                        'is_custom': field.get('custom', False)
+                        "name": field_name,
+                        "type": field_type,
+                        "is_custom": field.get("custom", False),
                     }
-                    print(f"   📊 Potential story point field: {field_id} = '{field_name}' (type: {field_type})")
-            
+                    print(
+                        f"   📊 Potential story point field: {field_id} = '{field_name}' (type: {field_type})"
+                    )
+
             return fields
-            
+
         except RequestException as e:
             print(f"   ⚠️  Failed to discover JIRA fields: {e}")
-            return {}
+            return {}