loom-kernel 2.16.0__tar.gz → 2.17.0__tar.gz

{loom_kernel-2.16.0 → loom_kernel-2.17.0}/CHANGELOG.md

@@ -230,6 +230,19 @@
   params_type, *, name)` from `loom.prefect.flow`, so CI can check that every
   inherited parameter is a field declared `str`, `date` or `datetime` without
   building the flow.
+- **prefect:** `deploy_flow(flow, *, env, work_pool=None)`, exported from
+  `loom.prefect` and `loom.prefect.deploy`, registers the deployment of one
+  flow built by `etl_flow`, `backfill_flow` or `maintenance_flow`, with the
+  same name, tags, parameters, schedule, trigger and work-pool settings
+  `discover_and_deploy_etls(flows_package=...)` gives it, and returns its id.
+  Flows built on demand, such as by a module `__getattr__`, or a single ETL
+  deployed by name no longer need the private `_deploy_single` and metadata
+  attribute. `env` is required; `work_pool` is used when the YAML names no
+  pool for `env`, and with neither it raises `ValueError`. Before registering
+  it checks that the flow's `source_file` exposes the flow under its
+  attribute name (the flow name with `-` replaced by `_`), as the worker
+  imports it, and raises `ValueError` otherwise; a module not yet imported is
+  imported from that file. Any other object raises `TypeError`.
 
 ### etl
 
@@ -310,9 +323,25 @@
   rows and the step fails. Polars checks the row count of the frame the
   replace already collects, at no extra cost; Spark runs `isEmpty()`, one
   job that stops at the first row, before the write recomputes the frame. On
-  Polars a `Null`-typed column still fails first, with `SchemaError`.
+  Polars a `Null`-typed column still fails first, with `SchemaError`. On
+  Spark a streaming DataFrame, whose rows cannot be counted before the
+  write, raises `ValueError` and the table is left as it was.
   The default, `allow_empty=True`, keeps today's behaviour, and `ReplaceSpec`
   gains the `allow_empty` field.
+- **etl:** `MaintenanceSpec`, `VacuumSpec`, `CompactSpec` and `ZOrderSpec` are
+  exported from `loom.etl.maintenance`, next to `OpSpec` and
+  `OperationDeclaration`, so a custom maintenance op (an `OpSpec` appended to
+  each `MaintenanceSpec` by a wrapping `OperationDeclaration`) and a custom
+  `DeltaTableMaintainer` are written without the private `_ops` module. The
+  ETL guide and the package docstring show how to write one.
+- **etl:** `loom.etl.schema.annotation_to_loom_type(ann)` converts one Python
+  type annotation to the `LoomType` it declares, as `resolve_schema` does for
+  each field of a contract (`X | None` maps as `X`; an unsupported annotation
+  raises `TypeError`), and `loom.etl.backends.polars` exports
+  `loom_type_to_polars` and `polars_to_loom_type`, so the Polars dtype of a
+  contract field is `loom_type_to_polars(annotation_to_loom_type(ann))`. The
+  private names `loom.etl.schema._contract._annotation_to_loom_type` and
+  `loom.etl.backends.polars._dtype.*` keep working.
 
 ## ⚠ Behaviour changes
 
@@ -402,6 +431,9 @@
   placeholders it started with and repeats the call with the same values,
   which is harmless. The update is one attempt with a 10-second timeout; if
   it fails, the flow logs it at `ERROR` in the run's logs and goes on.
+- **prefect:** the private `_deploy_single(flow, meta, work_pool, env)` of
+  `loom.prefect.deploy._discovery` now takes `(flow, meta, plan)`; callers
+  migrate to the public `deploy_flow(flow, env=..., work_pool=...)`.
 
 ### etl
 
@@ -410,6 +442,13 @@
   `_map_process_nodes`) are deprecated and removed in loom 3.0; each emits a
   `DeprecationWarning` naming its replacement, `loom.etl.compiler.filter_plan`
   or, for `_collect_all_names`, `iter_processes` and `iter_all_steps`.
+- **etl:** `InvalidStageError` names what it reports: its message reads
+  `Unknown step or process names: [...]` instead of `No steps or processes
+  match include=[...]`, the constructor's parameter is `unknown`, and the
+  names are kept on the new `unknown` attribute. Positional construction is
+  unchanged; `InvalidStageError(include=...)` still works, emits a
+  `DeprecationWarning` and is removed in loom 3.0. The error survives pickle
+  with its `unknown` names, so it crosses process boundaries intact.
 
 ## 🐛 Fixes
 

{loom_kernel-2.16.0 → loom_kernel-2.17.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: loom-kernel
-Version: 2.16.0
+Version: 2.17.0
 Summary: Loom Python project
 License-File: LICENSE
 Classifier: Programming Language :: Python :: 3

{loom_kernel-2.16.0 → loom_kernel-2.17.0}/src/loom/etl/backends/_write_policy.py

@@ -521,7 +521,12 @@ class _WritePolicy(TargetWriter, Generic[InputFrameT, WriteFrameT, PhysicalSchem
 
     @abstractmethod
     def _is_empty(self, frame: WriteFrameT) -> bool:
-        """Whether the materialised *frame* has no rows."""
+        """Whether the materialised *frame* has no rows.
+
+        Raises:
+            ValueError: When the backend cannot count the rows of *frame*
+                before the write, such as a Spark streaming DataFrame.
+        """
 
     def _materialize_checked(
         self,
@@ -536,6 +541,8 @@ class _WritePolicy(TargetWriter, Generic[InputFrameT, WriteFrameT, PhysicalSchem
         Raises:
             EmptyReplaceError: When *allow_empty* is ``False`` and the
                 materialised frame has no rows.
+            ValueError: When *allow_empty* is ``False`` and the backend
+                cannot count the rows of the materialised frame.
         """
         materialized = self._materialize_for_write(frame, streaming)
         if not allow_empty:

{loom_kernel-2.16.0 → loom_kernel-2.17.0}/src/loom/etl/backends/polars/__init__.py

@@ -1,5 +1,6 @@
 """Polars backend for the Loom ETL framework."""
 
+from loom.etl.backends.polars._dtype import loom_type_to_polars, polars_to_loom_type
 from loom.etl.backends.polars._file_writer import PolarsFileWriter
 from loom.etl.backends.polars._reader import PolarsSourceReader, decode_json_columns
 from loom.etl.backends.polars._schema import PolarsPhysicalSchema, read_delta_physical_schema
@@ -11,5 +12,7 @@ __all__ = [
     "PolarsSourceReader",
     "PolarsTargetWriter",
     "decode_json_columns",
+    "loom_type_to_polars",
+    "polars_to_loom_type",
     "read_delta_physical_schema",
 ]

{loom_kernel-2.16.0 → loom_kernel-2.17.0}/src/loom/etl/backends/polars/_dtype.py

@@ -1,6 +1,7 @@
 """LoomType ↔ Polars DataType conversion utilities.
 
-Internal module — not part of the public API.
+Internal module — import ``loom_type_to_polars`` and ``polars_to_loom_type``
+from :mod:`loom.etl.backends.polars`.
 
 Two conversion layers
 ---------------------

{loom_kernel-2.16.0 → loom_kernel-2.17.0}/src/loom/etl/backends/spark/_writer.py

@@ -144,8 +144,19 @@ class SparkTargetWriter(_WritePolicy[DataFrame, DataFrame, SparkPhysicalSchema])
         return frame
 
     def _is_empty(self, frame: DataFrame) -> bool:
-        """Whether *frame* has no rows; runs one Spark job that stops at the first row."""
-        return frame.isEmpty()
+        """Whether *frame* has no rows; runs one Spark job that stops at the first row.
+
+        Raises:
+            ValueError: When *frame* is a streaming DataFrame, whose rows
+                cannot be counted before the write.
+        """
+        if frame.isStreaming:
+            raise ValueError(
+                "replace(allow_empty=False) needs a batch DataFrame to check for rows, "
+                "but the frame to write is a streaming DataFrame. Read the source as a "
+                "batch DataFrame or declare replace() without allow_empty=False."
+            )
+        return bool(frame.isEmpty())
 
     def _predicate_to_sql(self, predicate: Any, params: Any) -> str:
         """Convert predicate to SQL."""

{loom_kernel-2.16.0 → loom_kernel-2.17.0}/src/loom/etl/compiler/_filter.py

@@ -6,7 +6,9 @@ from :mod:`loom.etl.compiler`.
 
 from __future__ import annotations
 
+import warnings
 from collections.abc import Callable, Iterable
+from typing import Any
 
 from loom.etl.compiler._plan import (
     ParallelProcessGroup,
@@ -22,18 +24,52 @@ from loom.etl.compiler._plan import (
 
 
 class InvalidStageError(ValueError):
-    """Raised when *include* names a step or process absent from the compiled plan.
+    """Raised when a selection names a step or process absent from the compiled plan.
 
     Args:
-        include: The names that match no step or process.
+        unknown: The selected names that match no step or process.
+        include: Deprecated keyword spelling of *unknown*, removed in loom 3.0.
+
+    Attributes:
+        unknown: The selected names that match no step or process.
+
+    Raises:
+        TypeError: When both or neither of *unknown* and *include* are given.
     """
 
-    def __init__(self, include: frozenset[str]) -> None:
+    def __init__(
+        self,
+        unknown: frozenset[str] | None = None,
+        *,
+        include: frozenset[str] | None = None,
+    ) -> None:
+        self.unknown = _unknown_names(unknown, include)
         super().__init__(
-            f"No steps or processes match include={sorted(include)!r}. "
+            f"Unknown step or process names: {sorted(self.unknown)!r}. "
             "Check that the names match the class names of your ETLStep or ETLProcess subclasses."
         )
 
+    def __reduce__(self) -> tuple[type[InvalidStageError], tuple[frozenset[str]], dict[str, Any]]:
+        return type(self), (self.unknown,), self.__dict__
+
+
+def _unknown_names(
+    unknown: frozenset[str] | None, include: frozenset[str] | None
+) -> frozenset[str]:
+    if include is None:
+        if unknown is None:
+            raise TypeError("InvalidStageError() requires the unknown names.")
+        return frozenset(unknown)
+    if unknown is not None:
+        raise TypeError("InvalidStageError() takes unknown= or the deprecated include=, not both.")
+    warnings.warn(
+        "InvalidStageError(include=...) is deprecated and will be removed in loom 3.0; "
+        "use InvalidStageError(unknown=...) instead.",
+        DeprecationWarning,
+        stacklevel=3,
+    )
+    return frozenset(include)
+
 
 def filter_plan(plan: PipelinePlan, include: Iterable[str]) -> PipelinePlan:
     """Return a new plan keeping only the steps and processes named in *include*.

{loom_kernel-2.16.0 → loom_kernel-2.17.0}/src/loom/etl/declarative/target/_into.py

@@ -126,7 +126,9 @@ class IntoTable:
                          is neither replaced nor created.  Use it for a
                          table, such as a dimension, that an empty read must
                          never wipe.  Defaults to ``True``: an empty frame
-                         replaces the table with an empty one.
+                         replaces the table with an empty one.  The Spark
+                         backend refuses a streaming DataFrame with
+                         :exc:`ValueError`, since it cannot count its rows.
 
         Returns:
             New ``IntoTable`` with REPLACE mode.

loom_kernel-2.17.0/src/loom/etl/maintenance/__init__.py

@@ -0,0 +1,124 @@
+"""Delta table maintenance — backend-agnostic vacuum, compact, and Z-Order.
+
+Public API
+----------
+
+Authoring::
+
+    from loom.etl.maintenance import MaintenanceStep, MaintainTable, MaintainSchema
+
+Running::
+
+    from loom.etl.maintenance import MaintenanceRunner, MaintenanceReport
+
+Result types::
+
+    from loom.etl.maintenance import (
+        VacuumResult,
+        OptimizeResult,
+        TableMaintenanceResult,
+        MaintenanceError,
+    )
+
+Backend protocol (for custom implementations)::
+
+    from loom.etl.maintenance import DeltaTableMaintainer
+
+Operation specs (for custom operations and backends)::
+
+    from loom.etl.maintenance import (
+        MaintenanceSpec,
+        OpSpec,
+        OperationDeclaration,
+        VacuumSpec,
+        CompactSpec,
+        ZOrderSpec,
+    )
+
+Example::
+
+    class NightlyMaintenance(MaintenanceStep[None]):
+        operations = [
+            MaintainSchema("raw").vacuum(retention_hours=168, dry_run=False).compact(),
+            MaintainTable("staging.orders")
+                .vacuum(dry_run=False)
+                .z_order_by(["run_date", "_id"]),
+        ]
+
+    runner = MaintenanceRunner.from_config(config)
+    report = runner.run(NightlyMaintenance)
+    report.raise_if_errors()
+
+Custom operations
+-----------------
+
+An operation is any class implementing :class:`OpSpec`: a ``name`` class
+variable, which keys its result in :attr:`TableMaintenanceResult.op_results`,
+and an ``execute(maintainer, uri, location)`` method returning a
+:class:`VacuumResult` or an :class:`OptimizeResult` (or a subclass). To run
+it, wrap a declaration in an :class:`OperationDeclaration` whose ``resolve``
+appends the op to each :class:`MaintenanceSpec`::
+
+    from dataclasses import dataclass, replace
+    from typing import ClassVar
+
+    from deltalake import DeltaTable
+
+    @dataclass(frozen=True)
+    class CheckpointSpec:
+        name: ClassVar[str] = "checkpoint"
+
+        def execute(self, maintainer, uri, location) -> OptimizeResult:
+            DeltaTable(uri, storage_options=location.storage_options).create_checkpoint()
+            return OptimizeResult()
+
+    class Checkpointed:
+        def __init__(self, inner: OperationDeclaration) -> None:
+            self._inner = inner
+
+        def resolve(self, config: StorageConfig) -> list[MaintenanceSpec]:
+            return [
+                replace(spec, ops=(*spec.ops, CheckpointSpec()))
+                for spec in self._inner.resolve(config)
+            ]
+
+    class NightlyMaintenance(MaintenanceStep[None]):
+        operations = [Checkpointed(MaintainSchema("raw").vacuum(dry_run=False))]
+"""
+
+from loom.etl.maintenance._builder import MaintainSchema, MaintainTable
+from loom.etl.maintenance._ops import CompactSpec, MaintenanceSpec, VacuumSpec, ZOrderSpec
+from loom.etl.maintenance._protocol import (
+    DeltaTableMaintainer,
+    OperationDeclaration,
+    OpSpec,
+    OptimizeResult,
+    TableMaintenanceResult,
+    VacuumResult,
+)
+from loom.etl.maintenance._runner import MaintenanceError, MaintenanceReport, MaintenanceRunner
+from loom.etl.maintenance._step import MaintenanceStep
+
+__all__ = [
+    # authoring
+    "MaintenanceStep",
+    "MaintainTable",
+    "MaintainSchema",
+    # runner
+    "MaintenanceRunner",
+    "MaintenanceReport",
+    "MaintenanceError",
+    # result types
+    "VacuumResult",
+    "OptimizeResult",
+    "TableMaintenanceResult",
+    # protocols
+    "DeltaTableMaintainer",
+    "OperationDeclaration",
+    "OpSpec",
+    # operation specs
+    "MaintenanceSpec",
+    "VacuumSpec",
+    "CompactSpec",
+    "ZOrderSpec",
+]

{loom_kernel-2.16.0 → loom_kernel-2.17.0}/src/loom/etl/maintenance/_ops.py

@@ -1,8 +1,9 @@
-"""Internal operation specs for Delta table maintenance.
+"""Operation specs for Delta table maintenance.
 
 These dataclasses are the compiled form of MaintainTable / MaintainSchema
-declarations — they carry the final parameter values that the backend will
-execute.  They are not part of the public API.
+declarations: they carry the final parameter values the backend executes.
+
+Internal module — import them from :mod:`loom.etl.maintenance`.
 """
 
 from __future__ import annotations
@@ -91,8 +92,14 @@ class ZOrderSpec:
 
 @dataclass(frozen=True)
 class MaintenanceSpec:
-    """All ops to execute against one concrete table (already resolved to its
-    logical ref — the runner resolves it to a URI via the locator).
+    """The ops to run, in order, against one table.
+
+    :meth:`~loom.etl.maintenance.OperationDeclaration.resolve` returns one per
+    table; the runner resolves ``table_ref`` to a location and runs each op.
+
+    Args:
+        table_ref: Logical table reference (e.g. ``"raw.events"``).
+        ops: Operations to execute against the table, in order.
     """
 
     table_ref: str

loom_kernel-2.17.0/src/loom/etl/runner/filtering.py

@@ -0,0 +1,41 @@
+"""Deprecated plan-filter names, removed in loom 3.0.
+
+Use :func:`loom.etl.compiler.filter_plan`. Accessing any name here emits a
+:class:`DeprecationWarning` naming its replacement.
+"""
+
+from __future__ import annotations
+
+import warnings
+from typing import Any
+
+from loom.etl.compiler import _filter
+
+#: Deprecated name → (attribute of ``loom.etl.compiler._filter`` it returns, replacement).
+_DEPRECATED: dict[str, tuple[str, str]] = {
+    "_filter_plan": ("filter_plan", "loom.etl.compiler.filter_plan"),
+    "_filter_process": ("_filter_process", "loom.etl.compiler.filter_plan"),
+    "_collect_all_names": (
+        "_collect_all_names",
+        "loom.etl.compiler.iter_processes and loom.etl.compiler.iter_all_steps",
+    ),
+    "_map_pipeline_nodes": ("_map_pipeline_nodes", "loom.etl.compiler.filter_plan"),
+    "_map_process_nodes": ("_map_process_nodes", "loom.etl.compiler.filter_plan"),
+}
+
+
+def __getattr__(name: str) -> Any:
+    entry = _DEPRECATED.get(name)
+    if entry is None:
+        raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+    source, replacement = entry
+    warnings.warn(
+        f"{__name__}.{name} is deprecated and will be removed in loom 3.0; "
+        f"use {replacement} instead.",
+        DeprecationWarning,
+        stacklevel=2,
+    )
+    return getattr(_filter, source)
+
+
+__all__: list[str] = []

{loom_kernel-2.16.0 → loom_kernel-2.17.0}/src/loom/etl/schema/__init__.py

@@ -4,7 +4,13 @@ from __future__ import annotations
 
 from loom.etl.declarative.expr._refs import TableRef, col
 
-from ._contract import JsonContract, SchemaContract, resolve_json_type, resolve_schema
+from ._contract import (
+    JsonContract,
+    SchemaContract,
+    annotation_to_loom_type,
+    resolve_json_type,
+    resolve_schema,
+)
 from ._schema import (
     ArrayType,
     CategoricalType,
@@ -27,6 +33,7 @@ __all__ = [
     "JsonContract",
     "resolve_schema",
     "resolve_json_type",
+    "annotation_to_loom_type",
     "ColumnSchema",
     "LoomDtype",
     "LoomType",

{loom_kernel-2.16.0 → loom_kernel-2.17.0}/src/loom/etl/schema/_contract.py

@@ -4,8 +4,8 @@ A *contract* is any annotated class (``msgspec.Struct``, ``dataclass``, or
 plain Python class with field annotations) or an existing
 :data:`~loom.etl._schema.LoomType` / ``tuple[ColumnSchema, ...]``.
 
-Two public entry points
------------------------
+Public entry points
+-------------------
 
 ``resolve_schema``
     Converts a schema contract to ``tuple[ColumnSchema, ...]``.  Used by
@@ -18,6 +18,9 @@ Two public entry points
     Used by :meth:`~loom.etl._source.FromTable.parse_json` and
     :meth:`~loom.etl._source.FromFile.parse_json`.
 
+``annotation_to_loom_type``
+    Converts one Python type annotation to a :data:`~loom.etl._schema.LoomType`.
+
 Supported annotation forms
 --------------------------
 
@@ -142,7 +145,7 @@ def resolve_json_type(contract: Any) -> LoomType:
         return contract
     if typing.get_origin(contract) is list:
         args = typing.get_args(contract)
-        inner = _annotation_to_loom_type(args[0]) if args else LoomDtype.UTF8
+        inner = annotation_to_loom_type(args[0]) if args else LoomDtype.UTF8
         return ListType(inner=inner)
     if isinstance(contract, type):
         return _class_to_struct_type(contract)
@@ -151,6 +154,54 @@ def resolve_json_type(contract: Any) -> LoomType:
     )
 
 
+def annotation_to_loom_type(ann: Any) -> LoomType:
+    """Convert a Python type annotation to the :data:`~loom.etl.schema.LoomType` it declares.
+
+    This is the mapping :func:`resolve_schema` applies to each field of an
+    annotated class. ``X | None`` and ``Optional[X]`` map as ``X``.
+
+    Args:
+        ann: ``int``, ``float``, ``str``, ``bool``, ``bytes``,
+             ``datetime.datetime``, ``datetime.date``, ``list[X]``, an
+             annotated class (mapped to a :class:`~loom.etl.schema.StructType`)
+             or a :data:`~loom.etl.schema.LoomType` (returned as-is).
+
+    Returns:
+        The matching :data:`~loom.etl.schema.LoomType`.
+
+    Raises:
+        TypeError: If *ann* has no Loom equivalent.
+
+    Example::
+
+        >>> annotation_to_loom_type(list[int] | None)
+        ListType(inner=<LoomDtype.INT64: 'Int64'>)
+    """
+    if isinstance(ann, _LOOM_INSTANCES):
+        return ann
+    if ann in _PY_TO_LOOM:
+        return _PY_TO_LOOM[ann]
+    is_opt, inner = _strip_optional(ann)
+    if is_opt:
+        return annotation_to_loom_type(inner)
+    origin = typing.get_origin(ann)
+    if origin is list:
+        args = typing.get_args(ann)
+        inner_type = annotation_to_loom_type(args[0]) if args else LoomDtype.UTF8
+        return ListType(inner=inner_type)
+    if isinstance(ann, type) and hasattr(ann, "__annotations__"):
+        return _class_to_struct_type(ann)
+    raise TypeError(
+        f"Cannot convert annotation {ann!r} to LoomType. "
+        "Supported: int, float, str, bool, bytes, datetime, date, list[X], "
+        "LoomType instances, and annotated classes."
+    )
+
+
+#: Alias of :func:`annotation_to_loom_type`.
+_annotation_to_loom_type = annotation_to_loom_type
+
+
 # ---------------------------------------------------------------------------
 # Internal helpers
 # ---------------------------------------------------------------------------
@@ -159,14 +210,14 @@ def resolve_json_type(contract: Any) -> LoomType:
 def _class_to_schema(cls: type[Any]) -> tuple[ColumnSchema, ...]:
     hints = _get_type_hints(cls)
     return tuple(
-        ColumnSchema(name=name, dtype=_annotation_to_loom_type(ann)) for name, ann in hints.items()
+        ColumnSchema(name=name, dtype=annotation_to_loom_type(ann)) for name, ann in hints.items()
     )
 
 
 def _class_to_struct_type(cls: type[Any]) -> StructType:
     hints = _get_type_hints(cls)
     fields = tuple(
-        StructField(name=name, dtype=_annotation_to_loom_type(ann)) for name, ann in hints.items()
+        StructField(name=name, dtype=annotation_to_loom_type(ann)) for name, ann in hints.items()
     )
     return StructType(fields=fields)
 
@@ -184,29 +235,6 @@ def _get_type_hints(cls: type[Any]) -> dict[str, Any]:
     return hints
 
 
-def _annotation_to_loom_type(ann: Any) -> LoomType:
-    """Recursively convert a Python type annotation to a :data:`LoomType`."""
-    if isinstance(ann, _LOOM_INSTANCES):
-        return ann
-    if ann in _PY_TO_LOOM:
-        return _PY_TO_LOOM[ann]
-    is_opt, inner = _strip_optional(ann)
-    if is_opt:
-        return _annotation_to_loom_type(inner)
-    origin = typing.get_origin(ann)
-    if origin is list:
-        args = typing.get_args(ann)
-        inner_type = _annotation_to_loom_type(args[0]) if args else LoomDtype.UTF8
-        return ListType(inner=inner_type)
-    if isinstance(ann, type) and hasattr(ann, "__annotations__"):
-        return _class_to_struct_type(ann)
-    raise TypeError(
-        f"Cannot convert annotation {ann!r} to LoomType. "
-        "Supported: int, float, str, bool, bytes, datetime, date, list[X], "
-        "LoomType instances, and annotated classes."
-    )
-
-
 def _strip_optional(ann: Any) -> tuple[bool, Any]:
     """Return ``(True, inner)`` if *ann* is ``Optional[X]`` or ``X | None``."""
     is_new_union = isinstance(ann, _builtin_types.UnionType)

{loom_kernel-2.16.0 → loom_kernel-2.17.0}/src/loom/prefect/__init__.py

@@ -18,6 +18,8 @@ Public API
   factory (hour/day/month/year partitions plus a finalize pass).
 - :func:`discover_and_deploy_etls` — walks a flows package and registers
   one Prefect deployment per ETL.
+- :func:`deploy_flow` — registers the Prefect deployment of one flow built
+  by a loom flow factory.
 - :class:`ManifestStore` / :class:`RunManifest` / :class:`StepEntry` —
   ephemeral retry manifest types.
 - :class:`S3JsonManifestStore` — S3-backed manifest implementation.
@@ -40,7 +42,7 @@ from loom.prefect._config import _load_flow_config as load_flow_config
 from loom.prefect._ctx import FlowCtx
 from loom.prefect._meta import FlowTrigger
 from loom.prefect._placeholders import resolve_placeholder
-from loom.prefect.deploy import discover_and_deploy_etls
+from loom.prefect.deploy import deploy_flow, discover_and_deploy_etls
 from loom.prefect.flow import BackfillChunk, backfill_flow, etl_flow, maintenance_flow
 from loom.prefect.manifest import (
     ManifestStore,
@@ -62,6 +64,7 @@ __all__ = [
     "S3JsonManifestStore",
     "StepEntry",
     "backfill_flow",
+    "deploy_flow",
     "discover_and_deploy_etls",
     "etl_flow",
     "maintenance_flow",

{loom_kernel-2.16.0 → loom_kernel-2.17.0}/src/loom/prefect/deploy/__init__.py

@@ -4,6 +4,8 @@ Public surface
 --------------
 - :func:`discover_and_deploy_etls` — register one Prefect deployment per
   ETL, found either in a flows package or in YAML declarations.
+- :func:`deploy_flow` — register the deployment of one flow built by a loom
+  flow factory.
 - ``entrypoint`` — the module Prefect imports to rebuild a YAML-declared
   flow; it reads the declaration file from ``LOOM_ETL_CONFIG``.
 
@@ -19,6 +21,6 @@ Per-ETL YAML loading and work-pool extraction live in
 imports from the flow package, never the reverse.
 """
 
-from loom.prefect.deploy._discovery import discover_and_deploy_etls
+from loom.prefect.deploy._discovery import deploy_flow, discover_and_deploy_etls
 
-__all__ = ["discover_and_deploy_etls"]
+__all__ = ["deploy_flow", "discover_and_deploy_etls"]