crackerjack 0.29.0__py3-none-any.whl → 0.31.4__py3-none-any.whl

crackerjack/services/cache.py

@@ -0,0 +1,314 @@
+import hashlib
+import json
+import time
+import typing as t
+from dataclasses import asdict, dataclass, field
+from pathlib import Path
+
+from crackerjack.models.task import HookResult
+
+
+@dataclass
+class CacheEntry:
+    key: str
+    value: t.Any
+    created_at: float = field(default_factory=time.time)
+    accessed_at: float = field(default_factory=time.time)
+    ttl_seconds: int = 3600
+    access_count: int = 0
+
+    @property
+    def is_expired(self) -> bool:
+        return (time.time() - self.created_at) > self.ttl_seconds
+
+    @property
+    def age_seconds(self) -> int:
+        return int(time.time() - self.created_at)
+
+    def touch(self) -> None:
+        self.accessed_at = time.time()
+        self.access_count += 1
+
+    def to_dict(self) -> dict[str, t.Any]:
+        """Convert to JSON-serializable dict."""
+        return asdict(self)
+
+    @classmethod
+    def from_dict(cls, data: dict[str, t.Any]) -> "CacheEntry":
+        """Create from dict loaded from JSON."""
+        return cls(**data)
+
+
+@dataclass
+class CacheStats:
+    hits: int = 0
+    misses: int = 0
+    evictions: int = 0
+    total_entries: int = 0
+    total_size_bytes: int = 0
+
+    @property
+    def hit_rate(self) -> float:
+        total = self.hits + self.misses
+        return (self.hits / total * 100) if total > 0 else 0.0
+
+    def to_dict(self) -> dict[str, t.Any]:
+        return {
+            "hits": self.hits,
+            "misses": self.misses,
+            "evictions": self.evictions,
+            "total_entries": self.total_entries,
+            "hit_rate_percent": round(self.hit_rate, 2),
+            "total_size_mb": round(self.total_size_bytes / 1024 / 1024, 2),
+        }
+
+
+class InMemoryCache:
+    def __init__(self, max_entries: int = 1000, default_ttl: int = 3600) -> None:
+        self.max_entries = max_entries
+        self.default_ttl = default_ttl
+        self._cache: dict[str, CacheEntry] = {}
+        self.stats = CacheStats()
+
+    def get(self, key: str) -> t.Any | None:
+        entry = self._cache.get(key)
+
+        if entry is None:
+            self.stats.misses += 1
+            return None
+
+        if entry.is_expired:
+            del self._cache[key]
+            self.stats.misses += 1
+            self.stats.evictions += 1
+            return None
+
+        entry.touch()
+        self.stats.hits += 1
+        return entry.value
+
+    def set(self, key: str, value: t.Any, ttl_seconds: int | None = None) -> None:
+        if ttl_seconds is None:
+            ttl_seconds = self.default_ttl
+
+        if len(self._cache) >= self.max_entries:
+            self._evict_lru()
+
+        self._cache[key] = CacheEntry(
+            key=key,
+            value=value,
+            ttl_seconds=ttl_seconds,
+        )
+
+        self.stats.total_entries = len(self._cache)
+
+    def invalidate(self, key: str) -> bool:
+        if key in self._cache:
+            del self._cache[key]
+            self.stats.total_entries = len(self._cache)
+            return True
+        return False
+
+    def clear(self) -> None:
+        evicted = len(self._cache)
+        self._cache.clear()
+        self.stats.evictions += evicted
+        self.stats.total_entries = 0
+
+    def cleanup_expired(self) -> int:
+        expired_keys = [key for key, entry in self._cache.items() if entry.is_expired]
+
+        for key in expired_keys:
+            del self._cache[key]
+
+        self.stats.evictions += len(expired_keys)
+        self.stats.total_entries = len(self._cache)
+        return len(expired_keys)
+
+    def _evict_lru(self) -> None:
+        if not self._cache:
+            return
+
+        lru_key = min(self._cache.keys(), key=lambda k: self._cache[k].accessed_at)
+
+        del self._cache[lru_key]
+        self.stats.evictions += 1
+
+
+class FileCache:
+    def __init__(self, cache_dir: Path, namespace: str = "crackerjack") -> None:
+        self.cache_dir = cache_dir / namespace
+        self.cache_dir.mkdir(parents=True, exist_ok=True)
+        self.stats = CacheStats()
+
+    def get(self, key: str) -> t.Any | None:
+        cache_file = self._get_cache_file(key)
+
+        if not cache_file.exists():
+            self.stats.misses += 1
+            return None
+
+        try:
+            with cache_file.open(encoding="utf-8") as f:
+                data = json.load(f)
+                entry = CacheEntry.from_dict(data)
+
+            if entry.is_expired:
+                cache_file.unlink(missing_ok=True)
+                self.stats.misses += 1
+                self.stats.evictions += 1
+                return None
+
+            entry.touch()
+
+            with cache_file.open("w", encoding="utf-8") as f:
+                json.dump(entry.to_dict(), f)
+
+            self.stats.hits += 1
+            return entry.value
+
+        except (json.JSONDecodeError, FileNotFoundError, OSError, KeyError):
+            self.stats.misses += 1
+            cache_file.unlink(missing_ok=True)
+            return None
+
+    def set(self, key: str, value: t.Any, ttl_seconds: int = 3600) -> None:
+        cache_file = self._get_cache_file(key)
+
+        entry = CacheEntry(
+            key=key,
+            value=value,
+            ttl_seconds=ttl_seconds,
+        )
+
+        try:
+            with cache_file.open("w", encoding="utf-8") as f:
+                json.dump(entry.to_dict(), f)
+        except (json.JSONDecodeError, OSError, KeyError):
+            pass
+
+    def invalidate(self, key: str) -> bool:
+        cache_file = self._get_cache_file(key)
+        if cache_file.exists():
+            cache_file.unlink()
+            return True
+        return False
+
+    def clear(self) -> None:
+        for cache_file in self.cache_dir.glob("*.cache"):
+            cache_file.unlink(missing_ok=True)
+
+    def cleanup_expired(self) -> int:
+        removed = 0
+        for cache_file in self.cache_dir.glob("*.cache"):
+            try:
+                with cache_file.open(encoding="utf-8") as f:
+                    data = json.load(f)
+                    entry = CacheEntry.from_dict(data)
+
+                if entry.is_expired:
+                    cache_file.unlink()
+                    removed += 1
+            except (json.JSONDecodeError, FileNotFoundError, OSError, KeyError):
+                cache_file.unlink(missing_ok=True)
+                removed += 1
+
+        self.stats.evictions += removed
+        return removed
+
+    def _get_cache_file(self, key: str) -> Path:
+        safe_key = hashlib.md5(key.encode(), usedforsecurity=False).hexdigest()
+        return self.cache_dir / f"{safe_key}.cache"
+
+
+class CrackerjackCache:
+    def __init__(
+        self,
+        cache_dir: Path | None = None,
+        enable_disk_cache: bool = True,
+    ) -> None:
+        self.cache_dir = cache_dir or Path.cwd() / ".crackerjack_cache"
+        self.enable_disk_cache = enable_disk_cache
+
+        self.hook_results_cache = InMemoryCache(max_entries=500, default_ttl=1800)
+        self.file_hash_cache = InMemoryCache(max_entries=2000)
+        self.config_cache = InMemoryCache(max_entries=100, default_ttl=7200)
+
+        if enable_disk_cache:
+            self.disk_cache = FileCache(self.cache_dir)
+
+    def get_hook_result(
+        self,
+        hook_name: str,
+        file_hashes: list[str],
+    ) -> HookResult | None:
+        cache_key = self._get_hook_cache_key(hook_name, file_hashes)
+        return self.hook_results_cache.get(cache_key)
+
+    def set_hook_result(
+        self,
+        hook_name: str,
+        file_hashes: list[str],
+        result: HookResult,
+    ) -> None:
+        cache_key = self._get_hook_cache_key(hook_name, file_hashes)
+        self.hook_results_cache.set(cache_key, result, ttl_seconds=1800)
+
+    def get_file_hash(self, file_path: Path) -> str | None:
+        stat = file_path.stat()
+        cache_key = f"file_hash:{file_path}:{stat.st_mtime}:{stat.st_size}"
+        return self.file_hash_cache.get(cache_key)
+
+    def set_file_hash(self, file_path: Path, file_hash: str) -> None:
+        stat = file_path.stat()
+        cache_key = f"file_hash:{file_path}:{stat.st_mtime}:{stat.st_size}"
+        self.file_hash_cache.set(cache_key, file_hash, ttl_seconds=3600)
+
+    def get_config_data(self, config_key: str) -> t.Any | None:
+        return self.config_cache.get(f"config:{config_key}")
+
+    def set_config_data(self, config_key: str, data: t.Any) -> None:
+        self.config_cache.set(f"config:{config_key}", data, ttl_seconds=7200)
+
+    def invalidate_hook_cache(self, hook_name: str | None = None) -> None:
+        if hook_name:
+            keys_to_remove = [
+                key
+                for key in self.hook_results_cache._cache
+                if key.startswith(f"hook_result:{hook_name}:")
+            ]
+            for key in keys_to_remove:
+                self.hook_results_cache.invalidate(key)
+        else:
+            self.hook_results_cache.clear()
+
+    def cleanup_all(self) -> dict[str, int]:
+        results = {
+            "hook_results": self.hook_results_cache.cleanup_expired(),
+            "file_hashes": self.file_hash_cache.cleanup_expired(),
+            "config": self.config_cache.cleanup_expired(),
+        }
+
+        if self.enable_disk_cache:
+            results["disk_cache"] = self.disk_cache.cleanup_expired()
+
+        return results
+
+    def get_cache_stats(self) -> dict[str, t.Any]:
+        stats = {
+            "hook_results": self.hook_results_cache.stats.to_dict(),
+            "file_hashes": self.file_hash_cache.stats.to_dict(),
+            "config": self.config_cache.stats.to_dict(),
+        }
+
+        if self.enable_disk_cache:
+            stats["disk_cache"] = self.disk_cache.stats.to_dict()
+
+        return stats
+
+    def _get_hook_cache_key(self, hook_name: str, file_hashes: list[str]) -> str:
+        hash_signature = hashlib.md5(
+            ",".join(sorted(file_hashes)).encode(),
+            usedforsecurity=False,
+        ).hexdigest()
+        return f"hook_result:{hook_name}:{hash_signature}"

crackerjack/services/config.py

@@ -0,0 +1,347 @@
+import subprocess
+import typing as t
+from pathlib import Path
+
+from rich.console import Console
+
+from crackerjack.dynamic_config import DynamicConfigGenerator, generate_config_for_mode
+from crackerjack.models.protocols import OptionsProtocol
+
+
+class ConfigurationService:
+    def __init__(self, console: Console, pkg_path: Path) -> None:
+        self.console = console
+        self.pkg_path = pkg_path
+        self.config_generator = DynamicConfigGenerator()
+
+    def update_precommit_config(self, options: OptionsProtocol) -> bool:
+        """Update pre-commit configuration and dynamic config versions."""
+        try:
+            # Generate config first
+            mode = self._determine_config_mode(options)
+            config_temp_path = generate_config_for_mode(mode)
+            if not config_temp_path:
+                self.console.print("[yellow]⚠️ No configuration generated[/yellow]")
+                return False
+
+            config_file = self.pkg_path / ".pre-commit-config.yaml"
+            config_content = config_temp_path.read_text()
+            config_file.write_text(config_content)
+
+            self._temp_config_path = config_temp_path
+            self.console.print("[green]✅[/green] Pre-commit configuration generated")
+
+            # Run pre-commit autoupdate if requested via -u flag
+            if getattr(options, "update_precommit", False):
+                success = self._run_precommit_autoupdate()
+                if success:
+                    self.console.print("[green]✅[/green] Pre-commit hooks updated")
+                else:
+                    self.console.print(
+                        "[yellow]⚠️[/yellow] Pre-commit autoupdate had issues"
+                    )
+
+                # Also update dynamic config versions
+                self._update_dynamic_config_versions()
+
+            return True
+        except Exception as e:
+            self.console.print(
+                f"[red]❌[/red] Failed to generate pre-commit config: {e}",
+            )
+            return False
+
+    def get_temp_config_path(self) -> Path | None:
+        return getattr(self, "_temp_config_path", None)
+
+    def _determine_config_mode(self, options: OptionsProtocol) -> str:
+        if options.experimental_hooks:
+            return "experimental"
+        if hasattr(options, "test") and options.test:
+            return "comprehensive"
+        return "comprehensive"
+
+    def validate_config(self) -> bool:
+        try:
+            config_file = self.pkg_path / ".pre-commit-config.yaml"
+            if not config_file.exists():
+                self.console.print(
+                    "[yellow]⚠️ No pre-commit configuration found[/yellow]",
+                )
+                return False
+            import yaml
+
+            with config_file.open() as f:
+                yaml_result = yaml.safe_load(f)
+                _ = (
+                    t.cast("dict[str, t.Any]", yaml_result)
+                    if yaml_result is not None
+                    else {}
+                )
+            self.console.print("[green]✅[/green] Pre-commit configuration is valid")
+            return True
+        except Exception as e:
+            self.console.print(f"[red]❌[/red] Configuration validation failed: {e}")
+            return False
+
+    def backup_config(self) -> Path | None:
+        try:
+            config_file = self.pkg_path / ".pre-commit-config.yaml"
+            if not config_file.exists():
+                return None
+            import time
+
+            timestamp = int(time.time())
+            backup_file = self.pkg_path / f".pre-commit-config.yaml.backup.{timestamp}"
+            backup_file.write_text(config_file.read_text())
+            self.console.print(
+                f"[cyan]💾[/cyan] Configuration backed up to {backup_file.name}",
+            )
+            return backup_file
+        except Exception as e:
+            self.console.print(
+                f"[yellow]⚠️[/yellow] Failed to backup configuration: {e}",
+            )
+            return None
+
+    def restore_config(self, backup_file: Path) -> bool:
+        try:
+            if not backup_file.exists():
+                self.console.print(
+                    f"[red]❌[/red] Backup file not found: {backup_file}",
+                )
+                return False
+            config_file = self.pkg_path / ".pre-commit-config.yaml"
+            config_file.write_text(backup_file.read_text())
+            self.console.print(
+                f"[green]✅[/green] Configuration restored from {backup_file.name}",
+            )
+            return True
+        except Exception as e:
+            self.console.print(f"[red]❌[/red] Failed to restore configuration: {e}")
+            return False
+
+    def get_config_info(self) -> dict[str, t.Any]:
+        try:
+            config_file = self.pkg_path / ".pre-commit-config.yaml"
+            if not config_file.exists():
+                return {"exists": False}
+            import yaml
+
+            with config_file.open() as f:
+                yaml_result = yaml.safe_load(f)
+                config_data = (
+                    t.cast("dict[str, t.Any]", yaml_result)
+                    if isinstance(yaml_result, dict)
+                    else {}
+                )
+            repos = config_data.get("repos", [])
+            if not isinstance(repos, list):
+                repos = []
+            hook_count = sum(
+                len(repo.get("hooks", [])) for repo in repos if isinstance(repo, dict)
+            )
+            stat = config_file.stat()
+
+            return {
+                "exists": True,
+                "file_size": stat.st_size,
+                "modified_time": stat.st_mtime,
+                "repo_count": len([r for r in repos if isinstance(r, dict)]),
+                "hook_count": hook_count,
+                "repos": [
+                    {
+                        "repo": repo.get("repo", "unknown"),
+                        "rev": repo.get("rev", "unknown"),
+                        "hooks": len(repo.get("hooks", [])),
+                    }
+                    for repo in repos
+                    if isinstance(repo, dict)
+                ],
+            }
+        except Exception as e:
+            return {"exists": True, "error": str(e)}
+
+    def update_pyproject_config(self, options: OptionsProtocol) -> bool:
+        try:
+            pyproject_file = self.pkg_path / "pyproject.toml"
+            if not pyproject_file.exists():
+                self.console.print("[yellow]⚠️ No pyproject.toml found[/yellow]")
+                return False
+            from tomllib import loads
+
+            from tomli_w import dumps
+
+            with pyproject_file.open() as f:
+                content = f.read()
+            config = loads(content)
+            if "tool" not in config:
+                config["tool"] = {}
+            if "ruff" not in config["tool"]:
+                config["tool"]["ruff"] = {
+                    "target-version": "py313",
+                    "line-length": 88,
+                    "fix": True,
+                    "unsafe-fixes": True,
+                    "show-fixes": True,
+                    "output-format": "full",
+                }
+                config["tool"]["ruff"]["format"] = {"docstring-code-format": True}
+                config["tool"]["ruff"]["lint"] = {
+                    "extend-select": ["C901", "F", "I", "UP"],
+                    "ignore": ["E402", "F821"],
+                    "fixable": ["ALL"],
+                }
+            if "pytest" not in config["tool"]:
+                config["tool"]["pytest"] = {
+                    "ini_options": {
+                        "asyncio_mode": "auto",
+                        "timeout": 300,
+                        "addopts": "--cov=crackerjack --cov-report=term",
+                        "markers": [
+                            "unit: marks test as a unit test",
+                            "benchmark: mark test as a benchmark",
+                            "integration: marks test as an integration test",
+                            "no_leaks: detect asyncio task leaks",
+                        ],
+                    },
+                }
+            with pyproject_file.open("w") as f:
+                f.write(dumps(config))
+            self.console.print("[green]✅[/green] pyproject.toml configuration updated")
+            return True
+        except Exception as e:
+            self.console.print(f"[red]❌[/red] Failed to update pyproject.toml: {e}")
+            return False
+
+    def _run_precommit_autoupdate(self) -> bool:
+        """Run pre-commit autoupdate to get latest hook versions."""
+        import subprocess
+
+        try:
+            self.console.print("[cyan]🔄[/cyan] Running pre-commit autoupdate...")
+            result = self._execute_precommit_autoupdate()
+
+            if result.returncode == 0:
+                self._display_autoupdate_results(result.stdout)
+                return True
+            else:
+                self._handle_autoupdate_error(result.stderr)
+                return False
+
+        except subprocess.TimeoutExpired:
+            self.console.print("[red]❌[/red] Pre-commit autoupdate timed out")
+            return False
+        except Exception as e:
+            self.console.print(
+                f"[red]❌[/red] Failed to run pre-commit autoupdate: {e}"
+            )
+            return False
+
+    def _execute_precommit_autoupdate(self) -> subprocess.CompletedProcess[str]:
+        """Execute the pre-commit autoupdate command."""
+
+        return subprocess.run(
+            ["uv", "run", "pre-commit", "autoupdate"],
+            cwd=self.pkg_path,
+            capture_output=True,
+            text=True,
+            timeout=60,
+        )
+
+    def _display_autoupdate_results(self, stdout: str) -> None:
+        """Display updated versions if any."""
+        if self._has_updates(stdout):
+            for line in stdout.split("\n"):
+                if self._is_update_line(line):
+                    self.console.print(f"[dim]  {line.strip()}[/dim]")
+
+    def _has_updates(self, stdout: str) -> bool:
+        """Check if the output contains update information."""
+        stdout_lower = stdout.lower()
+        return "updating" in stdout_lower or "updated" in stdout_lower
+
+    def _is_update_line(self, line: str) -> bool:
+        """Check if a line contains update information."""
+        return "updating" in line.lower() or "->" in line
+
+    def _handle_autoupdate_error(self, stderr: str) -> None:
+        """Handle pre-commit autoupdate error output."""
+        if stderr:
+            self.console.print(
+                f"[yellow]Pre-commit autoupdate stderr:[/yellow] {stderr}"
+            )
+
+    def _update_dynamic_config_versions(self) -> None:
+        """Update hardcoded versions in dynamic_config.py based on .pre-commit-config.yaml."""
+        try:
+            self.console.print("[cyan]🔄[/cyan] Updating dynamic config versions...")
+
+            version_updates = self._extract_version_updates()
+            if version_updates:
+                self._update_dynamic_config_file(version_updates)
+
+        except Exception as e:
+            self.console.print(
+                f"[yellow]⚠️[/yellow] Failed to update dynamic config versions: {e}"
+            )
+
+    def _extract_version_updates(self) -> dict[str, str]:
+        """Extract version mappings from .pre-commit-config.yaml."""
+        config_file = self.pkg_path / ".pre-commit-config.yaml"
+        if not config_file.exists():
+            return {}
+
+        import yaml
+
+        with config_file.open() as f:
+            config = yaml.safe_load(f)
+
+        if not config or "repos" not in config:
+            return {}
+
+        version_updates = {}
+        repos = config.get("repos", []) if isinstance(config, dict) else []
+        for repo in repos:
+            repo_url = repo.get("repo", "")
+            rev = repo.get("rev", "")
+            if repo_url and rev:
+                version_updates[repo_url] = rev
+
+        return version_updates
+
+    def _update_dynamic_config_file(self, version_updates: dict[str, str]) -> None:
+        """Update dynamic_config.py with version mappings."""
+        dynamic_config_path = self.pkg_path / "crackerjack" / "dynamic_config.py"
+        if dynamic_config_path.exists():
+            self._apply_version_updates(dynamic_config_path, version_updates)
+
+    def _apply_version_updates(
+        self, config_path: Path, version_updates: dict[str, str]
+    ) -> None:
+        """Apply version updates to dynamic_config.py."""
+        try:
+            content = config_path.read_text()
+            updated = False
+
+            for repo_url, new_rev in version_updates.items():
+                # Find and update the revision for this repo
+                import re
+
+                pattern = rf'("repo": "{re.escape(repo_url)}".*?"rev": )"([^"]+)"'
+                replacement = rf'\1"{new_rev}"'
+
+                new_content = re.sub(pattern, replacement, content, flags=re.DOTALL)
+                if new_content != content:
+                    content = new_content
+                    updated = True
+                    self.console.print(f"[dim]  Updated {repo_url} to {new_rev}[/dim]")
+
+            if updated:
+                config_path.write_text(content)
+                self.console.print("[green]✅[/green] Dynamic config versions updated")
+
+        except Exception as e:
+            self.console.print(
+                f"[yellow]⚠️[/yellow] Failed to apply version updates: {e}"
+            )