change to ruff also in CI. add mypy and fix typing errors, add mypy to CI

Author: collerek

.github/workflows/auto-merge-dependabot.yml

@@ -23,9 +23,7 @@ jobs:
               if: "${{ steps.metadata.outputs.update-type ==
                   'version-update:semver-minor' ||
                   steps.metadata.outputs.update-type ==
-                  'version-update:semver-patch' ||
-                  steps.metadata.outputs.dependency-names ==
-                  'black' }}"
+                  'version-update:semver-patch' }}"
 
               # https://cli.github.com/manual/gh_pr_merge
               run: gh pr merge --auto --squash "$PR_URL"

.github/workflows/black.yml

@@ -42,9 +42,6 @@ jobs:
     - name: Install Python wheel support to speed up things
       run: pip install wheel
 
-    - name: Pre-install black
-      run: pip install black
-
     # https://github.com/marketplace/actions/install-poetry-action
     - name: Install Poetry
       uses: snok/install-poetry@v1.4.1
@@ -77,8 +74,11 @@ jobs:
         pip install coveralls
         poetry run coveralls --service=github
 
-    - name: Lint with pylint
+    - name: Lint with ruff
       run: make lint
 
+    - name: Type check with mypy
+      run: make type_check
+
     - name: Build a distribution package
       run: poetry build -vvv

.github/workflows/python-ci.yml

@@ -13,6 +13,9 @@ lint:
 format:
 	poetry run ruff format .
 
+type_check:
+	poetry run mypy sql_metadata
+
 publish:
 	# run git tag -a v0.0.0 before running make publish
 	poetry build

Makefile

@@ -22,6 +22,7 @@ coverage = {extras = ["toml"], version = "^7.13"}
 pytest = "^9.0.2"
 pytest-cov = "^7.1.0"
 ruff = "^0.11"
+mypy = "^1.19"
 
 [build-system]
 requires = ["poetry-core>=1.0.0"]
@@ -37,6 +38,12 @@ select = ["E", "F", "W", "C90", "I"]
 [tool.ruff.lint.mccabe]
 max-complexity = 8
 
+[tool.mypy]
+python_version = "3.10"
+warn_return_any = true
+warn_unused_configs = true
+ignore_missing_imports = true
+
 [tool.coverage.run]
 relative_files = true
 

poetry.lock

@@ -7,6 +7,8 @@
 ``ValueError``).
 """
 
+from typing import Optional
+
 from sqlglot import exp
 
 from sql_metadata.dialect_parser import DialectParser
@@ -27,14 +29,14 @@ class ASTParser:
 
     def __init__(self, sql: str) -> None:
         self._raw_sql = sql
-        self._ast = None
-        self._dialect = None
+        self._ast: Optional[exp.Expression] = None
+        self._dialect: object = None
         self._parsed = False
         self._is_replace = False
-        self._cte_name_map = {}
+        self._cte_name_map: dict[str, str] = {}
 
     @property
-    def ast(self) -> exp.Expression:
+    def ast(self) -> Optional[exp.Expression]:
         """The sqlglot AST for the query, lazily parsed on first access.
 
         :returns: Root AST node, or ``None`` for empty/comment-only queries.
@@ -80,7 +82,7 @@ def cte_name_map(self) -> dict:
         _ = self.ast
         return self._cte_name_map
 
-    def _parse(self, sql: str) -> exp.Expression:
+    def _parse(self, sql: str) -> Optional[exp.Expression]:
         """Parse *sql* into a sqlglot AST.
 
         Delegates preprocessing to :class:`SqlCleaner` and dialect

pyproject.toml

@@ -205,7 +205,7 @@ def __init__(
         self,
         ast: exp.Expression,
         table_aliases: Dict[str, str],
-        cte_name_map: Dict = None,
+        cte_name_map: Optional[Dict] = None,
     ):
         self._ast = ast
         self._table_aliases = table_aliases
@@ -548,6 +548,7 @@ def _handle_cte(self, cte: exp.CTE, depth: int) -> None:
         body = cte.this
 
         if has_col_defs and body and isinstance(body, exp.Select):
+            assert table_alias is not None  # guarded by has_col_defs
             body_cols = self._flat_columns(body)
             real_cols = [x for x in body_cols if x != "*"]
             cte_col_names = [col.name for col in table_alias.columns]
@@ -615,7 +616,7 @@ def _flat_columns(self, node: exp.Expression) -> list:
         cols = []
         if node is None:
             return cols
-        seen_stars = set()
+        seen_stars: set[int] = set()
         for child in _dfs(node):
             name = self._collect_column_from_node(child, seen_stars)
             if name is not None:

sql_metadata/ast_parser.py

@@ -92,7 +92,7 @@ def extract_comments(sql: str) -> List[str]:
         tokens = list(_choose_tokenizer(sql).tokenize(sql))
     except Exception:
         return []
-    comments = []
+    comments: list[str] = []
     prev_end = -1
     for tok in tokens:
         _scan_gap(sql, prev_end + 1, tok.start, comments)

sql_metadata/column_extractor.py

@@ -6,12 +6,13 @@ class so that callers only need to call :meth:`DialectParser.parse`.
 """
 
 import logging
+from typing import Optional
 
 import sqlglot
 from sqlglot import Dialect, exp
 from sqlglot.dialects.tsql import TSQL
 from sqlglot.errors import ParseError, TokenError
-from sqlglot.tokens import Tokenizer
+from sqlglot.tokens import Tokenizer as BaseTokenizer
 
 from sql_metadata.comments import _has_hash_variables
 
@@ -37,12 +38,12 @@ class HashVarDialect(Dialect):
     of a ``VAR`` token instead.
     """
 
-    class Tokenizer(Tokenizer):
+    class Tokenizer(BaseTokenizer):
         """Tokenizer subclass that includes ``#`` in variable tokens."""
 
-        SINGLE_TOKENS = {**Tokenizer.SINGLE_TOKENS}
+        SINGLE_TOKENS = {**BaseTokenizer.SINGLE_TOKENS}
         SINGLE_TOKENS.pop("#", None)
-        VAR_SINGLE_TOKENS = {*Tokenizer.VAR_SINGLE_TOKENS, "#"}
+        VAR_SINGLE_TOKENS = {*BaseTokenizer.VAR_SINGLE_TOKENS, "#"}
 
 
 class BracketedTableDialect(TSQL):
@@ -63,7 +64,7 @@ class BracketedTableDialect(TSQL):
 class DialectParser:
     """Detect the appropriate sqlglot dialect and parse SQL into an AST."""
 
-    def parse(self, clean_sql: str) -> tuple:
+    def parse(self, clean_sql: str) -> tuple[exp.Expression, object]:
         """Parse *clean_sql*, returning ``(ast, dialect)``.
 
         Detects candidate dialects via heuristics, tries each in order,
@@ -112,7 +113,9 @@ def _detect_dialects(sql: str) -> list:
 
     # -- parsing ------------------------------------------------------------
 
-    def _try_dialects(self, clean_sql: str, dialects: list) -> tuple:
+    def _try_dialects(
+        self, clean_sql: str, dialects: list
+    ) -> tuple[exp.Expression, object]:
         """Try parsing *clean_sql* with each dialect, returning the best.
 
         :returns: 2-tuple of ``(ast_node, winning_dialect)``.
@@ -141,7 +144,7 @@ def _try_dialects(self, clean_sql: str, dialects: list) -> tuple:
         raise ValueError("This query is wrong")
 
     @staticmethod
-    def _parse_with_dialect(clean_sql: str, dialect) -> exp.Expression:
+    def _parse_with_dialect(clean_sql: str, dialect) -> Optional[exp.Expression]:
         """Parse *clean_sql* with a single dialect, suppressing warnings."""
         logger = logging.getLogger("sqlglot")
         old_level = logger.level
@@ -158,9 +161,13 @@ def _parse_with_dialect(clean_sql: str, dialect) -> exp.Expression:
         if not results or results[0] is None:
             return None
         result = results[0]
+        if result is None:
+            return None
         if isinstance(result, exp.Subquery) and not result.alias:
-            result = result.this
-        return result
+            inner = result.this
+            if isinstance(inner, exp.Expression):
+                return inner
+        return result  # type: ignore[return-value]
 
     # -- quality checks -----------------------------------------------------