pgdevkit 0.2.0__tar.gz → 0.2.2__tar.gz

{pgdevkit-0.2.0 → pgdevkit-0.2.2}/.github/workflows/python-test.yml

@@ -24,8 +24,6 @@ jobs:
         uses: actions/setup-python@v5
         with:
           python-version: ${{ matrix.python-version }}
-      - name: Ensure podman is installed
-        run: command -v podman || (sudo apt-get update && sudo apt-get install -y podman)
       - name: Install uv
         run: curl -LsSf https://astral.sh/uv/install.sh | sh
       - name: Install project dependencies

{pgdevkit-0.2.0 → pgdevkit-0.2.2}/PKG-INFO

@@ -1,10 +1,11 @@
 Metadata-Version: 2.4
 Name: pgdevkit
-Version: 0.2.0
+Version: 0.2.2
 Summary: A helper for developing with Postgres
 Requires-Python: >=3.14
+Requires-Dist: docker>=7.1.0
 Requires-Dist: psycopg[binary]>=3.2.0
-Requires-Dist: sqlglot[c]>=30.11.0
+Requires-Dist: sqlglot>=30.11.0
 Provides-Extra: azure
 Requires-Dist: azure-identity>=1.19.0; extra == 'azure'
 Provides-Extra: cli
@@ -87,15 +88,20 @@ CLI: `pgdb testdb up|reset|run-sql|status|shell|clean`.
 
 Container connection defaults (`localhost:54322`, `postgres`/`testpwd`) can
 be overridden with `PGDEVKIT_TESTDB_HOST`, `PGDEVKIT_TESTDB_PORT`,
-`PGDEVKIT_TESTDB_USER`, `PGDEVKIT_TESTDB_PASSWORD`. Before touching
-podman/docker, pgdevkit first checks (with a short timeout) whether Postgres
+`PGDEVKIT_TESTDB_USER`, `PGDEVKIT_TESTDB_PASSWORD`. Before touching the
+Docker API, pgdevkit first checks (with a short timeout) whether Postgres
 is already reachable at that address and skips container management if so.
 Set `PGDEVKIT_SKIP_CONTAINER=1` to always assume it's already there and skip
 that check too.
 
-To point at a local Postgres install instead of the podman container —
-useful when podman isn't available, or you'd rather use peer authentication
-as the current OS user — set `PGDEVKIT_TESTDB_HOST` to the unix socket
+Container management goes through the Docker API (the `docker` package,
+`docker.from_env()`, falling back to Podman's rootful/rootless socket) — it
+works against a real Docker daemon or Podman transparently, no CLI binary
+required either way.
+
+To point at a local Postgres install instead of the container — useful when
+neither is available, or you'd rather use peer authentication as the
+current OS user — set `PGDEVKIT_TESTDB_HOST` to the unix socket
 directory (e.g. `/var/run/postgresql`) and `PGDEVKIT_TESTDB_PASSWORD=""`.
 The role named by `PGDEVKIT_TESTDB_USER` must exist and match your OS user
 (`CREATE ROLE <user> SUPERUSER LOGIN;`) and `pg_hba.conf` must allow `peer`

{pgdevkit-0.2.0 → pgdevkit-0.2.2}/README.md

@@ -70,15 +70,20 @@ CLI: `pgdb testdb up|reset|run-sql|status|shell|clean`.
 
 Container connection defaults (`localhost:54322`, `postgres`/`testpwd`) can
 be overridden with `PGDEVKIT_TESTDB_HOST`, `PGDEVKIT_TESTDB_PORT`,
-`PGDEVKIT_TESTDB_USER`, `PGDEVKIT_TESTDB_PASSWORD`. Before touching
-podman/docker, pgdevkit first checks (with a short timeout) whether Postgres
+`PGDEVKIT_TESTDB_USER`, `PGDEVKIT_TESTDB_PASSWORD`. Before touching the
+Docker API, pgdevkit first checks (with a short timeout) whether Postgres
 is already reachable at that address and skips container management if so.
 Set `PGDEVKIT_SKIP_CONTAINER=1` to always assume it's already there and skip
 that check too.
 
-To point at a local Postgres install instead of the podman container —
-useful when podman isn't available, or you'd rather use peer authentication
-as the current OS user — set `PGDEVKIT_TESTDB_HOST` to the unix socket
+Container management goes through the Docker API (the `docker` package,
+`docker.from_env()`, falling back to Podman's rootful/rootless socket) — it
+works against a real Docker daemon or Podman transparently, no CLI binary
+required either way.
+
+To point at a local Postgres install instead of the container — useful when
+neither is available, or you'd rather use peer authentication as the
+current OS user — set `PGDEVKIT_TESTDB_HOST` to the unix socket
 directory (e.g. `/var/run/postgresql`) and `PGDEVKIT_TESTDB_PASSWORD=""`.
 The role named by `PGDEVKIT_TESTDB_USER` must exist and match your OS user
 (`CREATE ROLE <user> SUPERUSER LOGIN;`) and `pg_hba.conf` must allow `peer`

pgdevkit-0.2.2/pgdevkit/testdb/container.py

@@ -0,0 +1,114 @@
+from __future__ import annotations
+
+import os
+import time
+
+import docker
+import docker.errors
+import psycopg
+
+from . import constants
+
+# Candidate Docker-API-compatible socket URLs tried after plain
+# docker.from_env() (which only looks at DOCKER_HOST / the default Docker
+# socket) fails to connect -- covers rootful and rootless Podman, which
+# speaks the same API but doesn't always advertise itself via DOCKER_HOST.
+_FALLBACK_SOCKET_URLS = [
+    f"unix://{os.environ['XDG_RUNTIME_DIR']}/podman/podman.sock" if os.environ.get("XDG_RUNTIME_DIR") else None,
+    "unix:///run/podman/podman.sock",
+]
+
+
+def _client() -> docker.DockerClient:
+    """A Docker-API client, working against a real Docker daemon or a
+    Podman one (Podman exposes the same API over its own socket) -- callers
+    never need to know or care which one is actually running."""
+    try:
+        client = docker.from_env()
+        client.ping()
+        return client
+    except Exception:  # noqa: BLE001
+        pass
+    for base_url in _FALLBACK_SOCKET_URLS:
+        if base_url is None:
+            continue
+        try:
+            client = docker.DockerClient(base_url=base_url)
+            client.ping()
+            return client
+        except Exception:  # noqa: BLE001
+            continue
+    raise RuntimeError(
+        "Could not reach a Docker-compatible API. Set DOCKER_HOST, or make sure "
+        "Docker or Podman's API socket is running."
+    )
+
+
+def _available(timeout: float = 3.0) -> bool:
+    """Quick check (short timeout) for whether Postgres is already reachable
+    at HOST:PORT, so a database started outside pgdevkit's control (or the
+    container from a previous run) doesn't trigger another Docker API call."""
+    # libpq's connect_timeout is whole seconds; anything below 1 means "wait
+    # indefinitely" instead of a short timeout, so it's clamped up to 1.
+    connect_timeout = max(1, round(timeout))
+    dsn = constants.conninfo("postgres", connect_timeout=connect_timeout)
+    try:
+        with psycopg.connect(dsn):
+            return True
+    except Exception:  # noqa: BLE001
+        return False
+
+
+def _create_container(client: docker.DockerClient) -> None:
+    try:
+        client.containers.run(
+            constants.IMAGE,
+            name=constants.CONTAINER_NAME,
+            detach=True,
+            ports={"5432/tcp": constants.PORT},
+            environment={
+                "POSTGRES_USER": constants.USER,
+                "POSTGRES_PASSWORD": constants.PASSWORD,
+            },
+            command=["postgres", *constants.PG_SPEED_FLAGS],
+        )
+    except docker.errors.APIError as e:
+        if getattr(e, "status_code", None) == 409 or "already in use" in str(e):
+            client.containers.get(constants.CONTAINER_NAME).start()
+            return
+        raise RuntimeError(f"Starting the {constants.CONTAINER_NAME} container failed: {e}") from e
+
+
+def _wait_ready(timeout: float = 30.0) -> None:
+    deadline = time.monotonic() + timeout
+    dsn = constants.conninfo("postgres", connect_timeout=2)
+    last_error: Exception | None = None
+    while time.monotonic() < deadline:
+        try:
+            with psycopg.connect(dsn):
+                return
+        except Exception as e:  # noqa: BLE001
+            last_error = e
+            time.sleep(0.5)
+    raise RuntimeError(f"Postgres did not become ready within {timeout}s: {last_error}")
+
+
+def ensure_container() -> None:
+    """Idempotently ensure the shared pgdevkit-postgres container is running
+    and accepting connections. Never touches the Docker API if Postgres is
+    already reachable, or if PGDEVKIT_SKIP_CONTAINER says to assume it is."""
+    if os.environ.get("PGDEVKIT_SKIP_CONTAINER"):
+        return
+    if _available():
+        return
+    client = _client()
+    try:
+        container = client.containers.get(constants.CONTAINER_NAME)
+    except docker.errors.NotFound:
+        container = None
+    if container is not None:
+        if container.status != "running":
+            container.start()
+    else:
+        _create_container(client)
+    _wait_ready()

{pgdevkit-0.2.0 → pgdevkit-0.2.2}/pgdevkit/testdb/schema.py

@@ -63,8 +63,31 @@ _SCHEMA_QUALIFIED_TYPES = {
 }
 
 
+_DECLARE_RE = re.compile(
+    r"CREATE\s+(?:OR\s+REPLACE\s+)?(?:TABLE|VIEW|FUNCTION|PROCEDURE|TYPE|SCHEMA)\s+(\w+\.\w+)", re.IGNORECASE
+)
+_DEPEND_RE = re.compile(r"(?:FROM|JOIN|INTO|UPDATE|TABLE|ON)\s+(\w+\.\w+)", re.IGNORECASE)
+
+
+def _get_sql_deps_regex_fallback(sql: str) -> set[str]:
+    """Crude regex scan used when sqlglot can't parse a statement even with
+    error_level=IGNORE. This only feeds dependency *ordering* (which file to
+    apply first), not execution, so an imprecise-but-safe approximation here
+    is fine."""
+    declares = set(_DECLARE_RE.findall(sql))
+    deps = set(_DEPEND_RE.findall(sql))
+    return deps - declares
+
+
 def _get_sql_deps(sql: str) -> set[str]:
-    exprs = sqlglot.parse(sql, dialect="postgres")
+    try:
+        # error_level=IGNORE lets sqlglot recover from statements it can't
+        # fully parse (e.g. a schema-qualified `DROP TRIGGER ... ON
+        # schema.table`) and keep going, instead of raising and losing every
+        # other statement's dependency info in the same file.
+        exprs = sqlglot.parse(sql, dialect="postgres", error_level=sqlglot.ErrorLevel.IGNORE)
+    except Exception:  # noqa: BLE001
+        return _get_sql_deps_regex_fallback(sql)
     deps: set[str] = set()
     for e in exprs:
         if e is None:
@@ -172,54 +195,19 @@ async def _insert_test_data(
         await cur.executemany(insert_sql, rows)
 
 
-_UNSAFE_MIGRATION_PATTERNS = (
-    "DROP COLUMN",
-    "DROP TABLE",
-    "TRUNCATE",
-    "RENAME COLUMN",
-    "RENAME TO",
-    "DELETE FROM",
-    "OWNER TO",
-)
-
-
-def _is_additive_migration(sql: str) -> bool:
-    """Only pure-additive migrations (ADD COLUMN/CREATE ... IF NOT EXISTS,
-    etc.) are safe to (re-)apply against a schema that already reflects
-    later migrations — skip anything that could drop, rename, truncate, or
-    delete existing structure/data, alter an existing column, or change
-    ownership. This is a substring heuristic, not a SQL parser, so it errs
-    towards skipping (a false negative here means real data loss replayed
-    on every apply_schema() call) rather than trying to be exhaustive."""
-    normalized = sql.upper()
-    has_alter_column = "ALTER COLUMN" in normalized and "ADD COLUMN" not in normalized
-    has_unsafe_pattern = any(pattern in normalized for pattern in _UNSAFE_MIGRATION_PATTERNS)
-    return not (has_alter_column or has_unsafe_pattern)
-
-
-def _iter_migration_files(database_dir: Path):
-    """Yield every `*.sql` file in any `migrations/` subdirectory, in
-    filename order (the project's naming convention — numeric or date
-    prefixes — sorts chronologically)."""
-    for root, _, files in os.walk(database_dir):
-        if Path(root).name != "migrations":
-            continue
-        for file in sorted(files):
-            if file.endswith(".sql"):
-                yield Path(root) / file
-
-
 async def apply_schema(
     con: psycopg.AsyncConnection,
     database_dir: Path,
     extensions: tuple[str, ...] = (),
     force_reset: bool = False,
 ) -> None:
-    """Apply every .sql file under database_dir (in dependency-safe order),
-    seed any matching .test_data.json files, then apply purely-additive
-    `migrations/*.sql` files (see `_is_additive_migration`) so a schema that
-    ships changes via migration files rather than editing the base object
-    files stays in sync. Safe to call repeatedly."""
+    """Apply every .sql file under database_dir (in dependency-safe order)
+    and seed any matching .test_data.json files. Safe to call repeatedly.
+
+    `migrations/` subdirectories are never applied here — they're for
+    one-time manual application against real (already-provisioned)
+    databases, not for building a fresh schema. The base object files under
+    `database_dir` must reflect the current, final schema on their own."""
     await con.set_autocommit(True)
     for extension in extensions:
         await con.execute(SQL("CREATE EXTENSION IF NOT EXISTS {e}").format(e=Identifier(extension)))
@@ -241,15 +229,21 @@ async def apply_schema(
             logger.warning("Error executing %s (will retry): %s", file, e)
             failures.append((file, sql))
 
-    for file, sql in failures:
-        await _apply(file, sql)
-
-    for migration_file in _iter_migration_files(database_dir):
-        content = migration_file.read_text(encoding="utf-8")
-        if not _is_additive_migration(content):
-            continue
-        try:
-            await con.execute(cast(Any, content))
-            logger.info("Applied migration %s", migration_file.name)
-        except Exception as e:  # noqa: BLE001
-            logger.debug("Migration %s skipped (likely already applied): %s", migration_file.name, e)
+    # Retry the whole failed set, not just once: a single extra pass in
+    # original order can still raise on an item whose dependency is later
+    # in the same list and hasn't had its own retry yet. Every CREATE here
+    # is idempotent, so looping until a full pass makes no progress
+    # converges on any resolvable ordering without re-doing finished work.
+    while failures:
+        still_failing: list[tuple[Path, str]] = []
+        last_error: Exception | None = None
+        for file, sql in failures:
+            try:
+                await _apply(file, sql)
+            except Exception as e:  # noqa: BLE001
+                still_failing.append((file, sql))
+                last_error = e
+        if len(still_failing) == len(failures):
+            assert last_error is not None
+            raise last_error
+        failures = still_failing

{pgdevkit-0.2.0 → pgdevkit-0.2.2}/pyproject.toml

@@ -11,13 +11,14 @@ packages = ["pgdevkit"]
 
 [project]
 name = "pgdevkit"
-version = "0.2.0"
+version = "0.2.2"
 description = "A helper for developing with Postgres"
 readme = "README.md"
 requires-python = ">=3.14"
 dependencies = [
+    "docker>=7.1.0",
     "psycopg[binary]>=3.2.0",
-    "sqlglot[c]>=30.11.0",
+    "sqlglot>=30.11.0",
 ]
 
 [project.optional-dependencies]

{pgdevkit-0.2.0 → pgdevkit-0.2.2}/skills/pgdevkit/SKILL.md

@@ -73,7 +73,9 @@ def _testdb_env():
         os.environ[key] = value
 ```
 
-`ensure_testdb()` starts the shared `pgdevkit-postgres` container if needed (via `podman`), creates a database scoped to this project+branch (so different worktrees/branches never collide), and applies every `.sql` file under `database_dir` in dependency order, seeding any `.test_data.json` sidecar files.
+`ensure_testdb()` starts the shared `pgdevkit-postgres` container if needed (via the Docker API — works against a real Docker daemon or Podman's socket, no CLI binary required), creates a database scoped to this project+branch (so different worktrees/branches never collide), and applies every `.sql` file under `database_dir` in dependency order, seeding any `.test_data.json` sidecar files.
+
+**`migrations/` is never applied here, on purpose.** If the test schema is missing something, that's a sign the base `tables/`/`views`/... file has drifted behind a migration that was only ever run manually against a real database — fix the base file, don't add migration-replay to `apply_schema()` (tried once, reverted: a migration can't be judged "safe to re-run" from its SQL text alone — see `docs/database-layout.md`'s Migrations section).
 
 | What do you need? | Command |
 |---|---|
@@ -86,7 +88,7 @@ def _testdb_env():
 
 ### CI
 
-Podman needs to be available on the runner (`apt-get install -y podman` on `ubuntu-latest` if not preinstalled) — `ensure_testdb()`/`ensure_container()` shell out to it directly. There's no `PGDEVKIT_SKIP_CONTAINER` + service-container escape hatch wired through every fixture yet — if a project's CI can't run podman, it needs its own workaround for now.
+`ensure_testdb()`/`ensure_container()` talk to whatever Docker-compatible API is reachable (`DOCKER_HOST`, the default Docker socket, or Podman's socket as a fallback) — `ubuntu-latest`'s preinstalled Docker daemon just works, no setup step needed. There's no `PGDEVKIT_SKIP_CONTAINER` + service-container escape hatch wired through every fixture yet — if a project's CI has neither Docker nor Podman reachable, it needs its own workaround for now.
 
 ---
 

{pgdevkit-0.2.0 → pgdevkit-0.2.2}/tests/testdb/conftest.py

@@ -1,15 +1,25 @@
 from __future__ import annotations
 
 import os
-import shutil
 import subprocess
 from pathlib import Path
 from typing import Callable
 
 import pytest
 
+
+def _has_container_runtime() -> bool:
+    from pgdevkit.testdb.container import _client
+
+    try:
+        _client()
+        return True
+    except Exception:  # noqa: BLE001
+        return False
+
+
 requires_podman = pytest.mark.skipif(
-    shutil.which("podman") is None, reason="podman is not installed"
+    not _has_container_runtime(), reason="no Docker-compatible API reachable"
 )
 
 FIXTURES = Path(__file__).parent / "fixtures" / "database"

{pgdevkit-0.2.0 → pgdevkit-0.2.2}/tests/testdb/test_container.py

@@ -32,10 +32,10 @@ def test_ensure_container_skips_podman_when_already_available(monkeypatch):
     monkeypatch.setattr(container, "_available", lambda timeout=1.0: True)
 
     def _fail(*a, **k):
-        raise AssertionError("must not shell out to podman when already available")
+        raise AssertionError("must not touch the Docker API when already available")
 
-    monkeypatch.setattr(container, "_podman", _fail)
-    ensure_container()  # must return without calling podman
+    monkeypatch.setattr(container, "_client", _fail)
+    ensure_container()  # must return without calling the Docker API
 
 
 def test_ensure_container_skips_everything_when_skip_env_set(monkeypatch):
@@ -45,8 +45,8 @@ def test_ensure_container_skips_everything_when_skip_env_set(monkeypatch):
         raise AssertionError("must not run when PGDEVKIT_SKIP_CONTAINER is set")
 
     monkeypatch.setattr(container, "_available", _fail)
-    monkeypatch.setattr(container, "_podman", _fail)
-    ensure_container()  # must return without checking availability or calling podman
+    monkeypatch.setattr(container, "_client", _fail)
+    ensure_container()  # must return without checking availability or calling the Docker API
 
 
 def _admin_dsn() -> str:
@@ -78,7 +78,7 @@ def test_ensure_container_is_idempotent():
 def test_create_container_falls_back_to_start_when_name_in_use():
     ensure_container()  # container already exists under constants.CONTAINER_NAME
 
-    _create_container()  # "podman run" will fail with "already in use"; must fall back to "podman start"
+    _create_container(container._client())  # run will conflict; must fall back to start()
 
     with psycopg.connect(_admin_dsn()) as con:
         with con.cursor() as cur:

{pgdevkit-0.2.0 → pgdevkit-0.2.2}/tests/testdb/test_schema.py

@@ -7,34 +7,13 @@ import pytest
 
 from pgdevkit.testdb import constants
 from pgdevkit.testdb.container import ensure_container
-from pgdevkit.testdb.schema import _is_additive_migration, apply_schema
+from pgdevkit.testdb.schema import apply_schema
 from tests.testdb.conftest import RUN_SUFFIX, requires_podman
 
 FIXTURES = Path(__file__).parent / "fixtures" / "database"
 TEST_DB = f"pgdevkit_schema_selftest_{RUN_SUFFIX}"
 
 
-@pytest.mark.parametrize(
-    "sql,expected",
-    [
-        ("ALTER TABLE t ADD COLUMN IF NOT EXISTS x text;", True),
-        ("CREATE TABLE IF NOT EXISTS t (id serial primary key);", True),
-        ("CREATE INDEX IF NOT EXISTS idx ON t(x);", True),
-        ("ALTER TABLE t ALTER COLUMN x TYPE text;", False),
-        ("ALTER TABLE t DROP COLUMN x;", False),
-        ("DROP TABLE t;", False),
-        ("DROP TABLE IF EXISTS t;", False),
-        ("TRUNCATE t;", False),
-        ("ALTER TABLE t RENAME COLUMN x TO y;", False),
-        ("ALTER TABLE t RENAME TO t2;", False),
-        ("DELETE FROM t WHERE id = 1;", False),
-        ("ALTER TABLE t OWNER TO someone;", False),
-    ],
-)
-def test_is_additive_migration(sql, expected):
-    assert _is_additive_migration(sql) is expected
-
-
 def _admin_dsn() -> str:
     return constants.conninfo("postgres")
 
@@ -136,25 +115,11 @@ async def test_apply_schema_seeds_composite_enum_and_jsonb_columns(schema_test_d
 
 
 @requires_podman
-async def test_apply_schema_applies_additive_migrations(schema_test_db):
-    # app/migrations/001_add_gadget_note.sql adds a column not present in
-    # gadget.sql itself — only reachable via the migrations pass.
-    async with await psycopg.AsyncConnection.connect(_db_dsn(), autocommit=True) as con:
-        await apply_schema(con, FIXTURES)
-        async with con.cursor() as cur:
-            await cur.execute(
-                "SELECT column_name FROM information_schema.columns "
-                "WHERE table_schema = 'app' AND table_name = 'gadget' AND column_name = 'note'"
-            )
-            row = await cur.fetchone()
-    assert row is not None
-
-
-@requires_podman
-async def test_apply_schema_skips_unsafe_migrations(schema_test_db):
-    # app/migrations/002_unsafe_drop_gadget_note.sql drops the column that
-    # 001 added — apply_schema must skip it (not execute it), so the column
-    # added by 001 must still be present afterwards.
+async def test_apply_schema_never_applies_migrations_dir(schema_test_db):
+    # migrations/ is for one-time manual application against real databases,
+    # not for building a fresh schema — the base table file is the only
+    # source of truth apply_schema uses. app/migrations/001_add_gadget_note.sql
+    # adds a column that gadget.sql itself doesn't have; it must NOT appear.
     async with await psycopg.AsyncConnection.connect(_db_dsn(), autocommit=True) as con:
         await apply_schema(con, FIXTURES)
         async with con.cursor() as cur:
@@ -163,4 +128,4 @@ async def test_apply_schema_skips_unsafe_migrations(schema_test_db):
                 "WHERE table_schema = 'app' AND table_name = 'gadget' AND column_name = 'note'"
             )
             row = await cur.fetchone()
-    assert row is not None
+    assert row is None

{pgdevkit-0.2.0 → pgdevkit-0.2.2}/uv.lock

@@ -191,6 +191,20 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/c2/e6/f60198ea8d9dfa15fff9ed4ca02ce362f6eadd9ba757dcc50634c4257b63/cryptography-49.0.0-cp39-abi3-win_amd64.whl", hash = "sha256:026ac7423e6fa66872d3bf889be5974507da3944f866f704fa200eadacd00001", size = 3785547, upload-time = "2026-06-12T20:02:26.847Z" },
 ]
 
+[[package]]
+name = "docker"
+version = "7.2.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pywin32", marker = "sys_platform == 'win32'" },
+    { name = "requests" },
+    { name = "urllib3" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/88/7f/731ff914b0255d3d065f45fd4e626d4b8c95dbcbaada049f337a6ac16410/docker-7.2.0.tar.gz", hash = "sha256:cebb93773d334f778e023a7ee352a8d6e13ab1bd3b863a4d4a59dec897df43ac", size = 118731, upload-time = "2026-07-09T14:53:46.39Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/75/23/529140fe1aab80fc6992f93a706deec709140a6397439139a054e1515c45/docker-7.2.0-py3-none-any.whl", hash = "sha256:a3f45fdeb9165e2d25d9a1d02ddf3bc70fb572cf5ebbf9b58558c22caf29b71f", size = 148775, upload-time = "2026-07-09T14:53:45.224Z" },
+]
+
 [[package]]
 name = "idna"
 version = "3.18"
@@ -267,11 +281,12 @@ wheels = [
 
 [[package]]
 name = "pgdevkit"
-version = "0.2.0"
+version = "0.2.2"
 source = { editable = "." }
 dependencies = [
+    { name = "docker" },
     { name = "psycopg", extra = ["binary"] },
-    { name = "sqlglot", extra = ["c"] },
+    { name = "sqlglot" },
 ]
 
 [package.optional-dependencies]
@@ -301,11 +316,12 @@ test = [
 [package.metadata]
 requires-dist = [
     { name = "azure-identity", marker = "extra == 'azure'", specifier = ">=1.19.0" },
+    { name = "docker", specifier = ">=7.1.0" },
     { name = "psycopg", extras = ["binary"], specifier = ">=3.2.0" },
     { name = "psycopg-pool", marker = "extra == 'db'", specifier = ">=3.3.0" },
     { name = "pydantic", marker = "extra == 'db'", specifier = ">=2.0" },
     { name = "rich", marker = "extra == 'cli'", specifier = ">=13.0.0" },
-    { name = "sqlglot", extras = ["c"], specifier = ">=30.11.0" },
+    { name = "sqlglot", specifier = ">=30.11.0" },
     { name = "typer", marker = "extra == 'cli'", specifier = ">=0.26.7" },
 ]
 provides-extras = ["azure", "cli", "db"]
@@ -513,6 +529,19 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/0b/d7/1959b9648791274998a9c3526f6d0ec8fd2233e4d4acce81bbae76b44b2a/python_dotenv-1.2.2-py3-none-any.whl", hash = "sha256:1d8214789a24de455a8b8bd8ae6fe3c6b69a5e3d64aa8a8e5d68e694bbcb285a", size = 22101, upload-time = "2026-03-01T16:00:25.09Z" },
 ]
 
+[[package]]
+name = "pywin32"
+version = "312"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/fc/2b/1f3cded5822fd49c02f40544cbb5f58c7cfd6b1694869fd476cb6170ee97/pywin32-312-cp314-cp314-win32.whl", hash = "sha256:a77a90fbb6881238d2ca9c6fd797b25817f3768fe78d214a90137ff055a75f5b", size = 6468928, upload-time = "2026-06-04T07:49:43.188Z" },
+    { url = "https://files.pythonhosted.org/packages/21/82/3bf86d2e2808902013132e1ce905a7da0da53790f3836c64bf44d55e24f3/pywin32-312-cp314-cp314-win_amd64.whl", hash = "sha256:a4dd3a848290ef724347b19f301045831d8e802fa4464f491b98b1e0a081432e", size = 7024157, upload-time = "2026-06-04T07:49:45.34Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/0e/73f6d6800b4f27655abd9e9f6aaeaefcddb2b946e4674efa2bab184a7f7b/pywin32-312-cp314-cp314-win_arm64.whl", hash = "sha256:9fce94568364e0155e6dfb781ac5d95903be8baf28670632beab1b523f300daa", size = 6839598, upload-time = "2026-06-04T07:49:47.613Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/61/caa39686032d2ebdd04ff0ab5cbe163126c0066d98e00c9018646e42393b/pywin32-312-cp315-cp315-win32.whl", hash = "sha256:5c1fbe4a937a73ae9297384a3da38518cbc694c68ad8a809b2e19acd350f03ed", size = 6471159, upload-time = "2026-06-04T07:49:50.035Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/cd/7e1de64a4a6f69c04214169657ccab0d93a670ea50e35eb8f489d7378249/pywin32-312-cp315-cp315-win_amd64.whl", hash = "sha256:c2f03a0f73f804a13c2735b99392b0cd426bb4f2c4d0178e5ac966a0f21618d5", size = 7025293, upload-time = "2026-06-04T07:49:54.857Z" },
+    { url = "https://files.pythonhosted.org/packages/23/ed/4532e9388e65fa16b46776ef47ad631a64eda1631884488af707666350ed/pywin32-312-cp315-cp315-win_arm64.whl", hash = "sha256:a8597d28f267b39074aef51fa593530082b39cbe5a074226096857b1fed2dfb9", size = 6840337, upload-time = "2026-06-04T07:49:57.531Z" },
+]
+
 [[package]]
 name = "requests"
 version = "2.34.2"
@@ -559,26 +588,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/e3/86/53edf106e8cd3c883ccd0c6b470bf00ddf877a86e667665343b2d597329d/sqlglot-30.11.0-py3-none-any.whl", hash = "sha256:cffdee57d1f2f5472dc9f13087e618cf795841172b7d5ef78b63a051a52d2710", size = 698721, upload-time = "2026-06-11T17:11:35.737Z" },
 ]
 
-[package.optional-dependencies]
-c = [
-    { name = "sqlglotc" },
-]
-
-[[package]]
-name = "sqlglotc"
-version = "30.11.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "sqlglot" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/69/af/2e872cabb05e081cc9a642dab24dbd8f49648e239e86b0b4fdb34dc0c588/sqlglotc-30.11.0.tar.gz", hash = "sha256:6ce71f4d31459df966f3752848f397e254ff5d4e2772594e539e23cff0f2bbc8", size = 485462, upload-time = "2026-06-11T17:10:41.918Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/8f/f2/1d742df787a61d09fe93b9e454a8fa88ca2d73a8a5c8f9a3ad45c7993e39/sqlglotc-30.11.0-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:d49533b4a851f3603ecba9a724c32f227bca90cc0034b8a3ad66acdbde759a90", size = 31599156, upload-time = "2026-06-11T17:10:31.911Z" },
-    { url = "https://files.pythonhosted.org/packages/fb/28/81215d24dc14196f6b9f106de6522d871b0bc49666dc25b680b353b6ea11/sqlglotc-30.11.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a2cbeec4ec4591268585e5ad5f55fbee30ccd68227b5d2f77d483cdd63b65963", size = 24982016, upload-time = "2026-06-11T17:10:34.68Z" },
-    { url = "https://files.pythonhosted.org/packages/ae/4e/528b0d8d8f18edfe2b210983bf81234586b4108220d59c1fcb132bd9b594/sqlglotc-30.11.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2f4bcc7b76634171edccc13aabba9c1bea51f97caf2187daacbe433004058dc3", size = 26140612, upload-time = "2026-06-11T17:10:37.406Z" },
-    { url = "https://files.pythonhosted.org/packages/18/e5/d52b6d4e8e06c1a9771eff5886da6a4381aa624d94b5a8cc846f22a2b270/sqlglotc-30.11.0-cp314-cp314-win_amd64.whl", hash = "sha256:8c6ed84d557772880a082ef29d18b0c2cfee2d177e6528b30df2b7eaf6adb585", size = 10984419, upload-time = "2026-06-11T17:10:39.797Z" },
-]
-
 [[package]]
 name = "ty"
 version = "0.0.59"

pgdevkit-0.2.0/pgdevkit/testdb/container.py

@@ -1,89 +0,0 @@
-from __future__ import annotations
-
-import os
-import subprocess
-import time
-
-import psycopg
-
-from . import constants
-
-
-def _podman(*args: str, check: bool = True) -> subprocess.CompletedProcess:
-    return subprocess.run(["podman", *args], capture_output=True, text=True, check=check)
-
-
-def _available(timeout: float = 3.0) -> bool:
-    """Quick check (short timeout) for whether Postgres is already reachable
-    at HOST:PORT, so a database started outside pgdevkit's control (or the
-    container from a previous run) doesn't trigger another podman/docker
-    lifecycle call."""
-    # libpq's connect_timeout is whole seconds; anything below 1 means "wait
-    # indefinitely" instead of a short timeout, so it's clamped up to 1.
-    connect_timeout = max(1, round(timeout))
-    dsn = constants.conninfo("postgres", connect_timeout=connect_timeout)
-    try:
-        with psycopg.connect(dsn):
-            return True
-    except Exception:  # noqa: BLE001
-        return False
-
-
-def _container_status() -> str | None:
-    """Return 'running', 'exited', etc., or None if the container doesn't exist."""
-    result = _podman(
-        "inspect", constants.CONTAINER_NAME, "--format", "{{.State.Status}}", check=False
-    )
-    if result.returncode != 0:
-        return None
-    return result.stdout.strip()
-
-
-def _create_container() -> None:
-    result = _podman(
-        "run", "-d",
-        "--name", constants.CONTAINER_NAME,
-        "-p", f"{constants.PORT}:5432",
-        "-e", f"POSTGRES_USER={constants.USER}",
-        "-e", f"POSTGRES_PASSWORD={constants.PASSWORD}",
-        constants.IMAGE,
-        "postgres", *constants.PG_SPEED_FLAGS,
-        check=False,
-    )
-    if result.returncode != 0 and "already in use" in result.stderr:
-        _podman("start", constants.CONTAINER_NAME)
-        return
-    if result.returncode != 0:
-        raise RuntimeError(f"podman run failed: {result.stderr}")
-
-
-def _wait_ready(timeout: float = 30.0) -> None:
-    deadline = time.monotonic() + timeout
-    dsn = constants.conninfo("postgres", connect_timeout=2)
-    last_error: Exception | None = None
-    while time.monotonic() < deadline:
-        try:
-            with psycopg.connect(dsn):
-                return
-        except Exception as e:  # noqa: BLE001
-            last_error = e
-            time.sleep(0.5)
-    raise RuntimeError(f"Postgres did not become ready within {timeout}s: {last_error}")
-
-
-def ensure_container() -> None:
-    """Idempotently ensure the shared pgdevkit-postgres container is running
-    and accepting connections. Never touches podman/docker if Postgres is
-    already reachable, or if PGDEVKIT_SKIP_CONTAINER says to assume it is."""
-    if os.environ.get("PGDEVKIT_SKIP_CONTAINER"):
-        return
-    if _available():
-        return
-    status = _container_status()
-    if status == "running":
-        return
-    if status is not None:
-        _podman("start", constants.CONTAINER_NAME)
-    else:
-        _create_container()
-    _wait_ready()

pgdevkit-0.2.0/tests/testdb/fixtures/database/app/migrations/002_unsafe_drop_gadget_note.sql

@@ -1,3 +0,0 @@
--- Deliberately destructive: must be skipped by apply_schema's additive-only
--- filter, not applied. See test_apply_schema_skips_unsafe_migrations.
-ALTER TABLE app.gadget DROP COLUMN note;