delembic 0.2.0__py3-none-any.whl

delembic/__init__.py

@@ -0,0 +1,4 @@
+from delembic.migration import DataMigration
+
+__version__ = "0.2.0"
+__all__ = ["DataMigration"]

delembic/alembic_compat.py

@@ -0,0 +1,65 @@
+from pathlib import Path
+
+import sqlalchemy as sa
+
+
+class AlembicDepsError(Exception):
+    pass
+
+
+def get_alembic_applied_revisions(conn: sa.Connection, alembic_ini: Path) -> set[str]:
+    """
+    Walk Alembic script history from current heads back to base.
+    Returns all revision IDs that have been applied (i.e. are ancestors of current heads).
+    Requires alembic to be installed.
+    """
+    try:
+        from alembic.config import Config as AlembicConfig
+        from alembic.runtime.migration import MigrationContext
+        from alembic.script import ScriptDirectory
+    except ImportError:
+        raise AlembicDepsError(
+            "alembic package not installed. Run: pip install alembic"
+        )
+
+    alembic_cfg = AlembicConfig(str(alembic_ini))
+    script = ScriptDirectory.from_config(alembic_cfg)
+    ctx = MigrationContext.configure(conn)
+    current_heads = ctx.get_current_heads()
+
+    applied: set[str] = set()
+    for head in current_heads:
+        for rev in script.iterate_revisions(head, "base"):
+            applied.add(rev.revision)
+
+    return applied
+
+
+def get_current_heads(conn: sa.Connection) -> list[str]:
+    """Return the current Alembic head revision IDs from alembic_version table."""
+    try:
+        from alembic.runtime.migration import MigrationContext
+    except ImportError:
+        raise AlembicDepsError(
+            "alembic package not installed. Run: pip install alembic"
+        )
+
+    ctx = MigrationContext.configure(conn)
+    return list(ctx.get_current_heads())
+
+
+def check_alembic_deps(
+    conn: sa.Connection,
+    alembic_ini: Path,
+    required: list[str],
+    migration_revision: str,
+) -> None:
+    """Raise AlembicDepsError if any required Alembic revision has not been applied."""
+    applied = get_alembic_applied_revisions(conn, alembic_ini)
+    missing = [rev for rev in required if rev not in applied]
+    if missing:
+        raise AlembicDepsError(
+            f"Migration {migration_revision} requires Alembic revision(s) "
+            f"{', '.join(missing)} to be applied first. "
+            f"Run 'alembic upgrade head' (or to the required revision) before retrying."
+        )

delembic/cli.py

@@ -0,0 +1,199 @@
+import re
+import string
+from pathlib import Path
+
+import click
+import sqlalchemy as sa
+
+from delembic.config import Config, find_config
+from delembic.db import ensure_tables, get_applied, history_table, version_table
+from delembic.executor import run_upgrade
+from delembic.registry import load_migrations
+
+_INI_TEMPLATE = """\
+[delembic]
+script_location = delembic
+sqlalchemy.url = postgresql+psycopg://user:pass@localhost/mydb
+alembic_config = alembic.ini
+"""
+
+_ENV_TEMPLATE = """\
+from sqlalchemy import create_engine
+
+# Configure your database URL here or load from environment variables
+DATABASE_URL = "postgresql+psycopg://user:pass@localhost/mydb"
+
+
+def get_engine():
+    return create_engine(DATABASE_URL)
+"""
+
+_MIGRATION_TEMPLATE = """\
+from delembic import DataMigration
+
+
+class $class_name(DataMigration):
+
+    revision = "$revision"
+
+    depends_on = $depends_on
+
+    description = "$description"
+
+    def upgrade(self, conn):
+        pass
+
+    def validate(self, conn):
+        pass
+"""
+
+
+@click.group()
+def cli() -> None:
+    """Delembic — data migration framework."""
+
+
+@cli.command()
+@click.argument("directory", default="delembic")
+def init(directory: str) -> None:
+    """Initialize a new delembic project in the current directory.
+
+    DIRECTORY is the folder name for migration scripts (default: delembic).
+    """
+    cwd = Path.cwd()
+    ini_path = cwd / "delembic.ini"
+    script_dir = cwd / directory
+    versions_dir = script_dir / "versions"
+
+    if ini_path.exists():
+        raise click.ClickException("delembic.ini already exists.")
+
+    ini_content = _INI_TEMPLATE.replace("script_location = delembic", f"script_location = {directory}")
+
+    versions_dir.mkdir(parents=True, exist_ok=True)
+    ini_path.write_text(ini_content)
+    (script_dir / "env.py").write_text(_ENV_TEMPLATE)
+    (versions_dir / ".gitkeep").touch()
+
+    click.echo(f"Created {ini_path}")
+    click.echo(f"Created {script_dir / 'env.py'}")
+    click.echo(f"Created {versions_dir}/")
+    click.echo("\nEdit delembic.ini and set sqlalchemy.url before running migrations.")
+
+
+@cli.command()
+@click.option("-m", "--message", required=True, help="Short description of this migration.")
+def revision(message: str) -> None:
+    """Generate a new migration file."""
+    from delembic.alembic_compat import AlembicDepsError, get_current_heads
+
+    cfg = find_config()
+    cfg.versions_dir.mkdir(parents=True, exist_ok=True)
+
+    alembic_heads: list[str] = []
+    if cfg.alembic_config:
+        try:
+            engine = cfg.engine()
+            with engine.connect() as conn:
+                alembic_heads = get_current_heads(conn)
+        except AlembicDepsError as e:
+            click.echo(f"Warning: could not read Alembic heads: {e}", err=True)
+        except Exception as e:
+            click.echo(f"Warning: could not connect to DB for Alembic heads: {e}", err=True)
+
+    next_id = _next_revision_id(cfg.versions_dir)
+    slug = re.sub(r"[^a-z0-9]+", "_", message.lower()).strip("_")
+    filename = f"{next_id}_{slug}.py"
+    class_name = "".join(word.title() for word in slug.split("_"))
+    content = string.Template(_MIGRATION_TEMPLATE).substitute(
+        class_name=class_name,
+        revision=next_id,
+        description=message,
+        depends_on=repr(alembic_heads),
+    )
+    path = cfg.versions_dir / filename
+    path.write_text(content)
+    if alembic_heads:
+        click.echo(f"  Alembic heads captured: {alembic_heads}")
+    click.echo(f"Created {path}")
+
+
+@cli.command()
+@click.argument("target", default="head")
+def upgrade(target: str) -> None:
+    """Run unapplied migrations up to TARGET (default: head)."""
+    cfg = find_config()
+    engine = cfg.engine()
+    run_upgrade(engine, cfg.versions_dir, target, alembic_ini=cfg.alembic_config)
+
+
+@cli.command()
+def current() -> None:
+    """Show the most recently applied revision."""
+    cfg = find_config()
+    engine = cfg.engine()
+    with engine.connect() as conn:
+        try:
+            ensure_tables(conn)
+            conn.commit()
+            row = conn.execute(
+                sa.select(version_table.c.revision, version_table.c.applied_at)
+                .where(version_table.c.status == "success")
+                .order_by(version_table.c.applied_at.desc())
+                .limit(1)
+            ).fetchone()
+        except Exception as e:
+            raise click.ClickException(str(e))
+
+    if row:
+        click.echo(f"{row[0]}  (applied {row[1]})")
+    else:
+        click.echo("No migrations applied yet.")
+
+
+@cli.command()
+def history() -> None:
+    """List all migrations and their status."""
+    cfg = find_config()
+    migrations = load_migrations(cfg.versions_dir)
+
+    engine = cfg.engine()
+    with engine.connect() as conn:
+        try:
+            ensure_tables(conn)
+            conn.commit()
+            applied = get_applied(conn)
+            failed_rows = conn.execute(
+                sa.select(version_table.c.revision)
+                .where(version_table.c.status == "failed")
+            )
+            failed = {row[0] for row in failed_rows}
+        except Exception as e:
+            raise click.ClickException(str(e))
+
+    if not migrations:
+        click.echo("No migrations found.")
+        return
+
+    from delembic.dag import topological_sort
+    order = topological_sort(migrations)
+
+    for rev in order:
+        cls = migrations[rev]
+        if rev in applied:
+            status = "applied "
+        elif rev in failed:
+            status = "failed  "
+        else:
+            status = "pending "
+        click.echo(f"{status}  {rev}  {cls.description}")
+
+
+def _next_revision_id(versions_dir: Path) -> str:
+    existing = list(versions_dir.glob("D*.py"))
+    max_n = 0
+    for p in existing:
+        m = re.match(r"D(\d+)", p.stem)
+        if m:
+            max_n = max(max_n, int(m.group(1)))
+    return f"D{max_n + 1:03d}"

delembic/config.py

@@ -0,0 +1,38 @@
+import configparser
+from pathlib import Path
+
+import sqlalchemy as sa
+
+
+class Config:
+    def __init__(self, ini_path: Path):
+        self.ini_path = ini_path.resolve()
+        cp = configparser.ConfigParser()
+        cp.read(self.ini_path)
+        self.script_location = Path(cp.get("delembic", "script_location", fallback="delembic"))
+        self.url = cp.get("delembic", "sqlalchemy.url", fallback="")
+        _alembic_raw = cp.get("delembic", "alembic_config", fallback="")
+        self.alembic_config: Path | None = (
+            (self.ini_path.parent / _alembic_raw) if _alembic_raw else None
+        )
+
+    @property
+    def versions_dir(self) -> Path:
+        return self.ini_path.parent / self.script_location / "versions"
+
+    def engine(self) -> sa.Engine:
+        if not self.url:
+            raise RuntimeError("sqlalchemy.url not set in delembic.ini")
+        return sa.create_engine(self.url)
+
+
+def find_config() -> Config:
+    """Walk up from cwd looking for delembic.ini."""
+    cwd = Path.cwd()
+    for directory in [cwd, *cwd.parents]:
+        candidate = directory / "delembic.ini"
+        if candidate.exists():
+            return Config(candidate)
+    raise FileNotFoundError(
+        "delembic.ini not found. Run 'delembic init' first."
+    )

delembic/dag.py

@@ -0,0 +1,37 @@
+from typing import Type
+
+from delembic.migration import DataMigration
+
+
+class CycleError(Exception):
+    pass
+
+
+def topological_sort(migrations: dict[str, Type[DataMigration]]) -> list[str]:
+    """Return revision IDs in dependency-safe execution order (Kahn's algorithm)."""
+    in_degree: dict[str, int] = {rev: 0 for rev in migrations}
+    dependents: dict[str, list[str]] = {rev: [] for rev in migrations}
+
+    for rev, cls in migrations.items():
+        for dep in cls.depends_on:
+            if dep not in migrations:
+                # External dep (e.g. Alembic revision) — skip in sort, validate at runtime
+                continue
+            in_degree[rev] += 1
+            dependents[dep].append(rev)
+
+    queue = sorted(rev for rev, deg in in_degree.items() if deg == 0)
+    order: list[str] = []
+
+    while queue:
+        node = queue.pop(0)
+        order.append(node)
+        for dependent in sorted(dependents.get(node, [])):
+            in_degree[dependent] -= 1
+            if in_degree[dependent] == 0:
+                queue.append(dependent)
+
+    if len(order) != len(migrations):
+        raise CycleError("Cycle detected in migration dependency graph")
+
+    return order

delembic/db.py

@@ -0,0 +1,75 @@
+from datetime import datetime, timezone
+
+import sqlalchemy as sa
+
+_metadata = sa.MetaData()
+
+version_table = sa.Table(
+    "delembic_version",
+    _metadata,
+    sa.Column("revision", sa.Text, primary_key=True),
+    sa.Column("applied_at", sa.DateTime(timezone=True)),
+    sa.Column("status", sa.Text),
+    sa.Column("execution_time_seconds", sa.Float),
+)
+
+history_table = sa.Table(
+    "delembic_run_history",
+    _metadata,
+    sa.Column("id", sa.Integer, primary_key=True, autoincrement=True),
+    sa.Column("revision", sa.Text),
+    sa.Column("started_at", sa.DateTime(timezone=True)),
+    sa.Column("ended_at", sa.DateTime(timezone=True)),
+    sa.Column("duration_seconds", sa.Float),
+    sa.Column("status", sa.Text),
+    sa.Column("exception", sa.Text),
+    sa.Column("username", sa.Text),
+    sa.Column("hostname", sa.Text),
+)
+
+
+def ensure_tables(conn: sa.Connection) -> None:
+    _metadata.create_all(conn, checkfirst=True)
+
+
+def get_applied(conn: sa.Connection) -> set[str]:
+    rows = conn.execute(
+        sa.select(version_table.c.revision).where(version_table.c.status == "success")
+    )
+    return {row[0] for row in rows}
+
+
+def record_result(
+    conn: sa.Connection,
+    revision: str,
+    started_at: datetime,
+    ended_at: datetime,
+    duration: float,
+    status: str,
+    exception: str | None = None,
+    username: str | None = None,
+    hostname: str | None = None,
+) -> None:
+    conn.execute(
+        sa.delete(version_table).where(version_table.c.revision == revision)
+    )
+    conn.execute(
+        sa.insert(version_table).values(
+            revision=revision,
+            applied_at=ended_at,
+            status=status,
+            execution_time_seconds=duration,
+        )
+    )
+    conn.execute(
+        sa.insert(history_table).values(
+            revision=revision,
+            started_at=started_at,
+            ended_at=ended_at,
+            duration_seconds=duration,
+            status=status,
+            exception=exception,
+            username=username,
+            hostname=hostname,
+        )
+    )

delembic/executor.py

@@ -0,0 +1,115 @@
+import getpass
+import socket
+import time
+import traceback
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Type
+
+import sqlalchemy as sa
+
+from delembic.alembic_compat import AlembicDepsError, check_alembic_deps
+from delembic.dag import topological_sort
+from delembic.db import ensure_tables, get_applied, record_result
+from delembic.migration import DataMigration
+from delembic.registry import load_migrations
+
+
+def run_upgrade(
+    engine: sa.Engine,
+    versions_dir: Path,
+    target: str = "head",
+    alembic_ini: Path | None = None,
+) -> None:
+    migrations = load_migrations(versions_dir)
+    if not migrations:
+        print("No migrations found.")
+        return
+
+    order = topological_sort(migrations)
+
+    username = _safe(getpass.getuser)
+    hostname = _safe(socket.gethostname)
+
+    # meta_conn records delembic_version / run_history — always committed independently
+    # work_conn runs migration SQL — rolled back on failure without touching meta_conn
+    with engine.connect() as meta_conn:
+        ensure_tables(meta_conn)
+        meta_conn.commit()
+        applied = get_applied(meta_conn)
+
+        pending = [rev for rev in order if rev not in applied]
+
+        if target != "head":
+            if target not in order:
+                raise ValueError(f"Unknown target revision: {target}")
+            cutoff = order.index(target)
+            pending = [rev for rev in pending if order.index(rev) <= cutoff]
+
+        if not pending:
+            print("Already up to date.")
+            return
+
+        for revision in pending:
+            cls = migrations[revision]
+            instance = cls()
+
+            # Validate Alembic deps before attempting to run
+            alembic_deps = _external_deps(cls, migrations)
+            if alembic_deps:
+                if alembic_ini is None:
+                    raise SystemExit(
+                        f"Migration {revision} depends on Alembic revisions "
+                        f"{alembic_deps} but alembic_config is not set in delembic.ini."
+                    )
+                try:
+                    check_alembic_deps(meta_conn, alembic_ini, alembic_deps, revision)
+                except AlembicDepsError as e:
+                    print(f"  BLOCKED: {e}")
+                    raise SystemExit(1)
+
+            print(f"Running {revision}: {cls.description}")
+            started_at = datetime.now(timezone.utc)
+            t0 = time.monotonic()
+
+            with engine.connect() as work_conn:
+                try:
+                    instance.upgrade(work_conn)
+                    instance.validate(work_conn)
+                    ended_at = datetime.now(timezone.utc)
+                    duration = time.monotonic() - t0
+                    work_conn.commit()
+                    record_result(
+                        meta_conn, revision, started_at, ended_at, duration,
+                        "success", username=username, hostname=hostname,
+                    )
+                    meta_conn.commit()
+                    print(f"  OK ({duration:.2f}s)")
+
+                except Exception as e:
+                    ended_at = datetime.now(timezone.utc)
+                    duration = time.monotonic() - t0
+                    tb = traceback.format_exc()
+                    work_conn.rollback()
+                    record_result(
+                        meta_conn, revision, started_at, ended_at, duration,
+                        "failed", exception=tb, username=username, hostname=hostname,
+                    )
+                    meta_conn.commit()
+                    print(f"  FAILED: {e}")
+                    raise SystemExit(1)
+
+
+def _external_deps(
+    cls: Type[DataMigration],
+    migrations: dict[str, Type[DataMigration]],
+) -> list[str]:
+    """Return deps that are not Delembic revisions (i.e. Alembic or other external)."""
+    return [dep for dep in cls.depends_on if dep not in migrations]
+
+
+def _safe(fn):
+    try:
+        return fn()
+    except Exception:
+        return None

delembic/migration.py

@@ -0,0 +1,14 @@
+from abc import ABC, abstractmethod
+from typing import Any
+
+
+class DataMigration(ABC):
+    revision: str
+    depends_on: list[str] = []
+    description: str = ""
+
+    @abstractmethod
+    def upgrade(self, conn: Any) -> None: ...
+
+    def validate(self, conn: Any) -> None:
+        pass

delembic/registry.py

@@ -0,0 +1,34 @@
+import importlib.util
+import sys
+from pathlib import Path
+from typing import Type
+
+from delembic.migration import DataMigration
+
+
+def load_migrations(versions_dir: Path) -> dict[str, Type[DataMigration]]:
+    migrations: dict[str, Type[DataMigration]] = {}
+
+    for path in sorted(versions_dir.glob("*.py")):
+        if path.name.startswith("_"):
+            continue
+
+        spec = importlib.util.spec_from_file_location(path.stem, path)
+        if spec is None or spec.loader is None:
+            continue
+
+        module = importlib.util.module_from_spec(spec)
+        sys.modules[path.stem] = module
+        spec.loader.exec_module(module)  # type: ignore[union-attr]
+
+        for name in dir(module):
+            obj = getattr(module, name)
+            if (
+                isinstance(obj, type)
+                and issubclass(obj, DataMigration)
+                and obj is not DataMigration
+                and hasattr(obj, "revision")
+            ):
+                migrations[obj.revision] = obj
+
+    return migrations

delembic-0.2.0.dist-info/METADATA

@@ -0,0 +1,155 @@
+Metadata-Version: 2.4
+Name: delembic
+Version: 0.2.0
+Summary: Data migration framework for versioning ETL and data operations alongside Alembic
+Author-email: htshpradhan5@gmail.com
+License: MIT
+Requires-Python: >=3.11
+Requires-Dist: click>=8.0
+Requires-Dist: sqlalchemy>=2.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Provides-Extra: docs
+Requires-Dist: furo>=2024.0; extra == 'docs'
+Requires-Dist: myst-parser>=3.0; extra == 'docs'
+Requires-Dist: sphinx-copybutton>=0.5; extra == 'docs'
+Requires-Dist: sphinx>=7.0; extra == 'docs'
+Description-Content-Type: text/markdown
+
+# Delembic
+
+Data migration framework for Python — Alembic for ETL and data operations.
+
+Alembic versions schema changes. Delembic versions **data** changes: vocabulary loads, ETL runs, reference data inserts, corrections. Together they describe the complete database state.
+
+## Installation
+
+```bash
+pip install delembic
+```
+
+## Quick Start
+
+```bash
+# 1. Initialize in your project
+delembic init
+
+# 2. Edit delembic.ini — set your database URL
+# sqlalchemy.url = postgresql+psycopg://user:pass@host/dbname
+
+# 3. Create a migration
+delembic revision -m "load vocabulary"
+
+# 4. Fill in the generated file, then run
+delembic upgrade head
+```
+
+## Configuration
+
+`delembic init` creates:
+
+```
+your-project/
+├── delembic.ini          # config — commit this
+└── delembic/
+    ├── env.py            # optional connection helpers
+    └── versions/         # migration files live here
+```
+
+**`delembic.ini`:**
+
+```ini
+[delembic]
+script_location = delembic
+sqlalchemy.url = postgresql+psycopg://user:pass@localhost/mydb
+alembic_config = alembic.ini
+```
+
+You can name the script folder anything:
+
+```bash
+delembic init data-migrations
+```
+
+## Writing Migrations
+
+```python
+from delembic import DataMigration
+
+class LoadVocabulary(DataMigration):
+
+    revision = "D001"
+    depends_on = []
+    description = "Load OMOP vocabulary tables"
+
+    def upgrade(self, conn):
+        conn.execute(...)
+
+    def validate(self, conn):
+        count = conn.execute("SELECT COUNT(*) FROM concept").scalar()
+        assert count > 0, "vocabulary load produced no rows"
+```
+
+`conn` is a SQLAlchemy `Connection`. `validate` is optional — migration is marked failed if it raises.
+
+## Dependency Tracking
+
+Migrations declare explicit dependencies. Delembic builds a DAG and runs them in topological order.
+
+```python
+class LoadPerson(DataMigration):
+    revision = "D002"
+    depends_on = ["D001"]   # waits for D001
+```
+
+## Alembic Integration
+
+Point `alembic_config` at your `alembic.ini`:
+
+```ini
+[delembic]
+alembic_config = alembic.ini
+```
+
+When you create a migration, Delembic automatically captures the current Alembic head:
+
+```bash
+delembic revision -m "load person"
+# → depends_on = ['3d1e3e6abc12']   (current alembic head)
+```
+
+At upgrade time, Delembic verifies the required Alembic revision has been applied before running:
+
+```
+BLOCKED: Migration D002 requires Alembic revision(s) 3d1e3e6abc12 to be applied first.
+Run 'alembic upgrade head' before retrying.
+```
+
+## CLI Reference
+
+| Command | Description |
+|---|---|
+| `delembic init [DIR]` | Initialize project. DIR defaults to `delembic` |
+| `delembic revision -m "msg"` | Generate new migration file |
+| `delembic upgrade head` | Run all pending migrations |
+| `delembic upgrade D003` | Run migrations up to D003 |
+| `delembic current` | Show last applied revision |
+| `delembic history` | List all migrations with status |
+
+## Metadata Tables
+
+Delembic creates two tables:
+
+```sql
+delembic_version       -- current status per revision
+delembic_run_history   -- full audit log (start/end time, duration, exception, user, host)
+```
+
+Failed migration work is rolled back. The failure record is always committed — audit trail survives transaction failures.
+
+## Development
+
+```bash
+pip install -e ".[dev]"
+pytest
+```

delembic-0.2.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+delembic/__init__.py,sha256=eJsFgs5kAEKFOA0SaCRyWlLdMTqYJIn4nN1fZD1GAu8,96
+delembic/alembic_compat.py,sha256=0zNE9D2o6JJlnju3FrEChcEWdty-gCdT4DSxCIMGses,2152
+delembic/cli.py,sha256=8cDSZFhh_XTS93FQaBBRcWRM6FG6g-rabt5_fHnLTE0,5844
+delembic/config.py,sha256=oTa_dKnijU6HimIFBWLmcvOmeJbeG3eHfy6Nr7dCN28,1267
+delembic/dag.py,sha256=V5frlaQ765TzqwpEgi_4YPFygABGiihdVjFu17fUo_c,1193
+delembic/db.py,sha256=qFxKEqULtfSq8PPDbNLG_3GPLNj5r1ia5C8ea1rGKsA,2048
+delembic/executor.py,sha256=M8s31fO3y0OJUlfM7yA7t0kJGle1GSEiVNRb_csP1g8,4019
+delembic/migration.py,sha256=Vyt1cFQXtS8JseZ9kSQzUAyBkuOFEe1W7OYEkxSya6w,286
+delembic/registry.py,sha256=k4bCp61w3oPhEZEEVM6i_vuYw7C-8xlzA1kty-oPNWU,1028
+delembic-0.2.0.dist-info/METADATA,sha256=euid0K4SstknuoX8pBx3TsErkjFlQzq7YnHp5RKfh_I,3881
+delembic-0.2.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+delembic-0.2.0.dist-info/entry_points.txt,sha256=R_iUBPB80NsK7iYsnUoyCKpwD3qbH8I8V6XtdQWB_Q4,46
+delembic-0.2.0.dist-info/RECORD,,

delembic-0.2.0.dist-info/WHEEL

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

delembic-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+delembic = delembic.cli:cli