quadkit-sql 0.0.42__tar.gz → 0.0.43__tar.gz

quadkit_sql-0.0.43/.gitignore

@@ -0,0 +1,24 @@
+# Generated public-repository ignore rules.
+# Private monorepo paths are intentionally not referenced here.
+
+__pycache__/
+*.py[cod]
+*.so
+*.egg-info/
+.venv/
+venv/
+.env
+.env.*
+!.env.example
+.pytest_cache/
+.ruff_cache/
+.mypy_cache/
+.coverage
+coverage.xml
+htmlcov/
+build/
+dist/
+*.log
+.DS_Store
+.idea/
+.vscode/

{quadkit_sql-0.0.42 → quadkit_sql-0.0.43}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: quadkit-sql
-Version: 0.0.42
+Version: 0.0.43
 Summary: SQL database abstractions for Quadkit Framework — Postgres, MySQL, SQLite with migrations, repositories, and query building
 Project-URL: Homepage, https://dbtinoy-.github.io/quadkit
 Project-URL: Repository, https://github.com/dbtinoy-/quadkit

{quadkit_sql-0.0.42 → quadkit_sql-0.0.43}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "quadkit-sql"
-version = "0.0.42"
+version = "0.0.43"
 description = "SQL database abstractions for Quadkit Framework — Postgres, MySQL, SQLite with migrations, repositories, and query building"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -99,9 +99,6 @@ Documentation = "https://dbtinoy-.github.io/quadkit"
 Issues = "https://github.com/dbtinoy-/quadkit/issues"
 Changelog = "https://github.com/dbtinoy-/quadkit/blob/main/CHANGELOG.md"
 
-[project.entry-points."quadkit.admin.contributors"]
-sql = "quadkit.sql.admin.contributor:SqlAdminContributor"
-
 [project.entry-points."quadkit.providers"]
 database = "quadkit.sql.di.provider:DatabaseProvider"
 
@@ -181,9 +178,6 @@ overrides = [
 [tool.uv.sources.quadkit]
 workspace = true
 
-[tool.uv.sources.quadkit-admin]
-workspace = true
-
 [tool.uv.sources.quadkit-testing]
 workspace = true
 

{quadkit_sql-0.0.42 → quadkit_sql-0.0.43}/src/quadkit/sql/admin/audit_store.py

@@ -60,7 +60,7 @@ class SqlAdminAuditLogStore:
     session is registered), and it does not commit — commit semantics
     belong to the session owner (e.g. the request pipeline or unit of
     work).  For transactional audit entries, defer writes to the UoW's
-    commit via :class:`~quadkit.admin.audit.uow_writer.UowAuditWriter`.
+    commit via :class:`~the optional provider module`.
 
     Usage (opt-in at app level): register a provider that binds
     ``AdminAuditLoggerProtocol`` to this store with an injected session,

{quadkit_sql-0.0.42 → quadkit_sql-0.0.43}/src/quadkit/sql/cli/generators/seeder.py

@@ -120,7 +120,7 @@ class SeederGenerator(GeneratorBase):
         if lowered_type in {"bool", "boolean"}:
             return "True"
         if lowered_type in {"date", "datetime"}:
-            return "datetime.now(timezone.utc)"
+            return "clock.now()"
         if lowered_type == "uuid":
             return '"550e8400-e29b-41d4-a716-446655440000"'
         if "json" in lowered_type:

{quadkit_sql-0.0.42 → quadkit_sql-0.0.43}/src/quadkit/sql/cli/generators/type_map.py

@@ -156,7 +156,7 @@ def sa_type(field_type: str) -> str:
 #: Imports every generated model needs, merged with annotation-driven ones so
 #: the rendered module never repeats a module on two lines.
 BASE_IMPORTS: tuple[tuple[str, tuple[str, ...]], ...] = (
-    ("datetime", ("datetime", "timezone")),
+    ("datetime", ("datetime",)),
     ("pydantic", ("BaseModel", "ConfigDict", "Field")),
 )
 

{quadkit_sql-0.0.42 → quadkit_sql-0.0.43}/src/quadkit/sql/cli/templates/database_repository.py.jinja2

@@ -4,8 +4,9 @@ from __future__ import annotations
 
 from typing import Any
 import uuid as _uuid
-from datetime import datetime as _datetime, timezone as _timezone
-
+{% if needs_datetime %}from datetime import datetime
+{% endif %}
+from quadkit import clock
 from quadkit.contracts import DatabaseProviderProtocol
 
 from quadkit.sql.repositories.generic_repository import GenericRepository
@@ -53,7 +54,7 @@ class {{ repo_name }}Repository:
     def _prepare(self, data: dict[str, Any]) -> dict[str, Any]:
         row = dict(data)
         row.setdefault("{{ key_field }}", _uuid.uuid4().hex)
-        now = _datetime.now(_timezone.utc).isoformat()
+        now = clock.now().isoformat()
         row.setdefault("created_at", now)
         row["updated_at"] = now
         return row
@@ -84,7 +85,7 @@ class {{ repo_name }}Repository:
             row = {
                 **data,
                 "{{ key_field }}": key,
-                "updated_at": _datetime.now(_timezone.utc).isoformat(),
+                "updated_at": clock.now().isoformat(),
             }
             await self._provider.execute_update(
                 "{{ table_name }}", row, '"{{ key_field }}" = ?', [key]

{quadkit_sql-0.0.42 → quadkit_sql-0.0.43}/src/quadkit/sql/cli/templates/entity_model.py.jinja2

@@ -10,6 +10,7 @@ from __future__ import annotations
 import uuid
 {% for line in import_lines %}{{ line }}
 {% endfor %}
+from quadkit import clock
 
 class {{ entity_name }}(BaseModel):
     """{{ entity_name }} entity."""
@@ -17,12 +18,8 @@ class {{ entity_name }}(BaseModel):
     model_config = ConfigDict(from_attributes=True)
 
     id: str = Field(default_factory=lambda: uuid.uuid4().hex)
-    created_at: datetime = Field(
-        default_factory=lambda: datetime.now(timezone.utc)
-    )
-    updated_at: datetime = Field(
-        default_factory=lambda: datetime.now(timezone.utc)
-    )
+    created_at: datetime = Field(default_factory=clock.now)
+    updated_at: datetime = Field(default_factory=clock.now)
 {%- for field in fields %}
     {{ field.name }}: {{ field.py_type }}{% if not field.required %} | None = None{% endif %}
 {%- endfor %}

{quadkit_sql-0.0.42 → quadkit_sql-0.0.43}/src/quadkit/sql/cli/templates/seeder.py.jinja2

@@ -2,9 +2,9 @@
 
 from __future__ import annotations
 
-from datetime import datetime, timezone
 from typing import Any
 
+from quadkit import clock
 from quadkit.contracts import DatabaseProviderProtocol
 from quadkit.sql import SimpleUnitOfWork
 
@@ -14,8 +14,8 @@ SEED_DATA: list[dict[str, Any]] = [
         {%- for field in fields %}
         "{{ field.name }}": {{ field.sample_value }},
         {%- endfor %}
-        "created_at": datetime.now(timezone.utc),
-        "updated_at": datetime.now(timezone.utc),
+        "created_at": clock.now(),
+        "updated_at": clock.now(),
     },
 ]
 

{quadkit_sql-0.0.42 → quadkit_sql-0.0.43}/src/quadkit/sql/di/_registration.py

@@ -186,8 +186,8 @@ class _DatabaseRegistrationMixin:
 
             _warn_alembic_missing()
 
-        # Database-backed search backends have moved to quadkit-search
-        # (`quadkit.search.backends.mysql` / `quadkit.search.backends.postgres`).
+        # Database-backed search backends have moved to the optional provider
+        # (`the optional provider module` / `the optional provider module`).
         # SearchProvider is responsible for
         # resolving DatabaseProviderProtocol from the container and registering
         # the appropriate DatabaseSearchBackendProtocol singleton.  DatabaseProvider

{quadkit_sql-0.0.42 → quadkit_sql-0.0.43}/src/quadkit/sql/di/provider.py

@@ -178,7 +178,7 @@ class DatabaseProvider(_DatabaseRegistrationMixin, Provider):
             except Exception:  # noqa: BLE001 — optional tracing wiring degrades on any resolution failure
                 logger.debug("trace_provider_unavailable")
 
-        # Wire optional resilience pipeline factory (provided by quadkit-resilience).
+        # Wire optional resilience pipeline factory (provided by the optional provider).
         resilience = self._db_provider.resilience_handler
         if resilience._pipeline_factory is None:
             from quadkit.contracts.infra.resilience import (

{quadkit_sql-0.0.42 → quadkit_sql-0.0.43}/src/quadkit/sql/migrations/manager/_alembic.py

@@ -56,6 +56,20 @@ except ImportError:  # pragma: no cover - availability checked at runtime
     ALEMBIC_AVAILABLE = False
 
 
+def _packaged_alembic_ini() -> Path:
+    """Return the ``alembic.ini`` that sits beside the package source.
+
+    An installed wheel carries no such file, so callers fall back to a path
+    they own when this is absent.
+
+    Returns:
+        Path to the workspace ``alembic.ini`` (which need not exist).
+    """
+    # parents[4] lands in src/, where `command.init()` writes a template ini;
+    # parents[5] is the package root that ships the real file.
+    return Path(__file__).resolve().parents[5] / "alembic.ini"
+
+
 class AlembicManager:
     """Alembic migration manager facade for Quadkit DB.
 
@@ -129,14 +143,17 @@ class AlembicManager:
 
     def _create_alembic_config(self) -> Config:
         """Create and configure Alembic Config object."""
-        # Package root (packages/quadkit-sql/) — parents[4] would land in
-        # src/, where `command.init()` then writes a template alembic.ini.
-        package_root = Path(__file__).resolve().parents[5]
         config = Config()
-        if (package_root / "alembic.ini").exists():
-            config.config_file_name = str(package_root / "alembic.ini")
-        # else: installed (non-workspace) layout with no packaged ini — leave
-        # config_file_name unset so Alembic uses programmatic options only.
+        packaged_ini = _packaged_alembic_ini()
+        if packaged_ini.exists():
+            config.config_file_name = str(packaged_ini)
+        else:
+            # Installed wheel: `alembic.ini` lives at the package root, which
+            # sits outside the wheel, so there is no packaged ini to reference.
+            # `command.init()` asserts on `config_file_name`, so point it at
+            # the directory this manager already owns; `init()` writes the
+            # generated ini there, and only while that directory is empty.
+            config.config_file_name = str(self.migrations_path / "alembic.ini")
         config.set_main_option("script_location", str(self.migrations_path))
         # Strip +aiosqlite/+asyncpg for Alembic which is sync
         self.connection_string = self.database_url
@@ -147,6 +164,18 @@ class AlembicManager:
 
         config.set_main_option("sqlalchemy.url", self.connection_string)
         config.set_main_option("version_locations", str(self.script_location))
+        # `path_separator` must be set in the same breath as
+        # `version_locations`: alembic >= 1.16 deprecates splitting the value
+        # without it, and this manager sets `version_locations`
+        # programmatically. The packaged `alembic.ini` carries
+        # `path_separator = os`, so a *workspace* checkout never saw the
+        # warning -- but an *installed* layout resolves without that file and
+        # hit the legacy fallback on every boot. Setting it here makes the
+        # two layouts behave identically instead of leaving the guarantee to a
+        # file that ships only in the repo.
+        config.set_main_option("path_separator", "os")
+        # User overrides last, so `alembic_config={"path_separator": ":"}`
+        # still wins for a project that needs the legacy character.
         for key, value in self.alembic_config.items():
             config.set_main_option(key, str(value))
         return config

{quadkit_sql-0.0.42 → quadkit_sql-0.0.43}/src/quadkit/sql/migrations/orchestrator.py

@@ -134,7 +134,7 @@ class MigrationOrchestrator:
                     "package": "app",
                     "path": self.base_path / "migrations",
                     "dependencies": [
-                        "quadkit-admin",
+                        "the optional provider",
                         "quadkit-events",
                         "quadkit-tasks",
                     ],

{quadkit_sql-0.0.42 → quadkit_sql-0.0.43}/src/quadkit/sql/providers/database_service.py

@@ -204,7 +204,7 @@ class DatabaseService(_ConnectionMixin, _QueryMixin, _HealthMixin):
 
             raise ConfigurationError(
                 "MongoDB URLs are not supported by quadkit-sql. "
-                "Use quadkit-nosql instead: from quadkit.nosql import NoSQLProvider"
+                "Use the optional provider instead: from the optional provider module import NoSQLProvider"
             )
 
         from quadkit.sql.lib import infer_provider_type_from_url

{quadkit_sql-0.0.42 → quadkit_sql-0.0.43}/src/quadkit/sql/query/builder.py

@@ -189,7 +189,7 @@ class SearchQueryBuilder(QueryBuilder):
     makes the intent of passing a raw :data:`FilterExpression` explicit
     (rather than letting callers use the more generic :meth:`filter` alias).
 
-    Search-extension packages (``quadkit-search``, ``quadkit-sql``) accept
+    Search-extension packages (``the optional provider``, ``quadkit-sql``) accept
     a :class:`SearchQueryBuilder` or a plain :class:`QueryBuilder` and compile
     the resulting :class:`Query` to backend-specific query syntax via
     ``FilterCompilerProtocol``.

{quadkit_sql-0.0.42 → quadkit_sql-0.0.43}/src/quadkit/sql/resilience/__init__.py

@@ -1,7 +1,7 @@
 """Resilience primitives for database operations.
 
 Provides a resilience handler that wraps database operations with circuit
-breaker, retry with backoff, and timeout when ``quadkit-resilience`` is
+breaker, retry with backoff, and timeout when ``the optional provider`` is
 installed. Falls back to a no-op pass-through when absent.
 """
 

{quadkit_sql-0.0.42 → quadkit_sql-0.0.43}/src/quadkit/sql/resilience/core.py

@@ -1,14 +1,14 @@
 """Database resilience primitives.
 
 When a :class:`~quadkit.contracts.resilience.ResiliencePipelineFactory` is
-injected (provided by ``quadkit-resilience``), builds real circuit-breaker /
+injected (provided by ``the optional provider``), builds real circuit-breaker /
 retry pipelines with database-specific defaults.  When ``None`` is injected
-(or ``quadkit-resilience`` is not installed), a lightweight no-op pass-through
+(or ``the optional provider`` is not installed), a lightweight no-op pass-through
 is used instead — so ``quadkit-sql`` has **no** hard runtime dependency on the
 resilience extension.
 
 Cross-extension communication follows the contracts + DI pattern from
-``AGENTS.md``.  ``quadkit-sql`` never imports from ``quadkit-resilience``
+``AGENTS.md``.  ``quadkit-sql`` never imports from ``the optional provider``
 directly; it only consumes the :class:`~quadkit.contracts.resilience.ResiliencePipelineFactory`
 protocol resolved through the container.
 """
@@ -51,7 +51,7 @@ DB_RETRYABLE_EXCEPTIONS = (
 
 
 class _NoOpPipeline:
-    """Pass-through pipeline used when quadkit-resilience is not installed."""
+    """Pass-through pipeline used when the optional provider is not installed."""
 
     async def execute(
         self, func: Callable[..., Awaitable[T]], *args: Any, **kwargs: Any
@@ -67,7 +67,7 @@ class DatabaseResilienceHandler:
     injected by the DI container.  When a factory is present it builds real
     circuit-breaker / retry pipelines with database-specific defaults.  When
     ``None`` is passed a lightweight no-op pipeline is used, so ``quadkit-sql``
-    has no hard runtime dependency on ``quadkit-resilience``.
+    has no hard runtime dependency on ``the optional provider``.
     """
 
     def __init__(
@@ -77,7 +77,7 @@ class DatabaseResilienceHandler:
         """Initialise the resilience handler.
 
         Args:
-            pipeline_factory: Optional factory provided by ``quadkit-resilience``
+            pipeline_factory: Optional factory provided by ``the optional provider``
                 via the DI container.  Pass ``None`` for no-op behaviour.
         """
         self._pipeline_factory = pipeline_factory
@@ -194,7 +194,7 @@ async def retry_call(
         The return value of *func* on a successful attempt.
 
     Raises:
-        :class:`~quadkit.resilience.errors.RetryExhaustedError`: When all
+        :class:`~the optional provider module`: When all
             attempts are exhausted.
         Any exception raised by *func* that is not in ``config.retry_on``.
     """

{quadkit_sql-0.0.42 → quadkit_sql-0.0.43}/tests/conftest.py

@@ -14,17 +14,17 @@ BASE_DIR = os.path.dirname(os.path.abspath(__file__))
 
 # ensure local packages are importable when running tests directly
 # this mirrors the similar logic in other quadkit packages and is
-# intentionally simple so that pytest can find `quadkit.sql`,
-# `quadkit.contracts` and `quadkit.resilience` even though they live
-# outside the tests directory during development.
+# intentionally simple so that pytest can find `quadkit.sql` and
+# `quadkit.contracts` even though they live outside the tests
+# directory during development.
 PROJECT_ROOT = os.path.abspath(os.path.join(BASE_DIR, ".."))
 sys.path.insert(0, os.path.join(PROJECT_ROOT, "src"))
 sys.path.insert(0, os.path.join(PROJECT_ROOT, "..", "quadkit-contracts", "src"))
 
 # Import TestEnvironment lazily inside the fixture to avoid importing
 # optional test utilities (e.g., admin mocks) at module import time which
-# may pull in optional packages like quadkit.admin that are not available
-# in all test environments.
+# may pull in optional packages that are not available in all test
+# environments.
 
 # The fixtures the test suite expects (clean_database, seeded_database, etc.)
 # are provided by quadkit.testing.fixtures.db; import them lazily below in
@@ -87,7 +87,7 @@ async def test_bed():
 
     Importing `TestEnvironment` lazily ensures we don't try to import heavy
     admin/testing modules at collection time (which can pull optional
-    dependencies like `quadkit.admin`). If `quadkit.testing` isn't
+    dependencies that are not installed). If `quadkit.testing` isn't
     available in this environment, skip the dependent tests gracefully.
     """
     try:

{quadkit_sql-0.0.42 → quadkit_sql-0.0.43}/tests/integration/test_migrations.py

@@ -230,6 +230,20 @@ class TestAlembicManager:
         assert "issues" in result
         assert isinstance(result["issues"], list)
 
+    def test_config_names_the_migrations_dir_without_a_packaged_ini(
+        self, connection_string, temp_dir, monkeypatch
+    ):
+        """An installed wheel ships no `alembic.ini`, so the config names the
+        directory the manager owns instead of leaving the name unset."""
+        from quadkit.sql.migrations.manager import _alembic
+
+        monkeypatch.setattr(
+            _alembic, "_packaged_alembic_ini", lambda: temp_dir / "alembic.ini"
+        )
+        manager = AlembicManager(connection_string, temp_dir)
+
+        assert manager.config.config_file_name == str(temp_dir / "alembic.ini")
+
 
 @pytest.mark.skipif(not ALEMBIC_AVAILABLE, reason="Alembic is not installed")
 class TestMigrationUtilities:

{quadkit_sql-0.0.42 → quadkit_sql-0.0.43}/tests/unit/backends/test_cockroachdb_backend.py

@@ -2,8 +2,11 @@
 
 from __future__ import annotations
 
+import importlib.util
 from unittest.mock import AsyncMock, patch
 
+import pytest
+
 from quadkit.contracts.core import HealthCheckResult, HealthStatus
 from quadkit.sql.backends.cockroachdb import (
     CockroachDBConnection,
@@ -11,7 +14,12 @@ from quadkit.sql.backends.cockroachdb import (
 )
 from quadkit.sql.backends.postgres import PostgresConnectionPool
 
+requires_asyncpg = pytest.mark.skipif(
+    importlib.util.find_spec("asyncpg") is None, reason="asyncpg is not installed"
+)
+
 
+@requires_asyncpg
 class TestDefaults:
     def test_constructor_defaults(self) -> None:
         conn = CockroachDBConnection()
@@ -45,6 +53,7 @@ class TestDsnNormalisation:
         assert CockroachDBConnection._normalize_dsn(dsn) == dsn  # noqa: SLF001
 
 
+@requires_asyncpg
 class TestCreatePool:
     async def test_server_settings_injected(self) -> None:
         captured: dict[str, object] = {}
@@ -91,6 +100,7 @@ class TestCreatePool:
         assert captured["server_settings"]["application_name"] == "quadkit-cockroachdb"
 
 
+@requires_asyncpg
 class TestHealthCheckComponent:
     async def test_component_replaced(self) -> None:
         conn = CockroachDBConnection()
@@ -115,6 +125,7 @@ class TestHealthCheckComponent:
         assert fake_result.component == "database"
 
 
+@requires_asyncpg
 class TestFactory:
     def test_defaults_without_dsn(self) -> None:
         pool = create_cockroachdb_pool()

{quadkit_sql-0.0.42 → quadkit_sql-0.0.43}/tests/unit/backends/test_postgres_connection.py

@@ -97,11 +97,13 @@ class TestExecute:
             await pc.execute("BROKEN")
 
     async def test_generic_error_becomes_connection_error(self) -> None:
+        pytest.importorskip("asyncpg")
         pc, _ = _conn_results({("execute", "X"): OSError("socket gone")})
         with pytest.raises(DatabaseConnectionError, match="Connection error"):
             await pc.execute("X")
 
     async def test_timeout_maps_to_connection_error(self) -> None:
+        pytest.importorskip("asyncpg")
         pc, _ = _conn_results({("execute", "X"): DatabaseTimeoutError("slow")})
         with pytest.raises(DatabaseConnectionError, match="Connection error"):
             await pc.execute("X")
@@ -127,6 +129,7 @@ class TestFetchOne:
             await pc.fetch_one("B")
 
     async def test_generic_error_becomes_query_error(self) -> None:
+        pytest.importorskip("asyncpg")
         pc, _ = _conn_results({("fetchrow", "B"): OSError("down")})
         with pytest.raises(QueryError, match="Unexpected Postgres error"):
             await pc.fetch_one("B")

{quadkit_sql-0.0.42 → quadkit_sql-0.0.43}/tests/unit/cli/test_entity_model_generator.py

@@ -82,7 +82,7 @@ def test_unknown_type_falls_back_to_str(tmp_path: Path) -> None:
 def test_required_imports_are_emitted_and_merged(tmp_path: Path) -> None:
     """Constrained annotations bring their imports, each module once."""
     source = _render(tmp_path, "day:date,at:time,meta:json,email:email,site:url")
-    assert "from datetime import date, datetime, time, timezone" in source
+    assert "from datetime import date, datetime, time" in source
     assert "from typing import Any" in source
     assert "from pydantic import AnyHttpUrl, BaseModel, ConfigDict, EmailStr, Field" in (
         source

{quadkit_sql-0.0.42 → quadkit_sql-0.0.43}/tests/unit/cli/test_type_map.py

@@ -44,7 +44,7 @@ def test_render_imports_merges_base_and_annotation_imports() -> None:
     """Base imports are always present and each module appears once."""
     lines = render_imports(["date", "time", "dict[str, Any]", "EmailStr"])
 
-    assert "from datetime import date, datetime, time, timezone" in lines
+    assert "from datetime import date, datetime, time" in lines
     assert "from pydantic import AnyHttpUrl" not in lines
     assert "from pydantic import BaseModel, ConfigDict, EmailStr, Field" in lines
     assert "from typing import Any" in lines
@@ -54,7 +54,7 @@ def test_render_imports_merges_base_and_annotation_imports() -> None:
 def test_render_imports_without_annotations() -> None:
     """A plain entity needs only the base imports."""
     assert render_imports([]) == [
-        "from datetime import datetime, timezone",
+        "from datetime import datetime",
         "from pydantic import BaseModel, ConfigDict, Field",
     ]
 

quadkit_sql-0.0.43/tests/unit/migrations/test_alembic_config_path_separator.py

@@ -0,0 +1,107 @@
+"""`AlembicManager` builds a config alembic does not deprecate.
+
+These tests use the **real** ``alembic.config.Config`` on purpose.
+``tests/unit/test_migrations_manager.py`` patches ``Config`` out, so it can
+assert which options the manager *asks* for but never what alembic *does*
+with them -- which is why the regression below survived there.
+
+The regression: the manager sets ``version_locations`` programmatically, and
+alembic >= 1.16 deprecates splitting that value unless ``path_separator`` is
+also set. A workspace checkout hid it, because ``_create_alembic_config``
+finds the packaged ``alembic.ini`` (which carries ``path_separator = os``)
+and sets ``config_file_name``. An installed layout -- the wheel a generated
+project resolves from PyPI -- has no packaged ini, so every boot fell back to
+legacy splitting and emitted the deprecation.
+"""
+
+from __future__ import annotations
+
+import pathlib
+import warnings
+
+from alembic.script import ScriptDirectory
+import pytest
+
+from quadkit.sql.migrations.manager import AlembicManager
+from quadkit.sql.migrations.manager._alembic import _packaged_alembic_ini
+
+_DEPRECATION = "path_separator"
+
+
+@pytest.fixture
+def migrations_dir(tmp_path: pathlib.Path) -> pathlib.Path:
+    """A directory shaped enough for ``ScriptDirectory`` to load it."""
+    root = tmp_path / "migrations"
+    (root / "versions").mkdir(parents=True)
+    (root / "env.py").write_text("")
+    (root / "script.py.mako").write_text("")
+    return root
+
+
+@pytest.fixture
+def installed_layout(monkeypatch: pytest.MonkeyPatch):
+    """Hide the packaged ``alembic.ini``, as an installed wheel does.
+
+    Only that filename is hidden; every other path answers normally, so the
+    manager still finds the migrations directory under ``tmp_path``.
+    """
+    real_exists = pathlib.Path.exists
+
+    def fake_exists(self: pathlib.Path) -> bool:
+        if self.name == "alembic.ini":
+            return False
+        return real_exists(self)
+
+    monkeypatch.setattr(pathlib.Path, "exists", fake_exists)
+
+
+def test_installed_layout_emits_no_path_separator_deprecation(
+    migrations_dir: pathlib.Path, installed_layout: None
+) -> None:
+    """The case a generated project actually runs: no packaged ini."""
+    assert not _packaged_alembic_ini().exists(), (
+        "fixture did not hide the packaged ini; the test would pass vacuously"
+    )
+    manager = AlembicManager("sqlite:///x.db", migrations_path=str(migrations_dir))
+
+    with warnings.catch_warnings(record=True) as caught:
+        warnings.simplefilter("always")
+        ScriptDirectory.from_config(manager.config)
+
+    offenders = [str(w.message) for w in caught if _DEPRECATION in str(w.message)]
+    assert not offenders, f"alembic still deprecates the config: {offenders}"
+
+
+def test_version_locations_still_resolves_in_both_layouts(
+    migrations_dir: pathlib.Path,
+) -> None:
+    """``path_separator`` must not cost us the value it governs.
+
+    Guards the near-miss this fix had: setting the separator while dropping
+    ``version_locations`` leaves alembic with *no* version path at all, and
+    the deprecation assertion above would still pass -- silently, because
+    there is then nothing to split.
+    """
+    manager = AlembicManager("sqlite:///x.db", migrations_path=str(migrations_dir))
+    script = ScriptDirectory.from_config(manager.config)
+
+    assert script.version_locations == (str(migrations_dir / "versions"),) or list(
+        script.version_locations
+    ) == [str(migrations_dir / "versions")]
+
+
+def test_path_separator_defaults_to_os(migrations_dir: pathlib.Path) -> None:
+    manager = AlembicManager("sqlite:///x.db", migrations_path=str(migrations_dir))
+    assert manager.config.get_main_option("path_separator") == "os"
+
+
+def test_explicit_alembic_config_overrides_the_default(
+    migrations_dir: pathlib.Path,
+) -> None:
+    """The default is a floor, not a ceiling -- callers keep the last word."""
+    manager = AlembicManager(
+        "sqlite:///x.db",
+        migrations_path=str(migrations_dir),
+        alembic_config={"path_separator": ":"},
+    )
+    assert manager.config.get_main_option("path_separator") == ":"

{quadkit_sql-0.0.42 → quadkit_sql-0.0.43}/tests/unit/test_mysql_backend_scenario.py

@@ -1,9 +1,9 @@
 """Scenario coverage for the MySQL backend with an injected fake driver.
 
-The real ``aiomysql`` package is installed in this environment, but the
-pool/connection logic is exercised against an in-memory fake client
-(injected into the module-level ``aiomysql`` references) so no database
-server is required.  Covers pool creation (success, failure, retry
+The optional ``aiomysql`` driver is imported when present (the module skips
+otherwise), and the pool/connection logic is exercised against an in-memory
+fake client (injected into the module-level ``aiomysql`` references) so no
+database server is required.  Covers pool creation (success, failure, retry
 exhaustion), connection acquisition (plain + circuit breaker), health
 checks (healthy/cached/unhealthy paths), statistics, shutdown, and the
 ``MySQLConnection`` query surface with error mapping and monitoring.
@@ -15,9 +15,12 @@ import asyncio
 from contextlib import asynccontextmanager
 from typing import Any, Self
 
-import aiomysql
 import pytest
 
+pytest.importorskip("aiomysql")
+
+import aiomysql
+
 from quadkit.contracts.core import HealthStatus
 from quadkit.contracts.exceptions.resilience import RetryExhaustedError
 from quadkit.contracts.infra.resilience import RetryConfig

{quadkit_sql-0.0.42 → quadkit_sql-0.0.43}/tests/unit/test_round25_hardening.py

@@ -286,6 +286,7 @@ class TestHealthCheckerNeverRaises:
 class TestPostgresAutoCreate:
     @pytest.mark.asyncio
     async def test_autocreate_driver_error_wrapped(self, monkeypatch: pytest.MonkeyPatch) -> None:
+        pytest.importorskip("asyncpg")
         import asyncpg
 
         from quadkit.sql.providers.postgres_provider import PostgresProvider