snake-orm 0.1.0b1__py3-none-any.whl

snakeorm/query/recursive.py

@@ -0,0 +1,244 @@
+"""`WITH RECURSIVE`: walking an entire hierarchy with ONE query.
+
+It brings a NEW capability: "every descendant at any depth" cannot be written with subqueries
+(either you go down level by level with an N+1, or you use recursion). Emitted shape:
+
+    WITH RECURSIVE snake_rec AS (
+        (<anchor>) UNION [ALL]
+        SELECT t.<cols> FROM <table> AS t JOIN snake_rec ON t.<child> = snake_rec.<accumulated>
+    )
+    SELECT <cols> FROM snake_rec [ORDER BY ...] [LIMIT ...]
+
+`UNION ALL` by default: deduplicating every step would cost hashing everything accumulated so far,
+and a well-formed tree has no duplicates to drop. Over data with CYCLES that walk never ends —each
+lap yields rows the engine counts as new— so the operator is the CALLER's to pick: `distinct=True`
+emits a plain `UNION`, the lap that repeats contributes nothing, and the recursion stops on its own.
+
+A `limit()` is not a substitute. Measured against a real Postgres over a three-row cycle: `UNION
+ALL` with an `order_by()` and a `LIMIT 3` never returns, because the sort has to consume every row
+before it can emit one. The limit bounds what comes BACK, not how far the engine goes.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, replace
+from typing import TYPE_CHECKING, Any, Generic, TypeVar
+
+from snakeorm.dialects import SnakeDialect
+from snakeorm.core.exceptions import SnakeEmitError
+from snakeorm.expressions import SnakeExpr, SnakeOrder
+from snakeorm.metadata import SnakeTableInfo
+from snakeorm.sql.refs import qualified
+from snakeorm.sql.value import emit_order_key, guard_untabled_order_keys
+
+if TYPE_CHECKING:
+    from snakeorm.query.query import SnakeQuery
+
+T = TypeVar("T")
+
+CTE_NAME = "snake_rec"
+"""Name of the CTE. Fixed on purpose: it does not nest (a recursion admits no other inside it)."""
+
+SOURCE_ALIAS = "snake_src"
+"""Alias of the table inside the recursive step, mandatory: the CTE has the same column names, so
+without an alias they are ambiguous and Postgres rejects the query (the test against the engine caught it)."""
+
+
+@dataclass(frozen=True, slots=True)
+class SnakeRecursive(Generic[T]):
+    """An ANCHOR query that expands itself by following a hop onto itself.
+
+    `child_column` points upwards (`parent_id`) and `parent_column` identifies the accumulated row
+    (`id`): the direction is fixed by which one goes first (swapping them walks the ancestors, a
+    perfectly legitimate query).
+
+    `distinct` picks the set operator that joins each step to what has already been accumulated:
+    `False` (the default) emits `UNION ALL`, `True` emits `UNION`. It is the difference between a
+    walk that ends over cyclic data and one that does not.
+    """
+
+    anchor: SnakeQuery[T]
+    table: SnakeTableInfo
+    child_column: str
+    parent_column: str
+    distinct: bool = False
+    order_by_keys: tuple[SnakeOrder, ...] = ()
+    limit_value: int | None = None
+    offset_value: int | None = None
+
+    @property
+    def model(self) -> type[T]:
+        """The model of the rows: the same as the anchor's. The session uses it to instantiate them."""
+        return self.anchor.model
+
+    @property
+    def projected_columns(self) -> frozenset[str] | None:
+        """Never narrowed: the CTE's columns are the TABLE's, and a narrowed anchor is refused."""
+        return None
+
+    @property
+    def has_includes(self) -> bool:
+        """Never: an anchor with includes is rejected at build time, not here."""
+        return False
+
+    @property
+    def has_lock(self) -> bool:
+        """Never: a recursive CTE does not lock rows. It is rejected at build time."""
+        return False
+
+    @property
+    def has_bounds(self) -> bool:
+        """Tells whether it carries `limit`/`offset` of its own. The compound looks at this."""
+        return self.limit_value is not None or self.offset_value is not None
+
+    @property
+    def has_order(self) -> bool:
+        """Tells whether it carries `order_by` of its own. The compound looks at this."""
+        return bool(self.order_by_keys)
+
+    @property
+    def has_cte(self) -> bool:
+        """Always: this is the `WITH RECURSIVE`. The compound asks so it can refuse where a CTE
+        cannot be a branch, which is two of the three engines."""
+        return True
+
+    def order_by(self, *keys: SnakeExpr[Any] | SnakeOrder) -> SnakeRecursive[T]:
+        """Orders the RESULT (not the anchor nor the step). A bare column orders ascending.
+
+        The same guard the compound uses, and for the same reason: the `SELECT ... FROM cte` this
+        ordering hangs off has only the CTE's columns, so a key that navigates a relationship would
+        lose the hop and be written as another column's bare name.
+        """
+        normalized = tuple(
+            key if isinstance(key, SnakeOrder) else key.asc() for key in keys
+        )
+        guard_untabled_order_keys(
+            normalized,
+            self.projected_columns,
+            "A WITH RECURSIVE",
+            "Order the rows in Python after the traversal, or join the far table in a separate "
+            "query.",
+        )
+        return replace(self, order_by_keys=self.order_by_keys + normalized)
+
+    def limit(self, limit: int) -> SnakeRecursive[T]:
+        """Bounds the RESULT, and only the result: it does NOT bound the traversal.
+
+        It read as the safety net against a cycle until somebody measured it. Put an `order_by()`
+        in front of it —which is the normal way to ask for a hierarchy— and the engine has to
+        produce every row before it can sort them, so the bound never gets its turn and the query
+        hangs all the same. What ends a cyclic walk is `recursive(..., distinct=True)`.
+        """
+        return replace(self, limit_value=limit)
+
+    def offset(self, offset: int) -> SnakeRecursive[T]:
+        """Skips rows of the result (it replaces the previous one)."""
+        return replace(self, offset_value=offset)
+
+    def to_sql(self, dialect: SnakeDialect) -> tuple[str, tuple[object, ...]]:
+        """Compiles to `(sql, params)`, with the ANCHOR's params first.
+
+        That order is mandatory: the anchor comes earlier in the string and Postgres' `%s` is positional.
+        """
+        quote = dialect.quote_ident
+        columns = ", ".join(quote(column.name) for column in self.table.columns)
+        cte = quote(CTE_NAME)
+        source = quote(SOURCE_ALIAS)
+        # The step's columns go QUALIFIED by the alias: the CTE has the same names.
+        step_columns = ", ".join(
+            f"{source}.{quote(column.name)}" for column in self.table.columns
+        )
+
+        params: list[object] = []
+        anchor_sql, anchor_params = self.anchor.to_sql(dialect)
+        params.extend(anchor_params)
+
+        # The anchor is parenthesised only if the engine admits it (SQLite rejects `((SELECT ...)
+        # UNION ALL ...)`). Same flag as the UNION emitter. Without parentheses, an anchor with
+        # limit()/offset() of its own is inexpressible (the bounding would read off the whole UNION),
+        # so it is rejected in plain words.
+        if not dialect.supports_parenthesised_compound and self.anchor.has_bounds:
+            raise SnakeEmitError(
+                "This engine does not accept parentheses around the anchor of a WITH RECURSIVE, so "
+                "an anchor with its own limit()/offset() is inexpressible: the bound would read "
+                "off the whole traversal. Drop them from the anchor and bound the RESULT with "
+                ".limit() on the recursion."
+            )
+        anchor = (
+            f"({anchor_sql})" if dialect.supports_parenthesised_compound else anchor_sql
+        )
+
+        table = qualified(self.table.schema, self.table.name, dialect)
+        step = (
+            f"SELECT {step_columns} FROM {table} AS {source} "
+            f"JOIN {cte} ON {source}.{quote(self.child_column)} "
+            f"= {cte}.{quote(self.parent_column)}"
+        )
+        # The operator the CALLER chose. `UNION` is `UNION DISTINCT`, so the step drops what has
+        # already been accumulated and a cyclic walk runs out of new rows instead of running for ever.
+        operator = "UNION" if self.distinct else "UNION ALL"
+        sql = (
+            f"WITH RECURSIVE {cte} AS ({anchor} {operator} {step}) "
+            f"SELECT {columns} FROM {cte}"
+        )
+
+        if self.order_by_keys:
+            keys = ", ".join(
+                emit_order_key(key, dialect, params, None) for key in self.order_by_keys
+            )
+            sql = f"{sql} ORDER BY {keys}"
+
+        clause = dialect.limit_offset(self.limit_value, self.offset_value, params)
+        if clause:
+            sql = f"{sql} {clause}"
+        return sql, tuple(params)
+
+
+def build_recursive(
+    anchor: SnakeQuery[T],
+    table: SnakeTableInfo,
+    child: SnakeExpr[Any],
+    parent: SnakeExpr[Any],
+    distinct: bool = False,
+) -> SnakeRecursive[T]:
+    """Builds the recursion, rejecting whatever does not survive a CTE.
+
+    The hop's two columns must belong to the table that recurses (it joins ONTO ITSELF): a column
+    from another model would be emitted all the same and would produce an absurd JOIN, or worse,
+    wrong results with no error.
+
+    `distinct` travels straight through to the emission: it is a choice, not something to validate.
+    """
+    if anchor.has_includes:
+        raise SnakeEmitError(
+            "A query with include(...) cannot be the anchor of a recursion: the columns of the "
+            "CTE are those of the table, so the loaded relationships would be lost. Recurse "
+            "without include and load the relationships afterwards."
+        )
+    if anchor.has_lock:
+        raise SnakeEmitError(
+            "A query with for_update() cannot be the anchor of a recursion: Postgres does not "
+            "accept locks inside a recursive CTE. Lock the rows in a separate query."
+        )
+    if anchor.projected_columns is not None:
+        raise SnakeEmitError(
+            "A query narrowed with only()/defer() cannot be the anchor of a recursion: the CTE's "
+            "columns are the TABLE's, so the step selects every one of them and the anchor would "
+            "select a few, and the UNION inside the CTE would not line up. Recurse whole rows and "
+            "project afterwards."
+        )
+
+    names = {column.name for column in table.columns}
+    for expr in (child, parent):
+        if expr.path[-1] not in names:
+            raise SnakeEmitError(
+                f"Column '{expr.path[-1]}' does not belong to '{table.name}', and a recursion joins "
+                f"that table WITH ITSELF. Both columns of the hop have to be its own."
+            )
+    return SnakeRecursive(
+        anchor=anchor,
+        table=table,
+        child_column=child.path[-1],
+        parent_column=parent.path[-1],
+        distinct=distinct,
+    )

snakeorm/registry/__init__.py

@@ -0,0 +1,5 @@
+"""SnakeORM's registry of compiled models."""
+
+from snakeorm.registry.registry import SnakeRegistry as SnakeRegistry
+from snakeorm.registry.registry import registry_of as registry_of
+from snakeorm.registry.registry import registry as registry

snakeorm/registry/by_module.py

@@ -0,0 +1,163 @@
+"""Resolving a model NAME the way the module that wrote it means it.
+
+A class name does not identify a model: two apps can each declare a `Customer`, and the registry's
+by-name index keeps whichever registered LAST. Asking it is bug #14, and it does not fail — it
+returns a valid answer about the wrong table.
+
+Annotations never had the problem: `get_type_hints` evaluates against the MODULE's globals, so each
+file resolves its own `Post`. This does the same for names that arrive as ARGUMENTS
+(`through="Tagging"`), so one declaration stops having two rules on adjacent lines.
+
+Two callers, one reader. `resolve_in_module` answers about ONE name; `type_checking_names` answers
+about the whole block, for `linker.hints_of`, which resolves a model's annotations all at once. They
+share `_type_checking_imports` so a spelling one understands is a spelling the other does too.
+
+Two layers, in this order:
+
+1. The module's globals. Covers the forward declaration — the class comes later in the same file —
+   because `snake_link()` runs at the end. Costs nothing.
+2. The `if TYPE_CHECKING:` block, read from source. Covers the real circular import, where the name
+   is never in globals and `get_type_hints` raises `NameError`.
+
+If neither has it, it REFUSES naming both ways out. Falling back to the global index is what this
+module exists to stop.
+"""
+
+from __future__ import annotations
+
+import ast
+import importlib.util
+import inspect
+import sys
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from types import ModuleType
+
+
+def resolve_in_module(owner: type, name: str) -> type | None:
+    """The class `name` refers to, as seen from the module that declared `owner`.
+
+    `None` when the module cannot see it at all — the caller decides how to complain, because it is
+    the one that knows what the name was for.
+    """
+    module = sys.modules.get(owner.__module__)
+    if module is None:  # pragma: no cover - a class whose module was unloaded
+        return None
+    found = getattr(module, name, None)
+    if isinstance(found, type):
+        return found
+    return _from_type_checking(module, name)
+
+
+def type_checking_names(owner: type) -> dict[str, type]:
+    """Every class the OWNER's module imports under `if TYPE_CHECKING:`, imported for real.
+
+    The same reading as `resolve_in_module`'s second layer, answering for the whole block instead of
+    one name — because the caller that needs it, `get_type_hints`, resolves a model's annotations
+    ALL AT ONCE and cannot be asked about them one at a time.
+
+    Empty when there is no block, no source, or nothing importable in it. That is not a failure: the
+    caller passes this as extra scope, and extra scope that adds nothing simply changes nothing.
+    """
+    module = sys.modules.get(owner.__module__)
+    if module is None:  # pragma: no cover - a class whose module was unloaded
+        return {}
+    found: dict[str, type] = {}
+    for module_name, local, attribute in _type_checking_imports(module):
+        imported = _import(module_name, attribute)
+        if imported is not None:
+            found[local] = imported
+    return found
+
+
+def _from_type_checking(module: ModuleType, name: str) -> type | None:
+    """The class a `if TYPE_CHECKING:` import names, imported for real, or `None`.
+
+    This block is invisible at runtime by design, so the only way to read it is from the SOURCE. It
+    is the one case layer 1 cannot cover: a genuine circular import between two modules, where the
+    runtime import never happens.
+
+    Importing the named module HERE is safe in a way it would not have been at declaration time: by
+    the time anything asks, the cycle that made the author write `TYPE_CHECKING` is over.
+    """
+    for module_name, local, attribute in _type_checking_imports(module):
+        if local != name:
+            continue
+        imported = _import(module_name, attribute)
+        if imported is not None:
+            return imported
+    return None
+
+
+def _type_checking_imports(module: ModuleType) -> list[tuple[str, str, str]]:
+    """Every `from X import Y [as Z]` inside the module's type-checking blocks.
+
+    `(module, bound name, attribute)`, in source order. It is one reader for the two questions asked
+    of the block —one name, or all of them— so a spelling either understands is a spelling both do.
+    Splitting it was how `through=` and the annotations came to disagree in the first place.
+    """
+    try:
+        source = inspect.getsource(module)
+    except (OSError, TypeError):  # pragma: no cover - a module with no source on disk
+        return []
+    found: list[tuple[str, str, str]] = []
+    for statement in ast.parse(source).body:
+        if not isinstance(statement, ast.If) or not _is_type_checking(statement.test):
+            continue
+        for node in statement.body:
+            if not isinstance(node, ast.ImportFrom):
+                continue
+            absolute = _absolute(node, module)
+            if absolute is None:
+                continue
+            for alias in node.names:
+                found.append((absolute, alias.asname or alias.name, alias.name))
+    return found
+
+
+def _absolute(node: ast.ImportFrom, module: ModuleType) -> str | None:
+    """The module an import names, with `from .sibling import X` resolved against its package.
+
+    Relative imports are the ordinary way to write one inside a package, so skipping them would drop
+    the pair back onto the bare `NameError` this fallback exists to stop. Resolving them is not a
+    guess: the module carries its own `__package__` and `importlib.util.resolve_name` is what the
+    import system itself uses. `None` only when there is no package to resolve against.
+    """
+    if not node.level:
+        return node.module
+    package = getattr(module, "__package__", None)
+    if (
+        not package
+    ):  # pragma: no cover - a relative import outside any package cannot be executed
+        return None
+    try:
+        return importlib.util.resolve_name(
+            f"{'.' * node.level}{node.module or ''}", package
+        )
+    except (
+        ImportError,
+        ValueError,
+    ):  # pragma: no cover - more dots than the package is deep
+        return None
+
+
+def _is_type_checking(test: ast.expr) -> bool:
+    """Whether an `if` guards on `TYPE_CHECKING`, spelled bare or as `typing.TYPE_CHECKING`."""
+    if isinstance(test, ast.Name):
+        return test.id == "TYPE_CHECKING"
+    return isinstance(test, ast.Attribute) and test.attr == "TYPE_CHECKING"
+
+
+def _import(module_name: str, attribute: str) -> type | None:
+    """Imports `module_name` and returns its `attribute`, or `None` if either step fails.
+
+    Failures come back as `None` rather than raising: this is one of two layers, and a module that
+    cannot be imported is a name this layer cannot answer for — not an error in itself. The caller
+    refuses once, with both ways out named.
+    """
+    try:
+        found = getattr(importlib.import_module(module_name), attribute, None)
+    except ImportError:
+        return None
+    return found if isinstance(found, type) else None

snakeorm/registry/registry.py

@@ -0,0 +1,166 @@
+"""The Registry: the store of compiled models (class → SnakeTableInfo)."""
+
+from __future__ import annotations
+
+from snakeorm.core.exceptions import SnakeRegistryError
+from snakeorm.metadata import (
+    SnakeRelationshipInfo,
+    SnakeRoutineInfo,
+    SnakeTableInfo,
+    SnakeTriggerInfo,
+)
+
+
+class SnakeRegistry:
+    """A class → SnakeTableInfo store (and name → SnakeRoutineInfo alongside it).
+
+    @snake_model populates it (Phase 1); the linker reads it and replaces the already-linked tables
+    (Phase 2). The routines from `snake_function(...)` live apart (`_routines`): they are not
+    models, just a DESIRED function the diff compares against.
+    """
+
+    def __init__(self) -> None:
+        self._tables: dict[type, SnakeTableInfo] = {}
+        self._by_name: dict[str, SnakeTableInfo] = {}
+        self._model_by_name: dict[str, type] = {}
+        self._table_owner: dict[str, type] = {}
+        self._routines: dict[str, SnakeRoutineInfo] = {}
+        # Key (table, name): in Postgres a trigger's name is NOT unique on its own.
+        self._triggers: dict[tuple[str, str], SnakeTriggerInfo] = {}
+        # qualified table -> {discriminator value: class}. Nested (not a composite key) because the
+        # mapper asks for the WHOLE map ONCE and resolves each row with `dict.get`.
+        self._polymorphic: dict[str, dict[str, type]] = {}
+
+    def register(self, model: type, table: SnakeTableInfo) -> None:
+        """Registers (or replaces) a model's compiled table.
+
+        Guard: two DIFFERENT models cannot map to the same qualified name (re-registering the SAME
+        model is fine, e.g. after snake_link). Exception: a polymorphic hierarchy shares a table on
+        purpose; it is recognised from the metadata (`is_polymorphic_child`), not from a flag, so
+        nobody gets to skip the guard "just this once".
+        """
+        qualified = f"{table.schema}.{table.name}"
+        owner = self._table_owner.get(qualified)
+        if table.is_polymorphic_child:
+            assert table.polymorphic is not None
+            self._tables[model] = table
+            self._by_name[model.__name__] = table
+            self._model_by_name[model.__name__] = model
+            self._polymorphic.setdefault(qualified, {})[
+                table.polymorphic.value or ""
+            ] = model
+            return
+        if owner is not None and owner is not model:
+            raise SnakeRegistryError(
+                f"Table collision: '{qualified}' is already registered by "
+                f"{owner.__qualname__}. Disambiguate with prefix= or table= in @snake_model."
+            )
+        self._table_owner[qualified] = model
+        self._tables[model] = table
+        self._by_name[model.__name__] = table
+        self._model_by_name[model.__name__] = model
+
+    def polymorphic_map(self, table: SnakeTableInfo) -> dict[str, type]:
+        """Every subclass of that table, indexed by its discriminator value.
+
+        The WHOLE map is returned (not one class per value) because the mapper asks for it ONCE and
+        resolves each row with `dict.get`; asking per row was 55% slower on the hottest path. A
+        value with no subclass simply is not in the map, and that is NOT an error: it is hydrated as
+        the base class (you lose the subclass's fields, not the row).
+        """
+        return self._polymorphic.get(f"{table.schema}.{table.name}", {})
+
+    def table_of(self, model: type) -> SnakeTableInfo | None:
+        """Returns a model's compiled table, or None if it is not registered."""
+        return self._tables.get(model)
+
+    def table_by_name(self, name: str) -> SnakeTableInfo | None:
+        """Returns the table by the model's name (to resolve relation targets)."""
+        return self._by_name.get(name)
+
+    def model_by_name(self, name: str) -> type | None:
+        """Returns the model's CLASS by its name (to instantiate related objects in .include())."""
+        return self._model_by_name.get(name)
+
+    def table_by_qualified(self, qualified: str) -> SnakeTableInfo | None:
+        """Returns the table by its QUALIFIED name (`schema.table`), which IS unique.
+
+        The class name is not (two apps can each have their own `Customer`, and the index keyed by
+        `__name__` is kept by whichever comes last). The qualified one is protected by the collision
+        guard in `register()`.
+        """
+        return (
+            self._tables.get(self._table_owner[qualified])
+            if qualified in self._table_owner
+            else None
+        )
+
+    def model_by_qualified(self, qualified: str) -> type | None:
+        """Returns the CLASS that owns a qualified table. Counterpart of `table_by_qualified`."""
+        return self._table_owner.get(qualified)
+
+    def resolve_relationship(
+        self, relationship: SnakeRelationshipInfo
+    ) -> tuple[SnakeTableInfo | None, type | None]:
+        """Resolves a relation's target to `(table, class)`, unambiguously when ambiguity exists.
+
+        It prefers the linker's qualified `target_table`; it falls back to the class name only when
+        there is none (a relation rebuilt from a migration, which does not carry it). Centralised
+        here so that fixing the wrong target is ONE change and not twelve copies.
+        """
+        if relationship.target_table:
+            table = self.table_by_qualified(relationship.target_table)
+            if table is not None:
+                return table, self.model_by_qualified(relationship.target_table)
+        return self.table_by_name(relationship.target), self.model_by_name(
+            relationship.target
+        )
+
+    def models(self) -> tuple[type, ...]:
+        """Lists the registered models."""
+        return tuple(self._tables)
+
+    def register_routine(self, routine: SnakeRoutineInfo) -> None:
+        """Registers (or replaces) a DESIRED routine declared with `snake_function(...)`.
+
+        Keyed by `name`: redeclaring the same name replaces the `body`, like a `CREATE OR REPLACE`.
+        """
+        self._routines[routine.name] = routine
+
+    def routine_by_name(self, name: str) -> SnakeRoutineInfo | None:
+        """Returns the desired routine by name, or None if it is not declared."""
+        return self._routines.get(name)
+
+    def routines(self) -> tuple[SnakeRoutineInfo, ...]:
+        """Lists the registered desired routines (autodetect's code-first source of truth)."""
+        return tuple(self._routines.values())
+
+    def register_trigger(self, trigger: SnakeTriggerInfo) -> None:
+        """Registers (or replaces) a DESIRED trigger declared with `snake_trigger(...)`.
+
+        Keyed by (table, name): by name alone, a trigger of the same name on another table would
+        stomp on it.
+        """
+        self._triggers[(trigger.table, trigger.name)] = trigger
+
+    def triggers(self) -> tuple[SnakeTriggerInfo, ...]:
+        """Lists the registered desired triggers."""
+        return tuple(self._triggers.values())
+
+
+registry = SnakeRegistry()
+"""The default global registry that @snake_model populates."""
+
+
+def registry_of(model: type) -> SnakeRegistry:
+    """The registry where the model lives (the decorator put it there), or the global one.
+
+    It is what makes `@snake_model(registry=reg)` work: everything downstream —typed navigation,
+    the query, the session— has to resolve against THAT registry and not the global one, or a model
+    in its own registry is registered and unreachable.
+
+    It lives here rather than in `fields/` because it answers a REGISTRY question, and because two
+    other packages were already importing the private `_registry_of` across a package boundary,
+    which is the shape a helper takes just before it becomes public by accident.
+    """
+    return getattr(model, "__snake_registry__", registry)

snakeorm/session/__init__.py

@@ -0,0 +1,8 @@
+"""SnakeORM's session layer: synchronous execution of queries."""
+
+from snakeorm.session.asyncsession import AsyncSession as AsyncSession
+from snakeorm.session.factory import snake_session as snake_session
+from snakeorm.session.isolation import SnakeIsolation as SnakeIsolation
+from snakeorm.session.retry import is_transient as is_transient
+from snakeorm.session.retry import with_retry as with_retry
+from snakeorm.session.session import SnakeSession as SnakeSession