Update lru_cache.py

Author: lighting9999

other/lru_cache.py

@@ -2,58 +2,62 @@
 
 from collections.abc import Callable, Hashable
 from functools import wraps
-from typing import Any, Generic, ParamSpec, TypeVar, cast
+from typing import Any, ParamSpec, TypeVar, cast
 
 P = ParamSpec("P")
 R = TypeVar("R")
 
 
 class DoubleLinkedListNode:
     """Node for LRU Cache"""
-
-    def __init__(self, key: Any | None, val: Any | None) -> None:
+    
+    __slots__ = ("key", "val", "next", "prev")
+    
+    def __init__(self, key: Any, val: Any) -> None:
         self.key = key
         self.val = val
         self.next: DoubleLinkedListNode | None = None
         self.prev: DoubleLinkedListNode | None = None
-
+    
     def __repr__(self) -> str:
         return f"Node(key={self.key}, val={self.val})"
 
 
 class DoubleLinkedList:
     """Double Linked List for LRU Cache"""
-
+    
     def __init__(self) -> None:
+        # Create sentinel nodes
         self.head = DoubleLinkedListNode(None, None)
         self.rear = DoubleLinkedListNode(None, None)
+        # Link sentinel nodes together
         self.head.next = self.rear
         self.rear.prev = self.head
-
+    
     def __repr__(self) -> str:
         nodes = []
         current = self.head
         while current:
             nodes.append(repr(current))
             current = current.next
         return f"LinkedList({nodes})"
-
+    
     def add(self, node: DoubleLinkedListNode) -> None:
-        """Add node to list end"""
+        """Add node before rear"""
         prev = self.rear.prev
         if prev is None:
-            raise ValueError("Invalid list state")
-
+            return  # Should never happen with sentinel nodes
+        
         prev.next = node
         node.prev = prev
         self.rear.prev = node
         node.next = self.rear
-
+    
     def remove(self, node: DoubleLinkedListNode) -> DoubleLinkedListNode | None:
         """Remove node from list"""
         if node.prev is None or node.next is None:
             return None
-
+        
         node.prev.next = node.next
         node.next.prev = node.prev
         node.prev = node.next = None
@@ -62,21 +66,21 @@ def remove(self, node: DoubleLinkedListNode) -> DoubleLinkedListNode | None:
 
 class LRUCache:
     """LRU Cache implementation"""
-
+    
     def __init__(self, capacity: int) -> None:
         self.list = DoubleLinkedList()
         self.capacity = capacity
         self.size = 0
         self.hits = 0
         self.misses = 0
         self.cache: dict[Any, DoubleLinkedListNode] = {}
-
+    
     def __repr__(self) -> str:
         return (
             f"Cache(hits={self.hits}, misses={self.misses}, "
             f"cap={self.capacity}, size={self.size})"
         )
-
+    
     def get(self, key: Any) -> Any | None:
         """Get value for key"""
         if key in self.cache:
@@ -87,7 +91,7 @@ def get(self, key: Any) -> Any | None:
             return node.val
         self.misses += 1
         return None
-
+    
     def put(self, key: Any, value: Any) -> None:
         """Set value for key"""
         if key in self.cache:
@@ -96,43 +100,57 @@ def put(self, key: Any, value: Any) -> None:
                 node.val = value
                 self.list.add(node)
             return
-
+        
         if self.size >= self.capacity:
-            first = self.list.head.next
-            if first and first.key and self.list.remove(first):
-                del self.cache[first.key]
-                self.size -= 1
-
+            # Remove least recently used item
+            first_node = self.list.head.next
+            if first_node and first_node != self.list.rear:
+                if self.list.remove(first_node):
+                    del self.cache[first_node.key]
+                    self.size -= 1
+        
         new_node = DoubleLinkedListNode(key, value)
         self.cache[key] = new_node
         self.list.add(new_node)
         self.size += 1
-
-
-def lru_cache(size: int = 128) -> Callable[[Callable[P, R]], Callable[P, R]]:
+    
+    def cache_info(self) -> dict[str, Any]:
+        """Get cache statistics"""
+        return {
+            "hits": self.hits,
+            "misses": self.misses,
+            "capacity": self.capacity,
+            "size": self.size
+        }
+
+
+def lru_cache(maxsize: int = 128) -> Callable[[Callable[P, R]], Callable[P, R]]:
     """LRU Cache decorator"""
-
-    def decorator_func(func: Callable[P, R]) -> Callable[P, R]:
-        cache = LRUCache(size)
-
+    def decorator(func: Callable[P, R]) -> Callable[P, R]:
+        cache = LRUCache(maxsize)
+        
         @wraps(func)
         def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
+            # Create normalized cache key
             key = (args, tuple(sorted(kwargs.items())))
-            if (cached := cache.get(key)) is not None:
+            
+            # Try to get cached result
+            cached = cache.get(key)
+            if cached is not None:
                 return cached
-
+            
+            # Compute and cache result
             result = func(*args, **kwargs)
             cache.put(key, result)
             return result
-
-        # Add cache_info attribute
-        wrapper.cache_info = lambda: cache  # type: ignore[attr-defined]
+        
+        # Attach cache info method
+        wrapper.cache_info = cache.cache_info  # type: ignore[attr-defined]
         return wrapper
-
-    return decorator_func
+    
+    return decorator
 
 
 if __name__ == "__main__":
     import doctest
-
     doctest.testmod()