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

gitflow_analytics/core/progress.py

@@ -13,6 +13,7 @@ DESIGN DECISIONS:
 - Testable: Can be globally disabled for testing, with event capture capability
 - Nested support: Handles nested progress contexts with proper positioning
 - Consistent styling: All progress bars follow the same formatting rules
+- Rich integration: Optional Rich library support for enhanced terminal UI
 
 USAGE:
     from gitflow_analytics.core.progress import get_progress_service
@@ -30,10 +31,24 @@ import sys
 import threading
 from contextlib import contextmanager
 from dataclasses import dataclass
-from typing import Any, Optional
+from typing import Any, Dict, Optional
 
 from tqdm import tqdm
 
+# Import UI components if available
+try:
+    from ..ui.progress_display import (
+        RICH_AVAILABLE,
+        RepositoryInfo,
+        RepositoryStatus,
+        create_progress_display,
+    )
+
+    UI_AVAILABLE = True
+except ImportError:
+    UI_AVAILABLE = False
+    RICH_AVAILABLE = False
+
 
 @dataclass
 class ProgressContext:
@@ -73,38 +88,76 @@ class ProgressService:
 
     This service provides a unified interface for creating and managing progress bars
     throughout the application. It supports nested progress contexts, global disable
-    for testing, and event capture for verification.
+    for testing, event capture for verification, and optional Rich terminal UI.
     """
 
-    def __init__(self):
-        """Initialize the progress service."""
+    def __init__(self, display_style: str = "auto", version: str = "1.3.11"):
+        """Initialize the progress service.
+
+        Args:
+            display_style: Display style ("rich", "simple", or "auto")
+            version: Version string for display
+        """
         self._enabled = True
         self._lock = threading.Lock()
         self._active_contexts: list[ProgressContext] = []
         self._position_counter = 0
         self._capture_events = False
         self._captured_events: list[ProgressEvent] = []
+        self._display_style = display_style
+        self._version = version
+
+        # Rich display components
+        self._rich_display = None
+        self._repository_contexts: Dict[str, Any] = {}
+        self._use_rich = False
+
+        # Initialize display based on configuration
+        self._init_display()
 
         # Check environment for testing mode
+        # Note: If user explicitly requested rich mode, don't disable it
         self._check_testing_environment()
 
+    def _init_display(self):
+        """Initialize the appropriate display based on configuration."""
+        if UI_AVAILABLE and self._display_style in ("rich", "auto"):
+            try:
+                self._rich_display = create_progress_display(
+                    style=self._display_style, version=self._version, update_frequency=0.5
+                )
+                self._use_rich = self._display_style == "rich" or (
+                    self._display_style == "auto" and RICH_AVAILABLE
+                )
+            except Exception:
+                # Fall back to tqdm if Rich fails
+                self._use_rich = False
+                self._rich_display = None
+
     def _check_testing_environment(self):
         """Check if running in a testing environment and disable if needed.
 
         WHY: Progress bars interfere with test output and can cause issues in CI/CD.
         This automatically detects common testing scenarios and disables progress.
         """
+        # Don't auto-disable if user explicitly requested rich mode
+        explicit_rich = self._display_style == "rich"
+
         # Disable in pytest
         if "pytest" in sys.modules:
             self._enabled = False
+            self._use_rich = False
 
         # Disable if explicitly requested via environment
         if os.environ.get("GITFLOW_DISABLE_PROGRESS", "").lower() in ("1", "true", "yes"):
             self._enabled = False
+            self._use_rich = False
 
         # Disable if not in a TTY (e.g., CI/CD, piped output)
-        if not sys.stdout.isatty():
+        # BUT: Keep enabled if user explicitly requested rich mode
+        if not sys.stdout.isatty() and not explicit_rich:
             self._enabled = False
+            self._use_rich = False
 
     def create_progress(
         self,
@@ -154,16 +207,21 @@ class ProgressService:
 
             # Create actual progress bar if enabled
             if self._enabled:
-                context.progress_bar = tqdm(
-                    total=total,
-                    desc=description,
-                    unit=unit,
-                    position=position,
-                    leave=leave,
-                    # Consistent styling
-                    bar_format="{l_bar}{bar}| {n_fmt}/{total_fmt} [{elapsed}<{remaining}, {rate_fmt}]",
-                    dynamic_ncols=True,
-                )
+                if self._use_rich and self._rich_display:
+                    # For Rich display, we don't create individual tqdm bars
+                    # Instead, we'll manage everything through the Rich display
+                    context.progress_bar = None
+                else:
+                    context.progress_bar = tqdm(
+                        total=total,
+                        desc=description,
+                        unit=unit,
+                        position=position,
+                        leave=leave,
+                        # Consistent styling
+                        bar_format="{l_bar}{bar}| {n_fmt}/{total_fmt} [{elapsed}<{remaining}, {rate_fmt}]",
+                        dynamic_ncols=True,
+                    )
 
             self._active_contexts.append(context)
             return context
@@ -196,7 +254,18 @@ class ProgressService:
                 )
 
             # Update actual progress bar if it exists
-            if context.progress_bar:
+            if self._use_rich and self._rich_display:
+                # Update Rich display based on context type
+                if hasattr(context, "repository_name"):
+                    # Repository-specific progress
+                    speed = increment / 0.1 if increment > 0 else 0  # Simple speed calculation
+                    self._rich_display.update_repository(
+                        context.repository_name, context.current, speed
+                    )
+                else:
+                    # Overall progress
+                    self._rich_display.update_overall(context.current, description)
+            elif context.progress_bar:
                 context.progress_bar.update(increment)
                 if description:
                     context.progress_bar.set_description(description)
@@ -334,26 +403,158 @@ class ProgressService:
         with self._lock:
             self._captured_events = []
 
+    # Rich-specific methods
+    def start_rich_display(
+        self, total_items: int = 100, description: str = "Analyzing repositories"
+    ):
+        """Start the Rich display if available.
+
+        Args:
+            total_items: Total number of items to process
+            description: Description of the overall task
+        """
+        if self._use_rich and self._rich_display and self._enabled:
+            self._rich_display.start(total_items, description)
+
+    def stop_rich_display(self):
+        """Stop the Rich display if active."""
+        if self._use_rich and self._rich_display:
+            self._rich_display.stop()
+
+    def start_repository(self, repo_name: str, total_commits: int = 0):
+        """Start processing a repository with Rich display.
+
+        Args:
+            repo_name: Name of the repository
+            total_commits: Total number of commits to process
+        """
+        if self._use_rich and self._rich_display and self._enabled:
+            self._rich_display.start_repository(repo_name, total_commits)
+
+    def finish_repository(
+        self, repo_name: str, success: bool = True, error_message: Optional[str] = None
+    ):
+        """Finish processing a repository with Rich display.
+
+        Args:
+            repo_name: Name of the repository
+            success: Whether processing was successful
+            error_message: Error message if processing failed
+        """
+        if self._use_rich and self._rich_display and self._enabled:
+            self._rich_display.finish_repository(repo_name, success, error_message)
+
+    def update_statistics(self, **kwargs):
+        """Update Rich display statistics.
+
+        Args:
+            **kwargs: Statistics to update (total_commits, total_developers, etc.)
+        """
+        if self._use_rich and self._rich_display and self._enabled:
+            self._rich_display.update_statistics(**kwargs)
+
+    def initialize_repositories(self, repository_list: list):
+        """Initialize all repositories with pending status in Rich display.
+
+        Args:
+            repository_list: List of repositories to be processed.
+                            Each item should have 'name' and optionally 'path' fields.
+        """
+        if self._use_rich and self._rich_display and self._enabled:
+            self._rich_display.initialize_repositories(repository_list)
+
+    def set_phase(self, phase: str):
+        """Set the current processing phase for Rich display.
+
+        Args:
+            phase: Description of the current phase
+        """
+        if self._use_rich and self._rich_display and self._enabled:
+            self._rich_display.set_phase(phase)
+
+    def create_repository_progress(
+        self, repo_name: str, total: int, description: str
+    ) -> ProgressContext:
+        """Create a progress context specifically for repository processing.
+
+        Args:
+            repo_name: Name of the repository
+            total: Total number of items to process
+            description: Description of the task
+
+        Returns:
+            ProgressContext with repository information
+        """
+        context = self.create_progress(total, description, unit="commits", nested=True)
+        # Add repository name to context for Rich display handling
+        # Note: We use object.__setattr__ to bypass dataclass frozen status if needed
+        object.__setattr__(context, "repository_name", repo_name)
+
+        if self._use_rich and self._rich_display and self._enabled:
+            self.start_repository(repo_name, total)
+
+        return context
+
 
 # Global singleton instance
 _progress_service: Optional[ProgressService] = None
 _service_lock = threading.Lock()
 
 
-def get_progress_service() -> ProgressService:
+def get_progress_service(
+    display_style: Optional[str] = None, version: Optional[str] = None
+) -> ProgressService:
     """Get the global progress service instance.
 
+    Args:
+        display_style: Optional display style override ("rich", "simple", or "auto")
+        version: Optional version string for display
+
     Returns:
         The singleton ProgressService instance
 
     Thread-safe singleton pattern ensures only one progress service exists.
+    If display_style is provided and differs from current style, the service is reconfigured.
     """
     global _progress_service
 
+    # Check if we need to reconfigure an existing service
+    if _progress_service is not None and display_style is not None:
+        with _service_lock:
+            # If display style changed, reconfigure the service
+            if _progress_service._display_style != display_style:
+                # Close any active displays
+                if _progress_service._use_rich and _progress_service._rich_display:
+                    _progress_service.stop_rich_display()
+
+                # Reconfigure with new display style
+                _progress_service._display_style = display_style
+                _progress_service._use_rich = False
+                _progress_service._rich_display = None
+
+                # Re-enable if user explicitly requested rich mode
+                if display_style == "rich":
+                    _progress_service._enabled = True
+
+                # Reinitialize display
+                _progress_service._init_display()
+
     if _progress_service is None:
         with _service_lock:
             if _progress_service is None:
-                _progress_service = ProgressService()
+                # Get display style from environment or use default
+                if display_style is None:
+                    display_style = os.environ.get("GITFLOW_PROGRESS_STYLE", "auto")
+                if version is None:
+                    # Try to get version from package
+                    try:
+                        from .._version import __version__
+
+                        version = __version__
+                    except ImportError:
+                        version = "1.3.11"
+
+                _progress_service = ProgressService(display_style=display_style, version=version)
 
     return _progress_service
 

gitflow_analytics/core/subprocess_git.py

@@ -0,0 +1,145 @@
+"""Subprocess-based Git operations to avoid authentication prompts."""
+
+import logging
+import subprocess
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+
+class SubprocessGit:
+    """Git operations using subprocess to avoid GitPython authentication issues."""
+
+    @staticmethod
+    def get_commits_in_range(
+        repo_path: Path, start_date: datetime, end_date: datetime, branch: str = "HEAD"
+    ) -> list[dict[str, Any]]:
+        """Get commits in date range using git log subprocess.
+
+        This avoids GitPython's potential authentication triggers by using
+        subprocess directly with environment variables that prevent prompts.
+        """
+        # Format dates for git log
+        start_str = start_date.strftime("%Y-%m-%d")
+        end_str = end_date.strftime("%Y-%m-%d")
+
+        # Build git log command with JSON-like format for easy parsing
+        cmd = [
+            "git",
+            "log",
+            f"--since={start_str}",
+            f"--until={end_str}",
+            "--all",  # All branches
+            "--no-merges",  # Skip merge commits
+            "--format=%H|%ae|%an|%at|%s",  # hash|email|name|timestamp|subject
+            "--numstat",  # Include file changes
+        ]
+
+        # Set environment to prevent any authentication prompts
+        env = {
+            "GIT_TERMINAL_PROMPT": "0",
+            "GIT_ASKPASS": "echo",
+            "SSH_ASKPASS": "echo",
+            "GCM_INTERACTIVE": "never",
+            "DISPLAY": "",
+        }
+
+        try:
+            result = subprocess.run(
+                cmd, cwd=repo_path, capture_output=True, text=True, env=env, timeout=30
+            )
+
+            if result.returncode != 0:
+                logger.warning(f"Git log failed: {result.stderr}")
+                return []
+
+            return SubprocessGit._parse_git_log(result.stdout)
+
+        except subprocess.TimeoutExpired:
+            logger.error("Git log timed out - likely authentication issue")
+            return []
+        except Exception as e:
+            logger.error(f"Error running git log: {e}")
+            return []
+
+    @staticmethod
+    def _parse_git_log(output: str) -> list[dict[str, Any]]:
+        """Parse git log output into commit dictionaries."""
+        commits = []
+        current_commit = None
+
+        for line in output.split("\n"):
+            if not line:
+                continue
+
+            if "|" in line and not line[0].isdigit():
+                # This is a commit line
+                if current_commit:
+                    commits.append(current_commit)
+
+                parts = line.split("|")
+                if len(parts) >= 5:
+                    current_commit = {
+                        "hash": parts[0],
+                        "author_email": parts[1],
+                        "author_name": parts[2],
+                        "timestamp": int(parts[3]),
+                        "message": "|".join(parts[4:]),  # Message might contain |
+                        "files": [],
+                    }
+            elif current_commit and line[0].isdigit():
+                # This is a numstat line (additions deletions filename)
+                parts = line.split("\t")
+                if len(parts) >= 3:
+                    current_commit["files"].append(
+                        {"additions": parts[0], "deletions": parts[1], "filename": parts[2]}
+                    )
+
+        # Don't forget the last commit
+        if current_commit:
+            commits.append(current_commit)
+
+        return commits
+
+    @staticmethod
+    def check_remotes_safe(repo_path: Path) -> bool:
+        """Check if repository has remotes without triggering authentication."""
+        cmd = ["git", "remote", "-v"]
+
+        env = {
+            "GIT_TERMINAL_PROMPT": "0",
+            "GIT_ASKPASS": "echo",
+        }
+
+        try:
+            result = subprocess.run(
+                cmd, cwd=repo_path, capture_output=True, text=True, env=env, timeout=5
+            )
+            return bool(result.stdout.strip())
+        except:
+            return False
+
+    @staticmethod
+    def get_branches_safe(repo_path: Path) -> list[str]:
+        """Get list of branches without triggering authentication."""
+        branches = []
+
+        # Get local branches
+        cmd = ["git", "branch", "--format=%(refname:short)"]
+
+        try:
+            result = subprocess.run(cmd, cwd=repo_path, capture_output=True, text=True, timeout=5)
+
+            if result.returncode == 0:
+                branches = [b.strip() for b in result.stdout.split("\n") if b.strip()]
+
+        except:
+            pass
+
+        # Default to common branch names if none found
+        if not branches:
+            branches = ["main", "master", "develop"]
+
+        return branches

gitflow_analytics/extractors/ml_tickets.py

@@ -673,7 +673,7 @@ class MLTicketExtractor(TicketExtractor):
         return mapping.get(ml_category, "other")
 
     def analyze_ticket_coverage(
-        self, commits: list[dict[str, Any]], prs: list[dict[str, Any]]
+        self, commits: list[dict[str, Any]], prs: list[dict[str, Any]], progress_display=None
     ) -> dict[str, Any]:
         """Enhanced ticket coverage analysis with ML categorization insights.
 
@@ -683,12 +683,13 @@ class MLTicketExtractor(TicketExtractor):
         Args:
             commits: List of commit data
             prs: List of PR data
+            progress_display: Optional progress display for showing analysis progress
 
         Returns:
             Enhanced analysis results with ML insights
         """
         # Get base analysis from parent
-        base_analysis = super().analyze_ticket_coverage(commits, prs)
+        base_analysis = super().analyze_ticket_coverage(commits, prs, progress_display)
 
         if not self.enable_ml:
             # Add indicator that ML was not used