crackerjack 0.37.9__py3-none-any.whl → 0.45.2__py3-none-any.whl

crackerjack/managers/publish_manager.py

@@ -3,34 +3,44 @@ import typing as t
 from contextlib import suppress
 from pathlib import Path
 
-from rich.console import Console
+from acb.console import Console
+from acb.depends import Inject, depends
 
-from crackerjack.models.protocols import FileSystemInterface, SecurityServiceProtocol
+from crackerjack.core.retry import retry_api_call
+from crackerjack.models.protocols import (
+    ChangelogGeneratorProtocol,
+    FileSystemInterface,
+    GitServiceProtocol,
+    RegexPatternsProtocol,
+    SecurityServiceProtocol,
+    VersionAnalyzerProtocol,
+)
 
 
 class PublishManagerImpl:
+    @depends.inject  # type: ignore[misc]
     def __init__(
         self,
-        console: Console,
-        pkg_path: Path,
+        git_service: Inject[GitServiceProtocol],
+        version_analyzer: Inject[VersionAnalyzerProtocol],
+        changelog_generator: Inject[ChangelogGeneratorProtocol],
+        filesystem: Inject[FileSystemInterface],
+        security: Inject[SecurityServiceProtocol],
+        regex_patterns: Inject[RegexPatternsProtocol],
+        console: Inject[Console],
+        pkg_path: Inject[Path],
         dry_run: bool = False,
-        filesystem: FileSystemInterface | None = None,
-        security: SecurityServiceProtocol | None = None,
     ) -> None:
+        # Foundation dependencies
         self.console = console
         self.pkg_path = pkg_path
         self.dry_run = dry_run
 
-        if filesystem is None:
-            from crackerjack.services.filesystem import FileSystemService
-
-            filesystem = FileSystemService()
-
-        if security is None:
-            from crackerjack.services.security import SecurityService
-
-            security = SecurityService()
-
+        # Services injected via ACB DI
+        self._git_service = git_service
+        self._version_analyzer = version_analyzer
+        self._changelog_generator = changelog_generator
+        self._regex_patterns = regex_patterns
         self.filesystem = filesystem
         self.security = security
 
@@ -77,9 +87,20 @@ class PublishManagerImpl:
         pyproject_path = self.pkg_path / "pyproject.toml"
         try:
             content = self.filesystem.read_file(pyproject_path)
-            from crackerjack.services.regex_patterns import update_pyproject_version
 
-            new_content = update_pyproject_version(content, new_version)
+            # Use injected service or get through ACB DI
+            if self._regex_patterns is not None:
+                update_pyproject_version_func = (
+                    self._regex_patterns.update_pyproject_version
+                )
+            else:
+                from acb.depends import depends
+
+                update_pyproject_version_func = depends.get_sync(
+                    RegexPatternsProtocol
+                ).update_pyproject_version
+
+            new_content = update_pyproject_version_func(content, new_version)
             if content != new_content:
                 if not self.dry_run:
                     self.filesystem.write_file(pyproject_path, new_content)
@@ -156,7 +177,7 @@ class PublishManagerImpl:
             self.console.print(f"[red]❌[/ red] Version bump failed: {e}")
             raise
 
-    def _prompt_for_version_type(self, recommendation=None) -> str:
+    def _prompt_for_version_type(self, recommendation: t.Any = None) -> str:
         try:
             from rich.prompt import Prompt
 
@@ -178,17 +199,13 @@ class PublishManagerImpl:
             )
             return "patch"
 
-    def _get_version_recommendation(self):
+    def _get_version_recommendation(self) -> t.Any:
         """Get AI-powered version bump recommendation based on git history."""
         try:
             import asyncio
 
-            from crackerjack.services.git import GitService
-            from crackerjack.services.version_analyzer import VersionAnalyzer
-
-            # Initialize services
-            git_service = GitService(self.console, self.pkg_path)
-            version_analyzer = VersionAnalyzer(self.console, git_service)
+            # Use injected version analyzer service
+            version_analyzer = self._version_analyzer
 
             # Get recommendation asynchronously
             try:
@@ -217,7 +234,7 @@ class PublishManagerImpl:
             self.console.print(f"[yellow]⚠️[/yellow] Version analysis failed: {e}")
             return None
 
-    def _display_version_analysis(self, recommendation):
+    def _display_version_analysis(self, recommendation: t.Any) -> None:
         """Display version analysis in a compact format."""
         if not recommendation:
             return
@@ -323,7 +340,7 @@ class PublishManagerImpl:
 
     def build_package(self) -> bool:
         try:
-            self.console.print("[yellow]🔨[/ yellow] Building package...")
+            self.console.print("[yellow]🔨[/ yellow] Building package")
 
             if self.dry_run:
                 return self._handle_dry_run_build()
@@ -390,8 +407,8 @@ class PublishManagerImpl:
             return False
 
         try:
-            self.console.print("[yellow]🚀[/ yellow] Publishing to PyPI...")
-            return self._perform_publish_workflow()
+            self.console.print("[yellow]🚀[/ yellow] Publishing to PyPI")
+            return self._perform_publish_workflow_with_retry()
         except Exception as e:
             self.console.print(f"[red]❌[/ red] Publish error: {e}")
             return False
@@ -408,6 +425,17 @@ class PublishManagerImpl:
 
         return self._execute_publish()
 
+    @retry_api_call(max_attempts=3, delay=2.0, backoff=2.0, max_delay=60.0)
+    def _perform_publish_workflow_with_retry(self) -> bool:
+        """Perform the publish workflow with retry logic for API connection errors."""
+        if self.dry_run:
+            return self._handle_dry_run_publish()
+
+        if not self.build_package():
+            return False
+
+        return self._execute_publish()
+
     def _handle_dry_run_publish(self) -> bool:
         self.console.print("[yellow]🔍[/ yellow] Would publish package to PyPI")
         return True
@@ -501,7 +529,28 @@ class PublishManagerImpl:
             self.console.print(f"[red]❌[/ red] Cleanup error: {e}")
             return False
 
+    def create_git_tag_local(self, version: str) -> bool:
+        """Create git tag locally without pushing (for use with push_with_tags)."""
+        try:
+            if self.dry_run:
+                self.console.print(
+                    f"[yellow]🔍[/ yellow] Would create git tag: v{version}",
+                )
+                return True
+            result = self._run_command(["git", "tag", f"v{version}"])
+            if result.returncode == 0:
+                self.console.print(f"[green]🏷️[/ green] Created git tag: v{version}")
+                return True
+            self.console.print(
+                f"[red]❌[/ red] Failed to create tag: {result.stderr}",
+            )
+            return False
+        except Exception as e:
+            self.console.print(f"[red]❌[/ red] Tag creation error: {e}")
+            return False
+
     def create_git_tag(self, version: str) -> bool:
+        """Create git tag and push it immediately (legacy method for standalone use)."""
         try:
             if self.dry_run:
                 self.console.print(
@@ -556,12 +605,8 @@ class PublishManagerImpl:
     def _update_changelog_for_version(self, old_version: str, new_version: str) -> None:
         """Update changelog with entries from git commits since last version."""
         try:
-            from crackerjack.services.changelog_automation import ChangelogGenerator
-            from crackerjack.services.git import GitService
-
-            # Initialize services
-            git_service = GitService(self.console, self.pkg_path)
-            changelog_generator = ChangelogGenerator(self.console, git_service)
+            # Use injected changelog generator service
+            changelog_generator = self._changelog_generator
 
             # Look for changelog file
             changelog_path = self.pkg_path / "CHANGELOG.md"

crackerjack/managers/test_command_builder.py

@@ -1,11 +1,30 @@
+import os
 from pathlib import Path
 
+import psutil
+from acb.console import Console
+from acb.depends import Inject, depends
+
+from crackerjack.config.settings import CrackerjackSettings
 from crackerjack.models.protocols import OptionsProtocol
 
 
 class TestCommandBuilder:
-    def __init__(self, pkg_path: Path) -> None:
-        self.pkg_path = pkg_path
+    @depends.inject
+    def __init__(
+        self,
+        pkg_path: Inject[Path],
+        console: Inject[Console],
+        settings: Inject[CrackerjackSettings],
+    ) -> None:
+        # Normalize to pathlib.Path to avoid async path methods
+        try:
+            self.pkg_path = Path(str(pkg_path))
+        except Exception:
+            self.pkg_path = Path(pkg_path)
+
+        self.console = console
+        self.settings = settings
 
     def build_command(self, options: OptionsProtocol) -> list[str]:
         cmd = ["uv", "run", "python", "-m", "pytest"]
@@ -19,11 +38,185 @@ class TestCommandBuilder:
 
         return cmd
 
-    def get_optimal_workers(self, options: OptionsProtocol) -> int:
-        if hasattr(options, "test_workers") and options.test_workers:
+    def _handle_not_implemented_error(self, print_info: bool) -> int:
+        """Handle NotImplementedError specifically."""
+        if print_info and self.console:
+            self.console.print(
+                "[yellow]⚠️  CPU detection unavailable, using 2 workers[/yellow]"
+            )
+        return 2
+
+    def _handle_general_error(self, print_info: bool, e: Exception) -> int:
+        """Handle general exceptions gracefully."""
+        if print_info and self.console:
+            self.console.print(
+                f"[yellow]⚠️  Worker detection failed: {e}. Using 2 workers.[/yellow]"
+            )
+        return 2
+
+    def get_optimal_workers(
+        self, options: OptionsProtocol, print_info: bool = True
+    ) -> int | str:
+        """Calculate optimal worker count using pytest-xdist.
+
+        This method leverages pytest-xdist's built-in '-n auto' for CPU detection
+        while adding memory safety checks and support for custom worker configurations.
+
+        Worker Selection Logic:
+        ----------------------
+        1. Emergency rollback: CRACKERJACK_DISABLE_AUTO_WORKERS=1 → 1 worker
+        2. Explicit value (test_workers > 0): Use as-is
+        3. Auto-detect (test_workers = 0 AND auto_detect_workers=True): Return "auto"
+        4. Legacy mode (test_workers = 0 AND auto_detect_workers=False): 1 worker
+        5. Fractional (test_workers < 0): Divide CPU count by abs(value)
+
+        Safety Bounds:
+        -------------
+        - Minimum: 1 worker (sequential execution)
+        - Maximum: 8 workers (configurable via settings.testing.max_workers)
+        - Memory: 2GB per worker minimum (configurable)
+
+        Examples:
+        --------
+        >>> options = Options(test_workers=4)
+        >>> builder.get_optimal_workers(options)
+        4  # Explicit value
+
+        >>> options = Options(test_workers=0)  # auto_detect_workers=True
+        >>> builder.get_optimal_workers(options)
+        "auto"  # Delegates to pytest-xdist
+
+        >>> options = Options(test_workers=-2)  # 8-core machine
+        >>> builder.get_optimal_workers(options)
+        4  # 8 // 2 = 4 (with memory safety check)
+
+        Returns:
+            int | str: Number of workers (1-8) or "auto" for pytest-xdist detection
+
+        Raises:
+            Never raises - returns safe default (2) on any error
+        """
+        try:
+            # Check for emergency rollback
+            if self._check_emergency_rollback(print_info):
+                return 1
+
+            # Check explicit worker count
+            explicit_result = self._check_explicit_workers(options, print_info)
+            if explicit_result is not None:
+                return explicit_result
+
+            # Check auto-detection
+            auto_result = self._check_auto_detection(options, print_info)
+            if auto_result is not None:
+                return auto_result
+
+            # Check fractional workers
+            fractional_result = self._check_fractional_workers(options, print_info)
+            if fractional_result is not None:
+                return fractional_result
+
+            # Safe default if no conditions match
+            return 2
+
+        except NotImplementedError:
+            return self._handle_not_implemented_error(print_info)
+        except Exception as e:
+            return self._handle_general_error(print_info, e)
+
+    def _check_emergency_rollback(self, print_info: bool) -> bool:
+        """Check for emergency rollback via environment variable."""
+        if os.getenv("CRACKERJACK_DISABLE_AUTO_WORKERS") == "1":
+            if print_info and self.console:
+                self.console.print(
+                    "[yellow]⚠️  Auto-detection disabled via environment variable[/yellow]"
+                )
+            return True
+        return False
+
+    def _check_explicit_workers(
+        self, options: OptionsProtocol, print_info: bool
+    ) -> int | None:
+        """Check for explicit worker count."""
+        if hasattr(options, "test_workers") and options.test_workers > 0:
             return options.test_workers
+        return None
+
+    def _check_auto_detection(
+        self, options: OptionsProtocol, print_info: bool
+    ) -> str | int | None:
+        """Check for auto-detection setting."""
+        if hasattr(options, "test_workers") and options.test_workers == 0:
+            # Check if auto-detection is enabled in settings
+            if self.settings and self.settings.testing.auto_detect_workers:
+                # Show message only when getting optimal workers with print_info=True
+                if print_info and self.console:
+                    self.console.print(
+                        "[cyan]🔧 Using pytest-xdist auto-detection for workers[/cyan]"
+                    )
+                return "auto"  # pytest-xdist will handle CPU detection
+
+            # Legacy behavior: auto_detect_workers=False
+            return 1
+        return None
+
+    def _check_fractional_workers(
+        self, options: OptionsProtocol, print_info: bool
+    ) -> int | None:
+        """Check for fractional worker setting."""
+        if hasattr(options, "test_workers") and options.test_workers < 0:
+            import multiprocessing
+
+            cpu_count = multiprocessing.cpu_count()
+            divisor = abs(options.test_workers)
+            workers = max(1, cpu_count // divisor)
 
-        return 1
+            # Apply memory safety check
+            workers = self._apply_memory_limit(workers)
+
+            if print_info and self.console:
+                self.console.print(
+                    f"[cyan]🔧 Fractional workers: {cpu_count} cores ÷ {divisor} = {workers} workers[/cyan]"
+                )
+
+            return workers
+        return None
+
+    def _apply_memory_limit(self, workers: int) -> int:
+        """Limit workers based on available memory to prevent OOM.
+
+        Args:
+            workers: Desired number of workers
+
+        Returns:
+            int: Worker count limited by available memory
+        """
+        try:
+            # Get memory threshold from settings (default 2GB per worker)
+            memory_per_worker = (
+                self.settings.testing.memory_per_worker_gb if self.settings else 2.0
+            )
+
+            # Calculate available memory in GB
+            available_gb = psutil.virtual_memory().available / (1024**3)
+
+            # Calculate max workers based on memory
+            max_by_memory = max(1, int(available_gb / memory_per_worker))
+
+            # Return the minimum of desired workers and memory-limited workers
+            limited_workers = min(workers, max_by_memory)
+
+            # Log if we're limiting due to memory
+            if limited_workers < workers and self.console:
+                self.console.print(
+                    f"[yellow]⚠️  Limited to {limited_workers} workers (available memory: {available_gb:.1f}GB)[/yellow]"
+                )
+
+            return limited_workers
+
+        except Exception:
+            # Conservative fallback if psutil fails
+            return min(workers, 4)
 
     def get_test_timeout(self, options: OptionsProtocol) -> int:
         if hasattr(options, "test_timeout") and options.test_timeout:
@@ -33,20 +226,86 @@ class TestCommandBuilder:
             return 900
         return 300
 
+    def _detect_package_name(self) -> str:
+        """Detect the main package name for coverage reporting."""
+        # Method 1: Try to read from pyproject.toml
+        pyproject_path = self.pkg_path / "pyproject.toml"
+        if pyproject_path.exists():
+            from contextlib import suppress
+
+            with suppress(Exception):
+                import tomllib
+
+                with pyproject_path.open("rb") as f:
+                    data = tomllib.load(f)
+                    project_name = data.get("project", {}).get("name")
+                    if project_name:
+                        # Convert project name to package name (hyphens to underscores)
+                        return project_name.replace("-", "_")
+            # Fall back to directory detection
+
+        # Method 2: Look for Python packages in the project root
+        for item in self.pkg_path.iterdir():
+            if (
+                item.is_dir()
+                and not item.name.startswith(".")
+                and item.name not in ("tests", "docs", "build", "dist", "__pycache__")
+                and (item / "__init__.py").exists()
+            ):
+                return item.name
+
+        # Method 3: Fallback to crackerjack if nothing found (for crackerjack itself)
+        return "crackerjack"
+
     def _add_coverage_options(self, cmd: list[str], options: OptionsProtocol) -> None:
+        # Determine package name from project structure
+        package_name = self._detect_package_name()
+
         cmd.extend(
             [
-                "--cov=crackerjack",
+                f"--cov={package_name}",
                 "--cov-report=term-missing",
                 "--cov-report=html",
+                "--cov-report=json",  # Required for badge updates
                 "--cov-fail-under=0",
             ]
         )
 
     def _add_worker_options(self, cmd: list[str], options: OptionsProtocol) -> None:
+        """Add pytest-xdist worker options with proper distribution strategy.
+
+        Args:
+            cmd: Command list to append worker options to
+            options: Test options containing worker configuration
+        """
         workers = self.get_optimal_workers(options)
-        if workers > 1:
-            cmd.extend(["-n", str(workers)])
+
+        # Skip benchmarks for parallelization (results get skewed)
+        if hasattr(options, "benchmark") and options.benchmark:
+            if self.console:
+                self.console.print(
+                    "[yellow]⚠️  Benchmarks running sequentially (parallel execution skews results)[/yellow]"
+                )
+            return
+
+        if workers == "auto":
+            # Use pytest-xdist's native auto-detection
+            cmd.extend(["-n", "auto", "--dist=loadfile"])
+            if self.console:
+                self.console.print(
+                    "[cyan]🚀 Tests running with auto-detected workers (--dist=loadfile)[/cyan]"
+                )
+        elif isinstance(workers, int) and workers > 1:
+            # Explicit worker count
+            cmd.extend(["-n", str(workers), "--dist=loadfile"])
+            if self.console:
+                self.console.print(
+                    f"[cyan]🚀 Tests running with {workers} workers (--dist=loadfile)[/cyan]"
+                )
+        else:
+            # Sequential execution (workers == 1)
+            if self.console:
+                self.console.print("[cyan]🧪 Tests running sequentially[/cyan]")
 
     def _add_benchmark_options(self, cmd: list[str], options: OptionsProtocol) -> None:
         if hasattr(options, "benchmark") and options.benchmark:
@@ -63,11 +322,30 @@ class TestCommandBuilder:
         cmd.extend(["--timeout", str(timeout)])
 
     def _add_verbosity_options(self, cmd: list[str], options: OptionsProtocol) -> None:
-        cmd.append("-v")
+        """Add verbosity options with enhanced detail levels.
+
+        Verbosity Levels:
+        - Standard (-v): Basic test names
+        - Verbose (-vv): Assertions, captured output, test details
+        - Extra verbose (-vvv): Full locals, all test internals (ai_debug mode)
+        """
+        # Determine verbosity level
+        if options.verbose:
+            if getattr(options, "ai_debug", False):
+                cmd.append("-vvv")  # Extra verbose for AI debugging
+                self.console.print("[cyan]🔍 Using extra verbose mode (-vvv)[/cyan]")
+            else:
+                cmd.append("-vv")  # Double verbose shows more context
+                self.console.print("[cyan]🔍 Using verbose mode (-vv)[/cyan]")
+        else:
+            cmd.append("-v")  # Standard verbose
 
         cmd.extend(
             [
-                "--tb=short",
+                # Longer tracebacks in verbose mode
+                "--tb=long" if options.verbose else "--tb=short",
+                # Show all test outcomes summary (not just failures)
+                "-ra",
                 "--strict-markers",
                 "--strict-config",
             ]
@@ -85,7 +363,7 @@ class TestCommandBuilder:
         cmd.append(str(self.pkg_path))
 
     def build_specific_test_command(self, test_pattern: str) -> list[str]:
-        cmd = ["uv", "run", "python", "-m", "pytest", "-v"]
+        cmd = ["uv", "run", "python", "-m", "pytest", "-v"]  # Always use verbose mode
 
         cmd.extend(
             [
@@ -108,6 +386,6 @@ class TestCommandBuilder:
             "-m",
             "pytest",
             "--collect-only",
-            "--quiet",
+            # Removed --quiet to ensure collection headers are visible
             "tests" if (self.pkg_path / "tests").exists() else ".",
         ]