snake-orm 0.1.0b1__py3-none-any.whl

snakeorm/metadata/table.py

@@ -0,0 +1,97 @@
+"""Immutable metadata of a compiled model (the graph's root node)."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from snakeorm.core.placement import DEFAULT_DATABASE, DEFAULT_SCHEMA
+from snakeorm.metadata.check import SnakeCheckInfo
+from snakeorm.metadata.column import SnakeColumnInfo
+from snakeorm.metadata.index import SnakeIndexInfo
+from snakeorm.metadata.polymorphic import SnakePolymorphicInfo
+from snakeorm.metadata.primary_key import SnakePrimaryKeyInfo
+from snakeorm.metadata.relationship import SnakeRelationshipInfo
+from snakeorm.metadata.table_kind import SnakeTableKind
+
+
+@dataclass(frozen=True, slots=True)
+class SnakeTableInfo:
+    """Compiled model: name, columns, primary key, relations and indexes.
+
+    This is the graph's root node. The whole ORM (SQL, migrations, query) reads from here;
+    the runtime never inspects the class again.
+    """
+
+    name: str
+    columns: tuple[SnakeColumnInfo, ...]
+    primary_key: SnakePrimaryKeyInfo
+    relationships: tuple[SnakeRelationshipInfo, ...] = ()
+    schema: str = DEFAULT_SCHEMA
+    # Connection the node lives on. An axis INDEPENDENT of `kind` (what it is vs where it lives).
+    database: str = DEFAULT_DATABASE
+    db_comment: str | None = None  # COMMENT ON TABLE
+    indexes: tuple[SnakeIndexInfo, ...] = ()
+    # Domain rules the DB enforces (`CHECK (...)`). Condition as an AST, not emitted SQL.
+    checks: tuple[SnakeCheckInfo, ...] = ()
+    # What the node IS and who governs it, one single axis instead of booleans: see `SnakeTableKind`.
+    kind: SnakeTableKind = SnakeTableKind.TABLE
+    view_definition: str | None = None  # the view's RAW SELECT (only with `sql=`)
+    view_query: object = None
+    """The `SnakeQuery` that defines the view, uncompiled (only with `query=`).
+
+    It is stored UNCOMPILED on purpose: a view's body is written differently on every engine
+    —quoting, schema qualification, literals, LIMIT/OFFSET— and compiling it at model declaration
+    time froze it into one engine's. The emitter is the one that compiles it, with the target
+    dialect.
+
+    Typed `object` and not `SnakeQuery` because `metadata/` sits BELOW `query/` in the layer graph:
+    annotating it with its real type would invert the dependency. Whoever uses it narrows it.
+    """
+    # EXPLICIT dependencies of this view on OTHER views (resolved names). Forces the migration's
+    # topological order (create A before B). Only between views; empty on a normal table.
+    depends_on: tuple[str, ...] = ()
+    # Participation in a POLYMORPHIC hierarchy. `None` on a normal table. Another axis independent
+    # of `kind`/`database`: see `SnakePolymorphicInfo`.
+    polymorphic: SnakePolymorphicInfo | None = None
+
+    @property
+    def is_polymorphic_child(self) -> bool:
+        """Whether it is a CHILD of a hierarchy: shares a table with the base, filtered by its value.
+
+        Since the physical table is a single one: autogen does NOT emit its `CREATE TABLE` (the base
+        does) and queries DO filter it by its discriminator.
+        """
+        return self.polymorphic is not None and not self.polymorphic.is_base
+
+    @property
+    def is_view(self) -> bool:
+        """Whether the node is a VIEW (read only, no constraints). Derived from `kind`."""
+        return self.kind is SnakeTableKind.VIEW
+
+    @property
+    def is_managed(self) -> bool:
+        """Whether MIGRATIONS govern this node.
+
+        An `EXTERNAL` mirror (`@snake_db_first`) is queried and written like any other model, but
+        autogen ignores it: its schema is governed by the DB, not by us.
+        """
+        return self.kind is not SnakeTableKind.EXTERNAL
+
+    def get_column(self, name: str) -> SnakeColumnInfo | None:
+        """Returns the column with that SQL name, or None if it does not exist."""
+        for column in self.columns:
+            if column.name == name:
+                return column
+        return None
+
+    def get_column_by_attr(self, attr: str) -> SnakeColumnInfo | None:
+        """Returns the column whose Python ATTRIBUTE is `attr`, or None if it does not exist.
+
+        With `snake_column(name=...)` the SQL name and the attribute's differ, and whoever walks the
+        graph uses the attribute. It tries `attr_name` and falls back to the SQL name (hand-written
+        metadata may not carry it).
+        """
+        for column in self.columns:
+            if column.attr_name == attr:
+                return column
+        return self.get_column(attr)

snakeorm/metadata/table_kind.py

@@ -0,0 +1,23 @@
+"""What a graph node IS and WHO governs it."""
+
+from __future__ import annotations
+
+from enum import Enum
+
+
+class SnakeTableKind(Enum):
+    """Nature of a graph node: one single axis, not a bag of booleans.
+
+    Replaces `is_view`/`managed`: N booleans give you illegal states (a managed external view?);
+    the enum makes them unwritable. `database` does NOT belong here (an axis independent of what
+    the node is).
+
+    - `TABLE`: a table we manage (create/alter/drop).
+    - `VIEW`: a view we manage (`@snake_view`). READ ONLY, no constraints.
+    - `EXTERNAL`: a mirror of something existing that we do NOT govern (`@snake_db_first`);
+      migrations IGNORE it.
+    """
+
+    TABLE = "table"
+    VIEW = "view"
+    EXTERNAL = "external"

snakeorm/metadata/trigger.py

@@ -0,0 +1,62 @@
+"""Metadata of a TRIGGER: the signal that lives in the database.
+
+Against a code signal (`snakeorm/signals.py`), a trigger holds even when the row is written by
+another process or by a `psql`, because the rule lives in the schema. That is why the `body` is SQL
+and only SQL: no callables, this is the border between the two mechanisms.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import Enum
+
+from snakeorm.core.placement import DEFAULT_SCHEMA
+from snakeorm.core.exceptions import SnakeModelDefinitionError
+
+
+class SnakeTriggerTiming(Enum):
+    """When it fires relative to the operation. Engine-agnostic: all three are standard SQL."""
+
+    BEFORE = "BEFORE"
+    AFTER = "AFTER"
+    INSTEAD_OF = "INSTEAD OF"
+
+
+class SnakeTriggerEvent(Enum):
+    """Which operation fires it."""
+
+    INSERT = "INSERT"
+    UPDATE = "UPDATE"
+    DELETE = "DELETE"
+    TRUNCATE = "TRUNCATE"
+
+
+@dataclass(frozen=True, slots=True)
+class SnakeTriggerInfo:
+    """A trigger on a table: when, on what, and what it runs.
+
+    `body` is raw and opaque (`EXECUTE FUNCTION audit()`), as in `SnakeRoutineInfo`: the diff only
+    compares the string (typing PL/pgSQL would mean putting a whole language inside the ORM).
+    `for_each_row` tells a per-ROW trigger apart from a per-STATEMENT one; per row by default
+    (required for `NEW`/`OLD`).
+    """
+
+    name: str
+    table: str
+    timing: SnakeTriggerTiming
+    events: tuple[SnakeTriggerEvent, ...]
+    body: str
+    schema: str = DEFAULT_SCHEMA
+    for_each_row: bool = True
+
+    def __post_init__(self) -> None:
+        """A trigger with no events fires on nothing: a dead object.
+
+        It is rejected at DECLARATION time (not at emission), while the user still remembers what
+        they meant to write.
+        """
+        if not self.events:
+            raise SnakeModelDefinitionError(
+                f"Trigger '{self.name}' does not declare any event, so it would never fire. "
+                f"Declare at least one event (INSERT, UPDATE, DELETE or TRUNCATE)."
+            )

snakeorm/metadata/type_params.py

@@ -0,0 +1,348 @@
+"""SQL parameters of a column, grouped BY TYPE FAMILY.
+
+Every Python type family has its own parameters: an `int` has width, a `str` has length, a
+`Decimal` has precision and scale, a `dict` has backing. Loose and flat inside `SnakeColumnInfo`,
+nothing stopped you from writing a column with `max_length` AND `precision` at once — a state no
+engine can represent, living in the graph that is supposed to BE the truth.
+
+Grouped, that combination cannot even be built. And the dialect now receives ONE parameter instead
+of five: that is what finally lets `precision` enter `map_type` (it used to be concatenated onto
+the type FROM OUTSIDE, with an f-string, which is why it was the only unvalidated one).
+
+Adding a new family = a dataclass here and a branch in each dialect. Neither the compiler nor
+`SnakeColumnInfo` gets touched: the guard is structural and reads `python_type`.
+"""
+
+from __future__ import annotations
+
+from typing import get_origin
+
+from dataclasses import dataclass
+from datetime import datetime, time
+from decimal import Decimal
+
+from snakeorm.core.exceptions import SnakeModelDefinitionError
+from snakeorm.metadata.int_size import SnakeIntSize
+from snakeorm.metadata.json_storage import SnakeJsonStorage
+
+
+def base_type(python_type: object) -> object:
+    """A parameterised generic reduced to its ORIGIN; anything else unchanged.
+
+    `dict[str, object]` answers `dict`, `list[int]` answers `list`, and `bool` answers `bool` —
+    `get_origin` of a plain class is `None`, which is what keeps the identity comparison below
+    strict where it has to be.
+
+    It exists because the guard compared `python_type is self.python_type`, so a user who
+    parameterised their column —the only way to write a JSON column WITHOUT dragging in `Any`—
+    got a refusal at import, with a message that asked them to change `dict` into `dict`. The
+    project's rule number one is zero `Any`, and the ORM was forcing it.
+    """
+    return get_origin(python_type) or python_type
+
+
+@dataclass(frozen=True, slots=True)
+class SnakeIntParams:
+    """Parameters of an `int` column: how much room it takes in the database."""
+
+    size: SnakeIntSize = SnakeIntSize.BIGINT
+
+    @property
+    def python_type(self) -> type:
+        """The Python type this family belongs to. The compiler's guard uses it."""
+        return int
+
+    def accepts(self, python_type: object) -> bool:
+        """The family covers EXACTLY its type. By identity, not by inheritance: `bool` is a
+        subclass of `int` and accepting it would size a boolean column as an integer.
+
+        The ORIGIN is what gets compared, so `dict[str, object]` is a `dict` — which is the only
+        way to declare a JSON column without a bare `dict` and the `Any` it drags in. It does not
+        loosen the identity: `get_origin(bool)` is `None`, so `bool` still compares as itself."""
+        return base_type(python_type) is self.python_type
+
+    @property
+    def declarator(self) -> str:
+        """The name of the field specifier that declares them. It goes into the error messages, so
+        the warning says WHAT to write and not just what is wrong."""
+        return "snake_int"
+
+
+@dataclass(frozen=True, slots=True)
+class SnakeStrParams:
+    """Parameters of a `str` column: its maximum length, if it declares one.
+
+    The CEILING is set by each engine (Postgres and MySQL do not agree, and MySQL's even depends on
+    the collation); here we only head off what means nothing on any of them.
+    """
+
+    max_length: int | None = None
+    fixed: bool = False
+    """FIXED length (`CHAR(n)`) instead of variable (`VARCHAR(n)`).
+
+    It is not a stricter VARCHAR: `CHAR` pads with spaces up to `n` and compares ignoring that
+    padding. Whoever stores country codes, ISINs or a hash of known length wants it for exactly that
+    reason, and everybody else should not pay for it — which is why the default is still VARCHAR.
+    """
+
+    def __post_init__(self) -> None:
+        """A VARCHAR has to fit at least one character, and a CHAR has to say how many.
+
+        `VARCHAR(0)` is LEGAL on both engines and useless: it only accepts the empty string. That
+        the engine swallows it does not make it a reasonable declaration — nobody wants a column
+        like that — and this ORM shouts instead of letting through what is almost certainly a slip.
+        """
+        if self.max_length is not None and self.max_length < 1:
+            raise SnakeModelDefinitionError(
+                f"A VARCHAR has to fit at least one character, and max_length={self.max_length} "
+                f"was asked for. For unbounded text, do not declare max_length at all: "
+                f"snake_str() already emits TEXT."
+            )
+        if self.fixed and self.max_length is None:
+            # A bare `CHAR` is `CHAR(1)` in SQL. Guessing it would mean taking a decision the user
+            # never took on their behalf, and a one-character column where text was expected does
+            # not show up until something gets truncated.
+            raise SnakeModelDefinitionError(
+                "A fixed-length column has to say HOW MANY characters: declare "
+                "snake_str(max_length=n, fixed=True). A CHAR without a length is CHAR(1) in SQL, "
+                "and that is almost never what anyone wants."
+            )
+
+    @property
+    def python_type(self) -> type:
+        """The Python type this family belongs to. The compiler's guard uses it."""
+        return str
+
+    def accepts(self, python_type: object) -> bool:
+        """The family covers EXACTLY its type. By identity, not by inheritance: `bool` is a
+        subclass of `int` and accepting it would size a boolean column as an integer.
+
+        The ORIGIN is what gets compared, so `dict[str, object]` is a `dict` — which is the only
+        way to declare a JSON column without a bare `dict` and the `Any` it drags in. It does not
+        loosen the identity: `get_origin(bool)` is `None`, so `bool` still compares as itself."""
+        return base_type(python_type) is self.python_type
+
+    @property
+    def declarator(self) -> str:
+        """The name of the field specifier that declares them. It goes into the error messages, so
+        the warning says WHAT to write and not just what is wrong."""
+        return "snake_str"
+
+
+@dataclass(frozen=True, slots=True)
+class SnakeDecimalParams:
+    """Parameters of a `Decimal` column: the NUMERIC's digits.
+
+    `precision` is mandatory: a NUMERIC without it accepts any number of digits, so rounding stops
+    being declared and starts depending on whatever comes in.
+
+    Only what is absurd on ANY engine is rejected here. The ceiling —1000 digits in Postgres, 65 in
+    MySQL— is engine knowledge and lives in its dialect, like `max_bind_params`.
+
+    On scale: Postgres 15 accepts negative scales and scales greater than the precision, as its own
+    extension. It is not exposed, on purpose. The standard demands `0 <= scale <= precision`, MySQL
+    demands it, and Postgres demanded it up to 15; opening it would make a model stop being portable
+    depending on the VERSION of the server behind it, which is exactly what the Dialect/Driver axis
+    avoids.
+    """
+
+    precision: int
+    scale: int | None = None
+
+    def __post_init__(self) -> None:
+        """Heads off the three impossible numbers at construction, the earliest point there is."""
+        if self.precision < 1:
+            raise SnakeModelDefinitionError(
+                f"A NUMERIC has to have at least one digit, and "
+                f"precision={self.precision} was asked for. Precision is the TOTAL number of "
+                f"digits; the decimal places go in scale."
+            )
+        if self.scale is None:
+            return
+        if self.scale < 0:
+            raise SnakeModelDefinitionError(
+                f"The scale of a NUMERIC cannot be negative (scale={self.scale} was asked for). "
+                f"It is the decimal places: 2 for money, 0 for exact integers."
+            )
+        if self.scale > self.precision:
+            raise SnakeModelDefinitionError(
+                f"The scale cannot exceed the precision: {self.scale} decimal places were asked "
+                f"for inside {self.precision} total digits, leaving nothing for the integer "
+                f"part. Raise precision or lower scale."
+            )
+
+    @property
+    def python_type(self) -> type:
+        """The Python type this family belongs to. The compiler's guard uses it."""
+        return Decimal
+
+    def accepts(self, python_type: object) -> bool:
+        """The family covers EXACTLY its type. By identity, not by inheritance: `bool` is a
+        subclass of `int` and accepting it would size a boolean column as an integer.
+
+        The ORIGIN is what gets compared, so `dict[str, object]` is a `dict` — which is the only
+        way to declare a JSON column without a bare `dict` and the `Any` it drags in. It does not
+        loosen the identity: `get_origin(bool)` is `None`, so `bool` still compares as itself."""
+        return base_type(python_type) is self.python_type
+
+    @property
+    def declarator(self) -> str:
+        """The name of the field specifier that declares them. It goes into the error messages, so
+        the warning says WHAT to write and not just what is wrong."""
+        return "snake_decimal"
+
+
+@dataclass(frozen=True, slots=True)
+class SnakeJsonParams:
+    """Parameters of a `dict` column: which DB object backs it."""
+
+    storage: SnakeJsonStorage = SnakeJsonStorage.JSONB
+
+    @property
+    def python_type(self) -> type:
+        """The Python type this family belongs to. The compiler's guard uses it."""
+        return dict
+
+    def accepts(self, python_type: object) -> bool:
+        """The family covers EXACTLY its type. By identity, not by inheritance: `bool` is a
+        subclass of `int` and accepting it would size a boolean column as an integer.
+
+        The ORIGIN is what gets compared, so `dict[str, object]` is a `dict` — which is the only
+        way to declare a JSON column without a bare `dict` and the `Any` it drags in. It does not
+        loosen the identity: `get_origin(bool)` is `None`, so `bool` still compares as itself."""
+        return base_type(python_type) is self.python_type
+
+    @property
+    def declarator(self) -> str:
+        """The name of the field specifier that declares them. It goes into the error messages, so
+        the warning says WHAT to write and not just what is wrong."""
+        return "snake_json"
+
+
+@dataclass(frozen=True, slots=True)
+class SnakeDateTimeParams:
+    """Parameters of a date column: whether the column carries a zone, and its resolution.
+
+    `tz` is NOT a knob you pick by hand: the declarator sets it (`snake_datetimetz()` sets it to
+    `True`, `snake_datetime()` to `False`) and a compiler guard demands it match the annotation.
+    That way the MODEL says which column gets created —just as `snake_int(size=SMALLINT)` says
+    SMALLINT— without the redundancy being able to lie. Same treatment as `snake_enum(Status)` over
+    a `SnakeColumn[Status]`.
+
+    `precision` is the fractional-second digits: `0` whole seconds, `3` milliseconds, `6` the
+    Postgres default (exactly the resolution of Python's `datetime`).
+
+    Only what means nothing on ANY engine is rejected here —a negative digit count—. The CEILING is
+    set by each dialect: Postgres and MySQL stop at 6, SQL Server reaches 7 and Oracle 9, so pinning
+    it here would put a specific engine inside the model, and the project's golden rule is that the
+    metadata graph stays agnostic.
+    """
+
+    tz: bool = False
+    precision: int | None = None
+
+    def __post_init__(self) -> None:
+        """Heads off a negative precision at construction, the earliest point there is."""
+        if self.precision is not None and self.precision < 0:
+            raise SnakeModelDefinitionError(
+                f"The precision of a date cannot be negative ({self.precision} was asked for). "
+                f"It is the fractional-second digits: 0 is whole seconds, 3 milliseconds and "
+                f"6 microseconds, which is the resolution of Python's datetime."
+            )
+
+    @property
+    def python_type(self) -> type:
+        """The Python type this family belongs to. The compiler's guard uses it."""
+        return datetime
+
+    def accepts(self, python_type: object) -> bool:
+        """The family covers `datetime` AND `SnakeUtc`, which is a subclass of it.
+
+        The other families compare by identity; this one cannot, because `SnakeUtc` is the same data
+        type with a guarantee on top.
+        """
+        return isinstance(python_type, type) and issubclass(python_type, datetime)
+
+    @property
+    def declarator(self) -> str:
+        """The name of the field specifier that declares them. It goes into the error messages, so
+        the warning says WHAT to write and not just what is wrong."""
+        return "snake_datetime"
+
+
+@dataclass(frozen=True, slots=True)
+class SnakeFloatParams:
+    """Parameters of a `float` column: its WIDTH in bytes.
+
+    A Python `float` is double precision, so 8 is the default and it does not change: changing it
+    would make an already-written model lose precision silently on upgrade. Declaring 4 is a storage
+    decision —half the bytes per row— taken knowing what you lose.
+    """
+
+    size: int = 8
+
+    def __post_init__(self) -> None:
+        """Only 4 and 8: there is no engine with any other floating-point width.
+
+        Like every other structural guard, what means nothing on ANY engine dies at declaration
+        time. Per-engine ceilings are another matter and live in the dialect.
+        """
+        if self.size not in (4, 8):
+            raise SnakeModelDefinitionError(
+                f"A float is either 4 or 8 bytes, and size={self.size} was asked for. 4 is single "
+                f"precision (REAL/FLOAT) and 8 is double (DOUBLE PRECISION/DOUBLE), which is what a "
+                f"Python float is and the default of this ORM."
+            )
+
+    @property
+    def python_type(self) -> type:
+        """The Python type this family belongs to. The compiler's guard uses it."""
+        return float
+
+    def accepts(self, python_type: object) -> bool:
+        """The family covers EXACTLY its type, by identity and not by inheritance."""
+        return python_type is self.python_type
+
+    @property
+    def declarator(self) -> str:
+        """The name of the field specifier that declares them, so the error says WHAT to write."""
+        return "snake_float"
+
+
+@dataclass(frozen=True, slots=True)
+class SnakeTimeParams:
+    """Parameters of a `time` column: whether it carries a ZONE.
+
+    Two declarators, as with dates (`snake_datetime` / `snake_datetimetz`), and for the same reason:
+    the column SAYS which type it creates instead of it depending on whether the first value that
+    arrived carried an offset. A bare `TIME` throws the zone away, and an opening time stops meaning
+    the same thing when seen from somewhere else.
+    """
+
+    with_timezone: bool = False
+
+    @property
+    def python_type(self) -> type:
+        """The Python type this family belongs to. The compiler's guard uses it."""
+        return time
+
+    def accepts(self, python_type: object) -> bool:
+        """The family covers EXACTLY its type, by identity and not by inheritance."""
+        return python_type is self.python_type
+
+    @property
+    def declarator(self) -> str:
+        """The name of the field specifier that declares them, so the error says WHAT to write."""
+        return "snake_timetz" if self.with_timezone else "snake_time"
+
+
+SnakeTypeParams = (
+    SnakeIntParams
+    | SnakeStrParams
+    | SnakeDecimalParams
+    | SnakeJsonParams
+    | SnakeDateTimeParams
+    | SnakeFloatParams
+    | SnakeTimeParams
+)
+"""The parameters of ONE family. `None` on a column that has none (`bool`, `date`...)."""

snakeorm/migration/__init__.py

@@ -0,0 +1,88 @@
+"""SnakeORM migrations: DDL generation from the compiled metadata."""
+
+from snakeorm.migration.asyncrunner import AsyncMigrationRunner as AsyncMigrationRunner
+from snakeorm.migration.autodetect import autodetect as autodetect
+from snakeorm.migration.autodetect import current_routines as current_routines
+from snakeorm.migration.autodetect import current_schema as current_schema
+from snakeorm.migration.autodetect import replay as replay
+from snakeorm.migration.ddl import emit_add_check as emit_add_check
+from snakeorm.migration.ddl import emit_add_column as emit_add_column
+from snakeorm.migration.ddl import emit_add_foreign_key as emit_add_foreign_key
+from snakeorm.migration.ddl import emit_alter_column as emit_alter_column
+from snakeorm.migration.ddl import emit_column_comment as emit_column_comment
+from snakeorm.migration.ddl import emit_comments as emit_comments
+from snakeorm.migration.ddl import emit_create_function as emit_create_function
+from snakeorm.migration.ddl import emit_create_index as emit_create_index
+from snakeorm.migration.ddl import emit_create_schema as emit_create_schema
+from snakeorm.migration.ddl import emit_create_table as emit_create_table
+from snakeorm.migration.ddl import emit_create_trigger as emit_create_trigger
+from snakeorm.migration.ddl import emit_create_view as emit_create_view
+from snakeorm.migration.ddl import emit_drop_check as emit_drop_check
+from snakeorm.migration.ddl import emit_drop_column as emit_drop_column
+from snakeorm.migration.ddl import emit_drop_foreign_key as emit_drop_foreign_key
+from snakeorm.migration.ddl import foreign_key_name as foreign_key_name
+from snakeorm.migration.ddl import emit_drop_function as emit_drop_function
+from snakeorm.migration.ddl import emit_drop_index as emit_drop_index
+from snakeorm.migration.ddl import emit_drop_schema as emit_drop_schema
+from snakeorm.migration.ddl import emit_drop_table as emit_drop_table
+from snakeorm.migration.ddl import emit_drop_trigger as emit_drop_trigger
+from snakeorm.migration.ddl import emit_drop_view as emit_drop_view
+from snakeorm.migration.ddl import emit_rebuild_table as emit_rebuild_table
+from snakeorm.migration.ddl import emit_rename_column as emit_rename_column
+from snakeorm.migration.ddl import emit_rename_table as emit_rename_table
+from snakeorm.migration.ddl import emit_replace_view as emit_replace_view
+from snakeorm.migration.ddl import emit_table_comment as emit_table_comment
+from snakeorm.migration.ddl import inlined_foreign_keys as inlined_foreign_keys
+from snakeorm.migration.ddl import sql_type_of as sql_type_of
+from snakeorm.migration.diff import diff_routines as diff_routines
+from snakeorm.migration.diff import diff_schema as diff_schema
+from snakeorm.migration.diff import drop_order as drop_order
+from snakeorm.migration.diff import diff_triggers as diff_triggers
+from snakeorm.migration.loader import load as load
+from snakeorm.migration.operations import AddCheck as AddCheck
+from snakeorm.migration.operations import AddColumn as AddColumn
+from snakeorm.migration.operations import AddForeignKey as AddForeignKey
+from snakeorm.migration.operations import AlterColumn as AlterColumn
+from snakeorm.migration.operations import AlterTableComment as AlterTableComment
+from snakeorm.migration.operations import AlterFunction as AlterFunction
+from snakeorm.migration.operations import AlterTrigger as AlterTrigger
+from snakeorm.migration.operations import AlterView as AlterView
+from snakeorm.migration.operations import CreateFunction as CreateFunction
+from snakeorm.migration.operations import CreateIndex as CreateIndex
+from snakeorm.migration.operations import CreateSchema as CreateSchema
+from snakeorm.migration.operations import CreateTable as CreateTable
+from snakeorm.migration.operations import CreateTrigger as CreateTrigger
+from snakeorm.migration.operations import CreateView as CreateView
+from snakeorm.migration.operations import DropCheck as DropCheck
+from snakeorm.migration.operations import DropColumn as DropColumn
+from snakeorm.migration.operations import DropForeignKey as DropForeignKey
+from snakeorm.migration.operations import DropFunction as DropFunction
+from snakeorm.migration.operations import DropIndex as DropIndex
+from snakeorm.migration.operations import DropSchema as DropSchema
+from snakeorm.migration.operations import DropTable as DropTable
+from snakeorm.migration.operations import DropTrigger as DropTrigger
+from snakeorm.migration.operations import DropView as DropView
+from snakeorm.migration.operations import RebuildTable as RebuildTable
+from snakeorm.migration.operations import RenameColumn as RenameColumn
+from snakeorm.migration.operations import RenameTable as RenameTable
+from snakeorm.migration.operations import RunPython as RunPython
+from snakeorm.migration.operations import RunSQL as RunSQL
+from snakeorm.migration.operations import SnakeDataOperation as SnakeDataOperation
+from snakeorm.migration.operations import (
+    SnakeMigrationOperation as SnakeMigrationOperation,
+)
+from snakeorm.migration.operations import SnakeOperation as SnakeOperation
+from snakeorm.migration.realize import realize as realize
+from snakeorm.migration.renames import RenameSuggestion as RenameSuggestion
+from snakeorm.migration.renames import format_narrowing_hint as format_narrowing_hint
+from snakeorm.migration.renames import format_rename_hint as format_rename_hint
+from snakeorm.migration.renames import narrowing_warnings as narrowing_warnings
+from snakeorm.migration.renames import rename_suggestions as rename_suggestions
+from snakeorm.migration.renames import standing_view_warning as standing_view_warning
+from snakeorm.migration.render import render_migration as render_migration
+from snakeorm.migration.runner import Migration as Migration
+from snakeorm.migration.planner import dependency_order as dependency_order
+from snakeorm.migration.runner import MigrationRunner as MigrationRunner
+from snakeorm.migration.runner import squash_already_done as squash_already_done
+from snakeorm.migration.squash import squash as squash
+from snakeorm.migration.state import SchemaState as SchemaState