provide-foundation 0.0.0.dev1__py3-none-any.whl → 0.0.0.dev3__py3-none-any.whl

provide/foundation/tools/cache.py

@@ -5,11 +5,13 @@ Provides TTL-based caching to avoid re-downloading tools
 that are already installed and valid.
 """
 
-import json
 from datetime import datetime, timedelta
+import json
 from pathlib import Path
 
 from provide.foundation.errors import FoundationError
+from provide.foundation.file.atomic import atomic_write
+from provide.foundation.file.safe import safe_read_text
 from provide.foundation.logger import get_logger
 
 log = get_logger(__name__)
@@ -17,99 +19,93 @@ log = get_logger(__name__)
 
 class CacheError(FoundationError):
     """Raised when cache operations fail."""
-    
+
     pass
 
 
 class ToolCache:
     """
     Cache for installed tools with TTL support.
-    
+
     Tracks installed tool locations and expiration times to
     avoid unnecessary re-downloads and installations.
     """
-    
-    def __init__(self, cache_dir: Path | None = None):
+
+    def __init__(self, cache_dir: Path | None = None) -> None:
         """
         Initialize the cache.
-        
+
         Args:
             cache_dir: Cache directory (defaults to ~/.wrknv/cache).
         """
         self.cache_dir = cache_dir or (Path.home() / ".wrknv" / "cache")
         self.cache_dir.mkdir(parents=True, exist_ok=True)
-        
+
         self.metadata_file = self.cache_dir / "metadata.json"
         self.metadata = self._load_metadata()
-    
+
     def _load_metadata(self) -> dict[str, dict]:
         """
         Load cache metadata from disk.
-        
+
         Returns:
             Cache metadata dictionary.
         """
-        if self.metadata_file.exists():
+        content = safe_read_text(self.metadata_file, default="{}")
+        if content:
             try:
-                with self.metadata_file.open() as f:
-                    return json.load(f)
+                return json.loads(content)
             except Exception as e:
-                log.warning(f"Failed to load cache metadata: {e}")
-        
+                log.warning(f"Failed to parse cache metadata: {e}")
+
         return {}
-    
+
     def _save_metadata(self) -> None:
         """Save cache metadata to disk."""
         try:
-            with self.metadata_file.open("w") as f:
-                json.dump(self.metadata, f, indent=2)
+            content = json.dumps(self.metadata, indent=2)
+            atomic_write(self.metadata_file, content.encode("utf-8"))
         except Exception as e:
             log.error(f"Failed to save cache metadata: {e}")
-    
+
     def get(self, tool: str, version: str) -> Path | None:
         """
         Get cached tool path if valid.
-        
+
         Args:
             tool: Tool name.
             version: Tool version.
-            
+
         Returns:
             Path to cached tool if valid, None otherwise.
         """
         key = f"{tool}:{version}"
-        
+
         if entry := self.metadata.get(key):
             path = Path(entry["path"])
-            
+
             # Check if path exists
             if not path.exists():
                 log.debug(f"Cache miss: {key} path doesn't exist")
                 self.invalidate(tool, version)
                 return None
-            
+
             # Check if expired
             if self._is_expired(entry):
                 log.debug(f"Cache miss: {key} expired")
                 self.invalidate(tool, version)
                 return None
-            
+
             log.debug(f"Cache hit: {key}")
             return path
-        
+
         log.debug(f"Cache miss: {key} not in cache")
         return None
-    
-    def store(
-        self,
-        tool: str,
-        version: str,
-        path: Path,
-        ttl_days: int = 7
-    ) -> None:
+
+    def store(self, tool: str, version: str, path: Path, ttl_days: int = 7) -> None:
         """
         Store tool in cache.
-        
+
         Args:
             tool: Tool name.
             version: Tool version.
@@ -117,7 +113,7 @@ class ToolCache:
             ttl_days: Time-to-live in days.
         """
         key = f"{tool}:{version}"
-        
+
         self.metadata[key] = {
             "path": str(path),
             "tool": tool,
@@ -125,14 +121,14 @@ class ToolCache:
             "cached_at": datetime.now().isoformat(),
             "ttl_days": ttl_days,
         }
-        
+
         self._save_metadata()
         log.debug(f"Cached {key} at {path} (TTL: {ttl_days} days)")
-    
+
     def invalidate(self, tool: str, version: str | None = None) -> None:
         """
         Invalidate cache entries.
-        
+
         Args:
             tool: Tool name.
             version: Specific version, or None for all versions.
@@ -146,60 +142,59 @@ class ToolCache:
         else:
             # Invalidate all versions of tool
             keys_to_remove = [
-                k for k in self.metadata
-                if self.metadata[k].get("tool") == tool
+                k for k in self.metadata if self.metadata[k].get("tool") == tool
             ]
             for key in keys_to_remove:
                 del self.metadata[key]
                 log.debug(f"Invalidated cache for {key}")
-        
+
         self._save_metadata()
-    
+
     def _is_expired(self, entry: dict) -> bool:
         """
         Check if cache entry is expired.
-        
+
         Args:
             entry: Cache entry dictionary.
-            
+
         Returns:
             True if expired, False otherwise.
         """
         try:
             cached_at = datetime.fromisoformat(entry["cached_at"])
             ttl_days = entry.get("ttl_days", 7)
-            
+
             if ttl_days <= 0:
                 # Never expires
                 return False
-            
+
             expiry = cached_at + timedelta(days=ttl_days)
             return datetime.now() > expiry
         except Exception as e:
             log.debug(f"Error checking expiry: {e}")
             return True  # Treat as expired if we can't determine
-    
+
     def clear(self) -> None:
         """Clear all cache entries."""
         self.metadata = {}
         self._save_metadata()
         log.info("Cleared tool cache")
-    
+
     def list_cached(self) -> list[dict]:
         """
         List all cached tools.
-        
+
         Returns:
             List of cache entries with metadata.
         """
         results = []
-        
+
         for key, entry in self.metadata.items():
             # Add expiry status
             entry = entry.copy()
             entry["key"] = key
             entry["expired"] = self._is_expired(entry)
-            
+
             # Calculate days until expiry
             try:
                 cached_at = datetime.fromisoformat(entry["cached_at"])
@@ -212,55 +207,55 @@ class ToolCache:
                     entry["days_until_expiry"] = -1  # Never expires
             except Exception:
                 entry["days_until_expiry"] = 0
-            
+
             results.append(entry)
-        
+
         return results
-    
+
     def get_size(self) -> int:
         """
         Get total size of cached tools in bytes.
-        
+
         Returns:
             Total size in bytes.
         """
         total = 0
-        
+
         for entry in self.metadata.values():
             path = Path(entry["path"])
-            if path.exists():
-                try:
+            try:
+                if path.exists():
                     # Calculate directory size
                     if path.is_dir():
-                        total += sum(
-                            f.stat().st_size
-                            for f in path.rglob("*")
-                            if f.is_file()
-                        )
+                        for f in path.rglob("*"):
+                            if f.is_file():
+                                try:
+                                    total += f.stat().st_size
+                                except Exception as e:
+                                    log.debug(f"Failed to get size of file {f}: {e}")
                     else:
                         total += path.stat().st_size
-                except Exception as e:
-                    log.debug(f"Failed to get size of {path}: {e}")
-        
+            except Exception as e:
+                log.debug(f"Failed to get size of {path}: {e}")
+
         return total
-    
+
     def prune_expired(self) -> int:
         """
         Remove expired entries from cache.
-        
+
         Returns:
             Number of entries removed.
         """
         expired_keys = [
-            key for key, entry in self.metadata.items()
-            if self._is_expired(entry)
+            key for key, entry in self.metadata.items() if self._is_expired(entry)
         ]
-        
+
         for key in expired_keys:
             del self.metadata[key]
-        
+
         if expired_keys:
             self._save_metadata()
             log.info(f"Pruned {len(expired_keys)} expired cache entries")
-        
-        return len(expired_keys)
+
+        return len(expired_keys)

provide/foundation/tools/downloader.py

@@ -5,13 +5,14 @@ Provides capabilities for downloading tools with progress tracking,
 parallel downloads, and mirror support.
 """
 
-import hashlib
 from concurrent.futures import ThreadPoolExecutor
+import hashlib
 from pathlib import Path
 from typing import Callable
 
 from provide.foundation.errors import FoundationError
 from provide.foundation.logger import get_logger
+from provide.foundation.resilience import retry
 from provide.foundation.transport import UniversalClient
 
 log = get_logger(__name__)
@@ -19,48 +20,48 @@ log = get_logger(__name__)
 
 class DownloadError(FoundationError):
     """Raised when download fails."""
-    
+
     pass
 
 
 class ToolDownloader:
     """
     Advanced download capabilities for tools.
-    
+
     Features:
     - Progress reporting with callbacks
     - Parallel downloads for multiple files
     - Mirror fallback support
     - Checksum verification
-    
+
     Attributes:
         client: Transport client for HTTP requests.
         progress_callbacks: List of progress callback functions.
     """
-    
+
     def __init__(self, client: UniversalClient):
         """
         Initialize the downloader.
-        
+
         Args:
             client: Universal client for making HTTP requests.
         """
         self.client = client
         self.progress_callbacks: list[Callable[[int, int], None]] = []
-    
+
     def add_progress_callback(self, callback: Callable[[int, int], None]) -> None:
         """
         Add a progress callback.
-        
+
         Args:
             callback: Function that receives (downloaded_bytes, total_bytes).
         """
         self.progress_callbacks.append(callback)
-    
+
     def _report_progress(self, downloaded: int, total: int) -> None:
         """
         Report progress to all callbacks.
-        
+
         Args:
             downloaded: Bytes downloaded so far.
             total: Total bytes to download (0 if unknown).
@@ -70,100 +71,95 @@ class ToolDownloader:
                 callback(downloaded, total)
             except Exception as e:
                 log.warning(f"Progress callback failed: {e}")
-    
+
+    @retry(max_attempts=3, base_delay=1.0)
     def download_with_progress(
-        self,
-        url: str,
-        dest: Path,
-        checksum: str | None = None
+        self, url: str, dest: Path, checksum: str | None = None
     ) -> Path:
         """
         Download a file with progress reporting.
-        
+
         Args:
             url: URL to download from.
             dest: Destination file path.
             checksum: Optional checksum for verification.
-            
+
         Returns:
             Path to the downloaded file.
-            
+
         Raises:
             DownloadError: If download or verification fails.
         """
         log.debug(f"Downloading {url} to {dest}")
-        
+
         # Ensure parent directory exists
         dest.parent.mkdir(parents=True, exist_ok=True)
-        
+
         # Stream download with progress
         with self.client.stream("GET", url) as response:
             # Get total size if available
             total_size = int(response.headers.get("content-length", 0))
             downloaded = 0
-            
+
             # Write to file and report progress
             with dest.open("wb") as f:
                 for chunk in response.iter_bytes(8192):
                     f.write(chunk)
                     downloaded += len(chunk)
                     self._report_progress(downloaded, total_size)
-        
+
         # Verify checksum if provided
         if checksum:
             if not self.verify_checksum(dest, checksum):
                 dest.unlink()
                 raise DownloadError(f"Checksum mismatch for {url}")
-        
+
         log.info(f"Downloaded {url} successfully")
         return dest
-    
+
     def verify_checksum(self, file_path: Path, expected: str) -> bool:
         """
         Verify file checksum.
-        
+
         Args:
             file_path: Path to file to verify.
             expected: Expected checksum (hex string).
-            
+
         Returns:
             True if checksum matches, False otherwise.
         """
         # Default to SHA256
         hasher = hashlib.sha256()
-        
+
         with file_path.open("rb") as f:
             for chunk in iter(lambda: f.read(8192), b""):
                 hasher.update(chunk)
-        
+
         actual = hasher.hexdigest()
         return actual == expected
-    
-    def download_parallel(
-        self,
-        urls: list[tuple[str, Path]]
-    ) -> list[Path]:
+
+    def download_parallel(self, urls: list[tuple[str, Path]]) -> list[Path]:
         """
         Download multiple files in parallel.
-        
+
         Args:
             urls: List of (url, destination) tuples.
-            
+
         Returns:
             List of downloaded file paths in the same order as input.
-            
+
         Raises:
             DownloadError: If any download fails.
         """
         errors = []
-        
+
         with ThreadPoolExecutor(max_workers=4) as executor:
             # Submit all downloads, maintaining order with index
             futures = [
                 executor.submit(self.download_with_progress, url, dest)
                 for url, dest in urls
             ]
-            
+
             # Collect results in order
             results = []
             for i, future in enumerate(futures):
@@ -174,40 +170,50 @@ class ToolDownloader:
                 except Exception as e:
                     errors.append((url, e))
                     log.error(f"Failed to download {url}: {e}")
-        
+
         if errors:
             raise DownloadError(f"Some downloads failed: {errors}")
-        
+
         return results
-    
-    def download_with_mirrors(
-        self,
-        mirrors: list[str],
-        dest: Path
-    ) -> Path:
+
+    def download_with_mirrors(self, mirrors: list[str], dest: Path) -> Path:
         """
-        Try multiple mirrors until one succeeds.
-        
+        Try multiple mirrors until one succeeds using fallback pattern.
+
         Args:
             mirrors: List of mirror URLs to try.
             dest: Destination file path.
-            
+
         Returns:
             Path to downloaded file.
-            
+
         Raises:
             DownloadError: If all mirrors fail.
         """
-        errors = []
-        
+        from provide.foundation.resilience.fallback import FallbackChain
+
+        if not mirrors:
+            raise DownloadError("No mirrors provided")
+
+        # Create fallback functions for each mirror
+        fallback_funcs = []
         for mirror_url in mirrors:
-            try:
-                log.debug(f"Trying mirror: {mirror_url}")
-                return self.download_with_progress(mirror_url, dest)
-            except Exception as e:
-                log.warning(f"Mirror {mirror_url} failed: {e}")
-                errors.append((mirror_url, str(e)))
-                continue
-        
-        # All mirrors failed
-        raise DownloadError(f"All mirrors failed: {errors}")
+
+            def create_mirror_func(url):
+                def mirror_download():
+                    log.debug(f"Trying mirror: {url}")
+                    return self.download_with_progress(url, dest)
+
+                return mirror_download
+
+            fallback_funcs.append(create_mirror_func(mirror_url))
+
+        # Use FallbackChain to try mirrors in order
+        chain = FallbackChain(
+            fallbacks=fallback_funcs[1:]
+        )  # All but first are fallbacks
+
+        try:
+            return chain.execute(fallback_funcs[0])  # First is primary
+        except Exception as e:
+            raise DownloadError(f"All mirrors failed: {e}")