type checking: full code coverage

Author: telmomenezes

CHANGELOG.md

@@ -6,6 +6,7 @@
 - parser plugin foundation.
 - more comprehensive Hyperedge.check_correctness.
 - check parse correctness.
+- type checking: full code coverage.
 
 ### Changed
 - renamed library to hyperbase.

src/hyperbase/hyperedge.py

@@ -140,7 +140,7 @@ def build_atom(text: str, *parts: str) -> Atom:
     return Atom((atom,))
 
 
-class Hyperedge(tuple):
+class Hyperedge(tuple):  # type: ignore[type-arg]
     """Non-atomic hyperedge."""
     def __new__(cls, edges: Iterable[Hyperedge | None]) -> Hyperedge:
         return super(Hyperedge, cls).__new__(cls, tuple(edges))
@@ -206,7 +206,7 @@ def label(self) -> str:
         """Generate human-readable label for edge."""
         conn_atom = self.connector_atom()
         if len(self) == 2:
-            edge = self
+            edge: tuple[Any, ...] = self
         elif conn_atom is not None and conn_atom.parts()[-1] == '.':
             edge = self[1:]
         else:
@@ -231,7 +231,7 @@ def inner_atom(self) -> Atom:
 
         The inner atom of an atom is itself.
         """
-        return self[1].inner_atom()
+        return self[1].inner_atom()  # type: ignore[no-any-return]
 
     def connector_atom(self) -> Atom | None:
         """The inner atom of the connector.
@@ -243,7 +243,7 @@ def connector_atom(self) -> Atom | None:
 
         The connector atom of an atom is None.
         """
-        return self[0].inner_atom()
+        return self[0].inner_atom()  # type: ignore[no-any-return]
 
     def atoms(self) -> set[Atom]:
         """Returns the set of atoms contained in the edge.
@@ -408,15 +408,15 @@ def type(self) -> str:
         elif ptype[0] == 'M':
             if len(self) < 2:
                 raise RuntimeError('Edge is malformed, type cannot be determined: {}'.format(str(self)))
-            return self[1].type()
+            return self[1].type()  # type: ignore[no-any-return]
         elif ptype[0] == 'T':
             outter_type = 'S'
         elif ptype[0] == 'B':
             outter_type = 'C'
         elif ptype[0] == 'J':
             if len(self) < 2:
                 raise RuntimeError('Edge is malformed, type cannot be determined: {}'.format(str(self)))
-            return self[1].mtype()
+            return self[1].mtype()  # type: ignore[no-any-return]
         else:
             raise RuntimeError('Edge is malformed, type cannot be determined: {}'.format(str(self)))
 
@@ -427,7 +427,7 @@ def connector_type(self) -> str | None:
         If the edge has no connector (i.e. it's an atom), then None is
         returned.
         """
-        return self[0].type()
+        return self[0].type()  # type: ignore[no-any-return]
 
     def mtype(self) -> str:
         """Returns the main type of this edge as a string of one character.
@@ -458,7 +458,7 @@ def atom_with_type(self, atom_type: str) -> Atom | None:
         b/Cp
         """
         for item in self:
-            atom = item.atom_with_type(atom_type)
+            atom: Atom | None = item.atom_with_type(atom_type)
             if atom:
                 return atom
         return None
@@ -488,10 +488,10 @@ def argroles(self) -> str:
         """
         et = self.mtype()
         if et in {'R', 'C'} and self[0].mtype() in {'B', 'P'}:
-            return self[0].argroles()
+            return self[0].argroles()  # type: ignore[no-any-return]
         if et not in {'B', 'P'}:
             return ''
-        return self[1].argroles()
+        return self[1].argroles()  # type: ignore[no-any-return]
 
     def has_argroles(self) -> bool:
         """Returns True if the edge has argroles, False otherwise."""
@@ -531,8 +531,8 @@ def insert_edge_with_argrole(self, edge: Hyperedge, argrole: str, pos: int) -> H
         """Returns a new edge with the provided edge and its argroles inserted
         at the specified position."""
         new_edge = self.insert_argrole(argrole, pos)
-        new_edge = new_edge[:pos + 1] + (edge,) + new_edge[pos + 1:]
-        return Hyperedge(new_edge)
+        combined = tuple(new_edge[:pos + 1]) + (edge,) + tuple(new_edge[pos + 1:])
+        return Hyperedge(combined)
 
     def edges_with_argrole(self, argrole: str) -> list[Hyperedge]:
         """Returns the list of edges with the given argument role."""
@@ -665,26 +665,26 @@ def check_correctness(self) -> dict[Hyperedge, list[tuple[str, str]]]:
         return output
 
     def normalized(self) -> Hyperedge | None:
-        edge = self
+        edge: Hyperedge = self
         conn = edge[0]
         ar = conn.argroles()
         if ar != '':
             if ar[0] == '{':
                 ar = ar[1:-1]
-            roles_edges = zip(ar, edge[1:])
-            roles_edges = sorted(roles_edges, key=lambda role_edge: argrole_order[role_edge[0]])
-            edge = hedge([conn] + list(role_edge[1] for role_edge in roles_edges))
-            if not edge:
+            roles_edges_sorted = sorted(zip(ar, edge[1:]), key=lambda role_edge: argrole_order[role_edge[0]])
+            new_edge = hedge([conn] + list(role_edge[1] for role_edge in roles_edges_sorted))
+            if not new_edge:
                 return None
+            edge = new_edge
         return hedge([subedge.normalized() for subedge in edge])
 
-    def __add__(self, other) -> Hyperedge:
-        if type(other) in {tuple, list}:
-            return Hyperedge(super(Hyperedge, self).__add__(other))
-        elif other.atom:
-            return Hyperedge(super(Hyperedge, self).__add__((other,)))
+    def __add__(self, other: Hyperedge | tuple[Any, ...] | list[Any]) -> Hyperedge:
+        if isinstance(other, (list, tuple)) and not isinstance(other, Hyperedge):
+            return Hyperedge(tuple.__add__(self, tuple(other)))
+        elif isinstance(other, Hyperedge) and other.atom:
+            return Hyperedge(tuple.__add__(self, (other,)))
         else:
-            return Hyperedge(super(Hyperedge, self).__add__(other))
+            return Hyperedge(tuple.__add__(self, tuple(other)))
 
     def __str__(self) -> str:
         return self.to_str()
@@ -730,7 +730,7 @@ def is_atom(self) -> bool:
 
     def parts(self) -> list[str]:
         """Splits atom into its parts."""
-        return self[0].split('/')
+        return self[0].split('/')  # type: ignore[no-any-return]
 
     def root(self) -> str:
         """Extracts the root of an atom
@@ -847,7 +847,7 @@ def contains(self, needle: str, deep: bool = False) -> bool:
 
         Keyword argument:
         deep -- search recursively (default: False)"""
-        return self[0] == needle
+        return self[0] == needle  # type: ignore[no-any-return]
 
     def subedges(self) -> set[Hyperedge]:
         """Returns all the subedges contained in the edge, including atoms
@@ -905,7 +905,7 @@ def role(self) -> list[str]:
 
             ['J'].
         """
-        parts = self[0].split('/')
+        parts: list[str] = self[0].split('/')
         if len(parts) < 2:
             return list('J')
         else:
@@ -1087,13 +1087,13 @@ def normalized(self) -> Atom:
                 return self.replace_argroles(ar)
         return self
 
-    def __add__(self, other) -> Hyperedge:
-        if type(other) in {tuple, list}:
-            return Hyperedge((self,) + other)
-        elif other.atom:
+    def __add__(self, other: Hyperedge | tuple[Any, ...] | list[Any]) -> Hyperedge:
+        if isinstance(other, (list, tuple)) and not isinstance(other, Hyperedge):
+            return Hyperedge(tuple.__add__((self,), tuple(other)))
+        elif isinstance(other, Hyperedge) and other.atom:
             return Hyperedge((self, other))
         else:
-            return Hyperedge((self,) + other)
+            return Hyperedge(tuple.__add__((self,), tuple(other)))
 
 
 class UniqueAtom(Atom):
@@ -1112,7 +1112,7 @@ def unique(edge: Hyperedge) -> Hyperedge | None:
         if type(edge) == UniqueAtom:
             return edge
         else:
-            return UniqueAtom(edge)
+            return UniqueAtom(edge)  # type: ignore[arg-type]
     else:
         return hedge([unique(subedge) for subedge in edge])
 

src/hyperbase/parsers/__init__.py

@@ -33,7 +33,7 @@ def get_parser(name: str, **kwargs: Any) -> Parser:
             f"Available parsers: {available}"
         )
     cls = parsers[name].load()
-    return cls(**kwargs)
+    return cls(**kwargs)  # type: ignore[no-any-return]
 
 
 __all__ = ["Parser", "get_parser", "list_parsers"]

src/hyperbase/parsers/correctness.py

@@ -1,28 +1,30 @@
-from typing import List, Dict
+from __future__ import annotations
+
 from collections import Counter
+from typing import Any
 
 from hyperbase.hyperedge import Hyperedge
 from hyperbase.parsers.utils import filter_alphanumeric_strings
 
 
-def check_structural_quality(edge: Hyperedge) -> Dict:
-    errors = {}
-    
-    def _visit(current_edge):
+def check_structural_quality(edge: Hyperedge) -> dict[Hyperedge, list[tuple[str, str, int]]]:
+    errors: dict[Hyperedge, list[tuple[str, str, int]]] = {}
+
+    def _visit(current_edge: Hyperedge) -> None:
         if not current_edge or current_edge.atom:
             return
 
-        current_errors = []
-        
+        current_errors: list[tuple[str, str, int]] = []
+
         # Argrole checks
         try:
             ars = current_edge.argroles()
-            ar_counts = Counter()
+            ar_counts: Counter[str] = Counter()
             for ar in ars:
                 if ar not in 'mspaoixtjrc':
                     current_errors.append(('bad-argrole', f"Bad argument role '{ar}'. Should be one of 'mspaoixtjrc'.", 2))
                 ar_counts[ar] += 1
-            
+
             for role in 'spoiamc':
                  if ar_counts[role] > 1:
                      current_errors.append((f'duplicate-argrole-{role}', f"Argument role '{role}' should only be used once.", 2))
@@ -51,34 +53,34 @@ def _visit(current_edge):
 
 def badness_check(
     edge: Hyperedge,
-    tokens: List[str]
-) -> Dict[str, List[str]]:
+    tokens: list[str]
+) -> dict[Any, list[tuple[str, str, int]]]:
 
     raw_errors = edge.check_correctness()
-    errors = {}
+    errors: dict[Any, list[tuple[str, str, int]]] = {}
     for k, v in raw_errors.items():
         errors[k] = [(err_type, err_msg, 0) for err_type, err_msg in v]
 
     structural_errors = check_structural_quality(edge)
-    for k, v in structural_errors.items():
+    for k, v2 in structural_errors.items():
         if k in errors:
-            errors[k].extend(v)
+            errors[k].extend(v2)
         else:
-            errors[k] = v
+            errors[k] = v2
 
     # Only check token matching if we have a valid edge
     if edge:
         try:
             tokens = filter_alphanumeric_strings(tokens)
             roots = filter_alphanumeric_strings([atom.label() for atom in edge.all_atoms()])
 
-      
+
             # Track which tokens and roots have been matched
-            matched_tokens = set()
-            matched_roots = set()
+            matched_tokens: set[int] = set()
+            matched_roots: set[int] = set()
 
             # Count remaining unmatched instances of each root
-            def count_unmatched_roots(root_value):
+            def count_unmatched_roots(root_value: str) -> int:
                 count = 0
                 for root_idx, root in enumerate(roots):
                     if root == root_value and root_idx not in matched_roots:
@@ -119,7 +121,7 @@ def count_unmatched_roots(root_value):
                                 continue  # This root is already matched
 
                             concatenated = ""
-                            root_sequence = []
+                            root_sequence: list[int] = []
 
                             for root_idx in range(root_start_idx, len(roots)):
                                 if root_idx in matched_roots:
@@ -152,7 +154,7 @@ def count_unmatched_roots(root_value):
                                 continue  # Already matched
 
                             concatenated = ""
-                            token_sequence = []
+                            token_sequence: list[int] = []
 
                             for next_token_idx in range(token_idx, len(tokens)):
                                 if next_token_idx in matched_tokens:
@@ -242,7 +244,7 @@ def count_unmatched_roots(root_value):
                                     if token_idx in matched_tokens:
                                         break  # Found a match, no need to try other combinations
 
-            token_matching_errors = []
+            token_matching_errors: list[tuple[str, str, int]] = []
             # Report unmatched roots
             for root_idx, root in enumerate(roots):
                 if root_idx not in matched_roots:

src/hyperbase/parsers/parser.py

@@ -1,36 +1,39 @@
-from typing import List
+from __future__ import annotations
+
+from collections.abc import Iterator
+from typing import Any
 
 
 class Parser:
-    def sentensize(self, text):
+    def sentensize(self, text: str) -> list[str]:
         raise NotImplementedError
 
-    def parse(self, text):
+    def parse(self, text: str) -> Iterator[dict[str, Any]]:
         for sentence in self.sentensize(text):
             for parse in self.parse_sentence(sentence):
                 yield parse
 
-    def parse_sentence(self, sentence):
+    def parse_sentence(self, sentence: str) -> list[dict[str, Any]]:
         raise NotImplementedError
 
-    def parse_batch(self, sentences: List[str]) -> List[List[dict]]:
+    def parse_batch(self, sentences: list[str]) -> list[list[dict[str, Any]]]:
         """Parse multiple sentences. Subclasses may override with a
         true batched implementation (e.g. a single CT2 call)."""
         return [self.parse_sentence(sentence) for sentence in sentences]
 
     def parse_text(
         self, text: str, batch_size: int = 8, progress: bool = False
-    ) -> List[dict]:
+    ) -> list[dict[str, Any]]:
         """Sentensize text, then parse all sentences in batches.
 
         Returns a flat list of parse results across all sentences.
         """
         sentences = [s for s in self.sentensize(text) if len(s.split()) > 1]
         batch_range = range(0, len(sentences), batch_size)
         if progress:
-            from tqdm import tqdm
+            from tqdm import tqdm  # type: ignore[import-untyped]
             batch_range = tqdm(batch_range, desc="Parsing batches", leave=False)
-        results: List[dict] = []
+        results: list[dict[str, Any]] = []
         for i in batch_range:
             batch = sentences[i:i + batch_size]
             for sentence_results in self.parse_batch(batch):

src/hyperbase/parsers/utils.py

@@ -1,7 +1,4 @@
-from typing import List
-
-
-def filter_alphanumeric_strings(strings: List[str]) -> List[str]:
+def filter_alphanumeric_strings(strings: list[str]) -> list[str]:
     """
     Filter a list of strings to include only those containing alphanumeric characters,
     and remove all non-alphanumeric characters from each string.
@@ -12,7 +9,7 @@ def filter_alphanumeric_strings(strings: List[str]) -> List[str]:
     Returns:
         Filtered list containing only lowercased alphanumeric characters
     """
-    filtered = []
+    filtered: list[str] = []
     for s in strings:
         # Remove non-alphanumeric characters and lowercase
         cleaned = ''.join(c.lower() for c in s if c.isalnum())