Spaces:
Sleeping
Sleeping
File size: 2,482 Bytes
ca65887 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 | import hashlib
import tempfile
import time
from dataclasses import dataclass
from pathlib import Path
@dataclass(slots=True)
class CacheEntry:
key: str
path: Path
created_at: float
expires_at: float
size_bytes: int
class EphemeralCacheManager:
def __init__(
self,
cache_dir: str | None = None,
ttl_seconds: int = 300,
max_files: int = 256,
) -> None:
self._base_dir = Path(cache_dir) if cache_dir else Path(tempfile.gettempdir()) / "birdnet-validator-cache"
self._base_dir.mkdir(parents=True, exist_ok=True)
self._ttl_seconds = ttl_seconds
self._max_files = max_files
self._entries: dict[str, CacheEntry] = {}
def get(self, key: str) -> Path | None:
self.cleanup_expired()
entry = self._entries.get(key)
if not entry:
return None
if not entry.path.exists():
self._entries.pop(key, None)
return None
return entry.path
def put_bytes(self, key: str, data: bytes, suffix: str = ".bin") -> Path:
self.cleanup_expired()
self._enforce_capacity()
digest = hashlib.sha256(key.encode("utf-8")).hexdigest()[:16]
file_path = self._base_dir / f"{digest}{suffix}"
file_path.write_bytes(data)
now = time.time()
self._entries[key] = CacheEntry(
key=key,
path=file_path,
created_at=now,
expires_at=now + self._ttl_seconds,
size_bytes=len(data),
)
return file_path
def cleanup_key(self, key: str) -> None:
entry = self._entries.pop(key, None)
if not entry:
return
if entry.path.exists():
entry.path.unlink()
def cleanup_expired(self) -> None:
now = time.time()
expired_keys = [key for key, entry in self._entries.items() if entry.expires_at <= now or not entry.path.exists()]
for key in expired_keys:
self.cleanup_key(key)
def clear(self) -> None:
for key in list(self._entries.keys()):
self.cleanup_key(key)
def _enforce_capacity(self) -> None:
if len(self._entries) < self._max_files:
return
oldest_keys = sorted(self._entries.keys(), key=lambda key: self._entries[key].created_at)
overflow = (len(self._entries) - self._max_files) + 1
for key in oldest_keys[:overflow]:
self.cleanup_key(key)
|