Update lru_cache.py

Author: lighting9999

other/lru_cache.py

@@ -2,67 +2,67 @@
 
 from collections.abc import Callable
 from functools import wraps
-from typing import Any, ParamSpec, TypeVar
+from typing import Any, ParamSpec, TypeVar, cast
 
 P = ParamSpec("P")
 R = TypeVar("R")
 
 
 class DoubleLinkedListNode:
     """Node for LRU Cache"""
-
+    
     __slots__ = ("key", "next", "prev", "val")
-
+    
     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 before rear"""
         prev = self.rear.prev
         if prev is None:
             return
-
+        
         # Insert node between prev and rear
         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
-
+        
         # Bypass node
         node.prev.next = node.next
         node.next.prev = node.prev
-
+        
         # Clear node references
         node.prev = None
         node.next = None
@@ -71,21 +71,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:
@@ -96,7 +96,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:
@@ -106,63 +106,62 @@ def put(self, key: Any, value: Any) -> None:
                 node.val = value
                 self.list.add(node)
             return
-
+        
         # Evict LRU item if at capacity
         if self.size >= self.capacity:
             first_node = self.list.head.next
             if (
-                first_node
+                first_node is not None
                 and first_node.key is not None
                 and first_node != self.list.rear
                 and self.list.remove(first_node)
             ):
                 del self.cache[first_node.key]
                 self.size -= 1
-
+        
         # Add new node
         new_node = DoubleLinkedListNode(key, value)
         self.cache[key] = new_node
         self.list.add(new_node)
         self.size += 1
-
+    
     def cache_info(self) -> dict[str, Any]:
         """Get cache statistics"""
         return {
             "hits": self.hits,
             "misses": self.misses,
             "capacity": self.capacity,
-            "size": self.size,
+            "size": self.size
         }
 
 
 def lru_cache(maxsize: int = 128) -> Callable[[Callable[P, R]], Callable[P, R]]:
     """LRU Cache decorator"""
-
     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())))
-
+            
             # Try to get cached result
-            if (cached := cache.get(key)) is not None:
-                return cached
-
+            cached = cache.get(key)
+            if cached is not None:
+                return cast(R, cached)
+            
             # Compute and cache result
             result = func(*args, **kwargs)
             cache.put(key, result)
             return result
-
+        
         # Attach cache info method
         wrapper.cache_info = cache.cache_info  # type: ignore[attr-defined]
         return wrapper
-
+    
     return decorator
 
 
 if __name__ == "__main__":
     import doctest
-
     doctest.testmod()