comfygit-core 0.2.0__py3-none-any.whl

comfygit_core/caching/api_cache.py

@@ -0,0 +1,210 @@
+"""Unified cache manager for API responses with expiration support."""
+
+import hashlib
+import json
+import time
+from pathlib import Path
+from typing import Any
+
+from ..logging.logging_config import get_logger
+from ..models.exceptions import ComfyDockError
+
+logger = get_logger(__name__)
+
+
+class APICacheManager:
+    """Manages persistent caching of API responses with expiration."""
+
+    def __init__(self, cache_name: str = "api",
+                 default_ttl_hours: int = 24,
+                 cache_base_path: Path | None = None):
+        """Initialize cache manager.
+
+        Args:
+            cache_name: Name of the cache subdirectory
+            default_ttl_hours: Default time-to-live in hours for cache entries
+            cache_base_path: Required cache base path (workspace cache directory)
+
+        Raises:
+            ValueError: If cache_base_path is None
+        """
+        if cache_base_path is None:
+            raise ValueError(
+                "cache_base_path is required. All caches must be workspace-relative."
+            )
+        self.cache_name = cache_name
+        self.default_ttl_seconds = default_ttl_hours * 3600
+        self.cache_dir = cache_base_path / cache_name
+        self._ensure_cache_directory()
+
+        logger.debug(f"Initialized API cache at: {self.cache_dir}")
+
+    def _ensure_cache_directory(self):
+        """Ensure cache directory exists.
+
+        Raises:
+            ComfyDockError: If cache directory creation fails
+        """
+        try:
+            self.cache_dir.mkdir(parents=True, exist_ok=True)
+            logger.debug(f"Cache directory: {self.cache_dir}")
+        except Exception as e:
+            raise ComfyDockError(
+                f"Failed to create cache directory {self.cache_dir}. "
+                f"Workspace cache should exist before cache initialization: {e}"
+            )
+
+    def _get_cache_file_path(self, cache_type: str) -> Path:
+        """Get path for a specific cache file."""
+        return self.cache_dir / f"{cache_type}_cache.json"
+
+    def _sanitize_key(self, key: str) -> str:
+        """Sanitize cache key to be filesystem-safe."""
+        # Create a hash of the key to avoid filesystem issues
+        key_hash = hashlib.md5(key.encode()).hexdigest()[:8]
+        # Keep some readable part of the key
+        safe_key = "".join(c if c.isalnum() or c in '-_' else '_' for c in key)
+        return f"{safe_key[:50]}_{key_hash}"
+
+    def get(self, cache_type: str, key: str, ttl_seconds: int | None = None) -> Any | None:
+        """Get a value from cache if it exists and hasn't expired.
+        
+        Args:
+            cache_type: Type of cache (e.g., 'github', 'registry')
+            key: Cache key
+            ttl_seconds: Time-to-live in seconds (overrides default)
+            
+        Returns:
+            Cached value if valid, None if expired or not found
+        """
+        ttl = ttl_seconds if ttl_seconds is not None else self.default_ttl_seconds
+        cache_file = self._get_cache_file_path(cache_type)
+
+        if not cache_file.exists():
+            return None
+
+        try:
+            logger.debug(f"Reading cache for {cache_type}:{key}")
+            with open(cache_file, encoding='utf-8') as f:
+                cache_data = json.load(f)
+
+            logger.debug(f"Found {len(cache_data)} entries in cache for {cache_type}")
+            sanitized_key = self._sanitize_key(key)
+            if sanitized_key not in cache_data:
+                logger.debug(f"Cache miss for {cache_type}:{key}")
+                return None
+
+            entry = cache_data[sanitized_key]
+            timestamp = entry.get('timestamp', 0)
+
+            logger.debug(f"Cache timestamp for {cache_type}:{key}: {timestamp}")
+
+            # Check if entry has expired
+            if time.time() - timestamp > ttl:
+                logger.debug(f"Cache expired for {cache_type}:{key}")
+                return None
+
+            logger.debug(f"Cache hit for {cache_type}:{key}")
+            return entry.get('data')
+
+        except Exception as e:
+            logger.warning(f"Error reading cache for {cache_type}: {e}")
+            return None
+
+    def set(self, cache_type: str, key: str, value: Any) -> bool:
+        """Store a value in cache with current timestamp.
+        
+        Args:
+            cache_type: Type of cache (e.g., 'github', 'registry')
+            key: Cache key
+            value: Value to cache
+            
+        Returns:
+            True if successfully cached, False otherwise
+        """
+        cache_file = self._get_cache_file_path(cache_type)
+
+        try:
+            # Load existing cache
+            if cache_file.exists():
+                with open(cache_file, encoding='utf-8') as f:
+                    cache_data = json.load(f)
+            else:
+                cache_data = {}
+
+            # Add new entry
+            sanitized_key = self._sanitize_key(key)
+            cache_data[sanitized_key] = {
+                'timestamp': time.time(),
+                'data': value,
+                'original_key': key  # Store original key for debugging
+            }
+
+            # Write updated cache
+            with open(cache_file, 'w', encoding='utf-8') as f:
+                json.dump(cache_data, f, indent=2)
+
+            logger.debug(f"Cached {cache_type}:{key}")
+            return True
+
+        except Exception as e:
+            logger.warning(f"Error writing cache for {cache_type}: {e}")
+            return False
+
+    def clear(self, cache_type: str | None = None):
+        """Clear cache entries.
+        
+        Args:
+            cache_type: Specific cache type to clear, or None to clear all
+        """
+        try:
+            if cache_type:
+                cache_file = self._get_cache_file_path(cache_type)
+                if cache_file.exists():
+                    cache_file.unlink()
+                    logger.info(f"Cleared {cache_type} cache")
+            else:
+                # Clear all cache files
+                for cache_file in self.cache_dir.glob("*_cache.json"):
+                    cache_file.unlink()
+                logger.info("Cleared all caches")
+        except Exception as e:
+            logger.warning(f"Error clearing cache: {e}")
+
+    def cleanup_expired(self, cache_type: str | None = None):
+        """Remove expired entries from cache.
+        
+        Args:
+            cache_type: Specific cache type to clean, or None to clean all
+        """
+        cache_types = [cache_type] if cache_type else ['github', 'registry']
+
+        for ct in cache_types:
+            cache_file = self._get_cache_file_path(ct)
+            if not cache_file.exists():
+                continue
+
+            try:
+                with open(cache_file, encoding='utf-8') as f:
+                    cache_data = json.load(f)
+
+                # Filter out expired entries
+                current_time = time.time()
+                cleaned_data = {}
+                expired_count = 0
+
+                for key, entry in cache_data.items():
+                    timestamp = entry.get('timestamp', 0)
+                    if current_time - timestamp <= self.default_ttl_seconds:
+                        cleaned_data[key] = entry
+                    else:
+                        expired_count += 1
+
+                if expired_count > 0:
+                    with open(cache_file, 'w', encoding='utf-8') as f:
+                        json.dump(cleaned_data, f, indent=2)
+                    logger.info(f"Removed {expired_count} expired entries from {ct} cache")
+
+            except Exception as e:
+                logger.warning(f"Error cleaning up {ct} cache: {e}")
+

comfygit_core/caching/base.py

@@ -0,0 +1,212 @@
+"""Base classes for caching infrastructure.
+
+Provides workspace-relative cache path management and content caching infrastructure
+that can be extended for specific cache types (ComfyUI, custom nodes, models, etc).
+"""
+
+import hashlib
+import json
+import shutil
+from datetime import datetime, timezone
+from pathlib import Path
+
+from ..logging.logging_config import get_logger
+from ..models.exceptions import ComfyDockError
+
+logger = get_logger(__name__)
+
+
+class CacheBase:
+    """Minimal base providing workspace-relative cache management.
+
+    All caches must be workspace-relative. No platform-specific defaults
+    or environment variable overrides.
+    """
+
+    def __init__(self, cache_name: str = "comfygit",
+                 cache_base_path: Path | None = None):
+        """Initialize cache base.
+
+        Args:
+            cache_name: Name of the cache subdirectory
+            cache_base_path: Required cache base path (workspace cache directory)
+
+        Raises:
+            ValueError: If cache_base_path is None
+        """
+        if cache_base_path is None:
+            raise ValueError(
+                "cache_base_path is required. All caches must be workspace-relative."
+            )
+        self.cache_name = cache_name
+        self.cache_base = cache_base_path
+
+    def _ensure_cache_dirs(self, *subdirs: str):
+        """Ensure cache subdirectories exist.
+
+        Args:
+            *subdirs: Subdirectory paths to create under cache_base
+
+        Raises:
+            ComfyDockError: If cache directory creation fails
+        """
+        try:
+            for subdir in subdirs:
+                (self.cache_base / subdir).mkdir(parents=True, exist_ok=True)
+        except Exception as e:
+            raise ComfyDockError(
+                f"Failed to create cache directory under {self.cache_base}. "
+                f"Workspace cache should exist before cache initialization: {e}"
+            )
+
+
+class ContentCacheBase(CacheBase):
+    """Base for content-based caching (files, directories, large data).
+
+    Provides infrastructure for caching content with:
+    - Directory-based storage (cache_key/content/)
+    - Metadata tracking (size, hash, timestamps)
+    - Index file for fast lookup
+    - Content hashing for integrity
+    """
+
+    def __init__(self, content_type: str, cache_base_path: Path | None = None):
+        """Initialize content cache.
+
+        Args:
+            content_type: Type of content being cached (e.g., "comfyui", "custom_nodes")
+            cache_base_path: Override cache base path (for testing)
+        """
+        super().__init__("comfygit", cache_base_path)
+        self.content_type = content_type
+        self.cache_dir = self.cache_base / content_type
+        self.store_dir = self.cache_dir / "store"
+        self.index_file = self.cache_dir / "index.json"
+
+        # Ensure directories exist
+        self._ensure_cache_dirs(content_type, f"{content_type}/store")
+
+        # Load index
+        self.index = self._load_index()
+
+    def _load_index(self) -> dict:
+        """Load cache index from disk.
+
+        Returns:
+            Index dictionary mapping cache keys to metadata
+        """
+        if not self.index_file.exists():
+            return {}
+
+        try:
+            with open(self.index_file, encoding='utf-8') as f:
+                data = json.load(f)
+            return data.get("items", {})
+        except Exception as e:
+            logger.error(f"Failed to load cache index: {e}")
+            return {}
+
+    def _save_index(self):
+        """Save cache index to disk atomically."""
+        try:
+            data = {
+                "version": "1.0",
+                "content_type": self.content_type,
+                "updated_at": datetime.now(timezone.utc).isoformat(),
+                "items": self.index
+            }
+
+            # Atomic write: temp file then replace
+            temp_file = self.index_file.with_suffix(".tmp")
+            with open(temp_file, "w", encoding='utf-8') as f:
+                json.dump(data, f, indent=2)
+            temp_file.replace(self.index_file)
+
+        except Exception as e:
+            logger.error(f"Failed to save cache index: {e}")
+
+    def _calculate_content_hash(self, content_dir: Path) -> str:
+        """Calculate SHA256 hash of directory content for integrity checking.
+
+        Args:
+            content_dir: Directory to hash
+
+        Returns:
+            SHA256 hexdigest of all files in directory
+        """
+        hasher = hashlib.sha256()
+
+        # Sort files for deterministic hashing
+        for file_path in sorted(content_dir.rglob("*")):
+            if file_path.is_file():
+                # Include relative path in hash
+                rel_path = file_path.relative_to(content_dir)
+                hasher.update(str(rel_path).encode())
+
+                # Include file content
+                with open(file_path, "rb") as f:
+                    for chunk in iter(lambda: f.read(65536), b""):
+                        hasher.update(chunk)
+
+        return hasher.hexdigest()
+
+    def cache_content(self, cache_key: str, source_path: Path,
+                     metadata: dict | None = None) -> Path:
+        """Cache content from source directory.
+
+        Args:
+            cache_key: Unique cache key
+            source_path: Path to source content directory
+            metadata: Optional additional metadata to store
+
+        Returns:
+            Path to cached content directory
+        """
+        cache_dir = self.store_dir / cache_key
+        content_dir = cache_dir / "content"
+
+        # Clean up existing cache entry
+        if cache_dir.exists():
+            shutil.rmtree(cache_dir)
+
+        cache_dir.mkdir(parents=True)
+
+        # Copy content
+        shutil.copytree(source_path, content_dir)
+
+        # Calculate metadata
+        size_bytes = sum(
+            f.stat().st_size for f in content_dir.rglob("*") if f.is_file()
+        )
+        content_hash = self._calculate_content_hash(content_dir)
+
+        # Store metadata
+        full_metadata = {
+            "cache_key": cache_key,
+            "cached_at": datetime.now(timezone.utc).isoformat(),
+            "size_bytes": size_bytes,
+            "content_hash": content_hash,
+            **(metadata or {})
+        }
+
+        with open(cache_dir / "metadata.json", "w", encoding='utf-8') as f:
+            json.dump(full_metadata, f, indent=2)
+
+        # Update index
+        self.index[cache_key] = full_metadata
+        self._save_index()
+
+        logger.debug(f"Cached {self.content_type} with key: {cache_key}")
+        return content_dir
+
+    def get_cached_path(self, cache_key: str) -> Path | None:
+        """Get path to cached content if it exists.
+
+        Args:
+            cache_key: Cache key to look up
+
+        Returns:
+            Path to content directory, or None if not cached
+        """
+        content_path = self.store_dir / cache_key / "content"
+        return content_path if content_path.exists() else None

comfygit_core/caching/comfyui_cache.py

@@ -0,0 +1,100 @@
+"""ComfyUI version cache manager.
+
+Caches ComfyUI installations by version to avoid re-downloading and re-cloning.
+Supports releases, commits, and branches.
+"""
+
+from dataclasses import dataclass
+from pathlib import Path
+
+from .base import ContentCacheBase
+
+
+@dataclass
+class ComfyUISpec:
+    """Specification for a ComfyUI version."""
+    version: str              # "v0.3.20", "abc123", "main"
+    version_type: str         # "release", "commit", "branch"
+    commit_sha: str | None = None  # Actual commit SHA (for branches)
+
+
+class ComfyUICacheManager(ContentCacheBase):
+    """Cache manager for ComfyUI versions.
+
+    Caches ComfyUI installations by version, including the .git directory
+    for faster cloning and git operations.
+
+    Cache structure:
+        store/
+            release_v0.3.20/
+                content/        # Full ComfyUI directory with .git
+                metadata.json   # version, type, commit_sha, size, hash
+            commit_abc123/
+                content/
+                metadata.json
+    """
+
+    def __init__(self, cache_base_path: Path | None = None):
+        """Initialize ComfyUI cache manager.
+
+        Args:
+            cache_base_path: Override cache base path (for testing)
+        """
+        super().__init__("comfyui", cache_base_path)
+
+    def generate_cache_key(self, spec: ComfyUISpec | str) -> str:
+        """Generate cache key from version specification.
+
+        For releases: "release_v0.3.20"
+        For commits: "commit_abc123"
+        For branches: Use commit SHA for exact caching (branches can change)
+        For simple strings: "version_{version}"
+
+        Args:
+            spec: ComfyUISpec or simple version string
+
+        Returns:
+            Cache key string
+        """
+        if isinstance(spec, str):
+            # Simple string version
+            return f"version_{spec}"
+
+        # Use commit SHA for branches (they can change)
+        if spec.version_type == "branch" and spec.commit_sha:
+            return f"commit_{spec.commit_sha}"
+
+        # For releases and commits, use the version
+        return f"{spec.version_type}_{spec.version}"
+
+    def cache_comfyui(self, spec: ComfyUISpec, source_path: Path) -> Path:
+        """Cache a ComfyUI installation.
+
+        Args:
+            spec: ComfyUI version specification
+            source_path: Path to ComfyUI installation (with .git)
+
+        Returns:
+            Path to cached content
+        """
+        cache_key = self.generate_cache_key(spec)
+
+        metadata = {
+            "version": spec.version,
+            "version_type": spec.version_type,
+            "commit_sha": spec.commit_sha
+        }
+
+        return self.cache_content(cache_key, source_path, metadata)
+
+    def get_cached_comfyui(self, spec: ComfyUISpec | str) -> Path | None:
+        """Get cached ComfyUI path if it exists.
+
+        Args:
+            spec: ComfyUISpec or simple version string
+
+        Returns:
+            Path to cached ComfyUI content, or None if not cached
+        """
+        cache_key = self.generate_cache_key(spec)
+        return self.get_cached_path(cache_key)