modelsync 0.1.0__tar.gz

modelsync-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Brian L. Pond
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

modelsync-0.1.0/PKG-INFO

@@ -0,0 +1,178 @@
+Metadata-Version: 2.4
+Name: modelsync
+Version: 0.1.0
+Summary: Synchronize database models with actuals — document-driven project.
+Author: Brian L. Pond
+License: MIT
+Project-URL: Homepage, https://github.com/brian-pond/modelsync
+Project-URL: Repository, https://github.com/brian-pond/modelsync
+Classifier: Development Status :: 4 - Beta
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: sqlalchemy>=2.0
+Provides-Extra: dev
+Requires-Dist: build; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Requires-Dist: sqlmodel; extra == "dev"
+Requires-Dist: typer>=0.9; extra == "dev"
+Provides-Extra: postgres
+Requires-Dist: psycopg[binary]>=3; extra == "postgres"
+Dynamic: license-file
+
+# modelsync
+
+A Python library for schema and model synchronization: keep your database schema in sync with your SQLAlchemy or SQLModel definitions.
+
+## Prerequisites
+
+- Python 3.11+
+
+## Setup
+
+Create a virtual environment and install the package in editable mode:
+
+```bash
+python3 -m venv .venv
+source .venv/bin/activate   # Linux/macOS
+# .venv\Scripts\activate   # Windows
+pip install -e ".[dev]"
+```
+
+## Installing in other projects
+
+To use modelsync in another Python application:
+
+- **Development (same machine):** From your other project, run `pip install -e /path/to/modelsync` or `uv pip install -e /path/to/modelsync`. Changes in the modelsync repo are reflected immediately.
+- **Built wheel:** From the modelsync repo run `uv build` (requires `uv` and dev deps: `pip install -e ".[dev]"`). This produces a wheel in `dist/` (e.g. `dist/modelsync-0.1.0-py3-none-any.whl`). In your other project: `pip install /path/to/modelsync/dist/modelsync-0.1.0-py3-none-any.whl`.
+- **Private index:** Upload the contents of `dist/` to your index; then `pip install modelsync --index-url https://your-index/simple/`.
+
+## Running tests
+
+From the project root, with the virtual environment activated:
+
+```bash
+pytest tests/
+```
+
+Run only unit tests or only integration tests:
+
+```bash
+pytest tests/unit/
+pytest tests/integration/
+```
+
+See `tests/TESTS_README.md` for how tests are organized.
+
+## Usage
+
+Use modelsync as a library: define your models (e.g. SQLAlchemy or SQLModel), then compare them to the database. By default, only a plan is produced; apply only when you explicitly opt in.
+
+### ModelSync: the three main entry points
+
+**1. `ModelSync(...)` — set up the connection**
+
+Create a `ModelSync` instance by passing either:
+
+- **`credentials={"url": "sqlite:///./mydb.sqlite"}`** — modelsync will open the database, run your call, then close it. No need to manage the connection yourself.
+- **`connection=engine.connect()`** — you provide an open connection; you are responsible for closing it when done.
+
+For databases that use schemas (e.g. PostgreSQL), also pass **`target_schema="public"`** (or your schema name). For SQLite you can omit it.
+
+**2. `compare(models)` — see what would change (dry run)**
+
+Pass one model class or a list of model classes. modelsync compares their combined schema to the live database and returns a **plan** of steps (create table, add column, add constraint, etc.) without executing anything. Use this to inspect changes, log them, or generate a DDL script with `plan.sql()`. Returns a `SyncPlan` or a `SyncError` if something went wrong.
+
+**3. `do_sync(models)` — apply the changes**
+
+Same comparison as `compare()`, but **runs** the plan against the database. By default all steps run in one transaction: if any step fails, everything is rolled back. Returns the applied `SyncPlan` on success or a `SyncError` on failure. Optional: `commit_per_step=True` to commit after each step (partial progress on failure), or `log_file="path"` to append applied steps to a file.
+
+---
+
+Define one or more models and pass them (single class or a list) to `compare()` or `do_sync()`. The example below uses `compare()` to get a plan.
+
+```python
+from sqlalchemy import Column, Float, ForeignKey, Integer, String
+from sqlalchemy.orm import DeclarativeBase
+
+from modelsync import ModelSync, SyncError
+
+class Product(DeclarativeBase):
+    __tablename__ = "product"
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    name = Column(String(255), nullable=False)
+    price = Column(Float, nullable=False)
+
+class Cart(DeclarativeBase):
+    __tablename__ = "cart"
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    product_id = Column(Integer, ForeignKey("product.id"), nullable=False)
+    quantity = Column(Integer, nullable=False)
+
+sync = ModelSync(credentials={"url": "sqlite:///./mydb.sqlite"})
+result_plan = sync.compare([Product, Cart])
+
+if isinstance(result_plan, SyncError):
+    print("Compare failed:", result_plan.messages)
+else:
+    if not result_plan.steps:
+        print("Your target database is up to date.")
+    else:
+        for step in result_plan.steps:
+            print(step)
+        # result_plan.sql() returns the full DDL script for inspection or manual execution
+```
+
+**Using your own connection** — you open the connection and close it yourself:
+
+```python
+from sqlalchemy import create_engine
+
+engine = create_engine("sqlite:///./mydb.sqlite")
+with engine.connect() as conn:
+    sync = ModelSync(connection=conn)
+    result_plan = sync.compare([Product, Cart])
+engine.dispose()
+```
+
+### Possible Outcomes
+
+#### Scenario 1
+If the target database is empty, printing each step might show:
+
+```
+Create table product
+Create table cart
+```
+
+#### Scenario 2
+If the database already matches your models, you'll see *Your target database is up to date.* and no steps.
+
+#### Scenario 3
+What if `cart` already exists in the database but is missing the `quantity` column? Then you might see:
+
+```
+Add column quantity to cart
+```
+
+To get the full DDL script as a single string, use `result_plan.sql()`.
+
+### Applying the plan with do_sync()
+
+To compare and apply the plan in one go (run the DDL against the database), use `do_sync()`. It uses the same comparison as `compare()` but executes the steps in a single transaction (all-or-nothing; rollback on failure). Returns the applied `SyncPlan` on success or `SyncError` on failure.
+
+```python
+result_plan = sync.do_sync([Product, Cart])
+
+if isinstance(result_plan, SyncError):
+    print("Sync failed:", result_plan.messages)
+else:
+    print(f"Applied {len(result_plan.steps)} step(s). Schema is now in sync.")
+```
+
+Optional: `do_sync(..., commit_per_step=True)` commits after each step so partial progress is kept if a later step fails. `do_sync(..., log_file="/path/to/sync.log")` appends applied steps as JSON lines to a file.
+

modelsync-0.1.0/README.md

@@ -0,0 +1,152 @@
+# modelsync
+
+A Python library for schema and model synchronization: keep your database schema in sync with your SQLAlchemy or SQLModel definitions.
+
+## Prerequisites
+
+- Python 3.11+
+
+## Setup
+
+Create a virtual environment and install the package in editable mode:
+
+```bash
+python3 -m venv .venv
+source .venv/bin/activate   # Linux/macOS
+# .venv\Scripts\activate   # Windows
+pip install -e ".[dev]"
+```
+
+## Installing in other projects
+
+To use modelsync in another Python application:
+
+- **Development (same machine):** From your other project, run `pip install -e /path/to/modelsync` or `uv pip install -e /path/to/modelsync`. Changes in the modelsync repo are reflected immediately.
+- **Built wheel:** From the modelsync repo run `uv build` (requires `uv` and dev deps: `pip install -e ".[dev]"`). This produces a wheel in `dist/` (e.g. `dist/modelsync-0.1.0-py3-none-any.whl`). In your other project: `pip install /path/to/modelsync/dist/modelsync-0.1.0-py3-none-any.whl`.
+- **Private index:** Upload the contents of `dist/` to your index; then `pip install modelsync --index-url https://your-index/simple/`.
+
+## Running tests
+
+From the project root, with the virtual environment activated:
+
+```bash
+pytest tests/
+```
+
+Run only unit tests or only integration tests:
+
+```bash
+pytest tests/unit/
+pytest tests/integration/
+```
+
+See `tests/TESTS_README.md` for how tests are organized.
+
+## Usage
+
+Use modelsync as a library: define your models (e.g. SQLAlchemy or SQLModel), then compare them to the database. By default, only a plan is produced; apply only when you explicitly opt in.
+
+### ModelSync: the three main entry points
+
+**1. `ModelSync(...)` — set up the connection**
+
+Create a `ModelSync` instance by passing either:
+
+- **`credentials={"url": "sqlite:///./mydb.sqlite"}`** — modelsync will open the database, run your call, then close it. No need to manage the connection yourself.
+- **`connection=engine.connect()`** — you provide an open connection; you are responsible for closing it when done.
+
+For databases that use schemas (e.g. PostgreSQL), also pass **`target_schema="public"`** (or your schema name). For SQLite you can omit it.
+
+**2. `compare(models)` — see what would change (dry run)**
+
+Pass one model class or a list of model classes. modelsync compares their combined schema to the live database and returns a **plan** of steps (create table, add column, add constraint, etc.) without executing anything. Use this to inspect changes, log them, or generate a DDL script with `plan.sql()`. Returns a `SyncPlan` or a `SyncError` if something went wrong.
+
+**3. `do_sync(models)` — apply the changes**
+
+Same comparison as `compare()`, but **runs** the plan against the database. By default all steps run in one transaction: if any step fails, everything is rolled back. Returns the applied `SyncPlan` on success or a `SyncError` on failure. Optional: `commit_per_step=True` to commit after each step (partial progress on failure), or `log_file="path"` to append applied steps to a file.
+
+---
+
+Define one or more models and pass them (single class or a list) to `compare()` or `do_sync()`. The example below uses `compare()` to get a plan.
+
+```python
+from sqlalchemy import Column, Float, ForeignKey, Integer, String
+from sqlalchemy.orm import DeclarativeBase
+
+from modelsync import ModelSync, SyncError
+
+class Product(DeclarativeBase):
+    __tablename__ = "product"
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    name = Column(String(255), nullable=False)
+    price = Column(Float, nullable=False)
+
+class Cart(DeclarativeBase):
+    __tablename__ = "cart"
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    product_id = Column(Integer, ForeignKey("product.id"), nullable=False)
+    quantity = Column(Integer, nullable=False)
+
+sync = ModelSync(credentials={"url": "sqlite:///./mydb.sqlite"})
+result_plan = sync.compare([Product, Cart])
+
+if isinstance(result_plan, SyncError):
+    print("Compare failed:", result_plan.messages)
+else:
+    if not result_plan.steps:
+        print("Your target database is up to date.")
+    else:
+        for step in result_plan.steps:
+            print(step)
+        # result_plan.sql() returns the full DDL script for inspection or manual execution
+```
+
+**Using your own connection** — you open the connection and close it yourself:
+
+```python
+from sqlalchemy import create_engine
+
+engine = create_engine("sqlite:///./mydb.sqlite")
+with engine.connect() as conn:
+    sync = ModelSync(connection=conn)
+    result_plan = sync.compare([Product, Cart])
+engine.dispose()
+```
+
+### Possible Outcomes
+
+#### Scenario 1
+If the target database is empty, printing each step might show:
+
+```
+Create table product
+Create table cart
+```
+
+#### Scenario 2
+If the database already matches your models, you'll see *Your target database is up to date.* and no steps.
+
+#### Scenario 3
+What if `cart` already exists in the database but is missing the `quantity` column? Then you might see:
+
+```
+Add column quantity to cart
+```
+
+To get the full DDL script as a single string, use `result_plan.sql()`.
+
+### Applying the plan with do_sync()
+
+To compare and apply the plan in one go (run the DDL against the database), use `do_sync()`. It uses the same comparison as `compare()` but executes the steps in a single transaction (all-or-nothing; rollback on failure). Returns the applied `SyncPlan` on success or `SyncError` on failure.
+
+```python
+result_plan = sync.do_sync([Product, Cart])
+
+if isinstance(result_plan, SyncError):
+    print("Sync failed:", result_plan.messages)
+else:
+    print(f"Applied {len(result_plan.steps)} step(s). Schema is now in sync.")
+```
+
+Optional: `do_sync(..., commit_per_step=True)` commits after each step so partial progress is kept if a later step fails. `do_sync(..., log_file="/path/to/sync.log")` appends applied steps as JSON lines to a file.
+

modelsync-0.1.0/pyproject.toml

@@ -0,0 +1,52 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "modelsync"
+version = "0.1.0"
+description = "Synchronize database models with actuals — document-driven project."
+readme = "README.md"
+license = { text = "MIT" }
+requires-python = ">=3.11"
+authors = [{ name = "Brian L. Pond" }]
+dependencies = [
+    "sqlalchemy>=2.0",
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+]
+
+[project.urls]
+Homepage = "https://github.com/brian-pond/modelsync"
+Repository = "https://github.com/brian-pond/modelsync"
+
+[project.optional-dependencies]
+dev = [
+    "build",
+    "pytest",
+    "ruff",
+    "sqlmodel",
+    "typer>=0.9",
+]
+postgres = [
+    "psycopg[binary]>=3",
+]
+
+[tool.ruff]
+target-version = "py311"
+line-length = 100
+src = ["src"]
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "B", "C4", "UP", "ARG", "SIM"]
+ignore = []
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[project.scripts]
+modelsync = "modelsync.cli:main"

modelsync-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

modelsync-0.1.0/src/modelsync/__init__.py

@@ -0,0 +1,24 @@
+"""
+modelsync — schema and model synchronization.
+
+Document-driven project; requirements live under docs/requirements/.
+Library API: ModelSync(connection=... | credentials=..., target_schema=...),
+sync.compare(models) -> SyncPlan | SyncError.
+"""
+
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    __version__ = version("modelsync")
+except PackageNotFoundError:
+    __version__ = "0.0.0"
+
+from modelsync.errors import SyncError
+from modelsync.plan.steps import SyncPlan
+from modelsync.sync import ModelSync
+
+__all__ = [
+    "ModelSync",
+    "SyncError",
+    "SyncPlan",
+]

modelsync-0.1.0/src/modelsync/adapters/__init__.py

@@ -0,0 +1,13 @@
+"""
+Adapters: third-party models (SQLAlchemy, SQLModel) → internal schema.
+
+See docs/technical/02-architecture.md (Core functions, Adapters).
+"""
+
+from modelsync.adapters.model_schema import ModelSchema
+from modelsync.adapters.sa_to_neutral import sa_column_to_neutral_type
+
+__all__ = [
+    "ModelSchema",
+    "sa_column_to_neutral_type",
+]

modelsync-0.1.0/src/modelsync/adapters/model_schema.py

@@ -0,0 +1,218 @@
+"""
+Build internal schema from SQLAlchemy or SQLModel model classes.
+
+Callers pass a single model or sequence of models; we collect their Table
+definitions and build a ModelSchema (name -> TableDef). See docs/requirements/01-functional.md
+(Model discovery and API, Schema parity scope).
+
+**Read-only contract:** Ingestion does not mutate caller models. We only read from
+model.__table__ and its columns/constraints/indexes; we never assign to or modify
+the caller's Table or column objects. ModelSchema stores only internal TableDef
+instances, not references to the original tables.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from typing import Any, Protocol
+
+from sqlalchemy import Table
+from sqlalchemy.engine import Dialect
+from sqlalchemy.schema import CheckConstraint, ForeignKeyConstraint, UniqueConstraint
+
+from modelsync.adapters.sa_to_neutral import sa_column_to_neutral_type
+from modelsync.internal.objects import (
+    CheckDef,
+    ColumnDef,
+    ForeignKeyDef,
+    IndexDef,
+    PrimaryKeyDef,
+    QualifiedName,
+    TableDef,
+    UniqueDef,
+)
+
+
+def _get_table_from_model(model: type) -> Table:
+    """Return the SQLAlchemy Table for a declarative or SQLModel class."""
+    table = getattr(model, "__table__", None)
+    if table is None:
+        raise TypeError(f"Model {model!r} has no __table__; not a mapped table class")
+    if not isinstance(table, Table):
+        raise TypeError(f"Model {model!r}.__table__ is not a Table: {type(table)}")
+    return table
+
+
+def _column_type_str(column: Any, dialect: Dialect | None) -> str:
+    """Return neutral type string for internal schema (dialect=None) or compiled type (dialect set)."""
+    if dialect is None:
+        return sa_column_to_neutral_type(column)
+    return column.type.compile(dialect=dialect)
+
+
+def _default_expr(column: Any, _dialect: Dialect) -> str | None:
+    """Return server default expression as string, or None."""
+    default = getattr(column, "server_default", None) or getattr(column, "default", None)
+    if default is None:
+        return None
+    if hasattr(default, "arg") and default.arg is not None:
+        if callable(default.arg):
+            return None  # Python-side default; no DDL expression
+        return str(default.arg)
+    if hasattr(default, "text") and default.text is not None:
+        return default.text
+    return None
+
+
+def _extract_table_def(
+    table: Table,
+    target_schema: str | None,
+    dialect: Dialect | None = None,
+) -> TableDef:
+    """Build a TableDef from a SQLAlchemy Table. When dialect is None, use neutral type names."""
+    schema = table.schema if table.schema is not None else target_schema
+    qualified_name = QualifiedName(schema=schema, name=table.name)
+
+    columns: list[ColumnDef] = []
+    # Only the single integer PK column should have autoincrement=True (SA uses "auto" on others too).
+    is_single_pk = (
+        table.primary_key
+        and len(table.primary_key.columns) == 1
+    )
+    pk_col_name = (
+        list(table.primary_key.columns)[0].name
+        if is_single_pk
+        else None
+    )
+    _integer_type_names = ("Integer", "INTEGER", "BigInteger", "BIGINT", "SmallInteger", "SMALLINT")
+    for col in table.c:
+        default = _default_expr(col, dialect)
+        type_str = _column_type_str(col, dialect)
+        comment = getattr(col, "comment", None)
+        sa_auto = getattr(col, "autoincrement", False)
+        if isinstance(sa_auto, str):
+            sa_auto = sa_auto == "auto"
+        is_pk_col = pk_col_name is not None and col.name == pk_col_name
+        is_integer = type(col.type).__name__ in _integer_type_names
+        autoincrement = bool(
+            is_single_pk and is_pk_col and is_integer and sa_auto
+        )
+        columns.append(
+            ColumnDef(
+                name=col.name,
+                data_type_name=type_str,
+                nullable=col.nullable,
+                default=default,
+                comment=comment,
+                autoincrement=autoincrement,
+            )
+        )
+
+    primary_key: PrimaryKeyDef | None = None
+    if table.primary_key and table.primary_key.columns:
+        primary_key = PrimaryKeyDef(column_names=tuple(c.name for c in table.primary_key.columns))
+
+    unique_constraints: list[UniqueDef] = []
+    foreign_keys: list[ForeignKeyDef] = []
+    check_constraints: list[CheckDef] = []
+
+    for constraint in table.constraints:
+        match constraint:
+            case UniqueConstraint() if constraint is not table.primary_key:
+                unique_constraints.append(
+                    UniqueDef(
+                        name=constraint.name,
+                        column_names=tuple(c.name for c in constraint.columns),
+                    )
+                )
+            case CheckConstraint():
+                expression = str(constraint.sqltext)
+                check_constraints.append(CheckDef(name=constraint.name, expression=expression))
+            case ForeignKeyConstraint():
+                ref_col = next(iter(constraint.elements)).column
+                ref_table = ref_col.table
+                ref_schema = ref_table.schema if ref_table.schema is not None else target_schema
+                ref_name = QualifiedName(schema=ref_schema, name=ref_table.name)
+                foreign_keys.append(
+                    ForeignKeyDef(
+                        name=constraint.name,
+                        column_names=tuple(c.name for c in constraint.columns),
+                        ref_table=ref_name,
+                        ref_column_names=tuple(el.column.name for el in constraint.elements),
+                    )
+                )
+
+    indexes: list[IndexDef] = []
+    for idx in table.indexes:
+        indexes.append(
+            IndexDef(
+                name=idx.name or f"ix_{table.name}_{'_'.join(c.name for c in idx.columns)}",
+                column_names=tuple(c.name for c in idx.columns),
+                unique=idx.unique or False,
+            )
+        )
+
+    comment = getattr(table, "comment", None)
+
+    return TableDef(
+        name=qualified_name,
+        columns=tuple(columns),
+        primary_key=primary_key,
+        unique_constraints=tuple(unique_constraints),
+        foreign_keys=tuple(foreign_keys),
+        check_constraints=tuple(check_constraints),
+        indexes=tuple(indexes),
+        comment=comment,
+    )
+
+
+class _SchemaNormalizer(Protocol):
+    """Protocol for normalizing a TableDef so it compares equal across backends."""
+
+    def normalize_reflected_table(self, table_def: TableDef) -> TableDef: ...
+
+
+class ModelSchema:
+    """
+    Internal schema derived from code models (SQLAlchemy/SQLModel).
+
+    Tables are keyed by QualifiedName. Built by from_models().
+    """
+
+    def __init__(self) -> None:
+        self._tables: dict[QualifiedName, TableDef] = {}
+
+    @property
+    def tables(self) -> dict[QualifiedName, TableDef]:
+        """Tables keyed by qualified name."""
+        return self._tables
+
+    @classmethod
+    def from_models(
+        cls,
+        models: type | Sequence[type],
+        target_schema: str | None = None,
+        *,
+        schema_normalizer: _SchemaNormalizer | None = None,
+    ) -> ModelSchema:
+        """
+        Build ModelSchema from one or more model classes.
+
+        Each model must have __table__ (SQLAlchemy Table). Column types are
+        mapped to neutral type names (no target database). target_schema is
+        used when table.schema is None (e.g. PostgreSQL default schema).
+        If schema_normalizer is provided (e.g. modelsync Dialect), its
+        normalize_reflected_table is applied so model-side internal schema compares equal to database-side internal schema.
+        """
+        if isinstance(models, type):
+            model_seq: Sequence[type] = (models,)
+        else:
+            model_seq = models
+        instance = cls()
+        for model in model_seq:
+            table = _get_table_from_model(model)
+            table_def = _extract_table_def(table, target_schema, dialect=None)
+            if schema_normalizer is not None:
+                table_def = schema_normalizer.normalize_reflected_table(table_def)
+            instance._tables[table_def.name] = table_def
+        return instance