sqlalchemy 2.0.51: MetaData

Clean-room public code sample — generation instructions

Write a brand-new, minimal, self-contained code sample in this clean-room directory.
Do not copy, paraphrase, or reference any existing project source. Work only from this spec.

A csx.json manifest scaffold already exists. Do not recreate it from memory. Preserve its case.goal, packages and symbols; fill its empty case.contract with exact assertions and correct its environment, commands and verifierAdapter for the files you generate.

Goal: verify sqlalchemy.MetaData in pkg:pypi/sqlalchemy@2.0.51
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:pypi/sqlalchemy@2.0.51
Demonstrate these symbols/APIs:
  - sqlalchemy.MetaData

Rules:
  - One focused purpose; the smallest project that proves the goal.
  - Include a contract test (test/contract.*) that runs OFFLINE and exits 0 exactly when the goal behavior works.
  - Pin every dependency with a lockfile so resolution is reproducible.
  - No secrets, credentials, or tokens. No real URLs (only example.com or localhost). No absolute paths.
  - No personal names, emails, company names, or project identifiers of any kind.
  - No binaries and no generated output (node_modules, dist, target, venv, .git, .env).
  - Keep it under 200 files and 256KB packed.

{"case":{"caseId":"case:sha256:30bb5010ad95aadbfc8a06fe198cdc8e48e284721b8b04978ad0427f0604e7e8","contract":["sqlalchemy.MetaData registers Table objects and provides access through metadata.tables","sqlalchemy.MetaData enforces custom naming_convention for schema constraints","sqlalchemy.MetaData resolves table dependency order via metadata.sorted_tables","sqlalchemy.MetaData creates and drops schema tables using create_all and drop_all on an engine","sqlalchemy.MetaData reflects existing database schemas into Table objects with metadata.reflect"],"goal":"verify sqlalchemy.MetaData in pkg:pypi/sqlalchemy@2.0.51","kind":"HOW","packages":["pkg:pypi/sqlalchemy@2.0.51"],"schemaVersion":1,"symbols":["sqlalchemy.MetaData"]},"contractCommand":["python","test/contract.py"],"environment":{"arch":"x64","distro":"ubuntu","ecosystem":"pypi","libc":"glibc","libcVersion":"2.39","os":"linux","osVersionBucket":"24","packageManager":"pip","schemaVersion":1},"license":"MIT-0","packages":["pkg:pypi/sqlalchemy@2.0.51"],"schemaVersion":1,"subject":"pkg:pypi/sqlalchemy@2.0.51","symbols":["sqlalchemy.MetaData"],"verifierAdapter":"python@1"}

sqlalchemy==2.0.51

"""Demonstration of schema management, constraint naming, reflection, and lifecycle operations using sqlalchemy.MetaData."""

from typing import Any, List, Tuple
from sqlalchemy import (
    Column,
    ForeignKey,
    Integer,
    MetaData,
    String,
    Table,
)


def get_naming_convention() -> dict:
    """Return standard constraint naming conventions for schema migrations."""
    return {
        "ix": "ix_%(column_0_label)s",
        "uq": "uq_%(table_name)s_%(column_0_name)s",
        "ck": "ck_%(table_name)s_%(constraint_name)s",
        "fk": "fk_%(table_name)s_%(column_0_name)s_%(referred_table_name)s",
        "pk": "pk_%(table_name)s",
    }


def create_metadata(naming_convention: dict = None) -> MetaData:
    """Instantiate a MetaData collection with optional naming convention."""
    if naming_convention is not None:
        return MetaData(naming_convention=naming_convention)
    return MetaData()


def define_schema(metadata: MetaData) -> Tuple[Table, Table]:
    """Define schema tables with foreign key relationship on the given MetaData."""
    organizations = Table(
        "organizations",
        metadata,
        Column("id", Integer, primary_key=True),
        Column("name", String(50), nullable=False),
    )
    members = Table(
        "members",
        metadata,
        Column("id", Integer, primary_key=True),
        Column("org_id", Integer, ForeignKey("organizations.id"), nullable=False),
        Column("email", String(100), unique=True, nullable=False),
    )
    return organizations, members


def get_sorted_table_names(metadata: MetaData) -> List[str]:
    """Return table names ordered topologically by foreign key dependencies."""
    return [table.name for table in metadata.sorted_tables]


def create_all_tables(metadata: MetaData, bind: Any) -> None:
    """Issue DDL CREATE statements for all registered tables."""
    metadata.create_all(bind=bind)


def drop_all_tables(metadata: MetaData, bind: Any) -> None:
    """Issue DDL DROP statements for all registered tables."""
    metadata.drop_all(bind=bind)


def reflect_metadata(bind: Any) -> MetaData:
    """Reflect database schema into a fresh MetaData instance."""
    reflected = MetaData()
    reflected.reflect(bind=bind)
    return reflected


def clear_metadata(metadata: MetaData) -> None:
    """Remove all registered Table objects from the MetaData collection."""
    metadata.clear()

{
  "schemaVersion": 1,
  "goal": "verify sqlalchemy.MetaData in pkg:pypi/sqlalchemy@2.0.51",
  "kind": "HOW",
  "packages": [
    "pkg:pypi/sqlalchemy@2.0.51"
  ],
  "symbols": [
    "sqlalchemy.MetaData"
  ]
}

"""Contract verification test for sqlalchemy.MetaData."""

import os
import sys

# Ensure project root is on sys.path for local module imports
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))

from sqlalchemy import MetaData, Table, create_engine, inspect
import sample


def test_metadata_table_registry() -> None:
    """Assertion 1: sqlalchemy.MetaData registers Table objects and provides access through metadata.tables."""
    metadata = sample.create_metadata()
    org_table, member_table = sample.define_schema(metadata)

    assert "organizations" in metadata.tables
    assert "members" in metadata.tables
    assert metadata.tables["organizations"] is org_table
    assert metadata.tables["members"] is member_table
    assert isinstance(metadata.tables["organizations"], Table)


def test_metadata_naming_convention() -> None:
    """Assertion 2: sqlalchemy.MetaData enforces custom naming_convention for schema constraints."""
    convention = sample.get_naming_convention()
    metadata = sample.create_metadata(naming_convention=convention)
    org_table, member_table = sample.define_schema(metadata)

    # Primary key constraint name
    assert member_table.primary_key.name == "pk_members"
    assert org_table.primary_key.name == "pk_organizations"

    # Foreign key constraint name
    fk_constraints = [c for c in member_table.constraints if c.__class__.__name__ == "ForeignKeyConstraint"]
    assert len(fk_constraints) == 1
    assert fk_constraints[0].name == "fk_members_org_id_organizations"

    # Unique constraint name
    unique_constraints = [c for c in member_table.constraints if c.__class__.__name__ == "UniqueConstraint"]
    assert len(unique_constraints) == 1
    assert unique_constraints[0].name == "uq_members_email"


def test_metadata_sorted_tables_dependency_order() -> None:
    """Assertion 3: sqlalchemy.MetaData resolves table dependency order via metadata.sorted_tables."""
    metadata = sample.create_metadata()
    # Define tables where members depends on organizations
    sample.define_schema(metadata)

    sorted_names = sample.get_sorted_table_names(metadata)
    assert sorted_names == ["organizations", "members"], f"Expected dependent order, got: {sorted_names}"


def test_metadata_create_and_drop_all() -> None:
    """Assertion 4: sqlalchemy.MetaData creates and drops schema tables using create_all and drop_all on an engine."""
    engine = create_engine("sqlite:///:memory:")
    metadata = sample.create_metadata()
    sample.define_schema(metadata)

    sample.create_all_tables(metadata, engine)

    inspector = inspect(engine)
    table_names = inspector.get_table_names()
    assert "organizations" in table_names
    assert "members" in table_names

    sample.drop_all_tables(metadata, engine)

    inspector = inspect(engine)
    remaining_tables = inspector.get_table_names()
    assert len(remaining_tables) == 0


def test_metadata_reflect_schema() -> None:
    """Assertion 5: sqlalchemy.MetaData reflects existing database schemas into Table objects with metadata.reflect."""
    engine = create_engine("sqlite:///:memory:")
    source_metadata = sample.create_metadata()
    sample.define_schema(source_metadata)
    sample.create_all_tables(source_metadata, engine)

    reflected_metadata = sample.reflect_metadata(engine)
    assert "organizations" in reflected_metadata.tables
    assert "members" in reflected_metadata.tables

    reflected_org = reflected_metadata.tables["organizations"]
    reflected_members = reflected_metadata.tables["members"]
    assert "name" in reflected_org.c
    assert "email" in reflected_members.c

    sample.clear_metadata(reflected_metadata)
    assert len(reflected_metadata.tables) == 0


def main() -> None:
    test_metadata_table_registry()
    test_metadata_naming_convention()
    test_metadata_sorted_tables_dependency_order()
    test_metadata_create_and_drop_all()
    test_metadata_reflect_schema()
    print("All contract assertions passed.")


if __name__ == "__main__":
    main()