stored_dict:

 - cache self.path
 - add lru cache

Author: ecdsa

electrum/stored_dict.py

@@ -2,6 +2,7 @@
 from typing import Any, Optional, Tuple, Union, Iterator, Iterable, List, Sequence
 from .logging import Logger
 
+from .lrucache import LRUCache
 
 FLEX_KEY = str | int | None
 _RaiseKeyError = object() # singleton for no-default behavior
@@ -99,6 +100,7 @@ class BaseStoredObject:
     _key: FLEX_KEY = None
     _parent: Optional['BaseStoredObject'] = None
     _lock: threading.RLock = None
+    _path = None
 
     def set_db(self, db):
         self._db = db
@@ -116,24 +118,29 @@ def lock(self):
 
     @property
     def path(self) -> Sequence[FLEX_KEY] | None:
+        if self._path is not None:
+            return self._path
         # return None iff we are pruned from root
         x = self
         s = [x._key]
         while x._parent is not None:
             x = x._parent
             s = [x._key] + s
         if x._key != '':
-            return None
-        assert self._db is not None
-        return s
+            s = []
+            #return None
+        else:
+            assert self._db is not None
+        self._path = s
+        return self._path
 
 
 class StoredObject(BaseStoredObject):
     """for attr.s objects """
 
     def __setattr__(self, key: str, value):
         assert isinstance(key, str), repr(key)
-        if self.path and not key.startswith('_'):
+        if not key.startswith('_') and self.path:
             if value != getattr(self, key):
                 self._db.replace(self.path, key, value)
         object.__setattr__(self, key, value)
@@ -163,6 +170,7 @@ def __init__(self, db: BaseDB, key: FLEX_KEY, parent):
         self._parent = parent
         self._key = key_to_str(key)
         self._should_convert = True
+        self._cache = LRUCache(maxsize=100)
 
     def should_convert(self):
         return self._parent._should_convert if self._parent is not None else self._should_convert
@@ -176,6 +184,8 @@ def get_dict(self, key) -> 'StoredDict':
 
     def __getitem__(self, key: FLEX_KEY) -> Any:
         key = key_to_str(key)
+        if cached := self._cache.get(key):
+            return cached
         value = self._db.get(self.path, key)
         if not self.should_convert():
             if isinstance(value, dict):
@@ -187,9 +197,10 @@ def __getitem__(self, key: FLEX_KEY) -> Any:
             value.set_db(self._db)
             value.set_parent(key=key, parent=self)
         elif isinstance(value, list):
-            return StoredList(self._db, key=key, parent=self)
+            value = StoredList(self._db, key=key, parent=self)
         elif isinstance(value, dict):
-            return StoredDict(self._db, key=key, parent=self)
+            value = StoredDict(self._db, key=key, parent=self)
+        self._cache[key] = value
         return value
 
     def __setitem__(self, key: FLEX_KEY, value: Any) -> None:
@@ -201,10 +212,14 @@ def __setitem__(self, key: FLEX_KEY, value: Any) -> None:
         if isinstance(value, StoredDict):
             raise Exception('trying to set StoredDict')
         self._db.put(self.path, key, value)
+        if key in self._cache:
+            del self._cache[key]
 
     def __delitem__(self, key: FLEX_KEY) -> None:
         key = key_to_str(key)
         self._db.remove(self.path, key)
+        if key in self._cache:
+            del self._cache[key]
 
     def __iter__(self) -> Iterator[str]:
         return self._db.iter_keys(self.path)
@@ -239,6 +254,7 @@ def get(self, key: FLEX_KEY, default: Any = None) -> Any:
 
     def clear(self) -> None:
         self._db.clear(self.path)
+        self._cache.clear()
 
     def pop(self, key: FLEX_KEY, default: Any = _RaiseKeyError) -> Any:
         try: