crackerjack 0.20.1__tar.gz → 0.20.3__tar.gz

{crackerjack-0.20.1 → crackerjack-0.20.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: crackerjack
-Version: 0.20.1
+Version: 0.20.3
 Summary: Crackerjack: code quality toolkit
 Keywords: bandit,black,creosote,mypy,pyright,pytest,refurb,ruff
 Author-Email: lesleslie <les@wedgwoodwebworks.com>
@@ -192,9 +192,35 @@ Crackerjack provides advanced testing capabilities powered by pytest:
 ### Standard Testing
 
 - **Parallel Test Execution:** Tests run in parallel by default using pytest-xdist for faster execution
-- **Timeout Protection:** All tests have a default 60-second timeout to prevent hanging tests
+- **Smart Parallelization:** Automatically adjusts the number of worker processes based on project size
+- **Timeout Protection:** Tests have dynamic timeouts based on project size to prevent hanging tests
 - **Coverage Reports:** Automatically generates test coverage reports with configurable thresholds
 
+### Advanced Test Configuration
+
+Crackerjack offers fine-grained control over test execution:
+
+- **Worker Control:** Set the number of parallel workers with `--test-workers` (0 = auto-detect, 1 = disable parallelization)
+- **Timeout Control:** Customize test timeouts with `--test-timeout` (in seconds)
+- **Project Size Detection:** Automatically detects project size and adjusts timeout and parallelization settings
+- **Deadlock Prevention:** Uses advanced threading techniques to prevent deadlocks in test output processing
+- **Progress Tracking:** Shows periodic heartbeat messages for long-running tests
+
+Example test execution options:
+```bash
+# Run tests with a single worker (no parallelization)
+python -m crackerjack -t --test-workers=1
+
+# Run tests with a specific number of workers (e.g., 4)
+python -m crackerjack -t --test-workers=4
+
+# Run tests with a custom timeout (5 minutes per test)
+python -m crackerjack -t --test-timeout=300
+
+# Combine options for maximum control
+python -m crackerjack -t --test-workers=2 --test-timeout=600
+```
+
 ### Benchmark Testing
 
 Crackerjack includes benchmark testing capabilities:
@@ -278,10 +304,16 @@ class MyOptions:
         # Process options
         self.clean = True            # Clean code (remove docstrings, comments, etc.)
         self.test = True             # Run tests using pytest
+        self.skip_hooks = False      # Skip running pre-commit hooks
+
+        # Test execution options
+        self.test_workers = 2        # Number of parallel workers (0 = auto-detect, 1 = disable parallelization)
+        self.test_timeout = 120      # Timeout in seconds for individual tests (0 = use default based on project size)
+
+        # Benchmark options
         self.benchmark = False       # Run tests in benchmark mode
         self.benchmark_regression = False  # Fail tests if benchmarks regress beyond threshold
         self.benchmark_regression_threshold = 5.0  # Threshold percentage for benchmark regression
-        self.skip_hooks = False      # Skip running pre-commit hooks
 
         # Version and publishing options
         self.publish = None          # Publish to PyPI (micro, minor, major)
@@ -321,6 +353,8 @@ runner.process(MyOptions())
 -   `-s`, `--skip-hooks`: Skip running pre-commit hooks (useful with `-t`).
 -   `-x`, `--clean`: Clean code by removing docstrings, line comments, and extra whitespace.
 -   `-t`, `--test`: Run tests using `pytest`.
+-   `--test-workers`: Set the number of parallel workers for testing (0 = auto-detect, 1 = disable parallelization).
+-   `--test-timeout`: Set the timeout in seconds for individual tests (0 = use default based on project size).
 -   `--benchmark`: Run tests in benchmark mode (disables parallel execution).
 -   `--benchmark-regression`: Fail tests if benchmarks regress beyond threshold.
 -   `--benchmark-regression-threshold`: Set threshold percentage for benchmark regression (default 5.0%).
@@ -356,6 +390,28 @@ runner.process(MyOptions())
   python -m crackerjack -t -s
   ```
 
+#### Test Execution Options
+
+- **Single-Process Testing** - Run tests sequentially (no parallelization):
+  ```bash
+  python -m crackerjack -t --test-workers=1
+  ```
+
+- **Customized Parallel Testing** - Run tests with a specific number of workers:
+  ```bash
+  python -m crackerjack -t --test-workers=4
+  ```
+
+- **Long-Running Tests** - Increase test timeout for complex tests:
+  ```bash
+  python -m crackerjack -t --test-timeout=600
+  ```
+
+- **Optimized for Large Projects** - Reduce workers and increase timeout for large codebases:
+  ```bash
+  python -m crackerjack -t --test-workers=2 --test-timeout=300
+  ```
+
 #### Version Management
 
 - **Bump and Publish** - Bump version and publish to PyPI:

{crackerjack-0.20.1 → crackerjack-0.20.3}/README.md

@@ -150,9 +150,35 @@ Crackerjack provides advanced testing capabilities powered by pytest:
 ### Standard Testing
 
 - **Parallel Test Execution:** Tests run in parallel by default using pytest-xdist for faster execution
-- **Timeout Protection:** All tests have a default 60-second timeout to prevent hanging tests
+- **Smart Parallelization:** Automatically adjusts the number of worker processes based on project size
+- **Timeout Protection:** Tests have dynamic timeouts based on project size to prevent hanging tests
 - **Coverage Reports:** Automatically generates test coverage reports with configurable thresholds
 
+### Advanced Test Configuration
+
+Crackerjack offers fine-grained control over test execution:
+
+- **Worker Control:** Set the number of parallel workers with `--test-workers` (0 = auto-detect, 1 = disable parallelization)
+- **Timeout Control:** Customize test timeouts with `--test-timeout` (in seconds)
+- **Project Size Detection:** Automatically detects project size and adjusts timeout and parallelization settings
+- **Deadlock Prevention:** Uses advanced threading techniques to prevent deadlocks in test output processing
+- **Progress Tracking:** Shows periodic heartbeat messages for long-running tests
+
+Example test execution options:
+```bash
+# Run tests with a single worker (no parallelization)
+python -m crackerjack -t --test-workers=1
+
+# Run tests with a specific number of workers (e.g., 4)
+python -m crackerjack -t --test-workers=4
+
+# Run tests with a custom timeout (5 minutes per test)
+python -m crackerjack -t --test-timeout=300
+
+# Combine options for maximum control
+python -m crackerjack -t --test-workers=2 --test-timeout=600
+```
+
 ### Benchmark Testing
 
 Crackerjack includes benchmark testing capabilities:
@@ -236,10 +262,16 @@ class MyOptions:
         # Process options
         self.clean = True            # Clean code (remove docstrings, comments, etc.)
         self.test = True             # Run tests using pytest
+        self.skip_hooks = False      # Skip running pre-commit hooks
+
+        # Test execution options
+        self.test_workers = 2        # Number of parallel workers (0 = auto-detect, 1 = disable parallelization)
+        self.test_timeout = 120      # Timeout in seconds for individual tests (0 = use default based on project size)
+
+        # Benchmark options
         self.benchmark = False       # Run tests in benchmark mode
         self.benchmark_regression = False  # Fail tests if benchmarks regress beyond threshold
         self.benchmark_regression_threshold = 5.0  # Threshold percentage for benchmark regression
-        self.skip_hooks = False      # Skip running pre-commit hooks
 
         # Version and publishing options
         self.publish = None          # Publish to PyPI (micro, minor, major)
@@ -279,6 +311,8 @@ runner.process(MyOptions())
 -   `-s`, `--skip-hooks`: Skip running pre-commit hooks (useful with `-t`).
 -   `-x`, `--clean`: Clean code by removing docstrings, line comments, and extra whitespace.
 -   `-t`, `--test`: Run tests using `pytest`.
+-   `--test-workers`: Set the number of parallel workers for testing (0 = auto-detect, 1 = disable parallelization).
+-   `--test-timeout`: Set the timeout in seconds for individual tests (0 = use default based on project size).
 -   `--benchmark`: Run tests in benchmark mode (disables parallel execution).
 -   `--benchmark-regression`: Fail tests if benchmarks regress beyond threshold.
 -   `--benchmark-regression-threshold`: Set threshold percentage for benchmark regression (default 5.0%).
@@ -314,6 +348,28 @@ runner.process(MyOptions())
   python -m crackerjack -t -s
   ```
 
+#### Test Execution Options
+
+- **Single-Process Testing** - Run tests sequentially (no parallelization):
+  ```bash
+  python -m crackerjack -t --test-workers=1
+  ```
+
+- **Customized Parallel Testing** - Run tests with a specific number of workers:
+  ```bash
+  python -m crackerjack -t --test-workers=4
+  ```
+
+- **Long-Running Tests** - Increase test timeout for complex tests:
+  ```bash
+  python -m crackerjack -t --test-timeout=600
+  ```
+
+- **Optimized for Large Projects** - Reduce workers and increase timeout for large codebases:
+  ```bash
+  python -m crackerjack -t --test-workers=2 --test-timeout=300
+  ```
+
 #### Version Management
 
 - **Bump and Publish** - Bump version and publish to PyPI:

{crackerjack-0.20.1 → crackerjack-0.20.3}/crackerjack/crackerjack.py

@@ -1022,23 +1022,34 @@ class Crackerjack:
 
         if options.publish:
             if platform.system() == "Darwin":
-                authorize = self.execute_command(
-                    ["pdm", "self", "add", "keyring"], capture_output=True, text=True
+                # First check if keyring is already installed in PDM
+                check_keyring = self.execute_command(
+                    ["pdm", "self", "list"], capture_output=True, text=True
                 )
-                if authorize.returncode > 0:
-                    error = PublishError(
-                        message="Authentication setup failed",
-                        error_code=ErrorCode.AUTHENTICATION_ERROR,
-                        details=f"Failed to add keyring support to PDM.\nCommand output:\n{authorize.stderr}",
-                        recovery="Please manually add your keyring credentials to PDM. Run `pdm self add keyring` and try again.",
-                        exit_code=1,
-                    )
-                    handle_error(
-                        error=error,
-                        console=self.console,
-                        verbose=options.verbose,
-                        ai_agent=options.ai_agent,
+                keyring_installed = "keyring" in check_keyring.stdout
+
+                if not keyring_installed:
+                    # Only attempt to install keyring if it's not already installed
+                    self.console.print("Installing keyring for PDM...")
+                    authorize = self.execute_command(
+                        ["pdm", "self", "add", "keyring"],
+                        capture_output=True,
+                        text=True,
                     )
+                    if authorize.returncode > 0:
+                        error = PublishError(
+                            message="Authentication setup failed",
+                            error_code=ErrorCode.AUTHENTICATION_ERROR,
+                            details=f"Failed to add keyring support to PDM.\nCommand output:\n{authorize.stderr}",
+                            recovery="Please manually add your keyring credentials to PDM. Run `pdm self add keyring` and try again.",
+                            exit_code=1,
+                        )
+                        handle_error(
+                            error=error,
+                            console=self.console,
+                            verbose=options.verbose,
+                            ai_agent=options.ai_agent,
+                        )
 
             build = self.execute_command(
                 ["pdm", "build"], capture_output=True, text=True

{crackerjack-0.20.1 → crackerjack-0.20.3}/crackerjack/pyproject.toml

@@ -4,7 +4,7 @@ requires = [ "pdm-backend" ]
 
 [project]
 name = "crackerjack"
-version = "0.20.0"
+version = "0.20.2"
 description = "Crackerjack: code quality toolkit"
 readme = "README.md"
 keywords = [

{crackerjack-0.20.1 → crackerjack-0.20.3}/pyproject.toml

@@ -6,7 +6,7 @@ requires = [
 
 [project]
 name = "crackerjack"
-version = "0.20.1"
+version = "0.20.3"
 description = "Crackerjack: code quality toolkit"
 readme = "README.md"
 keywords = [

{crackerjack-0.20.1 → crackerjack-0.20.3}/tests/test_crackerjack.py

@@ -1,4 +1,5 @@
 import os
+import subprocess
 import typing as t
 from contextlib import suppress
 from dataclasses import dataclass
@@ -12,6 +13,7 @@ from crackerjack.crackerjack import (
     CodeCleaner,
     ConfigManager,
     Crackerjack,
+    OptionsProtocol,
     ProjectManager,
 )
 
@@ -180,7 +182,7 @@ class TestCrackerjackProcess:
         options = options_factory(commit=True, no_config_updates=True)
         with patch.object(Crackerjack, "_update_project") as mock_update_project:
 
-            def side_effect(opts: t.Any) -> None:
+            def side_effect(opts: OptionsProtocol) -> None:
                 if opts.no_config_updates:
                     mock_console_print("Skipping config updates.")
 
@@ -580,7 +582,9 @@ class TestCrackerjackProcess:
             with patch("platform.system", return_value="Linux"):
                 with patch.object(Crackerjack, "execute_command") as mock_cj_execute:
 
-                    def mock_execute_side_effect(*args: t.Any, **kwargs: t.Any):
+                    def mock_execute_side_effect(
+                        *args: t.Any, **kwargs: t.Any
+                    ) -> subprocess.CompletedProcess[str]:
                         cmd = args[0][0]
                         if cmd == "pdm" and "build" in args[0]:
                             return MagicMock(
@@ -596,55 +600,154 @@ class TestCrackerjackProcess:
 
             mock_handle_error.assert_called()
 
-    def test_process_with_darwin_platform(
-        self,
-        mock_execute: MagicMock,
-        mock_console_print: MagicMock,
-        tmp_path: Path,
-        tmp_path_package: Path,
-        create_package_dir: None,
-        options_factory: t.Callable[..., OptionsForTesting],
-    ) -> None:
-        options = options_factory(publish="micro", no_config_updates=True)
-        with patch("platform.system", return_value="Darwin"):
-            with patch.object(Crackerjack, "execute_command") as mock_cj_execute:
-                mock_cj_execute.side_effect = [
-                    MagicMock(returncode=0, stdout="Success"),
-                    MagicMock(returncode=0, stdout="Success"),
-                    MagicMock(returncode=0, stdout="Success"),
-                    MagicMock(returncode=0, stdout="Success"),
-                ]
-                with patch.object(Crackerjack, "_update_project"):
-                    cj = Crackerjack(dry_run=True)
-                    cj.process(options)
-                    mock_cj_execute.assert_any_call(
-                        ["pdm", "self", "add", "keyring"],
-                        capture_output=True,
-                        text=True,
-                    )
+    def test_keyring_check_install_darwin(self) -> None:
+        """Test checking for keyring on Darwin (macOS) and installing it."""
+        # Create a minimal options object
+        options = OptionsForTesting(publish=BumpOption.micro)
 
-    def test_process_with_darwin_platform_keyring_failure(
-        self,
-        mock_execute: MagicMock,
-        mock_console_print: MagicMock,
-        tmp_path: Path,
-        tmp_path_package: Path,
-        create_package_dir: None,
-        options_factory: t.Callable[..., OptionsForTesting],
-    ) -> None:
-        with patch("crackerjack.errors.handle_error") as mock_handle_error:
-            options = options_factory(publish="micro", no_config_updates=True)
-            with patch("platform.system", return_value="Darwin"):
-                with patch.object(Crackerjack, "execute_command") as mock_cj_execute:
-                    mock_cj_execute.return_value = MagicMock(
-                        returncode=1, stdout="", stderr="Authorization failed"
-                    )
-                    with patch.object(Crackerjack, "_update_project"):
-                        with suppress(SystemExit):
-                            cj = Crackerjack(dry_run=True)
-                            cj.process(options)
+        # Use a list to track actual calls
+        actual_calls = []
 
-            mock_handle_error.assert_called()
+        # Create a Crackerjack instance for testing
+        crackerjack = Crackerjack(dry_run=False)
+
+        # Mock platform.system to return 'Darwin'
+        with patch("platform.system", return_value="Darwin"):
+            # Create a custom execute_command function that tracks calls
+            def mock_execute_side_effect(
+                *args: t.Any, **kwargs: t.Any
+            ) -> subprocess.CompletedProcess[str]:
+                cmd = args[0]
+                actual_calls.append(cmd)  # Track each command
+
+                if cmd == ["pdm", "self", "list"]:
+                    # Important: This MUST NOT contain the string "keyring" to trigger installation
+                    return MagicMock(
+                        returncode=0, stdout="packages installed: pytest, black"
+                    )
+                elif cmd == ["pdm", "self", "add", "keyring"]:
+                    return MagicMock(returncode=0, stdout="installed keyring")
+                elif cmd == ["pdm", "build"]:
+                    return MagicMock(returncode=0, stdout="build output")
+                elif cmd == ["pdm", "publish", "--no-build"]:
+                    return MagicMock(returncode=0, stdout="publish output")
+                return MagicMock(returncode=0, stdout="")
+
+            # Mock execute_command with our custom side_effect
+            with patch.object(
+                crackerjack, "execute_command", side_effect=mock_execute_side_effect
+            ):
+                # Mock console.print
+                with patch.object(crackerjack.console, "print"):
+                    # Call the method we're testing
+                    crackerjack._publish_project(options)
+
+            # Check that all the expected commands were called
+            assert ["pdm", "self", "list"] in actual_calls
+            assert ["pdm", "self", "add", "keyring"] in actual_calls
+            assert ["pdm", "build"] in actual_calls
+            assert ["pdm", "publish", "--no-build"] in actual_calls
+
+    def test_keyring_already_installed_darwin(self) -> None:
+        """Test behavior when keyring is already installed on Darwin (macOS)."""
+        # Create a minimal options object
+        options = OptionsForTesting(publish=BumpOption.micro)
+
+        # Use a list to track actual calls
+        actual_calls = []
+
+        # Create a Crackerjack instance for testing
+        crackerjack = Crackerjack(dry_run=False)
+
+        # Mock platform.system to return 'Darwin'
+        with patch("platform.system", return_value="Darwin"):
+            # Create a custom execute_command function that tracks calls
+            def mock_execute_side_effect(
+                *args: t.Any, **kwargs: t.Any
+            ) -> subprocess.CompletedProcess[str]:
+                cmd = args[0]
+                actual_calls.append(cmd)  # Track each command
+
+                if cmd == ["pdm", "self", "list"]:
+                    return MagicMock(returncode=0, stdout="keyring         25.6.0")
+                elif cmd == ["pdm", "build"]:
+                    return MagicMock(returncode=0, stdout="build output")
+                elif cmd == ["pdm", "publish", "--no-build"]:
+                    return MagicMock(returncode=0, stdout="publish output")
+                return MagicMock(returncode=0, stdout="")
+
+            # Mock execute_command with our custom side_effect
+            with patch.object(
+                crackerjack, "execute_command", side_effect=mock_execute_side_effect
+            ):
+                # Mock console.print
+                with patch.object(crackerjack.console, "print"):
+                    # Call the method we're testing
+                    crackerjack._publish_project(options)
+
+            # Check that keyring installation was skipped
+            assert ["pdm", "self", "list"] in actual_calls
+            assert ["pdm", "self", "add", "keyring"] not in actual_calls
+            assert ["pdm", "build"] in actual_calls
+            assert ["pdm", "publish", "--no-build"] in actual_calls
+
+    def test_keyring_install_failure_darwin(self) -> None:
+        """Test handling of keyring installation failure on Darwin (macOS)."""
+        # Create a minimal options object with ai_agent False to avoid extra mocking
+        options = OptionsForTesting(publish=BumpOption.micro, ai_agent=False)
+
+        # Create a Crackerjack instance for testing
+        crackerjack = Crackerjack(dry_run=False)
+
+        # Mock the PublishError class to capture its creation
+        with patch("crackerjack.errors.PublishError") as mock_publish_error:
+            # Set up the mock to return a MagicMock that we can track
+            error_instance = MagicMock()
+            mock_publish_error.return_value = error_instance
+
+            # Mock handle_error to avoid actual exit
+            with patch("crackerjack.errors.handle_error") as mock_handle_error:
+                # Mock platform.system to return 'Darwin'
+                with patch("platform.system", return_value="Darwin"):
+                    # Create a custom execute_command function with failure scenario
+                    def mock_execute_side_effect(
+                        *args: t.Any, **kwargs: t.Any
+                    ) -> subprocess.CompletedProcess[str]:
+                        cmd = args[0]
+
+                        if cmd == ["pdm", "self", "list"]:
+                            # This must NOT contain the string "keyring" to trigger installation
+                            return MagicMock(
+                                returncode=0, stdout="packages installed: pytest, black"
+                            )
+                        elif cmd == ["pdm", "self", "add", "keyring"]:
+                            # Return a failure for keyring installation
+                            mock_result = MagicMock()
+                            mock_result.returncode = 1
+                            mock_result.stdout = ""
+                            mock_result.stderr = "Installation failed"
+                            return mock_result
+                        return MagicMock(returncode=0, stdout="")
+
+                    # Mock execute_command with our custom side_effect
+                    with patch.object(
+                        crackerjack,
+                        "execute_command",
+                        side_effect=mock_execute_side_effect,
+                    ):
+                        # Mock console.print to avoid terminal output
+                        with patch.object(crackerjack.console, "print"):
+                            # Call the method we're testing with error suppression
+                            with suppress(SystemExit):
+                                crackerjack._publish_project(options)
+
+                # Check that the error handler was called with the right error
+                mock_handle_error.assert_called_once_with(
+                    error=error_instance,
+                    console=crackerjack.console,
+                    verbose=options.verbose,
+                    ai_agent=options.ai_agent,
+                )
 
     def test_process_with_commit_input(
         self,