Tighten sqlalchemy-dqlite packaging, slots, and requirements fences

Four small hygiene changes:

- Add Framework :: AsyncIO trove classifier. The dialect ships an
  async surface (create_async_engine("dqlite+aio://...") via the
  ``dqlite.aio`` entry point); sibling packages already advertise
  the classifier and sqlalchemy-dqlite was an asymmetric omission.

- Declare ``__slots__ = ()`` on AsyncAdaptedConnection. The parent
  SA AdaptedConnection uses ``__slots__ = ("_connection",)``; a
  subclass without slots gets a ``__dict__`` per instance, defeating
  the parent's memory layout. SA's own aiosqlite adapter follows the
  same slot pattern.

- Extend test_properties_return_exclusion_objects to cover all 23
  overridden Requirements properties (was 12/23). A regression to
  bare True/False on any of cte / window_functions / returning /
  insert_from_select / on_update_or_delete_cascades / the
  ``_reflection`` family / temporary_tables / table_ddl_if_exists
  is now fenced — matching the policy ISSUE-132/133 established.

- Annotate set_isolation_level's AUTOCOMMIT and warn branches as
  belt-and-suspenders for third-party callers. SA's engine flow
  validates via get_isolation_level_values first and rejects
  unknown levels upstream, so those branches are unreachable for
  engine-driven paths; keep them for non-engine callers and make
  the reachability note explicit.

Author: antoineleclair

pyproject.toml

@@ -13,6 +13,7 @@ authors = [{ name = "Antoine Leclair", email = "antoineleclair@gmail.com" }]
 keywords = ["dqlite", "sqlite", "distributed", "database", "sqlalchemy", "orm"]
 classifiers = [
     "Development Status :: 3 - Alpha",
+    "Framework :: AsyncIO",
     "Intended Audience :: Developers",
     "License :: OSI Approved :: MIT License",
     "Operating System :: OS Independent",

src/sqlalchemydqlite/aio.py

@@ -209,6 +209,14 @@ class AsyncAdaptedConnection(AdaptedConnection):
     greenlet context.
     """
 
+    # Parent ``sqlalchemy.engine.interfaces.AdaptedConnection`` declares
+    # ``__slots__ = ("_connection",)``; without our own slots declaration
+    # each instance gets a ``__dict__`` and defeats the parent's memory
+    # optimization (SA's own ``AsyncAdapt_aiosqlite_connection`` follows
+    # the same pattern). We add no new instance attributes, so an empty
+    # slots tuple is correct.
+    __slots__ = ()
+
     def __init__(self, connection: "AsyncConnection") -> None:
         # ``_connection`` is the concrete ``dqlitedbapi.aio.AsyncConnection``
         # this adapter wraps; SQLAlchemy's parent ``AdaptedConnection``

src/sqlalchemydqlite/base.py

@@ -286,6 +286,17 @@ def set_isolation_level(self, dbapi_connection: DBAPIConnection, level: str | No
         to lose transactionality without knowing it. Other unsupported
         levels emit a warning (future-proof for isolation levels dqlite
         may grow to support).
+
+        Note on reachability: SA's engine flow
+        (``engine/default.py::_assert_and_set_isolation_level``) calls
+        ``get_isolation_level_values()`` first and rejects unknown
+        values with ``ArgumentError`` before reaching this method, so
+        the AUTOCOMMIT and warning branches are effectively dead for
+        engine-driven callers. They are kept as belt-and-suspenders
+        for third-party callers (test harnesses, custom engine
+        implementations) that bypass SA's upstream validation, and to
+        provide an explicit error message if the guarantees above
+        ever change.
         """
         if level is None or level == "SERIALIZABLE":
             return

tests/test_adapter_slots.py

@@ -0,0 +1,19 @@
+"""``AsyncAdaptedConnection`` must declare ``__slots__`` to preserve
+the memory layout of SA's parent ``AdaptedConnection`` (which uses
+slots for every pooled connection). Without slots each instance
+silently gets a ``__dict__``, defeating the optimization.
+"""
+
+from __future__ import annotations
+
+from unittest.mock import MagicMock
+
+import pytest
+
+from sqlalchemydqlite.aio import AsyncAdaptedConnection
+
+
+def test_async_adapted_connection_has_slots() -> None:
+    conn = AsyncAdaptedConnection(MagicMock())
+    with pytest.raises(AttributeError):
+        conn.__dict__  # noqa: B018

tests/test_requirements.py

@@ -20,6 +20,18 @@ def test_properties_return_exclusion_objects(self) -> None:
             "emulated_lastrowid",
             "supports_empty_inserts",
             "regexp_match",
+            "cte",
+            "window_functions",
+            "returning",
+            "insert_from_select",
+            "on_update_or_delete_cascades",
+            "self_referential_foreign_keys",
+            "unique_constraint_reflection",
+            "primary_key_constraint_reflection",
+            "foreign_key_constraint_reflection",
+            "index_reflection",
+            "temporary_tables",
+            "table_ddl_if_exists",
         ]
         for prop_name in properties:
             value = getattr(req, prop_name)