Database Fundamentals and Storage Engines Questions

import time
from collections import OrderedDict
from typing import Any, Optional

class LRUCacheTTL:
    def __init__(self, capacity: int):
        assert capacity > 0
        self.capacity = capacity
        self.store = OrderedDict()  # key -> (value, expiry_ts_or_None)

    def _now(self) -> float:
        return time.time()

    def _is_expired(self, entry) -> bool:
        value, expiry = entry
        return expiry is not None and expiry <= self._now()

    def get(self, key: Any) -> Optional[Any]:
        if key not in self.store:
            return None
        entry = self.store[key]
        if self._is_expired(entry):
            del self.store[key]
            return None
        # move to end = mark as recently used
        self.store.move_to_end(key, last=True)
        return entry[0]

    def put(self, key: Any, value: Any, ttl_seconds: Optional[float] = None) -> None:
        expiry = None if ttl_seconds is None else self._now() + ttl_seconds
        if key in self.store:
            # update value & expiry, mark most-recent
            self.store[key] = (value, expiry)
            self.store.move_to_end(key, last=True)
        else:
            # ensure capacity: pop oldest (LRU) entries; skip expired entries quickly
            while len(self.store) >= self.capacity:
                old_key, old_entry = next(iter(self.store.items()))
                if self._is_expired(old_entry):
                    # expired — remove and continue
                    del self.store[old_key]
                    continue
                # evict true LRU
                self.store.popitem(last=False)
                break
            self.store[key] = (value, expiry)