Fix type hints.

Author: gianchub

src/sqlalchemydiff/comparer.py

@@ -133,12 +133,14 @@ def compare(
                 db_one_info = self._get_db_info(ignore_specs, inspector, self.db_one_engine)
                 db_two_info = self._get_db_info(ignore_specs, inspector, self.db_two_engine)
 
-                if None not in [db_one_info, db_two_info]:
+                if db_one_info is not None and db_two_info is not None:
                     result[key] = inspector.diff(db_one_info, db_two_info)
 
         return self.compare_result_class(result, one_alias=one_alias, two_alias=two_alias)
 
-    def _filter_inspectors(self, ignore_inspectors: Optional[set[str]]) -> list[str]:
+    def _filter_inspectors(
+        self, ignore_inspectors: Optional[set[str]]
+    ) -> list[tuple[str, type[BaseInspector]]]:
         if not ignore_inspectors:
             ignore_inspectors = set()
 

src/sqlalchemydiff/inspection/base.py

@@ -68,7 +68,7 @@ def diff(self, one: dict, two: dict) -> dict: ...  # pragma: no cover
     @abc.abstractmethod
     def _is_supported(self, inspector: Inspector) -> bool: ...  # pragma: no cover
 
-    def _filter_ignorers(self, specs: list[IgnoreSpecType]) -> IgnoreClauses:
+    def _filter_ignorers(self, specs: Optional[list[IgnoreSpecType]]) -> IgnoreClauses:
         tables, enums, clauses = [], [], []
 
         for spec in specs or []:

src/sqlalchemydiff/inspection/ignore.py

@@ -1,4 +1,4 @@
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from typing import NamedTuple, Optional, Union
 
 
@@ -60,9 +60,10 @@ def create_specs(
 
 @dataclass
 class IgnoreClauses:
-    tables: Optional[list[str]] = None
-    enums: Optional[list[str]] = None
-    clauses: Optional[list[IgnoreSpecType]] = None
+    tables: list[str] = field(default_factory=list)
+    enums: list[str] = field(default_factory=list)
+    clauses: list[IgnoreSpecType] = field(default_factory=list)
 
-    def is_clause(self, table_name: str, inspector_key: str, object_name: str) -> bool:
-        return (table_name, inspector_key, object_name) in self.clauses
+    def is_clause(self, table_name: str, inspector_key: str, object_name: Optional[str]) -> bool:
+        clause = TableIgnoreSpec(table_name, inspector_key, object_name)
+        return clause in self.clauses

src/sqlalchemydiff/inspection/inspectors.py

@@ -1,4 +1,4 @@
-from typing import Optional
+from typing import Optional, cast
 
 from sqlalchemy.engine import Engine
 
@@ -209,7 +209,7 @@ def _format_unique_constraint(self, inspector: Inspector, table_name: str) -> li
             if not name:
                 name = f"unique_{table_name}_{'_'.join(constraint.get('column_names'))}"
             constraint["name"] = name
-        return result
+        return cast(list[dict], result)
 
     def _is_supported(self, inspector: Inspector) -> bool:
         return hasattr(inspector, "get_unique_constraints")
@@ -255,7 +255,7 @@ def inspect(
         inspector = self._get_inspector(engine)
 
         ignore_clauses = self._filter_ignorers(ignore_specs)
-        enums = inspector.get_enums() or []
+        enums = getattr(inspector, "get_enums", lambda: [])() or []
         return [enum for enum in enums if enum["name"] not in ignore_clauses.enums]
 
     def diff(self, one: dict, two: dict) -> dict:

src/sqlalchemydiff/inspection/mixins.py

@@ -7,6 +7,11 @@ class DiffMixin:
     Provides methods used by the inspectors to diff the results.
     """
 
+    one_alias: str
+    two_alias: str
+    one_only_alias: str
+    two_only_alias: str
+
     def _get_empty_result(self) -> dict:
         return {
             self.one_only_alias: [],
@@ -79,7 +84,7 @@ def _listdiff(self, one: Mapping[str, Iterable], two: Mapping[str, Iterable]) ->
 
         return result
 
-    def _itemsdiff(self, items_in_one: Iterable[Mapping], items_in_two: Iterable[Mapping]) -> list:
+    def _itemsdiff(self, items_in_one: Iterable[Mapping], items_in_two: Iterable[Mapping]) -> dict:
         """Diff iterables of items in mapping format.
 
         `items_in_one` and `items_in_two` are iterables of items in mapping format.