sqlalchemy 2.0.51: Table

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.Table 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.Table

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:82936a50f16b1df142aa89d48bc2645555eb802c203af07dc0a6c3b54aacdf7c","contract":["sqlalchemy.Table defines schema with columns, types, and primary key on MetaData","sqlalchemy.Table supports foreign key constraints and relationships","sqlalchemy.Table generates executable insert, select, update, and delete SQL constructs","sqlalchemy.Table registered in MetaData is accessible via metadata.tables dictionary"],"goal":"verify sqlalchemy.Table in pkg:pypi/sqlalchemy@2.0.51","kind":"HOW","packages":["pkg:pypi/sqlalchemy@2.0.51"],"schemaVersion":1,"symbols":["sqlalchemy.Table"]},"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.Table"],"verifierAdapter":"python@1"}

sqlalchemy==2.0.51

"""Demonstration of relational schema definition and operations using sqlalchemy.Table."""

from typing import Any, Dict
from sqlalchemy import Column, ForeignKey, Integer, MetaData, String, Table
from sqlalchemy.sql import Delete, Insert, Select, Update


def create_user_table(metadata: MetaData) -> Table:
    """Define a users table with columns and constraints."""
    return Table(
        "users",
        metadata,
        Column("id", Integer, primary_key=True, autoincrement=True),
        Column("name", String(50), nullable=False),
        Column("email", String(100), unique=True, nullable=False),
    )


def create_address_table(metadata: MetaData) -> Table:
    """Define an addresses table with a foreign key referencing users."""
    return Table(
        "addresses",
        metadata,
        Column("id", Integer, primary_key=True, autoincrement=True),
        Column("user_id", Integer, ForeignKey("users.id"), nullable=False),
        Column("email_address", String(100), nullable=False),
    )


def build_insert(table: Table, values: Dict[str, Any]) -> Insert:
    """Construct an INSERT statement for a given table."""
    return table.insert().values(**values)


def build_select_by_id(table: Table, record_id: int) -> Select:
    """Construct a SELECT statement filtering by primary key id."""
    return table.select().where(table.c.id == record_id)


def build_update(table: Table, record_id: int, values: Dict[str, Any]) -> Update:
    """Construct an UPDATE statement modifying record by id."""
    return table.update().where(table.c.id == record_id).values(**values)


def build_delete(table: Table, record_id: int) -> Delete:
    """Construct a DELETE statement removing record by id."""
    return table.delete().where(table.c.id == record_id)

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

"""Contract verification test for sqlalchemy.Table."""

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
import sample


def test_table_schema_definition() -> None:
    """Assertion 1: sqlalchemy.Table defines schema with columns, types, and primary key on MetaData."""
    metadata = MetaData()
    user_table = sample.create_user_table(metadata)

    assert isinstance(user_table, Table)
    assert user_table.name == "users"
    assert "id" in user_table.c
    assert "name" in user_table.c
    assert "email" in user_table.c

    assert user_table.c.id.primary_key is True
    assert user_table.c.name.nullable is False
    assert user_table.c.email.unique is True


def test_table_foreign_key_relationship() -> None:
    """Assertion 2: sqlalchemy.Table supports foreign key constraints and relationships."""
    metadata = MetaData()
    user_table = sample.create_user_table(metadata)
    address_table = sample.create_address_table(metadata)

    assert isinstance(address_table, Table)
    assert address_table.name == "addresses"
    assert len(address_table.foreign_keys) == 1

    fk = list(address_table.foreign_keys)[0]
    assert fk.target_fullname == "users.id"
    assert address_table.c.user_id.references(user_table.c.id) is True


def test_table_crud_sql_constructs() -> None:
    """Assertion 3: sqlalchemy.Table generates executable insert, select, update, and delete SQL constructs."""
    metadata = MetaData()
    user_table = sample.create_user_table(metadata)
    address_table = sample.create_address_table(metadata)

    engine = create_engine("sqlite:///:memory:")
    metadata.create_all(engine)

    with engine.begin() as conn:
        # INSERT
        insert_stmt = sample.build_insert(user_table, {"id": 1, "name": "Alice", "email": "alice@example.com"})
        conn.execute(insert_stmt)

        addr_insert = sample.build_insert(address_table, {"id": 10, "user_id": 1, "email_address": "alice@work.example.com"})
        conn.execute(addr_insert)

        # SELECT
        select_stmt = sample.build_select_by_id(user_table, 1)
        row = conn.execute(select_stmt).fetchone()
        assert row is not None
        assert row.id == 1
        assert row.name == "Alice"
        assert row.email == "alice@example.com"

        # UPDATE
        update_stmt = sample.build_update(user_table, 1, {"name": "Alice Smith"})
        conn.execute(update_stmt)

        updated_row = conn.execute(select_stmt).fetchone()
        assert updated_row is not None
        assert updated_row.name == "Alice Smith"

        # DELETE
        addr_delete = sample.build_delete(address_table, 10)
        conn.execute(addr_delete)

        delete_stmt = sample.build_delete(user_table, 1)
        conn.execute(delete_stmt)

        deleted_row = conn.execute(select_stmt).fetchone()
        assert deleted_row is None


def test_table_metadata_registry() -> None:
    """Assertion 4: sqlalchemy.Table registered in MetaData is accessible via metadata.tables dictionary."""
    metadata = MetaData()
    user_table = sample.create_user_table(metadata)
    address_table = sample.create_address_table(metadata)

    assert "users" in metadata.tables
    assert "addresses" in metadata.tables
    assert metadata.tables["users"] is user_table
    assert metadata.tables["addresses"] is address_table


def main() -> None:
    test_table_schema_definition()
    test_table_foreign_key_relationship()
    test_table_crud_sql_constructs()
    test_table_metadata_registry()
    print("All contract assertions passed.")


if __name__ == "__main__":
    main()