sqlpush 0.1.0__py3-none-any.whl

sqlpush/core/classify.py

@@ -0,0 +1,19 @@
+# src/sqlpush/core/classify.py
+from __future__ import annotations
+
+from sqlpush.types import RiskClass
+
+SAFE = frozenset({"add_table", "add_column", "add_constraint", "create_hypertable"})
+DESTRUCTIVE = frozenset({"drop_column", "drop_table", "drop_index", "drop_constraint"})
+
+
+def classify(op_type: str) -> RiskClass:
+    """Standalone add_index targets an EXISTING table
+    (indexes of new tables ride along with add_table), so it is risky:
+    a plain CREATE INDEX takes a SHARE lock that blocks writes."""
+    if op_type in DESTRUCTIVE:
+        return RiskClass.DESTRUCTIVE
+    if op_type in SAFE:
+        return RiskClass.SAFE
+    # modify_*, add_index, raw_sql, and anything unknown
+    return RiskClass.RISKY

sqlpush/core/diff.py

@@ -0,0 +1,205 @@
+"""The ONLY module in sqlpush that imports alembic."""
+
+from __future__ import annotations
+
+import fnmatch
+import io
+from collections.abc import Sequence
+
+from alembic.autogenerate import produce_migrations
+from alembic.migration import MigrationContext
+from alembic.operations import Operations
+from alembic.operations.ops import AlterColumnOp, OpContainer
+from sqlalchemy import MetaData, text
+from sqlalchemy.engine import Engine
+
+from sqlpush.core.classify import classify
+from sqlpush.types import Plan, PlannedOperation
+
+_SYSTEM_SCHEMAS = ("_timescaledb%", "information_schema", "pg_%")
+_SYSTEM_TABLES = ("alembic_version", "spatial_ref_sys")
+
+# Leaf op class -> sqlpush op type. Class names follow alembic 1.19.1
+# autogen output as observed in docs/notes/alembic-notes.md and probes:
+# table create is CreateTableOp (not "AddTableOp"), column modify is
+# AlterColumnOp (not "ModifyColumnOp"), index create is CreateIndexOp,
+# and constraint creates are the concrete Create*ConstraintOp subclasses
+# The AddConstraintOp base class is never emitted as a leaf op.
+# AlterColumnOp is absent ON PURPOSE: its label is derived per-op (see
+# _alter_column_label) because default-only, nullable-only and type
+# changes all arrive as the same class.
+_OP_TYPE = {
+    "CreateTableOp": "add_table",
+    "DropTableOp": "drop_table",
+    "AddColumnOp": "add_column",
+    "DropColumnOp": "drop_column",
+    "CreateIndexOp": "add_index",
+    "DropIndexOp": "drop_index",
+    "CreateUniqueConstraintOp": "add_constraint",
+    "CreateForeignKeyOp": "add_constraint",
+    "CreatePrimaryKeyOp": "add_constraint",
+    "CreateCheckConstraintOp": "add_constraint",
+    "DropConstraintOp": "drop_constraint",
+}
+
+
+def _alter_column_label(op: AlterColumnOp) -> str:
+    """Precise op type for AlterColumnOp (alembic-notes Pattern C).
+
+    Sentinel semantics: ``False`` and ``None`` both mean "leave
+    unchanged"; any other value is the new setting. Default-only and
+    nullable-only drift arrive as AlterColumnOp just like type changes,
+    so disambiguate on the attributes.
+    """
+    if op.modify_server_default not in (False, None):
+        return "modify_default"
+    if op.modify_nullable not in (False, None):
+        return "modify_nullable"
+    return "modify_type"
+
+
+def _is_system_schema(schema: str) -> bool:
+    return any(fnmatch.fnmatch(schema, pat) for pat in _SYSTEM_SCHEMAS)
+
+
+def _make_include_name(schemas: frozenset[str], default_schema: str):
+    def include_name(name, type_, parent_names):
+        # Prune schemas (and everything inside them) BEFORE reflection:
+        # system catalogs (timescale et al.) are then never reflected at
+        # all. Schema filtering routes through include_name: alembic
+        # 1.19 never calls include_object with type_ == "schema", and
+        # its return value must be a real bool (falsy = exclude).
+        # NB: alembic substitutes None for the default schema name in
+        # the schema pass (compare/schema.py), so map None back.
+        if type_ == "schema":
+            schema = default_schema if name is None else name
+        else:
+            schema = parent_names.get("schema_name") or default_schema
+        return schema in schemas and not _is_system_schema(schema)
+
+    return include_name
+
+
+def _make_include(schemas: frozenset[str], default_schema: str):
+    def include_object(obj, name, type_, reflected, compare_to):
+        # Bound the diff to the target schemas on every branch: derive
+        # the object's effective schema and require membership, for
+        # reflected-only, metadata-only and both-present objects alike.
+        # Column/Index/Constraint objects have no `.schema` of their own
+        # (SQLAlchemy 2.0.52): they resolve it through the parent table.
+        schema = (
+            getattr(obj, "schema", None)
+            or getattr(getattr(obj, "table", None), "schema", None)
+            or default_schema
+        )
+        if schema not in schemas or _is_system_schema(schema):
+            return False
+        if reflected and compare_to is None:
+            # DB-only object: skip system tables. NB: alembic also
+            # auto-excludes its own version table from autogen; the
+            # name check here is defense in depth.
+            return name not in _SYSTEM_TABLES
+        return True
+
+    return include_object
+
+
+def _flatten(ops):
+    # D1 (alembic-notes): ops targeting existing tables arrive wrapped in
+    # ModifyTableOps containers; Operations.invoke crashes on containers,
+    # so recurse into anything that is an OpContainer before invoking.
+    for op in ops:
+        if isinstance(op, OpContainer):
+            yield from _flatten(op.ops)
+        else:
+            yield op
+
+
+def _render_op_sql(op, engine: Engine) -> str:
+    buf = io.StringIO()
+    offline = MigrationContext.configure(
+        dialect=engine.dialect, opts={"as_sql": True, "output_buffer": buf}
+    )
+    operations = Operations(offline)
+    operations.invoke(op)
+    # offline render terminates each op with ";\n\n"; normalize so each
+    # PlannedOperation.sql is a single clean statement
+    return buf.getvalue().strip().rstrip(";")
+
+
+class DiffEngine:
+    def plan(
+        self,
+        metadata: MetaData,
+        engine: Engine,
+        *,
+        schemas: Sequence[str] | None = None,
+        exclude: Sequence[str] = (),
+    ) -> Plan:
+        if schemas is None:
+            with engine.connect() as conn:
+                search_path = conn.execute(text("SHOW search_path")).scalar()
+                # a live PG session always reports a search_path
+                assert search_path is not None
+                schemas = [
+                    s.strip()
+                    for s in search_path.split(",")
+                    if s.strip() and s.strip() != '"$user"'
+                ]
+        # New binding rather than a param reassignment: frozenset is a
+        # Set, not a Sequence, and the helpers below declare the exact
+        # type they take.
+        schema_set = frozenset(schemas)
+        exclude = tuple(exclude)
+        # Typed `str | None` by SQLAlchemy; a dialect without a default
+        # schema is meaningless for this PostgreSQL-only tool; "public"
+        # matches every supported server config.
+        default_schema = engine.dialect.default_schema_name or "public"
+
+        opts = {
+            "compare_type": True,
+            "compare_server_default": True,
+            "include_name": _make_include_name(schema_set, default_schema),
+            "include_object": _make_include(schema_set, default_schema),
+            "include_schemas": True,
+        }
+        with engine.connect() as conn:
+            ctx = MigrationContext.configure(conn, opts=opts)
+            script = produce_migrations(ctx, metadata)
+
+        # produce_migrations always builds the upgrade bundle
+        assert script.upgrade_ops is not None
+        ops: list[PlannedOperation] = []
+        for op in _flatten(script.upgrade_ops.ops):
+            ops.extend(self._translate(op, engine, exclude))
+        return Plan(operations=tuple(ops))
+
+    def _translate(self, op, engine: Engine, exclude: tuple[str, ...]) -> list[PlannedOperation]:
+        op_type = _OP_TYPE.get(type(op).__name__, "raw_sql")
+        if isinstance(op, AlterColumnOp):
+            op_type = _alter_column_label(op)
+        sql_text = _render_op_sql(op, engine)
+        table = getattr(getattr(op, "table", None), "name", None) or getattr(op, "table_name", None)
+        # AddColumnOp carries a real Column in `.column`; DropColumnOp and
+        # AlterColumnOp only expose the plain string `column_name`
+        # (alembic-notes op reference).
+        column = getattr(getattr(op, "column", None), "name", None) or getattr(
+            op, "column_name", None
+        )
+        # table-level patterns reach column-level ops too; a qualified
+        # table.column pattern suppresses only that specific column op
+        if table and any(fnmatch.fnmatch(table, pat) for pat in exclude):
+            return []
+        if table and column:
+            full = f"{table}.{column}"
+            if any(fnmatch.fnmatch(full, pat) for pat in exclude):
+                return []
+        return [
+            PlannedOperation(
+                type=op_type,
+                risk=classify(op_type),
+                sql=sql_text,
+                table=table,
+                column=column,
+            )
+        ]

sqlpush/core/render.py

@@ -0,0 +1,21 @@
+# src/sqlpush/core/render.py
+from __future__ import annotations
+
+from sqlpush.types import Plan, RiskClass
+
+_HEADERS = {
+    RiskClass.SAFE: "-- safe",
+    RiskClass.RISKY: "-- risky",
+    RiskClass.DESTRUCTIVE: "-- destructive",
+}
+
+
+def render(plan: Plan) -> str:
+    if not plan.operations:
+        return ""
+    sections: list[str] = []
+    for risk in (RiskClass.SAFE, RiskClass.RISKY, RiskClass.DESTRUCTIVE):
+        sqls = [op.sql for op in plan.operations if op.risk is risk]
+        if sqls:
+            sections.append(_HEADERS[risk] + "\n" + ";\n".join(sqls) + ";")
+    return "\n\n".join(sections)

sqlpush/directives/timescale.py

@@ -0,0 +1,79 @@
+# src/sqlpush/directives/timescale.py
+from __future__ import annotations
+
+from sqlalchemy import MetaData, text
+from sqlalchemy.engine import Connection, Engine
+from sqlalchemy.exc import ProgrammingError
+
+from sqlpush.annotations import HYPERTABLE_KEY
+from sqlpush.types import PlannedOperation, RiskClass
+
+
+def _is_hypertable(conn: Connection, table_name: str) -> bool:
+    try:
+        return bool(
+            conn.execute(
+                text(
+                    "SELECT 1 FROM timescaledb_information.hypertables "
+                    "WHERE hypertable_name = :name"
+                ),
+                {"name": table_name},
+            ).scalar()
+        )
+    except ProgrammingError:
+        # timescaledb_information views exist only where the extension
+        # is installed: on a non-timescale DB nothing can be a
+        # hypertable. Emit the op and let apply surface the server's
+        # own error: annotated models on non-timescale DBs are user
+        # error, not a state probe failure.
+        return False
+
+
+def _lit(value: str) -> str:
+    # single-quoted SQL literal escaping: ' -> '' (defense in depth
+    # against quote break-out via table/column names from user metadata)
+    return value.replace("'", "''")
+
+
+def hypertable_operations(
+    metadata: MetaData, engine: Engine | None = None
+) -> list[PlannedOperation]:
+    """Plan ``create_hypertable`` ops for ``@hypertable``-annotated tables.
+
+    ``engine=None`` emits unconditionally (DB-free preview/tests keep
+    the previous behavior). With ``engine``, a table already registered
+    in ``timescaledb_information.hypertables`` emits nothing: push stays
+    idempotent and ``check()`` reports clean on a synced annotated
+    schema: directives are state-aware like the diff.
+    """
+    pending = [
+        table for table in metadata.tables.values() if table.info.get(HYPERTABLE_KEY) is not None
+    ]
+    if engine is not None and pending:
+        with engine.connect() as conn:
+            pending = [t for t in pending if not _is_hypertable(conn, t.name)]
+    ops: list[PlannedOperation] = []
+    for table in pending:
+        info = table.info[HYPERTABLE_KEY]
+        name = _lit(table.name)
+        time_column = _lit(info.time_column)
+        parts = [f"SELECT create_hypertable('{name}', '{time_column}'"]
+        if info.chunk_time_interval:
+            parts.append(f", chunk_time_interval => INTERVAL '{_lit(info.chunk_time_interval)}'")
+        parts.append(", migrate_data => true")
+        # if_not_exists: race insurance between the state check above
+        # and the apply. create_default_indexes=false: timescale's
+        # implicit time-column index is invisible to metadata, so the
+        # default would drift forever (destructive drop_index) on a
+        # fully synced schema; users declare wanted indexes in the
+        # Table instead (metadata is the source of truth).
+        parts.append(", if_not_exists => true, create_default_indexes => false)")
+        ops.append(
+            PlannedOperation(
+                type="create_hypertable",
+                risk=RiskClass.SAFE,
+                sql="".join(parts) + ";",
+                table=table.name,
+            )
+        )
+    return ops

sqlpush/types.py

@@ -0,0 +1,100 @@
+# src/sqlpush/types.py
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import Enum
+from typing import Any
+
+
+class RiskClass(str, Enum):
+    SAFE = "safe"
+    RISKY = "risky"
+    DESTRUCTIVE = "destructive"
+
+
+@dataclass(frozen=True)
+class PlannedOperation:
+    type: str
+    risk: RiskClass
+    sql: str
+    table: str | None = None
+    column: str | None = None
+
+
+@dataclass(frozen=True)
+class Plan:
+    operations: tuple[PlannedOperation, ...] = ()
+
+    @property
+    def drift(self) -> bool:
+        return bool(self.operations)
+
+    @property
+    def has_destructive(self) -> bool:
+        return any(op.risk is RiskClass.DESTRUCTIVE for op in self.operations)
+
+    def to_json_dict(self) -> dict[str, Any]:
+        return {
+            "version": 1,
+            "drift": self.drift,
+            "operations": [
+                {
+                    "type": op.type,
+                    "risk": op.risk.value,
+                    "table": op.table,
+                    "column": op.column,
+                    "sql": op.sql,
+                }
+                for op in self.operations
+            ],
+            "sql": ";\n".join(op.sql for op in self.operations),
+        }
+
+
+@dataclass(frozen=True)
+class CheckResult:
+    clean: bool
+    drift: bool
+    has_destructive: bool
+
+
+@dataclass(frozen=True)
+class AppliedOperation:
+    type: str
+    # execution outcome only: "applied" | "failed". Blocked operations
+    # are refused by the gate before execution and live in
+    # Report.blocked instead.
+    status: str
+
+
+@dataclass(frozen=True)
+class Report:
+    # `applied` is the EXECUTION TRAIL of the run: it may contain
+    # "failed" entries (a CONCURRENTLY op that errored, see
+    # partial_failure), not only successes.
+    applied: tuple[AppliedOperation, ...] = ()
+    # `blocked`: destructive ops refused by the gate (allow_destructive=False)
+    # Hard stop, CLI maps this to exit 1.
+    # `skipped`: ops declined by policy (safe_only), informational only,
+    # the run proceeds without them.
+    blocked: tuple[PlannedOperation, ...] = ()
+    skipped: tuple[PlannedOperation, ...] = ()
+    partial_failure: bool = False
+    duration: float = 0.0
+
+
+class SqlpushError(Exception):
+    pass
+
+
+class ConnectFailed(SqlpushError):
+    pass
+
+
+class MetadataImportError(SqlpushError):
+    pass
+
+
+class DestructiveBlocked(SqlpushError):
+    """Reserved for future use: the destructive gate currently reports
+    through ``Report.blocked`` instead of raising."""

sqlpush-0.1.0.dist-info/METADATA

@@ -0,0 +1,215 @@
+Metadata-Version: 2.4
+Name: sqlpush
+Version: 0.1.0
+Summary: Schema lifecycle tool for production PostgreSQL/TimescaleDB on SQLAlchemy 2.0 (SQLModel included): diff, push and check schema drift straight from your models
+Keywords: sqlalchemy,alembic,postgresql,timescaledb,prisma,schema,migrations,database,drift,cli
+Author: Juan Miguel Contreras
+Author-email: Juan Miguel Contreras <19253629+juanmicl@users.noreply.github.com>
+License-Expression: MIT
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Database
+Classifier: Topic :: Software Development :: Quality Assurance
+Requires-Dist: alembic>=1.18,<2
+Requires-Dist: psycopg[binary]>=3.2
+Requires-Dist: sqlalchemy>=2.0
+Requires-Dist: typer>=0.12
+Requires-Python: >=3.10
+Project-URL: Homepage, https://github.com/juanmicl/sqlpush
+Project-URL: Repository, https://github.com/juanmicl/sqlpush
+Project-URL: Issues, https://github.com/juanmicl/sqlpush/issues
+Project-URL: Changelog, https://github.com/juanmicl/sqlpush/blob/main/CHANGELOG.md
+Description-Content-Type: text/markdown
+
+# sqlpush
+
+[![CI](https://github.com/juanmicl/sqlpush/actions/workflows/ci.yml/badge.svg?style=for-the-badge)](https://github.com/juanmicl/sqlpush/actions/workflows/ci.yml)
+[![PyPI](https://img.shields.io/pypi/v/sqlpush?style=for-the-badge)](https://pypi.org/project/sqlpush/)
+[![Python](https://img.shields.io/pypi/pyversions/sqlpush?style=for-the-badge)](https://pypi.org/project/sqlpush/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg?style=for-the-badge)](LICENSE)
+
+**Prisma `db push` for SQLAlchemy.** Apply your models (SQLAlchemy,
+SQLModel, anything built on `MetaData`) to a live PostgreSQL / TimescaleDB
+database directly, no migration files. sqlpush
+diffs your models against the real schema, classifies every operation by
+risk (safe / risky / destructive), and applies the plan atomically. Drift
+checks exit with codes your CI can gate on.
+
+```console
+sqlpush diff "myapp.models:metadata"      # see the SQL, ordered by risk
+sqlpush check "myapp.models:metadata"     # CI gate: exit 0/2/3
+sqlpush push "myapp.models:metadata"      # apply (destructive gated)
+```
+
+If you've ever run `Base.metadata.create_all()` in production and known it
+was wrong, then sighed at the migration-script treadmill when you reached
+for alembic: sqlpush is for you.
+
+## Why
+
+Declarative models are already the source of truth. Migration files
+re-encode what the models say, drift from them, and pile up forever.
+sqlpush closes the loop the way Prisma's `db push` does for its schema
+language, but for the SQLAlchemy ecosystem (SQLModel included):
+
+- **No migration files, ever.** The diff *is* the migration: computed fresh
+  from models vs. live database on every run, via alembic's autogenerate
+  engine used as a library.
+- **Risk-aware by default.** Every operation is classified `safe` /
+  `risky` / `destructive`. Destructive ops (drops) are **blocked until
+  `--allow-destructive`**: nothing executes at all while any is present.
+- **Drift detection built for CI.** `check` plans once and exits `0` clean /
+  `2` drift / `3` destructive drift, scriptable without parsing output.
+  `--json` emits a stable versioned contract.
+- **Safe under concurrency.** An advisory lock (keyed to the database, not
+  the DSN) coordinates workers: one pusher at a time, losers wait bounded
+  and re-verify, so deploy pipelines can race without corrupting anything.
+- **Hypertables without hand-written SQL.** Decorate a model with
+  `@hypertable` and the `create_hypertable` directive is planned
+  state-aware: idempotent pushes, clean checks, no false drift.
+
+PostgreSQL only, by design.
+
+## Install
+
+```console
+pip install sqlpush
+```
+
+Or from source:
+
+```console
+git clone https://github.com/juanmicl/sqlpush && cd sqlpush && uv sync
+```
+
+## The 30-second tour
+
+Point sqlpush at your metadata (`module:attribute`) and a database
+(`--dsn` or `$DATABASE_URL`):
+
+```console
+$ export DATABASE_URL="postgresql+psycopg://user:pass@host:5432/db"
+
+$ sqlpush diff "myapp.models:metadata"
+-- safe
+
+CREATE TABLE hero (
+    id SERIAL NOT NULL PRIMARY KEY,
+    name VARCHAR(50) NOT NULL
+);
+
+-- risky
+
+CREATE INDEX ix_hero_name ON hero (name);
+```
+
+Push it (the destructive gate is on by default):
+
+```console
+$ sqlpush push "myapp.models:metadata"
+1 destructive operation(s) blocked; re-run with --allow-destructive
+$ echo $?
+1
+
+$ sqlpush push "myapp.models:metadata" --allow-destructive
+$ echo $?
+0
+```
+
+In CI, check drift and fail loudly (see exit codes below). Limit scope with
+repeated `--schema` / `--exclude` options.
+
+## Exit codes
+
+| verb | 0 | 1 | 2 | 3 |
+| --- | --- | --- | --- | --- |
+| `diff` | always | | | |
+| `check` | clean | | drift | destructive drift |
+| `push` | applied | destructive blocked | error (incl. partial failure) | |
+
+`push --safe-only` runs only safe operations and skips the rest
+informationally (exit `0`). A failed `CREATE INDEX CONCURRENTLY` marks the
+run as partial failure (exit `2`) instead of silently half-applying.
+
+## FastAPI / SQLModel: replace `create_all`
+
+```python
+from contextlib import asynccontextmanager
+from sqlpush import aensure_schema
+
+
+@asynccontextmanager
+async def lifespan(app):
+    await aensure_schema(SQLModel.metadata, engine, mode="check")
+    yield
+```
+
+Push in the deploy pipeline, check at startup.
+
+## How it works
+
+```mermaid
+flowchart LR
+    models["SQLAlchemy MetaData"] --> diff["diff<br>alembic autogenerate, scoped"]
+    db[("live PostgreSQL")] --> diff
+    diff --> risk["risk classification<br>safe / risky / destructive"]
+    risk --> plan["plan"]
+    plan --> render["render"]
+    render --> apply["apply<br>atomic txn · CONCURRENTLY split · advisory lock"]
+    apply --> report["report"]
+```
+
+- **Diff engine** scopes reflection to your target schemas (default: the
+  session's real `search_path`) and prunes system catalogs (TimescaleDB
+  internals included) before reflection even starts.
+- **Classifier** maps each operation to a risk class; unknown operations
+  are `risky`, never silently safe.
+- **Executor** splits the plan: `CONCURRENTLY` statements run one-per-
+  transaction on autocommit, everything else applies in a single atomic
+  transaction with a bounded `lock_timeout`.
+- **Typed errors**: only `SqlpushError` / `ConnectFailed` /
+  `MetadataImportError` escape the API, never raw driver exceptions.
+
+## Comparison
+
+An honest view of the neighborhood (stars as of 2026-08):
+
+| | migration files | source of truth | risk gate | CI drift exit codes | TimescaleDB |
+| --- | --- | --- | --- | --- | --- |
+| **sqlpush** | none (the diff is the migration) | SQLAlchemy `MetaData` | classified safe/risky/destructive, destructive blocked by default | `check` 0/2/3 | `@hypertable` directives |
+| [alembic](https://github.com/sqlalchemy/alembic) (4.4k★) | yes | migration scripts (autogenerate assists) | no | no | no |
+| [atlas](https://github.com/ariga/atlas) (8.7k★) | optional (HCL) | HCL / SQL (ORMs via providers) | lint policies | yes | no |
+| [prisma `db push`](https://www.prisma.io/docs/orm/reference/prisma-cli-reference) (47k★) | none | Prisma schema (Node/TS) | no | no | no |
+| [migra](https://github.com/djrobstep/migra) (3.1k★) | diff only | SQL | n/a | partial | no (*deprecated*) |
+
+sqlpush is narrower than atlas and younger than alembic, deliberately.
+It is one tool for one job: keep a PostgreSQL schema in lockstep with
+SQLAlchemy models, safely enough to run from CI.
+
+Coming from [migra](https://github.com/djrobstep/migra) (now
+deprecated)? There is a [migration guide](docs/migrating-from-migra.md).
+
+## Design notes
+
+- `import sqlpush` stays light: the public API loads lazily, so the
+  annotations module carries none of alembic/typer/psycopg.
+- The advisory-lock key derives from the database OID: two DSN spellings
+  of the same database contend for the same lock.
+- `--json` output is a versioned contract (`"version": 1`) meant for
+  tooling; additive changes only within a version.
+
+## Roadmap (0.1.x)
+
+- `CREATE INDEX CONCURRENTLY` by default for indexes on existing tables
+- asyncpg DSN translation in `ensure_schema(AsyncEngine)`
+- jsonschema-validated `--json` output
+
+## License
+
+[MIT](LICENSE) · © 2026 Juan Miguel Contreras

sqlpush-0.1.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+sqlpush/__init__.py,sha256=Px0jJFHbwwM1-UHtDwD3xQlRifEMW4StSXQs5DD9z6w,1697
+sqlpush/annotations.py,sha256=AKK4t30lRznTFUfDYaH9r8WslHzzVs57GNtZGHxS8LM,1222
+sqlpush/api.py,sha256=n4NcrdmUWqu8TJluph61F2swEIJkZs0PQcFExzcebqU,5291
+sqlpush/apply/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sqlpush/apply/executor.py,sha256=-HgmscUO6M_xQ5HPBQhJkUo6XwEPPqBig7_G9aWQJAU,7242
+sqlpush/cli.py,sha256=UeyBnixEz1s6nf4Wv4Y7zrmce8y02pqfHCy2_brjg_Q,7388
+sqlpush/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sqlpush/core/classify.py,sha256=3NgoaheRgO6AfjtXm9ndvvUq-Ei1BvYKX03o3kkdgZA,718
+sqlpush/core/diff.py,sha256=g5e2kwKdu88k24S6lFNSPxxNDxeq55Yo22lLTPIXnvU,8381
+sqlpush/core/render.py,sha256=9SNEyHOGmMxKUfIjvo3x0MNVQ6N2o2fl3noWT1EWO3M,609
+sqlpush/directives/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sqlpush/directives/timescale.py,sha256=Z1X7A6o8-wVTTe8aJLzXC_ko2OP_i8-LaEmgSzy7mYg,3210
+sqlpush/types.py,sha256=D2FV3eJZt0znXpZLV8ZRFQr7mIoNKjai4C7zPL71fdE,2502
+sqlpush-0.1.0.dist-info/WHEEL,sha256=ZFFp7t7R4RYQ5KYZkmiFWoQvHay7SrTmn-6ZYfoFZ3U,80
+sqlpush-0.1.0.dist-info/entry_points.txt,sha256=VYha3PJSvklRgpcDAZYJdE66EXM79MSKQf0z8igyAOI,46
+sqlpush-0.1.0.dist-info/METADATA,sha256=gqo6pjZ06bLySmE8MRXze-_5uiu2-ZYS8mpy7iJw7wI,8535
+sqlpush-0.1.0.dist-info/RECORD,,

sqlpush-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.12.7
+Root-Is-Purelib: true
+Tag: py3-none-any

sqlpush-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+sqlpush = sqlpush.cli:main
+