ModelItemCache: Fix invalidation and add doc strings

Author: ales-erjavec

Orange/widgets/utils/itemdelegates.py

@@ -26,39 +26,41 @@
 class ModelItemCache(QObject):
     """
     An item data cache for accessing QAbstractItemModel.data
+
+    >>> cache = ModelItemCache()
+    >>> cache.itemData(index, (Qt.DisplayRole, Qt.DecorationRole))
+    {0: ...
     """
     __slots__ = ("__model", "__cache_data")
 
-    def __init__(self, *args, model=None, **kwargs):
+    def __init__(self, *args, maxsize=100 * 200, **kwargs):
         super().__init__(*args, **kwargs)
-        self.__model = None
-        self.__cache_data = LRUCache(100 * 200)
-        if model is not None:
-            self.setModel(model)
-
-    def __connect_helper(self, model):
-        model.dataChanged.connect(self.__invalidate_cache)
-        model.layoutAboutToBeChanged.connect(self.__invalidate_cache)
-        model.modelReset.connect(self.__invalidate_cache)
-        model.rowsInserted.connect(self.__invalidate_cache)
-        model.rowsRemoved.connect(self.__invalidate_cache)
-        model.rowsMoved.connect(self.__invalidate_cache)
-        model.columnsInserted.connect(self.__invalidate_cache)
-        model.columnsRemoved.connect(self.__invalidate_cache)
-        model.columnsMoved.connect(self.__invalidate_cache)
-
-    def __disconnect_helper(self, model):
-        model.dataChanged.disconnect(self.__invalidate_cache)
-        model.layoutAboutToBeChanged.disconnect(self.__invalidate_cache)
-        model.modelReset.disconnect(self.__invalidate_cache)
-        model.rowsInserted.disconnect(self.__invalidate_cache)
-        model.rowsRemoved.disconnect(self.__invalidate_cache)
-        model.rowsMoved.disconnect(self.__invalidate_cache)
-        model.columnsInserted.disconnect(self.__invalidate_cache)
-        model.columnsRemoved.disconnect(self.__invalidate_cache)
-        model.columnsMoved.disconnect(self.__invalidate_cache)
-
-    def setModel(self, model: QAbstractItemModel):
+        self.__model: Optional[QAbstractItemModel] = None
+        self.__cache_data: 'LRUCache[QPersistentModelIndex, Any]' = LRUCache(maxsize)
+
+    def __connect_helper(self, model: QAbstractItemModel) -> None:
+        model.dataChanged.connect(self.invalidate)
+        model.layoutAboutToBeChanged.connect(self.invalidate)
+        model.modelAboutToBeReset.connect(self.invalidate)
+        model.rowsAboutToBeInserted.connect(self.invalidate)
+        model.rowsAboutToBeRemoved.connect(self.invalidate)
+        model.rowsAboutToBeMoved.connect(self.invalidate)
+        model.columnsAboutToBeInserted.connect(self.invalidate)
+        model.columnsAboutToBeRemoved.connect(self.invalidate)
+        model.columnsAboutToBeMoved.connect(self.invalidate)
+
+    def __disconnect_helper(self, model: QAbstractItemModel) -> None:
+        model.dataChanged.disconnect(self.invalidate)
+        model.layoutAboutToBeChanged.disconnect(self.invalidate)
+        model.modelAboutToBeReset.disconnect(self.invalidate)
+        model.rowsAboutToBeInserted.disconnect(self.invalidate)
+        model.rowsAboutToBeRemoved.disconnect(self.invalidate)
+        model.rowsAboutToBeMoved.disconnect(self.invalidate)
+        model.columnsAboutToBeInserted.disconnect(self.invalidate)
+        model.columnsAboutToBeRemoved.disconnect(self.invalidate)
+        model.columnsAboutToBeMoved.disconnect(self.invalidate)
+
+    def setModel(self, model: QAbstractItemModel) -> None:
         if model is self.__model:
             return
         if self.__model is not None:
@@ -69,11 +71,12 @@ def setModel(self, model: QAbstractItemModel):
         if model is not None:
             self.__connect_helper(model)
 
-    def model(self):
+    def model(self) -> Optional[QAbstractItemModel]:
         return self.__model
 
     @Slot()
-    def __invalidate_cache(self):
+    def invalidate(self) -> None:
+        """Invalidate all cached data."""
         self.__cache_data.clear()
 
     def itemData(
@@ -83,12 +86,14 @@ def itemData(
         Return item data from `index` for `roles`.
 
         The returned mapping is a read only view of *all* data roles accessed
-        for the index through this interface. It will contain at least data for
-        `roles`, but can also contain other ones.
+        for the index through this caching interface. It will contain at least
+        data for `roles`, but can also contain other ones.
         """
         model = index.model()
         if model is not self.__model:
             self.setModel(model)
+        # NOTE: QPersistentModelIndex's hash changes when it is invalidated;
+        # it must be purged from __cache_data before that (`__connect_helper`)
         key = QPersistentModelIndex(index)
         try:
             item = self.__cache_data[key]
@@ -104,6 +109,7 @@ def itemData(
         return view
 
     def data(self, index: QModelIndex, role: int) -> Any:
+        """Return item data for `index` and `role`"""
         model = index.model()
         if model is not self.__model:
             self.setModel(model)
@@ -165,7 +171,6 @@ def cast_(type_: Type[A], value: Any) -> Optional[A]:
     except Exception:  # pylint: disable=broad-except
         return None
 
-
 def item_data(
         index: QModelIndex, roles: Sequence[int]
 ) -> Dict[int, Any]: