Merge pull request #2015 from vipul674/fix/l1-lock-variable-overwrite

[GSSoC'26] fix: rename l1_lock dict to l1_cache to prevent variable overwrite

Author: dipexplorer

src/services/distributed_lock_manager.py

@@ -53,7 +53,7 @@ def __init__(self, l1_capacity: int = 1000, l2_capacity: int = 10000):
         self.l2_capacity = l2_capacity
 
         # L1 Memory Lock (LFU implementation)
-        self.l1_lock: Dict[str, LFUNode] = {}
+        self.l1_cache: Dict[str, LFUNode] = {}
         self.freq_map: Dict[int, LFUDoublyLinkedList] = {}
         self.min_freq = 0
         self.l1_lock = threading.RLock()
@@ -83,8 +83,8 @@ def _update_freq(self, node: LFUNode):
 
     def get(self, key: str) -> Optional[Any]:
         with self.l1_lock:
-            if key in self.l1_lock:
-                node = self.l1_lock[key]
+            if key in self.l1_cache:
+                node = self.l1_cache[key]
                 self._update_freq(node)
                 logger.debug("L1 Lock HIT for key: %s", key)
                 return node.value
@@ -106,28 +106,28 @@ def get(self, key: str) -> Optional[Any]:
 
     def _promote_to_l1(self, key: str, value: Any):
         with self.l1_lock:
-            if len(self.l1_lock) >= self.l1_capacity:
+            if len(self.l1_cache) >= self.l1_capacity:
                 self._evict_l1()
 
             node = LFUNode(key, value, 1)
-            self.l1_lock[key] = node
+            self.l1_cache[key] = node
             if 1 not in self.freq_map:
                 self.freq_map[1] = LFUDoublyLinkedList()
             self.freq_map[1].insert_at_head(node)
             self.min_freq = 1
 
     def put(self, key: str, value: Any):
         with self.l1_lock:
-            if key in self.l1_lock:
-                node = self.l1_lock[key]
+            if key in self.l1_cache:
+                node = self.l1_cache[key]
                 node.value = value
                 self._update_freq(node)
             else:
-                if len(self.l1_lock) >= self.l1_capacity:
+                if len(self.l1_cache) >= self.l1_capacity:
                     self._evict_l1()
 
                 node = LFUNode(key, value, 1)
-                self.l1_lock[key] = node
+                self.l1_cache[key] = node
                 if 1 not in self.freq_map:
                     self.freq_map[1] = LFUDoublyLinkedList()
                 self.freq_map[1].insert_at_head(node)
@@ -140,7 +140,7 @@ def _evict_l1(self):
         if self.min_freq in self.freq_map:
             evicted_node = self.freq_map[self.min_freq].remove_tail()
             if evicted_node:
-                del self.l1_lock[evicted_node.key]
+                del self.l1_cache[evicted_node.key]
                 logger.debug("Evicted key %s from L1 lock (freq: %d)", evicted_node.key, evicted_node.freq)
 
     def _background_sync(self):
@@ -171,18 +171,18 @@ def _background_sync(self):
 
     def invalidate(self, key: str):
         with self.l1_lock:
-            if key in self.l1_lock:
-                node = self.l1_lock[key]
+            if key in self.l1_cache:
+                node = self.l1_cache[key]
                 self.freq_map[node.freq].remove_node(node)
-                del self.l1_lock[key]
+                del self.l1_cache[key]
 
         with self.l2_lock:
             if key in self.l2_store:
                 del self.l2_store[key]
 
     def get_stats(self) -> Dict[str, Any]:
         with self.l1_lock:
-            l1_size = len(self.l1_lock)
+            l1_size = len(self.l1_cache)
         with self.l2_lock:
             l2_size = len(self.l2_store)