crackerjack 0.33.0__py3-none-any.whl → 0.33.2__py3-none-any.whl

crackerjack/cli/utils.py

@@ -13,6 +13,7 @@ def get_package_version() -> str:
             pyproject_path = Path(__file__).parent.parent.parent / "pyproject.toml"
             with pyproject_path.open("rb") as f:
                 pyproject_data = tomllib.load(f)
-            return pyproject_data["project"]["version"]
+            version_value = pyproject_data["project"]["version"]
+            return str(version_value)
         except Exception:
             return "unknown"

crackerjack/code_cleaner.py

@@ -22,31 +22,31 @@ from .services.security_logger import (
 
 
 class SafePatternApplicator:
-    """Safe pattern applicator using centralized SAFE_PATTERNS."""
-
     def apply_docstring_patterns(self, code: str) -> str:
-        """Apply docstring removal patterns safely."""
         result = code
         result = SAFE_PATTERNS["docstring_triple_double"].apply(result)
         result = SAFE_PATTERNS["docstring_triple_single"].apply(result)
         return result
 
     def apply_formatting_patterns(self, content: str) -> str:
-        """Apply formatting patterns safely."""
-        # Apply spacing patterns
         content = SAFE_PATTERNS["spacing_after_comma"].apply(content)
         content = SAFE_PATTERNS["spacing_after_colon"].apply(content)
         content = SAFE_PATTERNS["multiple_spaces"].apply(content)
         return content
 
     def has_preserved_comment(self, line: str) -> bool:
-        """Check if a line contains preserved comments."""
         if line.strip().startswith("#! /"):
             return True
 
-        # Check for preserved comment keywords
         line_lower = line.lower()
-        preserved_keywords = ["coding:", "encoding:", "type:", "noqa", "pragma"]
+        preserved_keywords = [
+            "coding: ",
+            "encoding: ",
+            "type: ",
+            "noqa",
+            "pragma",
+            "regex ok",
+        ]
         return any(keyword in line_lower for keyword in preserved_keywords)
 
 
@@ -421,22 +421,13 @@ class CodeCleaner(BaseModel):
             self._create_formatting_step(),
         ]
 
-        return self.pipeline.clean_file(file_path, cleaning_steps)
+        result = self.pipeline.clean_file(file_path, cleaning_steps)
+        return t.cast(CleaningResult, result)
 
     def clean_files(
         self, pkg_dir: Path | None = None, use_backup: bool = True
     ) -> list[CleaningResult] | PackageCleaningResult:
-        """Clean package files with optional backup protection.
-
-        Args:
-            pkg_dir: Package directory to clean (defaults to current directory)
-            use_backup: Whether to use backup protection (default: True for safety)
-
-        Returns:
-            PackageCleaningResult with backup protection (default), list[CleaningResult] if use_backup=False (legacy)
-        """
         if use_backup:
-            # Use the comprehensive backup system for maximum safety
             package_result = self.clean_files_with_backup(pkg_dir)
             self.logger.info(
                 f"Package cleaning with backup completed: "
@@ -445,7 +436,6 @@ class CodeCleaner(BaseModel):
             )
             return package_result
 
-        # Legacy non-backup mode (deprecated, kept for compatibility)
         self.console.print(
             "[yellow]⚠️ WARNING: Running without backup protection. "
             "Consider using use_backup=True for safety.[/yellow]"
@@ -519,9 +509,10 @@ class CodeCleaner(BaseModel):
             "[yellow]📦 Creating backup of all package files...[/yellow]"
         )
 
-        backup_metadata = self.backup_service.create_package_backup(
+        backup_result = self.backup_service.create_package_backup(
             validated_pkg_dir, self.base_directory
         )
+        backup_metadata: BackupMetadata = t.cast(BackupMetadata, backup_result)
 
         self.console.print(
             f"[green]✅ Backup created: {backup_metadata.backup_id}[/green] "
@@ -539,23 +530,9 @@ class CodeCleaner(BaseModel):
         ]
 
     def _discover_package_files(self, root_dir: Path) -> list[Path]:
-        """Discover Python files in the main package directory using crackerjack naming convention.
-
-        Crackerjack convention:
-        - Project name with dashes → package name with underscores
-        - Single word → same name lowercase
-        - Package directory determined from pyproject.toml [project.name]
-
-        Args:
-            root_dir: Project root directory
-
-        Returns:
-            List of Python files found only in the main package directory
-        """
         package_dir = self._find_package_directory(root_dir)
 
         if not package_dir or not package_dir.exists():
-            # Fallback: look for any directory with __init__.py (excluding common non-package dirs)
             self.console.print(
                 "[yellow]⚠️ Could not determine package directory, searching for Python packages...[/yellow]"
             )
@@ -563,10 +540,8 @@ class CodeCleaner(BaseModel):
 
         self.logger.debug(f"Using package directory: {package_dir}")
 
-        # Get all Python files from the package directory only
-        package_files = list(package_dir.rglob("*.py"))
+        package_files = list[t.Any](package_dir.rglob("*.py"))
 
-        # Filter out any problematic subdirectories that might exist within the package
         exclude_dirs = {
             "__pycache__",
             ".pytest_cache",
@@ -584,15 +559,6 @@ class CodeCleaner(BaseModel):
         return filtered_files
 
     def _find_package_directory(self, root_dir: Path) -> Path | None:
-        """Find the main package directory using crackerjack naming convention.
-
-        Args:
-            root_dir: Project root directory
-
-        Returns:
-            Path to package directory or None if not found
-        """
-        # First, try to get project name from pyproject.toml
         pyproject_path = root_dir / "pyproject.toml"
         if pyproject_path.exists():
             try:
@@ -601,9 +567,9 @@ class CodeCleaner(BaseModel):
                 with pyproject_path.open("rb") as f:
                     config = tomllib.load(f)
 
-                project_name = config.get("project", {}).get("name")
+                project_name_raw = config.get("project", {}).get("name")
+                project_name: str | None = t.cast(str | None, project_name_raw)
                 if project_name:
-                    # Apply crackerjack naming convention
                     package_name = project_name.replace("-", "_").lower()
                     package_dir = root_dir / package_name
 
@@ -613,7 +579,6 @@ class CodeCleaner(BaseModel):
             except Exception as e:
                 self.logger.debug(f"Could not parse pyproject.toml: {e}")
 
-        # Fallback: infer from directory name
         package_name = root_dir.name.replace("-", "_").lower()
         package_dir = root_dir / package_name
 
@@ -623,7 +588,6 @@ class CodeCleaner(BaseModel):
         return None
 
     def _fallback_discover_packages(self, root_dir: Path) -> list[Path]:
-        """Fallback method to discover package files when convention-based detection fails."""
         python_files = []
         exclude_dirs = {
             "__pycache__",
@@ -669,11 +633,8 @@ class CodeCleaner(BaseModel):
     def _should_include_file_path(
         self, file_path: Path, exclude_dirs: set[str]
     ) -> bool:
-        """Check if a file path should be included (not in excluded directories)."""
-        # Convert path parts to set for efficient lookup
-        path_parts = set(file_path.parts)
+        path_parts = set[t.Any](file_path.parts)
 
-        # If any part of the path is in exclude_dirs, exclude it
         return not bool(path_parts.intersection(exclude_dirs))
 
     def _handle_no_files_to_process(
@@ -864,11 +825,6 @@ class CodeCleaner(BaseModel):
             return False
 
     def restore_from_backup_metadata(self, backup_metadata: BackupMetadata) -> None:
-        """Manually restore from backup metadata.
-
-        Args:
-            backup_metadata: Backup metadata containing restoration information
-        """
         self.console.print(
             f"[yellow]🔄 Manually restoring from backup: {backup_metadata.backup_id}[/yellow]"
         )
@@ -881,14 +837,6 @@ class CodeCleaner(BaseModel):
         )
 
     def create_emergency_backup(self, pkg_dir: Path | None = None) -> BackupMetadata:
-        """Create an emergency backup before potentially risky operations.
-
-        Args:
-            pkg_dir: Package directory to backup (defaults to current directory)
-
-        Returns:
-            BackupMetadata for the created backup
-        """
         validated_pkg_dir = self._prepare_package_directory(pkg_dir)
 
         self.console.print(
@@ -904,14 +852,6 @@ class CodeCleaner(BaseModel):
         return backup_metadata
 
     def restore_emergency_backup(self, backup_metadata: BackupMetadata) -> bool:
-        """Restore from an emergency backup with enhanced error handling.
-
-        Args:
-            backup_metadata: Backup metadata for restoration
-
-        Returns:
-            True if restoration succeeded, False otherwise
-        """
         try:
             self.console.print(
                 f"[yellow]🔄 Restoring emergency backup: {backup_metadata.backup_id}[/yellow]"
@@ -938,14 +878,6 @@ class CodeCleaner(BaseModel):
             return False
 
     def verify_backup_integrity(self, backup_metadata: BackupMetadata) -> bool:
-        """Verify the integrity of a backup without restoring it.
-
-        Args:
-            backup_metadata: Backup metadata to verify
-
-        Returns:
-            True if backup is valid and can be restored, False otherwise
-        """
         try:
             validation_result = self.backup_service._validate_backup(backup_metadata)
 
@@ -960,14 +892,12 @@ class CodeCleaner(BaseModel):
                     f"[red]❌ Backup verification failed: {backup_metadata.backup_id}[/red]"
                 )
 
-                for error in validation_result.validation_errors[
-                    :3
-                ]:  # Show first 3 errors
-                    self.console.print(f"[red]  • {error}[/red]")
+                for error in validation_result.validation_errors[:3]:
+                    self.console.print(f"[red] • {error}[/red]")
 
                 if len(validation_result.validation_errors) > 3:
                     remaining = len(validation_result.validation_errors) - 3
-                    self.console.print(f"[red]  ... and {remaining} more errors[/red]")
+                    self.console.print(f"[red] ... and {remaining} more errors[/red]")
 
                 return False
 
@@ -977,11 +907,6 @@ class CodeCleaner(BaseModel):
             return False
 
     def list_available_backups(self) -> list[Path]:
-        """List all available backup directories.
-
-        Returns:
-            List of backup directory paths
-        """
         if (
             not self.backup_service.backup_root
             or not self.backup_service.backup_root.exists()
@@ -998,17 +923,17 @@ class CodeCleaner(BaseModel):
 
             if backup_dirs:
                 self.console.print(
-                    f"[cyan]📦 Found {len(backup_dirs)} available backups:[/cyan]"
+                    f"[cyan]📦 Found {len(backup_dirs)} available backups: [/cyan]"
                 )
                 for backup_dir in sorted(backup_dirs):
-                    self.console.print(f"  • {backup_dir.name}")
+                    self.console.print(f" • {backup_dir.name}")
             else:
                 self.console.print("[yellow]⚠️ No backups found[/yellow]")
 
             return backup_dirs
 
         except Exception as e:
-            self.logger.error(f"Failed to list backups: {e}")
+            self.logger.error(f"Failed to list[t.Any] backups: {e}")
             self.console.print(f"[red]💥 Error listing backups: {e}[/red]")
             return []
 
@@ -1172,33 +1097,50 @@ class CodeCleaner(BaseModel):
             return _safe_applicator.has_preserved_comment(stripped_line)
 
         def _remove_comment_from_line(self, line: str) -> str:
-            if '"' not in line and "'" not in line and "#" not in line:
+            """Remove comment from line while preserving strings."""
+            if not self._line_needs_comment_processing(line):
                 return line
 
+            return self._process_line_for_comment_removal(line)
+
+        def _line_needs_comment_processing(self, line: str) -> bool:
+            """Check if line needs comment processing."""
+            return '"' in line or "'" in line or "#" in line
+
+        def _process_line_for_comment_removal(self, line: str) -> str:
+            """Process line to remove comments while preserving strings."""
             result_chars = []
-            in_string = False
-            quote_char = None
-            i = 0
-            length = len(line)
-
-            while i < length:
-                char = line[i]
-
-                if not in_string:
-                    if char == "#":
-                        break
-                    elif char in ('"', "'"):
-                        in_string = True
-                        quote_char = char
-                elif char == quote_char and (i == 0 or line[i - 1] != "\\"):
-                    in_string = False
-                    quote_char = None
+            string_state = {"in_string": False, "quote_char": None}
+
+            for i, char in enumerate(line):
+                if self._should_break_for_comment(char, string_state):
+                    break
 
+                self._update_string_state(char, i, line, string_state)
                 result_chars.append(char)
-                i += 1
 
             return "".join(result_chars).rstrip()
 
+        def _should_break_for_comment(
+            self, char: str, string_state: dict[str, t.Any]
+        ) -> bool:
+            """Check if we should break for a comment character."""
+            return not string_state["in_string"] and char == "#"
+
+        def _update_string_state(
+            self, char: str, index: int, line: str, string_state: dict[str, t.Any]
+        ) -> None:
+            """Update string parsing state."""
+            if not string_state["in_string"]:
+                if char in ('"', "'"):
+                    string_state["in_string"] = True
+                    string_state["quote_char"] = char
+            elif char == string_state["quote_char"] and (
+                index == 0 or line[index - 1] != "\\"
+            ):
+                string_state["in_string"] = False
+                string_state["quote_char"] = None
+
     def _create_docstring_finder_class(
         self,
         docstring_nodes: list[ast.AST],
@@ -1258,7 +1200,6 @@ class CodeCleaner(BaseModel):
                         )
                         content = cleaned_line.lstrip()
 
-                        # Use SAFE_PATTERNS for multiple spaces replacement
                         content = SAFE_PATTERNS["multiple_spaces"].apply(content)
 
                         cleaned_line = cleaned_line[:leading_whitespace] + content

crackerjack/config/global_lock_config.py

@@ -8,35 +8,24 @@ from ..models.protocols import OptionsProtocol
 
 @dataclass
 class GlobalLockConfig:
-    """Configuration for global hook locking system."""
-
     enabled: bool = True
-    timeout_seconds: float = 600.0  # 10 minutes default
-    stale_lock_hours: float = 2.0  # Clean locks older than 2 hours
+    timeout_seconds: float = 600.0
+    stale_lock_hours: float = 2.0
     lock_directory: Path = field(
         default_factory=lambda: Path.home() / ".crackerjack" / "locks"
     )
-    session_heartbeat_interval: float = 30.0  # Heartbeat every 30s
+    session_heartbeat_interval: float = 30.0
     max_retry_attempts: int = 3
     retry_delay_seconds: float = 5.0
     enable_lock_monitoring: bool = True
 
     @classmethod
-    def from_options(cls, options: "OptionsProtocol") -> "GlobalLockConfig":
-        """Create GlobalLockConfig from CLI options.
-
-        Args:
-            options: Options object containing CLI arguments
-
-        Returns:
-            Configured GlobalLockConfig instance
-        """
-        # Import here to avoid circular import
-
-        # Create config with custom values from options
+    def from_options(
+        cls: type["GlobalLockConfig"], options: "OptionsProtocol"
+    ) -> "GlobalLockConfig":
         enabled = not options.disable_global_locks
         timeout_seconds = float(options.global_lock_timeout)
-        # Get default lock directory from field definition
+
         default_lock_dir = Path.home() / ".crackerjack" / "locks"
         lock_directory = (
             Path(options.global_lock_dir)
@@ -44,7 +33,6 @@ class GlobalLockConfig:
             else default_lock_dir
         )
 
-        # Create instance with all parameters so __post_init__ is called
         config = cls(
             enabled=enabled,
             timeout_seconds=timeout_seconds,
@@ -54,56 +42,28 @@ class GlobalLockConfig:
         return config
 
     def __post_init__(self) -> None:
-        """Ensure lock directory exists and has proper permissions."""
         self.lock_directory.mkdir(parents=True, exist_ok=True)
-        # Set restrictive permissions (owner read/write only)
+
         self.lock_directory.chmod(0o700)
 
     @property
     def hostname(self) -> str:
-        """Get the current hostname for lock identification."""
         return socket.gethostname()
 
     @property
     def session_id(self) -> str:
-        """Get a unique session identifier."""
         return f"{self.hostname}_{os.getpid()}"
 
     def get_lock_path(self, hook_name: str) -> Path:
-        """Get the lock file path for a specific hook.
-
-        Args:
-            hook_name: Name of the hook
-
-        Returns:
-            Path to the lock file
-        """
         return self.lock_directory / f"{hook_name}.lock"
 
     def get_heartbeat_path(self, hook_name: str) -> Path:
-        """Get the heartbeat file path for a specific hook.
-
-        Args:
-            hook_name: Name of the hook
-
-        Returns:
-            Path to the heartbeat file
-        """
         return self.lock_directory / f"{hook_name}.heartbeat"
 
     def is_valid_lock_file(self, lock_path: Path) -> bool:
-        """Check if a lock file is valid (not stale).
-
-        Args:
-            lock_path: Path to the lock file
-
-        Returns:
-            True if the lock file is valid and not stale
-        """
         if not lock_path.exists():
             return False
 
-        # Check if the lock file is older than stale_lock_hours
         import time
 
         file_age_hours = (time.time() - lock_path.stat().st_mtime) / 3600