Merge branch 'develop' into dev-define-engines-abc

Author: shaneahmed

.github/workflows/mypy-type-check.yml

@@ -28,9 +28,12 @@ jobs:
     - name: Checkout repository
       uses: actions/checkout@v3
 
-    - name: Setup mypy
+    - name: Install dependencies
       run: |
-        pip install mypy
+        sudo apt update
+        sudo apt-get install -y libopenslide-dev openslide-tools libopenjp2-7 libopenjp2-tools
+        python -m pip install --upgrade pip
+        pip install -r requirements/requirements_dev.txt
 
     - name: Perform type checking
       run: |
@@ -39,5 +42,7 @@ jobs:
           tiatoolbox/__main__.py \
           tiatoolbox/typing.py \
           tiatoolbox/tiatoolbox.py \
-          tiatoolbox/utils/ \
-          tiatoolbox/tools/
+          tiatoolbox/utils \
+          tiatoolbox/tools \
+          tiatoolbox/data \
+          tiatoolbox/annotation

.gitignore

@@ -109,6 +109,7 @@ ENV/
 
 # IDE settings
 .vscode/
+.idea/
 
 # Mac generated
 .DS_Store

tests/test_annotation_stores.py

@@ -504,6 +504,21 @@ def test_sqlite_store_compile_options_exception(monkeypatch: object) -> None:
         SQLiteStore()
 
 
+def test_sqlite_store_compile_options_exception_json_rtree(monkeypatch: object) -> None:
+    """Test SQLiteStore compile options for exceptions."""
+    monkeypatch.setattr(sqlite3, "sqlite_version_info", (3, 38, 0))
+    monkeypatch.setattr(
+        SQLiteStore,
+        "compile_options",
+        lambda _x: ["ENABLE_RTREE"],
+        raising=True,
+    )
+    SQLiteStore()
+    monkeypatch.setattr(SQLiteStore, "compile_options", lambda _x: [], raising=True)
+    with pytest.raises(EnvironmentError, match="RTREE sqlite3"):
+        SQLiteStore()
+
+
 def test_sqlite_store_compile_options_exception_v3_38(monkeypatch: object) -> None:
     """Test SQLiteStore compile options for exceptions."""
     monkeypatch.setattr(sqlite3, "sqlite_version_info", (3, 38, 0))
@@ -1326,11 +1341,16 @@ def test_from_geojson_path_transform(
         _, store = fill_store(store_cls, tmp_path / "polygon.db")
         com = annotations_center_of_mass(list(store.values()))
         store.to_geojson(tmp_path / "polygon.json")
+
         # load the store translated so that origin is (100,100) and scaled by 2
+        def dummy_transform(annotation: Annotation) -> Annotation:
+            return annotation
+
         store2 = store_cls.from_geojson(
             tmp_path / "polygon.json",
             scale_factor=(2, 2),
             origin=(100, 100),
+            transform=dummy_transform,
         )
         assert len(store) == len(store2)
         com2 = annotations_center_of_mass(list(store2.values()))

tests/test_stainnorm.py

@@ -108,6 +108,16 @@ def test_get_normalizer_assertion() -> None:
         _ = get_normalizer("ruifrok", stain_matrix)
 
 
+def test_get_custom_normalizer_assertion() -> None:
+    """Test get custom normalizer assertion error."""
+    stain_matrix = None
+    with pytest.raises(
+        ValueError,
+        match=r"`stain_matrix` is None when using `method_name`=\"custom\".",
+    ):
+        _ = get_normalizer("custom", stain_matrix)
+
+
 def test_ruifrok_normalize(source_image: Path, norm_ruifrok: Path) -> None:
     """Test for stain normalization with stain matrix from Ruifrok and Johnston."""
     source_img = imread(Path(source_image))

tests/test_utils.py

@@ -19,7 +19,7 @@
 
 from tests.test_annotation_stores import cell_polygon
 from tiatoolbox import utils
-from tiatoolbox.annotation.storage import SQLiteStore
+from tiatoolbox.annotation.storage import DictionaryStore, SQLiteStore
 from tiatoolbox.models.architecture import fetch_pretrained_weights
 from tiatoolbox.utils import misc
 from tiatoolbox.utils.exceptions import FileNotSupportedError
@@ -1506,7 +1506,15 @@ def test_from_dat(tmp_path: Path) -> None:
     """Test generating an annotation store from a .dat file."""
     data = make_simple_dat()
     joblib.dump(data, tmp_path / "test.dat")
-    store = utils.misc.store_from_dat(tmp_path / "test.dat")
+    store = utils.misc.store_from_dat(tmp_path / "test.dat", cls=SQLiteStore)
+    assert len(store) == 2
+
+
+def test_dict_store_from_dat(tmp_path: Path) -> None:
+    """Test generating a DictionaryStore from a .dat file."""
+    data = make_simple_dat()
+    joblib.dump(data, tmp_path / "test.dat")
+    store = utils.misc.store_from_dat(tmp_path / "test.dat", cls=DictionaryStore)
     assert len(store) == 2
 
 

tiatoolbox/annotation/dsl.py

@@ -65,6 +65,8 @@
 from numbers import Number
 from typing import Callable
 
+from typing_extensions import TypedDict
+
 
 @dataclass
 class SQLNone:
@@ -82,7 +84,9 @@ def __repr__(self: SQLNone) -> str:
 class SQLExpression:
     """SQL expression base class."""
 
-    __hash__ = None
+    def __hash__(self: SQLExpression) -> int:
+        """Return hash of the object (Not used)."""
+        return hash(str(self))  # pragma: no cover
 
     def __repr__(self: SQLExpression) -> str:
         """Return a string representation of the object."""
@@ -156,19 +160,23 @@ def __abs__(self: SQLExpression) -> SQLTriplet:
         """Return the absolute value of the object."""
         return SQLTriplet(self, operator.abs)
 
-    def __eq__(self: SQLExpression, other: SQLExpression) -> SQLTriplet:
+    def __eq__(  # type: ignore[override]
+        self: SQLExpression, other: object
+    ) -> SQLTriplet:
         """Define how the object is compared for equality."""
         return SQLTriplet(self, operator.eq, other)
 
-    def __ne__(self: SQLExpression, other: object) -> SQLTriplet:
+    def __ne__(  # type: ignore[override]
+        self: SQLExpression, other: object
+    ) -> SQLTriplet:
         """Define how the object is compared for equality (not equal to)."""
         return SQLTriplet(self, operator.ne, other)
 
     def __neg__(self: SQLExpression) -> SQLTriplet:
         """Define how the object is compared for negation (not equal to)."""
         return SQLTriplet(self, operator.neg)
 
-    def __contains__(self: SQLExpression, other: object) -> bool:
+    def __contains__(self: SQLExpression, other: object) -> SQLTriplet:
         """Test whether the object contains the specified object or not."""
         return SQLTriplet(self, "contains", other)
 
@@ -209,9 +217,9 @@ class SQLTriplet(SQLExpression):
 
     def __init__(
         self: SQLExpression,
-        lhs: SQLTriplet | str,
+        lhs: SQLTriplet | str | SQLExpression | Number | bool | object,
         op: Callable | str | None = None,
-        rhs: SQLTriplet | str | None = None,
+        rhs: SQLTriplet | str | SQLExpression | Number | SQLNone | object | None = None,
     ) -> None:
         """Initialize :class:`SQLTriplet`."""
         self.lhs = lhs
@@ -244,7 +252,7 @@ def __init__(
             "bool": lambda x, _: f"({x} != 0)",
         }
 
-    def __str__(self: SQLExpression) -> str:
+    def __str__(self: SQLTriplet) -> str:
         """Return a human-readable, or informal, string representation of an object."""
         lhs = self.lhs
         rhs = self.rhs
@@ -268,7 +276,7 @@ def __str__(self: SQLJSONDictionary) -> str:
         """Return a human-readable, or informal, string representation of an object."""
         return f"json_extract(properties, '$.{self.acc}')"
 
-    def __getitem__(self: SQLJSONDictionary, key: str) -> SQLJSONDictionary:
+    def __getitem__(self: SQLJSONDictionary, key: str | int) -> SQLJSONDictionary:
         """Get an item from the dataset."""
         key_str = f"[{key}]" if isinstance(key, (int,)) else f'"{key}"'
 
@@ -424,11 +432,14 @@ def sql_has_key(dictionary: SQLJSONDictionary, key: str | int) -> SQLTriplet:
 
 # Constants defining the global variables for use in eval() when
 # evaluating expressions.
-
-_COMMON_GLOBALS = {
+COMMON_GLOBALS_Type = TypedDict(
+    "COMMON_GLOBALS_Type", {"__builtins__": dict[str, Callable], "re": object}
+)
+_COMMON_GLOBALS: COMMON_GLOBALS_Type = {
     "__builtins__": {"abs": abs},
     "re": re.RegexFlag,
 }
+
 SQL_GLOBALS = {
     "__builtins__": {**_COMMON_GLOBALS["__builtins__"], "sum": sql_list_sum},
     "props": SQLJSONDictionary(),