fix remaining mypy errors in untyped code

Author: collerek

pyproject.toml

@@ -42,6 +42,8 @@ max-complexity = 8
 python_version = "3.10"
 warn_return_any = true
 warn_unused_configs = true
+check_untyped_defs = true
+disallow_untyped_defs = true
 ignore_missing_imports = true
 
 [tool.coverage.run]

sql_metadata/ast_parser.py

@@ -50,7 +50,7 @@ def ast(self) -> Optional[exp.Expression]:
         return self._ast
 
     @property
-    def dialect(self):
+    def dialect(self) -> object:
         """The sqlglot dialect that produced the current AST.
 
         Set as a side-effect of :attr:`ast` access.  May be ``None``

sql_metadata/column_extractor.py

@@ -12,7 +12,7 @@
 """
 
 from dataclasses import dataclass
-from typing import Dict, Optional, Union
+from typing import Any, Dict, Optional, Union
 
 from sqlglot import exp
 
@@ -88,7 +88,7 @@ def _classify_clause(key: str, parent_type: type) -> str:
 # ---------------------------------------------------------------------------
 
 
-def _dfs(node: exp.Expression):
+def _dfs(node: exp.Expression) -> Any:
     """Yield *node* and all its descendants in depth-first order.
 
     :param node: Root expression node.
@@ -168,7 +168,7 @@ def add_column(self, name: str, clause: str) -> None:
         if clause:
             self.columns_dict.setdefault(clause, UniqueList()).append(name)
 
-    def add_alias(self, name: str, target, clause: str) -> None:
+    def add_alias(self, name: str, target: Any, clause: str) -> None:
         """Record a column alias and its target expression."""
         self.alias_names.append(name)
         if clause:
@@ -335,7 +335,9 @@ def _is_star_inside_function(star: exp.Star) -> bool:
     # DFS walk
     # -------------------------------------------------------------------
 
-    def _walk(self, node, clause: str = "", depth: int = 0) -> None:
+    def _walk(
+        self, node: Optional[exp.Expression], clause: str = "", depth: int = 0
+    ) -> None:
         """Depth-first walk of the AST in ``arg_types`` key order."""
         if node is None:
             return
@@ -346,7 +348,7 @@ def _walk(self, node, clause: str = "", depth: int = 0) -> None:
         if hasattr(node, "arg_types"):
             self._walk_children(node, clause, depth)
 
-    def _walk_children(self, node, clause: str, depth: int) -> None:
+    def _walk_children(self, node: exp.Expression, clause: str, depth: int) -> None:
         """Recurse into children of *node* in ``arg_types`` key order."""
         for key in node.arg_types:
             if key in _SKIP_KEYS:
@@ -360,7 +362,7 @@ def _walk_children(self, node, clause: str, depth: int) -> None:
             if not self._process_child_key(node, key, child, new_clause, depth):
                 self._recurse_child(child, new_clause, depth)
 
-    def _dispatch_leaf(self, node, clause: str, depth: int) -> bool:
+    def _dispatch_leaf(self, node: exp.Expression, clause: str, depth: int) -> bool:
         """Dispatch leaf-like AST nodes to their specialised handlers.
 
         Returns ``True`` if handled (stop recursion), ``False`` to continue.
@@ -384,7 +386,7 @@ def _dispatch_leaf(self, node, clause: str, depth: int) -> bool:
         return False
 
     def _process_child_key(
-        self, node, key: str, child, clause: str, depth: int
+        self, node: exp.Expression, key: str, child: Any, clause: str, depth: int
     ) -> bool:
         """Handle special cases for SELECT expressions, INSERT schema, JOIN USING.
 
@@ -401,7 +403,7 @@ def _process_child_key(
             return True
         return False
 
-    def _recurse_child(self, child, clause: str, depth: int) -> None:
+    def _recurse_child(self, child: Any, clause: str, depth: int) -> None:
         """Recursively walk a child value (single expression or list)."""
         if isinstance(child, list):
             for item in child:
@@ -437,7 +439,7 @@ def _handle_insert_schema(self, node: exp.Insert) -> None:
                 name = col_id.name if hasattr(col_id, "name") else str(col_id)
                 self._collector.add_column(name, "insert")
 
-    def _handle_join_using(self, child) -> None:
+    def _handle_join_using(self, child: Any) -> None:
         """Extract column identifiers from a JOIN USING clause."""
         if isinstance(child, list):
             for item in child:
@@ -473,7 +475,7 @@ def _handle_column(self, col: exp.Column, clause: str) -> None:
 
         c.add_column(full, clause)
 
-    def _handle_select_exprs(self, exprs, clause: str, depth: int) -> None:
+    def _handle_select_exprs(self, exprs: Any, clause: str, depth: int) -> None:
         """Handle the expressions list of a SELECT clause."""
         if not isinstance(exprs, list):
             return

sql_metadata/comments.py

@@ -24,7 +24,7 @@
 from sqlglot.tokens import Tokenizer
 
 
-def _choose_tokenizer(sql: str):
+def _choose_tokenizer(sql: str) -> Tokenizer:
     """Select the appropriate sqlglot tokenizer for *sql*.
 
     The default sqlglot tokenizer does **not** treat ``#`` as a comment

sql_metadata/dialect_parser.py

@@ -6,7 +6,7 @@ class so that callers only need to call :meth:`DialectParser.parse`.
 """
 
 import logging
-from typing import Optional
+from typing import Any, Optional
 
 import sqlglot
 from sqlglot import Dialect, exp
@@ -144,7 +144,7 @@ def _try_dialects(
         raise ValueError("This query is wrong")
 
     @staticmethod
-    def _parse_with_dialect(clean_sql: str, dialect) -> Optional[exp.Expression]:
+    def _parse_with_dialect(clean_sql: str, dialect: Any) -> Optional[exp.Expression]:
         """Parse *clean_sql* with a single dialect, suppressing warnings."""
         logger = logging.getLogger("sqlglot")
         old_level = logger.level

sql_metadata/nested_resolver.py

@@ -42,25 +42,25 @@ class _PreservingGenerator(Generator):
         ),
     }
 
-    def coalesce_sql(self, expression):
+    def coalesce_sql(self, expression: exp.Expression) -> str:
         args = [expression.this] + expression.expressions
         if len(args) == 2:
             return f"IFNULL({self.sql(args[0])}, {self.sql(args[1])})"
-        return super().coalesce_sql(expression)
+        return super().coalesce_sql(expression)  # type: ignore[misc, no-any-return]
 
-    def dateadd_sql(self, expression):
+    def dateadd_sql(self, expression: exp.Expression) -> str:
         return (
             f"DATE_ADD({self.sql(expression, 'this')}, "
             f"{self.sql(expression, 'expression')})"
         )
 
-    def datesub_sql(self, expression):
+    def datesub_sql(self, expression: exp.Expression) -> str:
         return (
             f"DATE_SUB({self.sql(expression, 'this')}, "
             f"{self.sql(expression, 'expression')})"
         )
 
-    def tsordsadd_sql(self, expression):
+    def tsordsadd_sql(self, expression: exp.Expression) -> str:
         this = self.sql(expression, "this")
         expr_node = expression.expression
         if isinstance(expr_node, exp.Mul):
@@ -74,13 +74,13 @@ def tsordsadd_sql(self, expression):
                 return f"DATE_SUB({this}, {left})"
         return f"DATE_ADD({this}, {self.sql(expression, 'expression')})"
 
-    def not_sql(self, expression):
+    def not_sql(self, expression: exp.Expression) -> str:
         child = expression.this
         if isinstance(child, exp.Is) and isinstance(child.expression, exp.Null):
             return f"{self.sql(child, 'this')} IS NOT NULL"
         if isinstance(child, exp.In):
             return f"{self.sql(child, 'this')} NOT IN ({self.expressions(child)})"
-        return super().not_sql(expression)
+        return super().not_sql(expression)  # type: ignore[arg-type, no-any-return]
 
 
 _GENERATOR = _PreservingGenerator()
@@ -287,7 +287,7 @@ def resolve(
         return columns, columns_dict, self._columns_aliases
 
     def _resolve_and_filter(
-        self, columns, drop_bare_aliases: bool = True
+        self, columns: "UniqueList", drop_bare_aliases: bool = True
     ) -> "UniqueList":
         """Apply subquery/CTE resolution and bare-alias handling."""
         resolved = UniqueList()

sql_metadata/parser.py

@@ -13,7 +13,9 @@
 
 import logging
 import re
-from typing import Dict, List, Optional, Tuple, Union
+from typing import Any, Dict, List, Optional, Tuple, Union
+
+from sqlglot import exp
 
 from sql_metadata.ast_parser import ASTParser
 from sql_metadata.column_extractor import ColumnExtractor
@@ -99,10 +101,10 @@ def _preprocess_query(self) -> str:
         if self._raw_query == "":
             return ""
 
-        def replace_quotes_in_string(match):
+        def replace_quotes_in_string(match: re.Match[str]) -> str:
             return re.sub('"', "<!!__QUOTE__!!>", match.group())
 
-        def replace_back_quotes_in_string(match):
+        def replace_back_quotes_in_string(match: re.Match[str]) -> str:
             return re.sub("<!!__QUOTE__!!>", '"', match.group())
 
         query = re.sub(r"'.*?'", replace_quotes_in_string, self._raw_query)
@@ -334,7 +336,7 @@ def subqueries_names(self) -> List[str]:
     # -------------------------------------------------------------------
 
     @staticmethod
-    def _extract_int_from_node(node) -> Optional[int]:
+    def _extract_int_from_node(node: Any) -> Optional[int]:
         """Safely extract an integer value from a Limit or Offset node."""
         if not node:
             return None
@@ -440,7 +442,7 @@ def _extract_values(self) -> List:
         return values
 
     @staticmethod
-    def _convert_value(val) -> Union[int, float, str]:
+    def _convert_value(val: exp.Expression) -> Union[int, float, str]:
         """Convert a sqlglot literal AST node to a Python type."""
         from sqlglot import exp
 

sql_metadata/sql_cleaner.py

@@ -30,7 +30,7 @@ def _strip_outer_parens(sql: str) -> str:
     """
     s = sql.strip()
 
-    def _is_wrapped(text):
+    def _is_wrapped(text: str) -> bool:
         if len(text) < 2 or text[0] != "(" or text[-1] != ")":
             return False
         inner = text[1:-1]
@@ -66,7 +66,7 @@ def _normalize_cte_names(sql: str) -> tuple:
         re.IGNORECASE,
     )
 
-    def replacer(match):
+    def replacer(match: re.Match[str]) -> str:
         prefix = match.group(1)
         qualified_name = match.group(2)
         suffix = match.group(3)

sql_metadata/table_extractor.py

@@ -212,7 +212,7 @@ def _first_position(self, name: str) -> int:
         return pos if pos >= 0 else len(self._raw_sql)
 
     @staticmethod
-    def _word_pattern(name_upper: str):
+    def _word_pattern(name_upper: str) -> re.Pattern[str]:
         """Build a regex matching *name_upper* as a whole word."""
         escaped = re.escape(name_upper)
         return re.compile(r"(?<![A-Za-z0-9_])" + escaped + r"(?![A-Za-z0-9_])")

sql_metadata/utils.py

@@ -17,7 +17,7 @@ class UniqueList(list):
     an internal ``set`` for O(1) membership checks.
     """
 
-    def __init__(self, *args, **kwargs):
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
         super().__init__(*args, **kwargs)
         self._seen: set = set(self)
 
@@ -32,7 +32,7 @@ def extend(self, items: Iterable[Any]) -> None:  # type: ignore[override]
         for item in items:
             self.append(item)
 
-    def __sub__(self, other) -> List:
+    def __sub__(self, other: Any) -> List:
         """Return a plain list of elements in *self* that are not in *other*."""
         other_set = set(other)
         return [x for x in self if x not in other_set]