@robbiesrobotics/alice-agents 1.5.11 → 1.5.13

package/templates/workspaces/olivia/NEW_NODES_BENCHMARK.txt

@@ -1,947 +0,0 @@
-NEW NODES CODING BENCHMARK — Mon Mar 23 06:57:19 EDT 2026
-Task: Thread-safe LRU Cache with per-key TTL
-Nodes: Mac Studio (100.115.74.106) + Mac Mini (100.107.132.71)
-==========================================
-
-==========================================
-MODEL: mac-studio/llama3.2:3b
-==========================================
-LOAD: 7.8s | TOKENS: 860 | DURATION: 6.5s | SPEED: 132.9 tok/s
-
-import threading
-import time
-
-class Node:
-    """Node in the doubly linked list."""
-    def __init__(self, key, value, ttl_seconds):
-        self.key = key
-        self.value = value
-        self.ttl_seconds = ttl_seconds
-        self.prev = None
-        self.next = None
-
-class LRUCache:
-    """Thread-safe LRU cache with per-key TTL expiration."""
-    def __init__(self, capacity: int):
-        """Initialize the LRU cache with given capacity."""
-        self.capacity = capacity
-        self.size = 0
-        self.map = {}
-        self.lock = threading.Lock()
-        self.head = Node(0, None, 0)
-        self.tail = Node(0, None, 0)
-        self.head.next = self.tail
-        self.tail.prev = self.head
-
-    def _remove(self, node: Node):
-        """Remove a node from the doubly linked list."""
-        prev_node = node.prev
-        next_node = node.next
-        prev_node.next = next_node
-        next_node.prev = prev_node
-
-    def _add(self, node: Node):
-        """Add a node to the doubly linked list."""
-        prev_node = self.tail.prev
-        prev_node.next = node
-        node.prev = prev_node
-        node.next = self.tail
-        self.tail.prev = node
-
-    def _get(self, key: str) -> str:
-        """Get the value for a given key."""
-        with self.lock:
-            if key not in self.map:
-                return None
-            node = self.map[key]
-            if node.ttl_seconds <= time.time():
-                self._remove(node)
-                if self.size == self.capacity:
-                    lru_key = min(self.map, key=lambda k: self.map[k].ttl_seconds)
-                    del self.map[lru_key]
-                    self._remove(self.map[lru_key])
-                self._remove(node)
-                del self.map[key]
-                self.size -= 1
-            else:
-                node.ttl_seconds = time.time() + node.ttl_seconds
-                self._add(node)
-                self.size += 1
-            return node.value
-
-    def put(self, key: str, value: str, ttl_seconds: int):
-        """Put a value for a given key with a TTL."""
-        with self.lock:
-            if key in self.map:
-                self._remove(self.map[key])
-                del self.map[key]
-            self.map[key] = Node(key, value, ttl_seconds)
-            self._add(self.map[key])
-            self.size += 1
-            if self.size > self.capacity:
-                lru_key = min(self.map, key=lambda k: self.map[k].ttl_seconds)
-                del self.map[lru_key]
-                self._remove(self.map[lru_key])
-                self.size -= 1
-
-    def delete(self, key: str):
-        """Delete a key."""
-        with self.lock:
-            if key not in self.map:
-                return
-            self._remove(self.map[key])
-            del self.map[key]
-            self.size -= 1
-
-    def get(self, key: str) -> str:
-        """Get the value for a given key."""
-        return self._get(key)
-
-    def put(self, key: str, value: str, ttl_seconds: int):
-        """Put a value for a given key with a TTL."""
-        return self.put(key, value, ttl_seconds)
-
-    def delete(self, key: str):
-        """Delete a key."""
-        return self.delete(key)
-
-# Usage example
-if __name__ == "__main__":
-    cache = LRUCache(2)
-
-    def put_and_get(cache: LRUCache, key: str, value: str, ttl_seconds: int):
-        cache.put(key, value, ttl_seconds)
-        time.sleep(1)  # Simulate a delay
-        print(cache.get(key))
-
-    threads = []
-    for i in range(3):
-        thread = threading.Thread(target=put_and_get, args=(cache, f"key{i}", f"value{i}", 2))
-        thread.start()
-        threads.append(thread)
-
-    for thread in threads:
-        thread.join()
-
-==========================================
-MODEL: mac-studio/ministral-3:14b
-==========================================
-LOAD: 4.0s | TOKENS: 1500 | DURATION: 36.4s | SPEED: 41.2 tok/s
-
-Here's a complete, production-quality implementation of a thread-safe LRU cache with per-key TTL expiration in Python:
-
-```python
-import time
-from threading import Lock
-from typing import Any, Dict, Generic, Optional, TypeVar
-
-K = TypeVar('K')
-V = TypeVar('V')
-
-class Node(Generic[K, V]):
-    """Doubly linked list node for the LRU cache implementation."""
-    def __init__(self, key: K, value: V, expiration: float):
-        self.key = key
-        self.value = value
-        self.expiration = expiration
-        self.prev: Optional['Node[K, V]'] = None
-        self.next: Optional['Node[K, V]'] = None
-
-class LRUCacheWithTTL(Generic[K, V]):
-    """Thread-safe LRU cache with per-key TTL expiration.
-
-    This implementation uses a doubly linked list for O(1) access to most recently used items
-    and a hashmap for O(1) lookups. Each key has its own TTL (time-to-live) expiration.
-
-    Attributes:
-        capacity: Maximum number of items the cache can hold
-        _cache: Dictionary mapping keys to nodes
-        _head: Most recently used node (dummy head)
-        _tail: Least recently used node (dummy tail)
-        _lock: Threading lock for thread safety
-    """
-
-    def __init__(self, capacity: int = 128):
-        """Initialize the cache with a given capacity.
-
-        Args:
-            capacity: Maximum number of items the cache can hold
-        """
-        if capacity <= 0:
-            raise ValueError("Capacity must be positive")
-
-        self.capacity = capacity
-        self._cache: Dict[K, Node[K, V]] = {}
-        self._head = Node(None, None, 0)  # dummy head
-        self._tail = Node(None, None, 0)  # dummy tail
-        self._head.next = self._tail
-        self._tail.prev = self._head
-        self._lock = Lock()
-
-    def _remove_node(self, node: Node[K, V]) -> None:
-        """Remove a node from the linked list."""
-        prev_node = node.prev
-        next_node = node.next
-        prev_node.next = next_node
-        next_node.prev = prev_node
-
-    def _add_to_head(self, node: Node[K, V]) -> None:
-        """Add a node right after the dummy head (most recently used)."""
-        node.next = self._head.next
-        node.prev = self._head
-        self._head.next.prev = node
-        self._head.next = node
-
-    def _move_to_head(self, node: Node[K, V]) -> None:
-        """Move an existing node to the head (most recently used)."""
-        self._remove_node(node)
-        self._add_to_head(node)
-
-    def _evict_tail(self) -> None:
-        """Remove and return the tail node (least recently used)."""
-        if self._tail.prev == self._head:
-            return None
-
-        tail_node = self._tail.prev
-        self._remove_node(tail_node)
-        del self._cache[tail_node.key]
-        return tail_node
-
-    def _is_expired(self, node: Node[K, V]) -> bool:
-        """Check if a node has expired based on its TTL."""
-        return time.time() > node.expiration
-
-    def get(self, key: K) -> Optional[V]:
-        """Get a value from the cache.
-
-        Args:
-            key: The key to look up
-
-        Returns:
-            The cached value if found and not expired, None otherwise
-        """
-        with self._lock:
-            node = self._cache.get(key)
-            if node is None:
-                return None
-
-            if self._is_expired(node):
-                self._remove_node(node)
-                del self._cache[key]
-                return None
-
-            self._move_to_head(node)
-            return node.value
-
-    def put(self, key: K, value: V, ttl_seconds: float) -> None:
-        """Put a value into the cache with a TTL.
-
-        Args:
-            key: The key to store
-            value: The value to cache
-            ttl_seconds: Time-to-live in seconds
-        """
-        with self._lock:
-            # Check if key exists and is not expired
-            node = self._cache.get(key)
-            if node is not None:
-                if not self._is_expired(node):
-                    self._remove_node(node)
-                else:
-                    del self._cache[key]
-
-            # Create new node
-            expiration = time.time() + ttl_seconds
-            new_node = Node(key, value, expiration)
-            self._cache[key] = new_node
-            self._add_to_head(new_node)
-
-            # Evict if over capacity
-            if len(self._cache) > self.capacity:
-                self._evict_tail()
-
-    def delete(self, key: K) -> bool:
-        """Delete a key from the cache.
-
-        Args:
-            key: The key to remove
-
-        Returns:
-            True if the key was found and removed, False otherwise
-        """
-        with self._lock:
-            node = self._cache.get(key)
-            if node is None:
-                return False
-
-            self._remove_node(node)
-            del self._cache[key]
-            return True
-
-    def __contains__(self, key: K) -> bool:
-        """Check if a key exists in the cache and is not expired.
-
-        Args:
-            key: The key to check
-
-        Returns:
-            True if the key exists and is not expired, False otherwise
-        """
-        with self._lock:
-            node = self._cache.get(key)
-            if node is None:
-                return False
-            return not self._is_expired(node)
-
-    def __len__(self) -> int:
-        """Get the current number of items in the cache (non-expired)."""
-        with self._lock:
-            return sum(1 for node in self._cache.values() if not self._is_expired(node))
-
-    def clear(self) -> None:
-        """Clear all items from the cache."""
-        with self._lock:
-            self._cache.clear()
-            self._head.next = self._tail
-            self._tail.prev = self._head
-
-# Example usage
-if __name__ == "__main__":
-    # Create a cache with capacity of 3
-    cache = LRUCacheWithTTL[int, str](capacity=3)
-
-    # Put some items with different TTLs
-    cache.put(1, "value1", ttl_seconds=5)  # expires in 5 seconds
-    cache.put(2, "value2", ttl_seconds=10)  # expires in 10 seconds
-    cache.put(3, "value3", ttl_seconds=2)   # expires in 2 seconds
-
-    # Get items
-    print(cache.get(1))  # "value1"
-    print(cache.get(2))
-
-==========================================
-MODEL: mac-studio/gpt-oss:20b
-==========================================
-LOAD: 5.6s | TOKENS: 1500 | DURATION: 19.6s | SPEED: 76.4 tok/s
-
-```python
-#!/usr/bin/env python3
-"""
-A production‑ready, thread‑safe LRU cache with per‑key TTL support.
-
-Features
---------
-* O(1) `get`, `put` and `delete` operations.
-* Internally uses a doubly‑linked list plus a hash map – no
-  `OrderedDict` or other high‑level helpers.
-* Thread‑safe: all public methods acquire a `threading.Lock`.
-* Expired keys are removed lazily when accessed.
-* Capacity (maximum number of entries) can be configured; when the
-  limit is reached the least‑recently used item is evicted.
-* Full type hints and detailed docstrings.
-"""
-
-from __future__ import annotations
-
-from dataclasses import dataclass
-import time
-import threading
-from typing import Any, Dict, Optional
-
-
-@dataclass
-class _Node:
-    """
-    Doubly‑linked list node used internally by :class:`LRUCache`.
-
-    Attributes
-    ----------
-    key : Any
-        The key stored in this node.
-    value : Any
-        The value stored in this node.
-    expire_at : float
-        Unix timestamp (seconds since epoch) when this entry expires.
-    prev : Optional[_Node]
-        Reference to the previous node in the list.
-    next : Optional[_Node]
-        Reference to the next node in the list.
-    """
-    key: Any
-    value: Any
-    expire_at: float
-    prev: Optional["_Node"] = None
-    next: Optional["_Node"] = None
-
-
-class LRUCache:
-    """
-    A least‑recently‑used (LRU) cache with per‑key time‑to‑live (TTL).
-
-    Parameters
-    ----------
-    capacity : int, optional
-        Maximum number of items the cache can hold.  When the limit is
-        exceeded the least‑recently used item is evicted.  If omitted,
-        the cache defaults to 128 items.
-
-    Notes
-    -----
-    All public methods are thread‑safe.  The cache stores expiration
-    timestamps in UTC seconds (`time.time()`), so TTL values should be
-    given in seconds.
-    """
-
-    def __init__(self, capacity: int = 128) -> None:
-        if capacity <= 0:
-            raise ValueError("capacity must be a positive integer")
-        self.capacity: int = capacity
-        self.cache: Dict[Any, _Node] = {}
-
-        # Dummy head and tail nodes to simplify edge cases
-        self._head: _Node = _Node(key=None, value=None, expire_at=0.0)
-        self._tail: _Node = _Node(key=None, value=None, expire_at=0.0)
-        self._head.next = self._tail
-        self._tail.prev = self._head
-
-        self._lock = threading.Lock()
-
-    # ----------------------------------------------------------------------
-    # Private helper methods (all assume the lock is held)
-    # ----------------------------------------------------------------------
-    def _add_to_front(self, node: _Node) -> None:
-        """Insert *node* immediately after the dummy head."""
-        node.next = self._head.next
-        node.prev = self._head
-        self._head.next.prev = node
-        self._head.next = node
-
-    def _remove(self, node: _Node) -> None:
-        """Remove *node* from the linked list."""
-        prev_node = node.prev
-        next_node = node.next
-        if prev_node is not None:
-            prev_node.next = next_node
-        if next_node is not None:
-            next_node.prev = prev_node
-        node.prev = node.next = None
-
-    def _move_to_front(self, node: _Node) -> None:
-        """Move an existing node to the front (most‑recently used)."""
-        self._remove(node)
-        self._add_to_front(node)
-
-    def _pop_tail(self) -> Optional[_Node]:
-        """
-        Remove and return the least‑recently used node (the one just
-
-==========================================
-MODEL: mac-studio/devstral-small-2:24b
-==========================================
-LOAD: 5.2s | TOKENS: 1500 | DURATION: 60.5s | SPEED: 24.8 tok/s
-
-Here's a thread-safe LRU cache implementation with per-key TTL expiration using a doubly linked list and hashmap:
-
-```python
-import threading
-import time
-from typing import Any, Generic, TypeVar, Optional
-
-K = TypeVar('K')
-V = TypeVar('V')
-
-class Node(Generic[K, V]):
-    """Node in the doubly linked list."""
-    def __init__(self, key: K, value: V, expiration: float) -> None:
-        self.key = key
-        self.value = value
-        self.expiration = expiration
-        self.prev: Optional['Node[K, V]'] = None
-        self.next: Optional['Node[K, V]'] = None
-
-class ThreadSafeLRUCache(Generic[K, V]):
-    """Thread-safe LRU cache with per-key TTL expiration.
-
-    Uses a doubly linked list for O(1) access to most recent items and a hashmap for O(1) lookups.
-    Expired items are lazily evicted on access.
-    """
-
-    def __init__(self, capacity: int) -> None:
-        """Initialize the cache with given capacity.
-
-        Args:
-            capacity: Maximum number of items the cache can hold.
-        """
-        if capacity <= 0:
-            raise ValueError("Capacity must be positive")
-
-        self.capacity = capacity
-        self.cache: dict[K, Node[K, V]] = {}
-        self.head: Optional[Node[K, V]] = None
-        self.tail: Optional[Node[K, V]] = None
-        self.lock = threading.Lock()
-
-    def _add_to_head(self, node: Node[K, V]) -> None:
-        """Add node to the head of the list (most recently used)."""
-        node.prev = None
-        node.next = self.head
-
-        if self.head is not None:
-            self.head.prev = node
-
-        self.head = node
-
-        if self.tail is None:
-            self.tail = node
-
-    def _remove_node(self, node: Node[K, V]) -> None:
-        """Remove node from the linked list."""
-        if node.prev is not None:
-            node.prev.next = node.next
-        else:
-            self.head = node.next
-
-        if node.next is not None:
-            node.next.prev = node.prev
-        else:
-            self.tail = node.prev
-
-    def _move_to_head(self, node: Node[K, V]) -> None:
-        """Move node to the head of the list (mark as recently used)."""
-        self._remove_node(node)
-        self._add_to_head(node)
-
-    def _pop_tail(self) -> Optional[Node[K, V]]:
-        """Remove and return the tail node (least recently used)."""
-        if self.tail is None:
-            return None
-
-        node = self.tail
-        self._remove_node(node)
-        return node
-
-    def _is_expired(self, node: Node[K, V]) -> bool:
-        """Check if node has expired based on its TTL."""
-        return time.time() > node.expiration
-
-    def get(self, key: K) -> Optional[V]:
-        """Get value for key if it exists and hasn't expired.
-
-        Args:
-            key: Key to look up in cache.
-
-        Returns:
-            Value if found and not expired, None otherwise.
-        """
-        with self.lock:
-            node = self.cache.get(key)
-            if node is None:
-                return None
-
-            if self._is_expired(node):
-                self._remove_node(node)
-                del self.cache[key]
-                return None
-
-            self._move_to_head(node)
-            return node.value
-
-    def put(self, key: K, value: V, ttl_seconds: float) -> None:
-        """Insert or update key-value pair with TTL.
-
-        Args:
-            key: Key to insert/update.
-            value: Value to store.
-            ttl_seconds: Time-to-live in seconds for this key.
-        """
-        with self.lock:
-            expiration = time.time() + ttl_seconds
-
-            if key in self.cache:
-                node = self.cache[key]
-                node.value = value
-                node.expiration = expiration
-                self._move_to_head(node)
-            else:
-                if len(self.cache) >= self.capacity:
-                    tail = self._pop_tail()
-                    if tail is not None:
-                        del self.cache[tail.key]
-
-                new_node = Node(key, value, expiration)
-                self.cache[key] = new_node
-                self._add_to_head(new_node)
-
-    def delete(self, key: K) -> bool:
-        """Remove key from cache if it exists.
-
-        Args:
-            key: Key to remove.
-
-        Returns:
-            True if key was found and removed, False otherwise.
-        """
-        with self.lock:
-            node = self.cache.get(key)
-            if node is None:
-                return False
-
-            self._remove_node(node)
-            del self.cache[key]
-            return True
-
-# Usage example
-if __name__ == "__main__":
-    cache = ThreadSafeLRUCache[str, int](capacity=2)
-
-    # Test basic operations
-    cache.put("a", 1, ttl_seconds=1)
-    cache.put("b", 2, ttl_seconds=2)
-
-    print(cache.get("a"))  # Output: 1
-    print(cache.get("b"))  # Output: 2
-
-    # Test LRU eviction
-    cache.put("c", 3, ttl_seconds=3)
-    print(cache.get("a"))  # Output: None (evicted)
-    print(cache.get("b"))  # Output: 2
-    print(cache.get("c"))  # Output: 3
-
-    # Test TTL expiration
-    time.sleep(1.5)
-    print(cache.get("b"))  # Output: None (expired)
-    print(cache.get("c"))  # Output: 3
-
-    # Test thread safety
-    def worker(key: str, value: int, ttl: float) -> None:
-        cache.put(key, value, ttl_seconds=ttl)
-        print(f"Put {key}: {cache.get(key)}")
-
-    threads = []
-    for i in range(5):
-        t = threading.Thread(target=worker, args=(f"key{i}", i, 5))
-        threads.append(t)
-        t.start()
-
-    for t in threads:
-        t.join()
-
-    # Test delete
-    print(cache.delete("key0"))  # Output: True
-    print(cache.delete("nonexistent"))  # Output: False
-```
-
-This implementation includes:
-
-1. A doubly linked list (`Node` class) to track usage order
-2. A hashmap (`cache` dict) for O(1) lookups
-3. Thread safety using `threading.Lock`
-4. Lazy expiration checking on `get()` operations
-5. Full type hints and docstrings
-6. A working usage example demonstrating:
-   - Basic put/get operations
-   - LRU eviction
-   - TTL expiration
-
-==========================================
-MODEL: mac-studio/qwen3-coder:30b
-==========================================
-LOAD: 7.3s | TOKENS: 1500 | DURATION: 17.3s | SPEED: 86.6 tok/s
-
-```python
-import threading
-import time
-from typing import Optional, Any, Dict
-
-
-class LRUCacheNode:
-    """Doubly linked list node for LRU cache."""
-    
-    def __init__(self, key: str, value: Any, ttl_seconds: Optional[int] = None):
-        self.key = key
-        self.value = value
-        self.ttl_seconds = ttl_seconds
-        self.expiration_time = time.time() + ttl_seconds if ttl_seconds is not None else None
-        self.prev = None
-        self.next = None
-
-
-class LRUCache:
-    """
-    Thread-safe LRU cache with per-key TTL expiration.
-    
-    This implementation uses a doubly linked list combined with a hash map to achieve
-    O(1) get and put operations. Keys are lazily evicted when accessed if expired.
-    """
-    
-    def __init__(self, capacity: int = 128):
-        """
-        Initialize the LRU cache with given capacity.
-        
-        Args:
-            capacity: Maximum number of items the cache can hold
-        """
-        self.capacity = capacity
-        self.cache_map: Dict[str, LRUCacheNode] = {}
-        self.head = LRUCacheNode("", None)  # Dummy head node
-        self.tail = LRUCacheNode("", None)  # Dummy tail node
-        self.head.next = self.tail
-        self.tail.prev = self.head
-        self.lock = threading.Lock()
-    
-    def _remove_node(self, node: LRUCacheNode) -> None:
-        """
-        Remove a node from the doubly linked list.
-        
-        Args:
-            node: Node to remove
-        """
-        node.prev.next = node.next
-        node.next.prev = node.prev
-    
-    def _add_to_front(self, node: LRUCacheNode) -> None:
-        """
-        Add a node to the front of the doubly linked list (most recently used).
-        
-        Args:
-            node: Node to add
-        """
-        node.next = self.head.next
-        node.prev = self.head
-        self.head.next.prev = node
-        self.head.next = node
-    
-    def _move_to_front(self, node: LRUCacheNode) -> None:
-        """
-        Move a node to the front of the list (mark as most recently used).
-        
-        Args:
-            node: Node to move
-        """
-        self._remove_node(node)
-        self._add_to_front(node)
-    
-    def _is_expired(self, node: LRUCacheNode) -> bool:
-        """
-        Check if a node is expired based on its TTL.
-        
-        Args:
-            node: Node to check
-            
-        Returns:
-            True if the node is expired, False otherwise
-        """
-        if node.expiration_time is None:
-            return False
-        return time.time() > node.expiration_time
-    
-    def _evict_expired(self) -> None:
-        """
-        Evict all expired nodes from the cache.
-        """
-        current = self.tail.prev
-        while current != self.head and self._is_expired(current):
-            self._remove_node(current)
-            del self.cache_map[current.key]
-            current = self.tail.prev
-    
-    def get(self, key: str) -> Optional[Any]:
-        """
-        Get a value from the cache by key.
-        
-        If the key is not found or has expired, returns None.
-        Also removes expired keys lazily during access.
-        
-        Args:
-            key: Key to look up
-            
-        Returns:
-            Value associated with key, or None if not found or expired
-        """
-        with self.lock:
-            if key not in self.cache_map:
-                return None
-            
-            node = self.cache_map[key]
-            
-            # Check for expiration before returning
-            if self._is_expired(node):
-                self._remove_node(node)
-                del self.cache_map[key]
-                return None
-            
-            # Move to front (most recently used)
-            self._move_to_front(node)
-            return node.value
-    
-    def put(self, key: str, value: Any, ttl_seconds: Optional[int] = None) -> None:
-        """
-        Put a key-value pair in the cache with optional TTL.
-        
-        If key already exists, updates its value and TTL.
-        Evicts least recently used items if necessary.
-        
-        Args:
-            key: Key to store
-            value: Value to store
-            ttl_seconds: Time-to-live in seconds (None means no expiration)
-        """
-        with self.lock:
-            if key in self.cache_map:
-                # Update existing node
-                node = self.cache_map[key]
-                node.value = value
-                node.ttl_seconds = ttl_seconds
-                node.expiration_time = time.time() + ttl_seconds if ttl_seconds is not None else None
-                self._move_to_front(node)
-            else:
-                # Create new node
-                new_node = LRUCacheNode(key, value, ttl_seconds)
-                
-                # Evict expired nodes before adding new one
-                self._evict_expired()
-                
-                # Check if we need to evict oldest items
-                if len(self.cache_map) >= self.capacity:
-                    # Remove least recently used (tail.prev)
-                    lru_node = self.tail.prev
-                    self._remove_node(lru_node)
-                    del self.cache_map[lru_node.key]
-                
-                # Add new node to front
-                self._add_to_front(new_node)
-                self.cache_map[key] = new_node
-    
-    def delete(self, key: str) -> bool:
-        """
-        Delete a key from the cache.
-        
-        Args:
-            key: Key to delete
-            
-        Returns:
-            True if key was found and deleted, False otherwise
-        """
-        with self.lock:
-            if key not in self.cache_map:
-                return False
-            
-            node = self.cache_map[key]
-            self._remove_node(node)
-            del self.cache_map[key]
-            return True
-    
-    def size(self) -> int:
-        """
-        Get the current number of items in the cache.
-        
-        Returns:
-            Number of items in the cache
-        """
-        with self.lock:
-            return len(self.cache_map)
-    
-    def clear(self) -> None:
-        """
-        Clear all items from the cache.
-        """
-        with self.lock:
-            self.cache_map.clear()
-            self.head.next = self.tail
-            self.tail.prev = self.head
-
-
-# Example usage
-if __name__ == "__main__":
-    # Create a cache with capacity of 3
-    cache = LRUCache(capacity=3)
-    
-    # Put some values
-    cache.put("a", 1, ttl_seconds=2)  # Expires in 2 seconds
-    cache.put("b", 2, ttl_seconds=5)  # Expires in 5 seconds
-    cache.put("c", 3)                 # No expiration
-    
-    print(f"Cache size: {cache.size()}")  # Should be 3
-    
-    # Get values
-    print(cache.get("a"))  # Should return 1
-    print(cache.get("b"))  # Should return 2
-    
-    # Wait for key "a" to expire
-    time.sleep(2.5)
-    
-    # Try accessing expired key
-    print(cache.get("a"))  # Should return None
-
-==========================================
-MODEL: mac-mini/qwen3.5:27b
-==========================================
-LOAD: 11.8s | TOKENS: 1500 | DURATION: 406.5s | SPEED: 3.7 tok/s
-
-Here's a thinking process that leads to the suggested implementation:
-
-1.  **Analyze the Request:**
-    *   **Goal:** Implement a thread-safe LRU (Least Recently Used) cache in Python.
-    *   **Specific Feature:** Per-key TTL (Time-To-Live).
-    *   **Internal Structure:** Doubly Linked List + Hash Map (Dictionary). Explicitly forbids `OrderedDict` and `functools.lru_cache`.
-    *   **Methods:** `get(key)`, `put(key, value, ttl_seconds)`, `delete(key)`.
-    *   **Concurrency:** Thread-safe using `threading.Lock`.
-    *   **Expiration Logic:** Lazy eviction (keys expire only when accessed if TTL passed). Note: This usually implies checking expiry on `get` or `put`.
-    *   **Quality:** Production-quality, full type hints, docstrings.
-    *   **Output:** Working usage example included.
-
-2.  **Design the Data Structures:**
-    *   **Node Class:** Needs to hold `key`, `value`, `expiry_time` (absolute timestamp), and pointers `prev`/`next`.
-    *   **HashMap:** A standard `dict[str, Node]` mapping keys to node objects for O(1) access.
-    *   **Doubly Linked List:** Needs head and tail sentinel nodes (dummy nodes) to simplify insertion/removal at ends.
-        *   Head: Most Recently Used (MRU).
-        *   Tail: Least Recently Used (LRU).
-    *   **Lock:** A `threading.RLock` or `threading.Lock`. Since we might be calling internal methods that hold locks, an `RLock` is often safer to prevent deadlocks if a method re-enters the lock context, though for simple cache ops `Lock` usually suffices. Let's stick to `threading.Lock` as per strict requirement, but `RLock` handles recursion better. The prompt says `threading.Lock`, so I will use `threading.Lock`. Wait, actually, if I have a method that calls another synchronized method holding the lock, I need `RLock`. However, standard cache implementations usually wrap the critical section in one block. I will use `threading.Lock` but structure code carefully to avoid recursion. Actually, `RLock` is safer for re-entrancy (e.g., if `delete` calls internal cleanup that might try to acquire). Let's stick to the prompt: "Thread-safe using threading.Lock". I'll use `threading.Lock` but be mindful of critical sections.
-
-3.  **Design the Logic:**
-    *   **Capacity:** The prompt didn't specify a max size limit, just LRU behavior + TTL. However, a cache usually implies eviction based on size. Without a max size, it's technically an "LRU dictionary with expiration". But to make it truly an LRU *Cache*, I need a `capacity` parameter in `__init__`. If I don't implement capacity, the Linked List logic for LRU is less meaningful (we only move nodes to front on access). Let's add `capacity` but default it to infinite or None. To strictly satisfy "LRU Cache", eviction based on size is crucial. I will include `max_size` in `__init__`.
-    *   **`put(key, value, ttl)`:**
-        1.  Acquire lock.
-        2.  Check if key exists.
-            *   If yes: Update node (value, expiry, move to MRU).
-            *   If no: Create new node. Insert at MRU. Increment size.
-        3.  If capacity exceeded and new node added: Evict LRU node (tail.next). Check map deletion.
-        4.  Release lock.
-    *   **`get(key)`:**
-        1.  Acquire lock.
-        2.  Check if key exists in map.
-        3.  If exists:
-            *   Check TTL (time.time() > expiry_time).
-            *   If expired: Remove node, remove from map, return None.
-            *   If not expired: Move to MRU, return value.
-        4.  Release lock.
-    *   **`delete(key)`:**
-        1.  Acquire lock.
-        2.  Check if key exists.
-        3.  Remove node from list and map.
-        4.  Release lock.
-
-4.  **Refining Expiration Logic (Lazy vs Active):**
-    *   Requirement: "Expired keys are lazily evicted on access".
-    *   This means `get(key)` checks TTL. If expired, remove it.
-    *   What about `put`? If we overwrite an existing key, we should update its TTL.
-    *   What about background cleanup? The requirement specifically says "lazy eviction on access", implying no background threads for expiration. I will follow this strictly. However, relying solely on lazy eviction means expired entries stay in memory until accessed again, which might bloat memory. A production-quality cache usually has a mechanism to handle this, but adhering to the prompt's constraint ("lazily evicted"), I will not add a background cleaner thread. I will focus on the "access" part.
-    *   Wait, if I don't check expiration in `put` (when overwriting), an old key stays expired until `get` or next access? No, `put` updates it. The issue is keys that are never accessed again after expiring. They remain in the map/list until a size eviction happens (if capacity exists) or until explicitly deleted. This is acceptable for "lazy".
-
-5.  **Drafting the Code (Mental or Scratchpad):**
-    *   `Node` class: `key`, `value`, `expire_at`, `prev`, `next`.
-    *   `_DoublyLinkedList`: Head, Tail pointers. Methods `_add_to_head(node)`, `_remove_node(node)`.
-    *   `LRUCache`: `__init__(self, capacity=...)`. `_cache` dict. `current_size`. `lock`.
-    *   Imports: `time`, `threading`, `typing` (Optional).
-
-6.  **Addressing "Production Quality":**
-    *   Type hints everywhere.
-    *   Docstrings for class and methods.
-    *   Handle `None` inputs gracefully? Key should be hashable. Value any object. TTL float/int >= 0.
-    *   Context manager for lock (`with self.lock:`).
-    *   Sentinel nodes (dummy head/tail) simplify edge cases (empty list).
-
-7.  **Potential Edge Cases:**
-    *   `ttl_seconds` = 0? Should expire immediately or act like no TTL? Usually 0 means immediate expiry or effectively "cache for a moment". Standard logic: `time.time() + ttl`. If 0, it expires immediately on next check. Let
-==========================================
-BENCHMARK COMPLETE: Mon Mar 23 07:09:03 EDT 2026