in progress: actually check the type hints

Author: chrishavlin

.github/workflows/type-check.yaml

@@ -0,0 +1,39 @@
+name: type checking
+
+on:
+  pull_request:
+    paths:
+      - inheritance_explorer/**/*.py
+      - pyproject.toml
+      - requirements/typecheck.txt
+      - .github/workflows/type-checking.yaml
+  workflow_dispatch:
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    name: type check
+    timeout-minutes: 60
+
+    steps:
+    - name: Checkout repo
+      uses: actions/checkout@v4
+
+    - name: Set up Python
+      uses: actions/setup-python@v5
+      with:
+        # run with oldest supported python version
+        # so that we always get compatible versions of
+        # core dependencies at type-check time
+        python-version: '3.10'
+
+    - name: Build
+      run: |
+        python3 -m pip install --upgrade pip
+        python3 -m pip install -r requirements/typecheck.txt
+
+    - name: list installed deps
+      run: python -m pip list
+
+    - name: Run mypy
+      run: mypy inheritance_explorer

inheritance_explorer/inheritance_explorer.py

@@ -1,11 +1,12 @@
 import collections
 import inspect
 import textwrap
-from typing import Any, List, Optional, Tuple, Union
+from typing import Any, Mapping, Optional, Tuple, Union
 
 import matplotlib.pyplot as plt
 import networkx as nx
 import numpy as np
+import numpy.typing as npt
 import pydot
 from matplotlib.axes import Axes
 from matplotlib.colors import rgb2hex
@@ -41,7 +42,7 @@ def child_id(self) -> str:
         return str(self._child_id)
 
     @property
-    def parent_id(self) -> str:
+    def parent_id(self) -> str | None:
         if self._parent_id:
             return str(self._parent_id)
         return
@@ -76,11 +77,11 @@ def __init__(
         self,
         baseclass: Any,
         funcname: Optional[str] = None,
-        default_color: Optional[str] = "#000000",
-        func_override_color: Optional[str] = "#ff0000",
-        similarity_cutoff: Optional[float] = 0.75,
-        max_recursion_level: Optional[int] = 500,
-        classes_to_exclude: Optional[List[str]] = None,
+        default_color: str = "#000000",
+        func_override_color: str = "#ff0000",
+        similarity_cutoff: float = 0.75,
+        max_recursion_level: int = 500,
+        classes_to_exclude: Optional[list[str]] = None,
     ):
 
         self.baseclass = baseclass
@@ -90,20 +91,22 @@ def __init__(
         self._nodenum: int = 0
         self._node_list = []  # a list of unique ChildNodes
         self._node_map = {}  # map of global node index to node name
-        self._override_src = collections.OrderedDict()
+        self._override_src: Mapping[int, str] = collections.OrderedDict()
         self._override_src_files = {}
         self._current_node = 1  # the current global node, must start at 1
         self._default_color = default_color
         self._override_color = func_override_color
         self._graphviz_args_kwargs = {}
         self.similarity_container = None
-        self.similarity_results = None
+        self.similarity_results: dict[str, npt.NDArray]
         self.similarity_cutoff = similarity_cutoff
         if classes_to_exclude is None:
             classes_to_exclude = []
         self.classes_to_exclude = classes_to_exclude
         self._build()
-        self._node_map_r = {v: k for k, v in self._node_map.items()}  # name to index
+        self._node_map_r: Mapping[str, int] = {
+            v: k for k, v in self._node_map.items()
+        }  # name to index
 
     def _get_source_info(self, obj) -> Optional[str]:
         f = getattr(obj, self.funcname)
@@ -346,9 +349,9 @@ def plot_similarity(
     def build_interactive_graph(
         self,
         include_similarity: bool = True,
-        node_style: dict = None,
-        edge_style: dict = None,
-        similarity_edge_style: dict = None,
+        node_style: dict[str, Any] | None = None,
+        edge_style: dict[str, Any] | None = None,
+        similarity_edge_style: dict[str, Any] | None = None,
         override_node_color: Union[str, tuple] = None,
         **kwargs,
     ) -> Network:
@@ -454,22 +457,22 @@ def build_interactive_graph(
         network_wrapper.from_nx(grph)
         return network_wrapper
 
-    def get_source_code(self, node: Union[str, int]) -> str:
+    def get_source_code(self, node: int | str) -> str:
         """
         retrieve the source code of the comparison function for a
         specified node
 
         Parameters
         ----------
-        node: Union[str, int]
+        node: int
         the node to fetch the source code for
 
         Returns
         -------
         str
         a string containing the source code for the node.
         """
-        if node in self._override_src:
+        if isinstance(node, int) and node in self._override_src:
             return self._override_src[node]
         elif isinstance(node, str) and node in self._node_map_r:
             node_id = self._node_map_r[node]
@@ -481,7 +484,9 @@ def get_source_code(self, node: Union[str, int]) -> str:
                 )
         raise KeyError(f"Could not find node for {node}")
 
-    def get_multiple_source_code(self, node_1: Union[str, int], *args) -> dict:
+    def get_multiple_source_code(
+        self, node_1: str | int, *args
+    ) -> Mapping[str | int, str]:
         """
         Retrieve the source code for multiple nodes
 
@@ -515,11 +520,11 @@ def display_code_comparison(self):
             display_code_compare(self)
 
 
-def _validate_color(clr, default_rgb_tuple: tuple) -> str:
+def _validate_color(clr, default_rgb_tuple: tuple[float, float, float]) -> str:
     if clr is None:
-        return rgb2hex(default_rgb_tuple)
+        return str(rgb2hex(default_rgb_tuple))
     elif isinstance(clr, tuple):
-        return rgb2hex(clr)
+        return str(rgb2hex(clr))
     elif isinstance(clr, str):
         return clr
     msg = f"clr has unexpected type: {type(clr)}"

inheritance_explorer/similarity.py

@@ -1,20 +1,39 @@
 import abc
 import collections
-from typing import Any, Dict, List, Optional, OrderedDict, Tuple
+from typing import Any, Optional, OrderedDict
 
 import numpy as np
+import numpy.typing as npt
 import pycode_similar
 
 
 class ResultsContainer:
-    def __init__(self, results_dict: dict):
-        for ky, val in results_dict.items():
-            setattr(self, ky, val)
+    def __init__(
+        self,
+        count: int,
+        total: int,
+        similarity_fraction: float,
+        base_class: Any,
+        this_class: Any,
+    ):
+
+        self.count = count
+        self.total = total
+        self.similarity_fraction = similarity_fraction
+        self.base_class = base_class
+        self.this_class = this_class
+
+
+_sim_results_tuple = tuple[
+    dict[int | str, OrderedDict[int | str, ResultsContainer]],
+    npt.NDArray,
+    tuple[int | str, ...],
+]
 
 
 class SimilarityContainer(abc.ABC):
 
-    _valid_methods: List[str] = ["permute", "reference"]
+    _valid_methods: list[str] = ["permute", "reference"]
 
     def __init__(self, method: str = "reference"):
         if method not in self._valid_methods:
@@ -24,7 +43,9 @@ def __init__(self, method: str = "reference"):
         self.method = method
         self.results = None  # for storing results of similarity tests
 
-    def run(self, source_dict: OrderedDict[Any, str], reference: Optional[Any] = None):
+    def run(
+        self, source_dict: OrderedDict[int | str, str], reference: Optional[Any] = None
+    ):
         """
         source_dict : dict
             dictionary mapping a node identifier to a source code string
@@ -44,7 +65,7 @@ def run(self, source_dict: OrderedDict[Any, str], reference: Optional[Any] = Non
     @abc.abstractmethod
     def _permute_and_run(
         self, source_dict: OrderedDict[Any, str]
-    ) -> Tuple[Dict, np.ndarray, tuple]:
+    ) -> _sim_results_tuple:
         pass
 
     @abc.abstractmethod
@@ -56,8 +77,8 @@ def _compare_single_set(
 
 class PycodeSimilarity(SimilarityContainer):
     def _compare_single_set(
-        self, source_dict: OrderedDict[Any, str], reference: Any
-    ) -> OrderedDict[Any, ResultsContainer]:
+        self, source_dict: OrderedDict[int | str, str], reference: Any
+    ) -> OrderedDict[str | int, ResultsContainer]:
 
         src = source_dict[reference]  # extract the reference
         # this will result in a self-comparison, but that is OK and makes some
@@ -68,24 +89,22 @@ def _compare_single_set(
         similarity = pycode_similar.detect(src_list)
 
         results = collections.OrderedDict()
-        for id, sim in zip(source_dict.keys(), similarity):
-            results[id] = ResultsContainer(
-                {
-                    "count": sim[1][0].plagiarism_count,
-                    "total": sim[1][0].total_count,
-                    "similarity_fraction": sim[1][0].plagiarism_percent,
-                    "base_class": reference,
-                    "this_class": id,
-                }
+        for class_id, sim in zip(source_dict.keys(), similarity):
+            results[class_id] = ResultsContainer(
+                count=sim[1][0].plagiarism_count,
+                total=sim[1][0].total_count,
+                similarity_fraction=sim[1][0].plagiarism_percent,
+                base_class=reference,
+                this_class=class_id,
             )
         return results
 
     def _permute_and_run(
-        self, source_dict: OrderedDict[Any, str]
-    ) -> Tuple[Dict, np.ndarray, tuple]:
+        self, source_dict: OrderedDict[int | str, str]
+    ) -> _sim_results_tuple:
         N = len(source_dict)
         similarity_matrix = np.ones((N, N))
-        results_by_ref = {}
+        results_by_ref: dict[int | str, OrderedDict[int | str, ResultsContainer]] = {}
         sim_axis = tuple([i for i in source_dict.keys()])
         for iref, ref in enumerate(source_dict.keys()):
             results = self._compare_single_set(source_dict.copy(), ref)

inheritance_explorer/tests/test_similarity.py

@@ -3,15 +3,7 @@
 import numpy as np
 import pytest
 
-from inheritance_explorer.similarity import PycodeSimilarity, ResultsContainer
-
-
-def test_results_container():
-
-    results = {"a": 1, "b": "c", "c": 3}
-    r = ResultsContainer(results)
-    for key, val in results.items():
-        assert getattr(r, key) == val
+from inheritance_explorer.similarity import PycodeSimilarity
 
 
 @pytest.fixture
@@ -41,25 +33,22 @@ def sample_source_dict():
     return source_dict, s_matrix.astype(bool)
 
 
-def check_result(results, source_dict, ref, expected_match):
-    for key, _ in source_dict.items():
-        if key != ref:
-            assert key in results
-            f = results[key]
-            if expected_match[key]:
-                assert f.similarity_fraction == 1.0
-            else:
-                assert f.similarity_fraction < 1.0
-
-
 def test_pycode_similarity_single_ref(sample_source_dict):
 
     s_dict, s_matrix = sample_source_dict
     ref = "a"
     p = PycodeSimilarity()
     results = p.run(s_dict, reference=ref)
     s_bool = dict(zip(s_dict.keys(), s_matrix[:, 0]))
-    check_result(results, s_dict, ref, expected_match=s_bool)
+
+    for key, _ in s_dict.items():
+        if key != ref:
+            assert key in results
+            f = results[key]
+            if s_bool[key]:
+                assert f.similarity_fraction == 1.0
+            else:
+                assert f.similarity_fraction < 1.0
 
 
 def test_pycode_similarity_permuted(sample_source_dict):

pyproject.toml

@@ -67,3 +67,15 @@ docs = [
     "nbsphinx",
 ]
 
+[tool.mypy]
+files = ["inheritance_explorer",]
+python_version = "3.10"
+warn_unused_configs = true
+strict = true
+enable_error_code = ["ignore-without-code", "redundant-expr", "truthy-bool"]
+warn_unreachable = true
+disallow_untyped_defs = false
+disallow_incomplete_defs = false
+implicit_optional = true
+disable_error_code = ["import-untyped", "import-not-found"]
+no_implicit_reexport = false

requirements/typecheck.txt

@@ -0,0 +1 @@
+mypy