How to Implement Probabilistic Early Expiration in Python

import heapq
import random
import time


class ProbabilisticEarlyExpirationMock:
    def __init__(self, capacity=1024, expiration_probability=0.1):
        self.capacity = capacity
        self.expiration_probability = expiration_probability
        self._items = {}
        self._expiry_heap = []
        self._next_id = 0

    def put(self, value):
        if len(self._items) >= self.capacity:
            self._evict_expired()
        if len(self._items) >= self.capacity:
            self._evict_random()
        item_id = self._next_id
        self._next_id += 1
        expires_at = time.monotonic() + random.uniform(0.1, 1.0)
        self._items[item_id] = (value, expires_at)
        heapq.heappush(self._expiry_heap, (expires_at, item_id))
        return item_id

    def get(self, item_id):
        if item_id not in self._items:
            return None
        value, expires_at = self._items[item_id]
        if time.monotonic() >= expires_at:
            del self._items[item_id]
            return None
        if random.random() < self.expiration_probability:
            del self._items[item_id]
            return None
        return value

    def _evict_expired(self):
        now = time.monotonic()
        while self._expiry_heap and self._expiry_heap[0][0] <= now:
            _, item_id = heapq.heappop(self._expiry_heap)
            self._items.pop(item_id, None)

    def _evict_random(self):
        if not self._items:
            return
        item_id = random.choice(list(self._items.keys()))
        del self._items[item_id]


if __name__ == "__main__":
    cache = ProbabilisticEarlyExpirationMock(capacity=5, expiration_probability=0.5)
    ids = [cache.put(i) for i in range(5)]
    print([cache.get(i) for i in ids])