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

crackerjack/services/filesystem.py

@@ -3,9 +3,10 @@ from collections.abc import Iterator
 from pathlib import Path
 
 from crackerjack.errors import ErrorCode, FileError, ResourceError
+from crackerjack.models.protocols import FileSystemInterface
 
 
-class FileSystemService:
+class FileSystemService(FileSystemInterface):
     @staticmethod
     def clean_trailing_whitespace_and_newlines(content: str) -> str:
         lines = content.splitlines()
@@ -17,37 +18,79 @@ class FileSystemService:
 
         return result
 
+    def _validate_path_exists(self, path_obj: Path, operation: str) -> None:
+        """Validate that a path exists."""
+        if not path_obj.exists():
+            raise FileError(
+                message=f"File does not exist: {path_obj}",
+                details=f"Attempted to {operation} file at {path_obj.absolute()}",
+                recovery="Check file path and ensure file exists",
+            )
+
+    def _handle_permission_error(
+        self, error: PermissionError, path: str | Path, operation: str
+    ) -> None:
+        """Handle permission errors."""
+        raise FileError(
+            message=f"Permission denied {operation}: {path}",
+            error_code=ErrorCode.PERMISSION_ERROR,
+            details=str(error),
+            recovery="Check file permissions and user access rights",
+        ) from error
+
+    def _handle_unicode_error(
+        self, error: UnicodeDecodeError, path: str | Path
+    ) -> None:
+        """Handle unicode decode errors."""
+        raise FileError(
+            message=f"Unable to decode file as UTF-8: {path}",
+            error_code=ErrorCode.FILE_READ_ERROR,
+            details=str(error),
+            recovery="Ensure file is text - based and UTF-8 encoded",
+        ) from error
+
+    def _handle_os_error(
+        self, error: OSError, path: str | Path, operation: str
+    ) -> None:
+        """Handle OS errors."""
+        raise FileError(
+            message=f"System error {operation}: {path}",
+            error_code=ErrorCode.FILE_READ_ERROR,
+            details=str(error),
+            recovery="Check disk space and file system integrity",
+        ) from error
+
+    def _handle_disk_space_error(
+        self, error: OSError, path: str | Path, operation: str
+    ) -> None:
+        """Handle disk space errors."""
+        if "No space left on device" in str(error):
+            raise ResourceError(
+                message=f"Insufficient disk space to {operation}: {path}",
+                details=str(error),
+                recovery="Free up disk space and try again",
+            ) from error
+        raise FileError(
+            message=f"System error {operation}: {path}",
+            error_code=ErrorCode.FILE_WRITE_ERROR,
+            details=str(error),
+            recovery="Check disk space and file system integrity",
+        ) from error
+
     def read_file(self, path: str | Path) -> str:
         try:
             path_obj = Path(path) if isinstance(path, str) else path
-            if not path_obj.exists():
-                raise FileError(
-                    message=f"File does not exist: {path_obj}",
-                    details=f"Attempted to read file at {path_obj.absolute()}",
-                    recovery="Check file path and ensure file exists",
-                )
+            self._validate_path_exists(path_obj, "read")
             return path_obj.read_text(encoding="utf-8")
         except PermissionError as e:
-            raise FileError(
-                message=f"Permission denied reading file: {path}",
-                error_code=ErrorCode.PERMISSION_ERROR,
-                details=str(e),
-                recovery="Check file permissions and user access rights",
-            ) from e
+            self._handle_permission_error(e, path, "reading file")
+            raise  # Ensure type checker knows this doesn't return
         except UnicodeDecodeError as e:
-            raise FileError(
-                message=f"Unable to decode file as UTF-8: {path}",
-                error_code=ErrorCode.FILE_READ_ERROR,
-                details=str(e),
-                recovery="Ensure file is text - based and UTF-8 encoded",
-            ) from e
+            self._handle_unicode_error(e, path)
+            raise  # Ensure type checker knows this doesn't return
         except OSError as e:
-            raise FileError(
-                message=f"System error reading file: {path}",
-                error_code=ErrorCode.FILE_READ_ERROR,
-                details=str(e),
-                recovery="Check disk space and file system integrity",
-            ) from e
+            self._handle_os_error(e, path, "reading file")
+            raise  # Ensure type checker knows this doesn't return
 
     def write_file(self, path: str | Path, content: str) -> None:
         try:
@@ -99,12 +142,7 @@ class FileSystemService:
             path_obj = Path(path) if isinstance(path, str) else path
             path_obj.mkdir(parents=parents, exist_ok=True)
         except PermissionError as e:
-            raise FileError(
-                message=f"Permission denied creating directory: {path}",
-                error_code=ErrorCode.PERMISSION_ERROR,
-                details=str(e),
-                recovery="Check parent directory permissions",
-            ) from e
+            self._handle_permission_error(e, path, "creating directory")
         except FileExistsError as e:
             if not parents:
                 raise FileError(
@@ -113,18 +151,7 @@ class FileSystemService:
                     recovery="Use exist_ok=True or check if directory exists first",
                 ) from e
         except OSError as e:
-            if "No space left on device" in str(e):
-                raise ResourceError(
-                    message=f"Insufficient disk space to create directory: {path}",
-                    details=str(e),
-                    recovery="Free up disk space and try again",
-                ) from e
-            raise FileError(
-                message=f"System error creating directory: {path}",
-                error_code=ErrorCode.FILE_WRITE_ERROR,
-                details=str(e),
-                recovery="Check disk space and file system integrity",
-            ) from e
+            self._handle_disk_space_error(e, path, "create directory")
 
     def glob(self, pattern: str, path: str | Path | None = None) -> list[Path]:
         base_path = Path(path) if path else Path.cwd()
@@ -220,12 +247,7 @@ class FileSystemService:
         try:
             shutil.copy2(src_path, dst_path)
         except PermissionError as e:
-            raise FileError(
-                message=f"Permission denied copying file: {src} -> {dst}",
-                error_code=ErrorCode.PERMISSION_ERROR,
-                details=str(e),
-                recovery="Check file and directory permissions",
-            ) from e
+            self._handle_permission_error(e, f"{src} -> {dst}", "copying file")
         except shutil.SameFileError as e:
             raise FileError(
                 message=f"Source and destination are the same file: {src}",
@@ -234,18 +256,7 @@ class FileSystemService:
                 recovery="Ensure source and destination paths are different",
             ) from e
         except OSError as e:
-            if "No space left on device" in str(e):
-                raise ResourceError(
-                    message=f"Insufficient disk space to copy file: {src} -> {dst}",
-                    details=str(e),
-                    recovery="Free up disk space and try again",
-                ) from e
-            raise FileError(
-                message=f"System error copying file: {src} -> {dst}",
-                error_code=ErrorCode.FILE_WRITE_ERROR,
-                details=str(e),
-                recovery="Check disk space and file system integrity",
-            ) from e
+            self._handle_disk_space_error(e, f"{src} -> {dst}", "copy file")
 
     def remove_file(self, path: str | Path) -> None:
         try:
@@ -342,69 +353,29 @@ class FileSystemService:
     ) -> Iterator[str]:
         try:
             path_obj = Path(path) if isinstance(path, str) else path
-            if not path_obj.exists():
-                raise FileError(
-                    message=f"File does not exist: {path_obj}",
-                    details=f"Attempted to read file at {path_obj.absolute()}",
-                    recovery="Check file path and ensure file exists",
-                )
+            self._validate_path_exists(path_obj, "read")
 
             with path_obj.open(encoding="utf-8") as file:
                 while chunk := file.read(chunk_size):
                     yield chunk
 
         except PermissionError as e:
-            raise FileError(
-                message=f"Permission denied reading file: {path}",
-                error_code=ErrorCode.PERMISSION_ERROR,
-                details=str(e),
-                recovery="Check file permissions",
-            ) from e
+            self._handle_permission_error(e, path, "reading file")
         except UnicodeDecodeError as e:
-            raise FileError(
-                message=f"File encoding error: {path}",
-                error_code=ErrorCode.FILE_READ_ERROR,
-                details=str(e),
-                recovery="Ensure file is encoded in UTF-8",
-            ) from e
+            self._handle_unicode_error(e, path)
         except OSError as e:
-            raise FileError(
-                message=f"System error reading file: {path}",
-                error_code=ErrorCode.FILE_READ_ERROR,
-                details=str(e),
-                recovery="Check file system integrity",
-            ) from e
+            self._handle_os_error(e, path, "reading file")
 
     def read_lines_streaming(self, path: str | Path) -> Iterator[str]:
         try:
             path_obj = Path(path) if isinstance(path, str) else path
-            if not path_obj.exists():
-                raise FileError(
-                    message=f"File does not exist: {path_obj}",
-                    details=f"Attempted to read file at {path_obj.absolute()}",
-                    recovery="Check file path and ensure file exists",
-                )
+            self._validate_path_exists(path_obj, "read")
             with path_obj.open(encoding="utf-8") as file:
                 for line in file:
                     yield line.rstrip("\n\r")
         except PermissionError as e:
-            raise FileError(
-                message=f"Permission denied reading file: {path}",
-                error_code=ErrorCode.PERMISSION_ERROR,
-                details=str(e),
-                recovery="Check file permissions",
-            ) from e
+            self._handle_permission_error(e, path, "reading file")
         except UnicodeDecodeError as e:
-            raise FileError(
-                message=f"File encoding error: {path}",
-                error_code=ErrorCode.FILE_READ_ERROR,
-                details=str(e),
-                recovery="Ensure file is encoded in UTF-8",
-            ) from e
+            self._handle_unicode_error(e, path)
         except OSError as e:
-            raise FileError(
-                message=f"System error reading file: {path}",
-                error_code=ErrorCode.FILE_READ_ERROR,
-                details=str(e),
-                recovery="Check file system integrity",
-            ) from e
+            self._handle_os_error(e, path, "reading file")

crackerjack/services/git.py

@@ -1,8 +1,11 @@
-import subprocess
+import subprocess  # nosec B404
 import typing as t
 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 GitInterface
 
 from .secure_subprocess import execute_secure_subprocess
 from .security_logger import get_security_logger
@@ -18,6 +21,7 @@ GIT_COMMANDS = {
     "commit": ["commit", "-m"],
     "add_updated": ["add", "-u"],
     "push_porcelain": ["push", "--porcelain"],
+    "push_with_tags": ["push", "--porcelain", "--follow-tags"],
     "current_branch": ["branch", "--show-current"],
     "commits_ahead": ["rev-list", "--count", "@{u}..HEAD"],
 }
@@ -31,8 +35,9 @@ class FailedGitResult:
         self.stderr = f"Git security validation failed: {error}"
 
 
-class GitService:
-    def __init__(self, console: Console, pkg_path: Path | None = None) -> None:
+class GitService(GitInterface):
+    @depends.inject
+    def __init__(self, console: Inject[Console], pkg_path: Path | None = None) -> None:
         self.console = console
         self.pkg_path = pkg_path or Path.cwd()
 
@@ -156,7 +161,7 @@ class GitService:
 
     def _retry_commit_after_restage(self, message: str) -> bool:
         self.console.print(
-            "[yellow]🔄[/ yellow] Pre - commit hooks modified files - attempting to re-stage and retry commit"
+            "[yellow]🔄[/yellow] Pre-commit hooks modified files - attempting to re-stage and retry commit"
         )
 
         add_result = self._run_git_command(GIT_COMMANDS["add_updated"])
@@ -204,6 +209,19 @@ class GitService:
             self.console.print(f"[red]❌[/ red] Error pushing: {e}")
             return False
 
+    def push_with_tags(self) -> bool:
+        """Push commits and any tags to remote using --follow-tags."""
+        try:
+            result = self._run_git_command(GIT_COMMANDS["push_with_tags"])
+            if result.returncode == 0:
+                self._display_push_success(result.stdout)
+                return True
+            self.console.print(f"[red]❌[/ red] Push failed: {result.stderr}")
+            return False
+        except Exception as e:
+            self.console.print(f"[red]❌[/ red] Error pushing: {e}")
+            return False
+
     def _display_push_success(self, push_output: str) -> None:
         lines = push_output.strip().split("\n") if push_output.strip() else []
 
@@ -326,3 +344,79 @@ class GitService:
             if result.returncode == 0 and result.stdout.strip().isdigit():
                 return int(result.stdout.strip())
         return 0
+
+    def get_changed_files_by_extension(
+        self,
+        extensions: list[str],
+        include_staged: bool = True,
+        include_unstaged: bool = True,
+    ) -> list[Path]:
+        """Get changed files filtered by file extensions.
+
+        Args:
+            extensions: List of extensions to filter by (e.g., [".py", ".md"])
+            include_staged: Include staged files in results
+            include_unstaged: Include unstaged files in results
+
+        Returns:
+            List of Path objects for changed files matching the extensions
+
+        Example:
+            >>> git_service.get_changed_files_by_extension([".py"])
+            [Path("crackerjack/services/git.py"), Path("tests/test_git.py")]
+        """
+        try:
+            all_changed: set[str] = set()
+
+            if include_staged:
+                staged_result = self._run_git_command(GIT_COMMANDS["staged_files"])
+                if staged_result.stdout.strip():
+                    all_changed.update(staged_result.stdout.strip().split("\n"))
+
+            if include_unstaged:
+                unstaged_result = self._run_git_command(GIT_COMMANDS["unstaged_files"])
+                if unstaged_result.stdout.strip():
+                    all_changed.update(unstaged_result.stdout.strip().split("\n"))
+
+            # Filter by extensions
+            filtered = [
+                self.pkg_path / f
+                for f in all_changed
+                if f and any(f.endswith(ext) for ext in extensions)
+            ]
+
+            # Only return files that actually exist
+            return [f for f in filtered if f.exists()]
+
+        except Exception as e:
+            self.console.print(
+                f"[yellow]⚠️[/yellow] Error getting changed files by extension: {e}"
+            )
+            return []
+
+    def get_current_commit_hash(self) -> str | None:
+        """Get the hash of the current commit (HEAD)."""
+        try:
+            result = self._run_git_command(["rev-parse", "HEAD"])
+            if result.returncode == 0 and result.stdout.strip():
+                return result.stdout.strip()
+            return None
+        except Exception:
+            self.console.print("[red]❌[/red] Error getting current commit hash")
+            return None
+
+    def reset_hard(self, commit_hash: str) -> bool:
+        """Reset the repository to a specific commit hash (hard reset)."""
+        try:
+            result = self._run_git_command(["reset", "--hard", commit_hash])
+            if result.returncode == 0:
+                self.console.print(
+                    f"[green]✅[/green] Repository reset to {commit_hash[:8]}"
+                )
+                return True
+            else:
+                self.console.print(f"[red]❌[/red] Reset failed: {result.stderr}")
+                return False
+        except Exception as e:
+            self.console.print(f"[red]❌[/red] Error during reset: {e}")
+            return False

crackerjack/services/health_metrics.py

@@ -347,11 +347,11 @@ class HealthMetricsService:
         try:
             from urllib.parse import urlparse
 
-            url = f"https://pypi.org/pypi/{package_name}/json"
+            url = f"https: //pypi.org/pypi/{package_name}/json"
 
             parsed = urlparse(url)
             if parsed.scheme != "https" or parsed.netloc != "pypi.org":
-                msg = f"Invalid URL: only https://pypi.org URLs are allowed, got {url}"
+                msg = f"Invalid URL: only https: //pypi.org URLs are allowed, got {url}"
                 raise ValueError(msg)
 
             if not parsed.path.startswith("/pypi/") or not parsed.path.endswith(
@@ -362,8 +362,7 @@ class HealthMetricsService:
 
             response = requests.get(url, timeout=10, verify=True)
             response.raise_for_status()
-            json_result = response.json()
-            return t.cast(dict[str, t.Any] | None, json_result)
+            return response.json()
         except Exception:
             return None
 
@@ -379,8 +378,7 @@ class HealthMetricsService:
         if not release_info:
             return None
 
-        upload_time_raw = release_info[0].get("upload_time", "")
-        return t.cast(str | None, upload_time_raw)
+        return release_info[0].get("upload_time", "")
 
     def _calculate_days_since_upload(self, upload_time: str) -> int | None:
         try:

crackerjack/services/heatmap_generator.py

@@ -205,7 +205,11 @@ class HeatMapGenerator:
         bucket_config: dict[str, t.Any],
     ) -> dict[str, t.Any]:
         """Build error count matrix for files and time buckets."""
-        error_matrix: dict[str, dict[int, int]] = defaultdict(lambda: defaultdict(int))
+        from collections import defaultdict
+
+        error_matrix: dict[str, t.Any] = defaultdict(
+            lambda: defaultdict(int)  # type: ignore[call-overload]
+        )
 
         for file_path, errors in self.error_data.items():
             for error in errors:
@@ -450,7 +454,7 @@ class HeatMapGenerator:
 
     def _calculate_metric_max_values(self, metric_types: list[str]) -> dict[str, float]:
         """Calculate max values for normalization."""
-        max_values = {}
+        max_values: dict[str, float] = {}
         for metric_type in metric_types:
             values = [
                 data["metrics"][metric_type]
@@ -558,8 +562,13 @@ class HeatMapGenerator:
         self, test_errors: list[dict[str, t.Any]]
     ) -> defaultdict[str, defaultdict[str, int]]:
         """Group test errors by file and error type."""
+        from collections import defaultdict as dd
+
+        def make_inner_defaultdict() -> defaultdict[str, int]:
+            return dd(int)
+
         test_matrix: defaultdict[str, defaultdict[str, int]] = defaultdict(
-            lambda: defaultdict(int)
+            make_inner_defaultdict
         )
 
         for error in test_errors: