Narrow Requirements property return types to compound

The SQLAlchemy dialect requirements file previously annotated every
property as ``-> Any``, which matched the inferred type of
``exclusions.open()`` / ``closed()`` helpers (untyped upstream) but
hid the actual contract from IDEs and mypy. Narrow each property's
return annotation to the real runtime type ``compound`` imported from
``sqlalchemy.testing.exclusions`` and widen the module-level mypy
disable to cover the matching ``no-any-return`` that the narrowing
surfaces at each call site. A new static-pin test walks every property
on the Requirements class and asserts its return annotation resolves
to ``compound`` so future additions can't silently slip back to
``Any``.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: antoineleclair

src/sqlalchemydqlite/requirements.py

@@ -1,10 +1,18 @@
 """SQLAlchemy test suite requirements for dqlite dialect."""
 
-# mypy: disable-error-code="no-untyped-call"
-
-from typing import Any
+# The ``exclusions.open()`` / ``closed()`` helpers are genuinely untyped
+# at their source in ``sqlalchemy.testing.exclusions``, so mypy reports
+# ``no-untyped-call`` (for the invocation) and ``no-any-return`` (for
+# the return, since the helper's inferred type is ``Any``) on every
+# single call below if we don't silence them. Narrowing each property's
+# return annotation to ``compound`` (the actual runtime type) is still
+# worthwhile — it gives IDE/hover signal and catches typos where a
+# property returns a non-``compound`` object — but the two call-site
+# silences have to stay until SA adds annotations upstream.
+# mypy: disable-error-code="no-untyped-call, no-any-return"
 
 from sqlalchemy.testing import exclusions
+from sqlalchemy.testing.exclusions import compound
 from sqlalchemy.testing.requirements import SuiteRequirements
 
 __all__ = ["Requirements"]
@@ -17,37 +25,37 @@ class Requirements(SuiteRequirements):
     """
 
     @property
-    def datetime_literals(self) -> Any:
+    def datetime_literals(self) -> compound:
         """dqlite/SQLite doesn't have native datetime literals."""
         return exclusions.closed()
 
     @property
-    def time_microseconds(self) -> Any:
+    def time_microseconds(self) -> compound:
         """SQLite stores time as text without microseconds."""
         return exclusions.closed()
 
     @property
-    def datetime_historic(self) -> Any:
+    def datetime_historic(self) -> compound:
         """SQLite date range limitation."""
         return exclusions.closed()
 
     @property
-    def unicode_ddl(self) -> Any:
+    def unicode_ddl(self) -> compound:
         """SQLite supports unicode in DDL."""
         return exclusions.open()
 
     @property
-    def savepoints(self) -> Any:
+    def savepoints(self) -> compound:
         """dqlite supports savepoints."""
         return exclusions.open()
 
     @property
-    def two_phase_transactions(self) -> Any:
+    def two_phase_transactions(self) -> compound:
         """dqlite doesn't support two-phase transactions."""
         return exclusions.closed()
 
     @property
-    def temp_table_reflection(self) -> Any:
+    def temp_table_reflection(self) -> compound:
         """SQLite supports temp table reflection."""
         return exclusions.open()
 
@@ -58,90 +66,90 @@ def temp_table_reflection(self) -> Any:
     # suite has a single source of truth to adjust.
 
     @property
-    def cte(self) -> Any:
+    def cte(self) -> compound:
         """Common Table Expressions (WITH)."""
         return exclusions.open()
 
     @property
-    def window_functions(self) -> Any:
+    def window_functions(self) -> compound:
         """SQL window functions (OVER / PARTITION BY)."""
         return exclusions.open()
 
     @property
-    def returning(self) -> Any:
+    def returning(self) -> compound:
         """RETURNING clause on DML."""
         return exclusions.open()
 
     @property
-    def insert_from_select(self) -> Any:
+    def insert_from_select(self) -> compound:
         """INSERT INTO ... SELECT."""
         return exclusions.open()
 
     @property
-    def on_update_or_delete_cascades(self) -> Any:
+    def on_update_or_delete_cascades(self) -> compound:
         """ON UPDATE/DELETE CASCADE foreign-key actions."""
         return exclusions.open()
 
     @property
-    def self_referential_foreign_keys(self) -> Any:
+    def self_referential_foreign_keys(self) -> compound:
         """Table references itself via foreign key."""
         return exclusions.open()
 
     @property
-    def unique_constraint_reflection(self) -> Any:
+    def unique_constraint_reflection(self) -> compound:
         """Inspector reports UNIQUE constraints."""
         return exclusions.open()
 
     @property
-    def primary_key_constraint_reflection(self) -> Any:
+    def primary_key_constraint_reflection(self) -> compound:
         """Inspector reports PRIMARY KEY constraints."""
         return exclusions.open()
 
     @property
-    def foreign_key_constraint_reflection(self) -> Any:
+    def foreign_key_constraint_reflection(self) -> compound:
         """Inspector reports FOREIGN KEY constraints."""
         return exclusions.open()
 
     @property
-    def index_reflection(self) -> Any:
+    def index_reflection(self) -> compound:
         """Inspector reports indexes."""
         return exclusions.open()
 
     @property
-    def temporary_tables(self) -> Any:
+    def temporary_tables(self) -> compound:
         """CREATE TEMPORARY TABLE support (same as SQLite)."""
         return exclusions.open()
 
     @property
-    def table_ddl_if_exists(self) -> Any:
+    def table_ddl_if_exists(self) -> compound:
         """CREATE TABLE IF NOT EXISTS / DROP TABLE IF EXISTS."""
         return exclusions.open()
 
     @property
-    def sane_rowcount(self) -> Any:
+    def sane_rowcount(self) -> compound:
         """UPDATE / DELETE rowcount is truthful. dqlite forwards the server's
         sqlite3_changes() verbatim via ResultResponse.rows_affected."""
         return exclusions.open()
 
     @property
-    def sane_multi_rowcount(self) -> Any:
+    def sane_multi_rowcount(self) -> compound:
         """executemany aggregates each iteration's rowcount, so multi-row
         UPDATE / DELETE totals match the caller's expectation."""
         return exclusions.open()
 
     @property
-    def emulated_lastrowid(self) -> Any:
+    def emulated_lastrowid(self) -> compound:
         """lastrowid is SQLite's ROWID, forwarded verbatim via
         ResultResponse.last_insert_id."""
         return exclusions.open()
 
     @property
-    def supports_empty_inserts(self) -> Any:
+    def supports_empty_inserts(self) -> compound:
         """INSERT INTO t DEFAULT VALUES. SQLite supports it; dqlite inherits."""
         return exclusions.open()
 
     @property
-    def regexp_match(self) -> Any:
+    def regexp_match(self) -> compound:
         """The portable ``col.regexp_match(pattern)`` operator compiles
         to ``col REGEXP ?``, which SQLite dispatches to a user-defined
         ``regexp`` function. pysqlite registers that function via

tests/test_requirements.py

@@ -51,3 +51,35 @@ def test_regexp_match_is_closed(self) -> None:
         """
         req = Requirements()
         assert req.regexp_match.enabled is False
+
+
+class TestRequirementsReturnAnnotations:
+    """Static pin: every property on the Requirements class advertises
+    its actual return type as ``compound``. If a future maintainer adds
+    a property returning ``Any`` (or a helper that yields a bare bool),
+    this test catches it before the return-type drift makes it into a
+    release."""
+
+    def test_every_property_annotates_compound_return(self) -> None:
+        import typing
+
+        from sqlalchemy.testing.exclusions import compound
+
+        from sqlalchemydqlite.requirements import Requirements
+
+        skipped = {"_sa_instance_state"}
+        missing: list[str] = []
+        for name in vars(Requirements):
+            if name.startswith("_") or name in skipped:
+                continue
+            attr = vars(Requirements)[name]
+            if not isinstance(attr, property):
+                continue
+            fget = attr.fget
+            assert fget is not None
+            hints = typing.get_type_hints(fget)
+            if hints.get("return") is not compound:
+                missing.append(name)
+        assert not missing, (
+            f"Requirements properties must annotate ``-> compound``; missing on: {sorted(missing)}"
+        )