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)