loom-kernel 1.2.0__tar.gz → 1.2.2__tar.gz

{loom_kernel-1.2.0 → loom_kernel-1.2.2}/CHANGELOG.md

@@ -1,3 +1,54 @@
+# 🚀 Release 1.2.2 ([#124](https://github.com/the-reacher-data/loom-py/pull/124)) ([`ced8b6a`](https://github.com/the-reacher-data/loom-py/commit/ced8b6ab8bba62b7d34e57ad334d26f29af1e0c2))
+
+
+## ✨ Features
+### etl
+- **etl:** replace_matching, el alias que dice lo que replace_partitions hace<br>
+  > replace_partitions nunca ha exigido particion fisica: colecta los VALORES de
+  > las columnas presentes en el frame y emite un replaceWhere de Delta sobre
+  > ellos. El nombre ha causado confusion real en tablas de model sin particionar
+  > (facts por dia, colas por fecha de snapshot). replace_matching(*cols) es el
+  > mismo spec con la semantica en el nombre; replace_partitions queda intacto
+  > (en uso) y su docstring apunta al alias.
+  > Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
+
+- **etl:** replace_physical_partitions — el replace de particiones DE VERDAD<br>
+  > La familia queda completa y cada nombre dice lo que hace:
+  > replace_matching(*cols): replaceWhere por los VALORES del frame; tablas sin
+  > particionar (facts por dia, colas por fecha).
+  > replace_physical_partitions(*cols): mismo predicado MAS un check en escritura
+  > contra el metadata Delta — si la tabla no esta fisicamente particionada por
+  > esas columnas, rechaza en alto en vez de degradar a rewrite por filas. Un
+  > backend sin metadata de particiones (spark hoy) tambien rechaza, no adivina.
+  > replace_partitions(*cols): intacto (en uso), su docstring dirige a los dos.
+  > Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
+  > --------
+  > Co-authored-by: Claude Fable 5 <noreply@anthropic.com>
+
+
+
+
+
+
+
+
+
+
+# 🚀 Release 1.2.1 ([#122](https://github.com/the-reacher-data/loom-py/pull/122)) ([`797f134`](https://github.com/the-reacher-data/loom-py/commit/797f134ebf64378a0af54f89d8fbac10e033553c))
+
+
+
+## 🐛 Fixes
+### prefect
+- **prefect:** let a flow declare its retry policy beside its schedule
+
+
+
+
+
+
+
+
 # 🚀 Release 1.2.0 ([#119](https://github.com/the-reacher-data/loom-py/pull/119)) ([`5afa8ff`](https://github.com/the-reacher-data/loom-py/commit/5afa8ff5f1d3c87e0cef82095a86bc9d400a0782))
 
 

{loom_kernel-1.2.0 → loom_kernel-1.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: loom-kernel
-Version: 1.2.0
+Version: 1.2.2
 Summary: Loom Python project
 License-File: LICENSE
 Classifier: Typing :: Typed

{loom_kernel-1.2.0 → loom_kernel-1.2.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "loom-kernel"
-version = "1.2.0"
+version = "1.2.2"
 description = "Loom Python project"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -278,7 +278,7 @@ markers = [
 
 [tool.commitizen]
 name = "cz_conventional_commits"
-version = "1.2.0"
+version = "1.2.2"
 tag_format = "v$version"
 version_files = [
     "pyproject.toml:project.version",

{loom_kernel-1.2.0 → loom_kernel-1.2.2}/src/loom/etl/backends/_write_policy.py

@@ -294,6 +294,8 @@ class _WritePolicy(TargetWriter, Generic[InputFrameT, WriteFrameT, PhysicalSchem
                 partition_cols=spec.partition_cols,
             )
             return
+        if spec.require_physical:
+            self._require_physical_partitions(target, spec.partition_cols)
         aligned = self._align(frame, existing, spec.schema_mode)
         materialized = self._materialize_checked(aligned, target, streaming)
         self._replace_partitions(
@@ -303,6 +305,30 @@ class _WritePolicy(TargetWriter, Generic[InputFrameT, WriteFrameT, PhysicalSchem
             schema_mode=spec.schema_mode,
         )
 
+    def _physical_partition_columns(self, target: ResolvedTarget) -> tuple[str, ...] | None:
+        """The table's physical partition columns, or ``None`` when the backend
+        cannot tell — which makes ``require_physical`` refuse rather than guess."""
+        return None
+
+    def _require_physical_partitions(
+        self, target: ResolvedTarget, partition_cols: tuple[str, ...]
+    ) -> None:
+        physical = self._physical_partition_columns(target)
+        if physical is None:
+            raise ValueError(
+                f"replace_physical_partitions: backend cannot verify the physical "
+                f"partitioning of {target}. Use replace_partitions/replace_matching, "
+                f"or a backend that exposes partition metadata."
+            )
+        missing = [col for col in partition_cols if col not in physical]
+        if missing:
+            raise ValueError(
+                f"replace_physical_partitions: table {target} is partitioned by "
+                f"{list(physical) or 'nothing'} but the write asked for {list(partition_cols)} "
+                f"(missing: {missing}). For value-based replacement on these columns "
+                f"use replace_matching instead."
+            )
+
     def _do_replace_where(
         self,
         frame: InputFrameT,

{loom_kernel-1.2.0 → loom_kernel-1.2.2}/src/loom/etl/backends/polars/_writer.py

@@ -405,6 +405,11 @@ class PolarsTargetWriter(_WritePolicy[pl.LazyFrame, pl.DataFrame, PolarsPhysical
         )
         _log_write_commit("replace", location)
 
+    def _physical_partition_columns(self, target: ResolvedTarget) -> tuple[str, ...] | None:
+        location = self._as_path_target(target).location
+        dt = DeltaTable(location.uri, storage_options=location.storage_options or {})
+        return tuple(dt.metadata().partition_columns)
+
     def _replace_partitions(
         self,
         frame: pl.DataFrame,

{loom_kernel-1.2.0 → loom_kernel-1.2.2}/src/loom/etl/declarative/target/_into.py

@@ -135,6 +135,12 @@ class IntoTable:
         Collects the distinct partition values from the frame at write time and
         builds the replace predicate dynamically — no params required.
 
+        Despite the name, this never requires the table to be physically
+        partitioned: the write is a Delta replaceWhere over the collected
+        VALUES. When the table is not partitioned and the columns are plain
+        keys (a date column on an unpartitioned fact), prefer the alias
+        :meth:`replace_matching`, which says what actually happens.
+
         For replacing a specific partition whose values come from run params,
         use :meth:`replace_partition`.
 
@@ -163,6 +169,86 @@ class IntoTable:
             )
         )
 
+    def replace_matching(
+        self,
+        *cols: str,
+        schema: SchemaMode = SchemaMode.STRICT,
+        streaming: bool = False,
+    ) -> IntoTable:
+        """Write mode: replace the rows matching the frame's values of *cols*.
+
+        Alias of :meth:`replace_partitions` with the semantics in the name: the
+        writer collects the distinct values of *cols* present in the batch frame
+        and issues a Delta replaceWhere over them — physical partitioning is
+        never required. This is the natural write mode for a model table built
+        slice by slice (a fact keyed by day, a queue keyed by its snapshot
+        date): the run recomputes its slices whole and substitutes exactly
+        those rows, idempotently.
+
+        Args:
+            *cols:   Column names whose frame values define the replaced rows.
+            schema:  Schema evolution strategy.
+
+        Returns:
+            New ``IntoTable`` with REPLACE_PARTITIONS mode.
+
+        Raises:
+            ValueError: If no column names are provided.
+
+        Example::
+
+            target = IntoTable("mg.fact_family_matriculation").replace_matching("day")
+        """
+        if not cols:
+            raise ValueError("replace_matching: at least one column name is required.")
+        return self.replace_partitions(*cols, schema=schema, streaming=streaming)
+
+    def replace_physical_partitions(
+        self,
+        *cols: str,
+        schema: SchemaMode = SchemaMode.STRICT,
+        streaming: bool = False,
+    ) -> IntoTable:
+        """Write mode: the TRUE partition replace — refuses on an unpartitioned table.
+
+        Same collected-values predicate as :meth:`replace_partitions`, plus a
+        write-time check that the Delta table is physically partitioned by
+        every column in *cols*: on a partitioned table the replaceWhere prunes
+        whole partitions instead of rewriting row groups, and asking for that
+        on a table that cannot deliver it is a design smell this mode turns
+        into an error. For value-based replacement on an unpartitioned table
+        use :meth:`replace_matching`.
+
+        Args:
+            *cols:   Physical partition column names to collect from the frame.
+            schema:  Schema evolution strategy.
+
+        Returns:
+            New ``IntoTable`` with REPLACE_PARTITIONS mode (physical check on).
+
+        Raises:
+            ValueError: If no column names are provided.
+
+        Example::
+
+            target = IntoTable("pg.snap_st_dgt_registration").replace_physical_partitions(
+                "year", "month", "day"
+            )
+        """
+        if not cols:
+            raise ValueError(
+                "replace_physical_partitions: at least one partition column name is required."
+            )
+        return self._with(
+            ReplacePartitionsSpec(
+                table_ref=self._ref,
+                partition_cols=cols,
+                schema_mode=schema,
+                streaming=streaming,
+                require_physical=True,
+            )
+        )
+
     def replace_partition(
         self,
         *,

{loom_kernel-1.2.0 → loom_kernel-1.2.2}/src/loom/etl/declarative/target/_table.py

@@ -75,6 +75,11 @@ class ReplacePartitionsSpec:
     partition_cols: tuple[str, ...]
     schema_mode: SchemaMode = SchemaMode.STRICT
     streaming: bool = False
+    require_physical: bool = False
+    """When ``True`` the writer refuses unless the table is PHYSICALLY
+    partitioned by every column in ``partition_cols`` — the true
+    partition-replace, where the predicate maps to whole-partition file
+    pruning instead of a row-level rewrite."""
 
 
 @dataclass(frozen=True)

loom_kernel-1.2.2/src/loom/prefect/_config.py

@@ -0,0 +1,105 @@
+"""Flow configuration loader for loom.prefect."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+import msgspec
+import yaml
+
+
+class FlowConfig(msgspec.Struct, frozen=True, kw_only=True):
+    """Retry and execution policy for a single ETL flow.
+
+    A flow retry is scheduled by the server rather than awaited in place: the
+    run returns to ``AwaitingRetry`` and a worker claims it again later, so the
+    container exits while it waits and hour-scale delays cost nothing.
+
+    Args:
+        flow_retries: Number of full-flow retries Prefect will attempt before
+            declaring the run failed (each retry is a new container).
+        flow_retry_delay_seconds: Seconds the server waits before rescheduling
+            the run. Prefect's ``FlowRunPolicy`` validates this as a single
+            integer, so a list of staggered delays is rejected here rather than
+            failing mid-run — see :func:`_coerce_retry_delay`.
+
+    Example::
+
+        cfg = _load_flow_config("config/etl_flows.yaml", "daily_orders")
+    """
+
+    flow_retries: int = 2
+    flow_retry_delay_seconds: int = 60
+
+
+def _coerce_retry_delay(value: Any) -> int:
+    """Return *value* as a flow retry delay, refusing shapes Prefect drops.
+
+    ``Flow.__init__`` accepts a list and only ``FlowRunPolicy`` rejects it, at
+    run time on the failure path. Staggered delays exist at task level only.
+
+    Raises:
+        TypeError: When *value* is a sequence of delays.
+        ValueError: When *value* is negative.
+    """
+    if isinstance(value, (list, tuple)):
+        raise TypeError(
+            "flow_retry_delay_seconds must be a single number: Prefect's "
+            "FlowRunPolicy rejects a list of delays. Staggered delays are a "
+            "task-level feature."
+        )
+    delay = int(value)
+    if delay < 0:
+        raise ValueError("flow_retry_delay_seconds must not be negative")
+    return delay
+
+
+def flow_config_from_mapping(section: dict[str, Any] | None) -> FlowConfig:
+    """Build a ``FlowConfig`` from a mapping, falling back to the defaults.
+
+    Args:
+        section: Mapping holding any of the ``flow_retry*`` keys. ``None`` and
+            an empty mapping both yield the defaults.
+
+    Returns:
+        The resolved ``FlowConfig``.
+    """
+    if not section:
+        return FlowConfig()
+    defaults = FlowConfig()
+    return FlowConfig(
+        flow_retries=int(section.get("flow_retries", defaults.flow_retries)),
+        flow_retry_delay_seconds=_coerce_retry_delay(
+            section.get("flow_retry_delay_seconds", defaults.flow_retry_delay_seconds)
+        ),
+    )
+
+
+def _load_flow_config(config_path: str, flow_name: str) -> FlowConfig:
+    """Load ``FlowConfig`` for *flow_name* from a YAML file.
+
+    YAML structure::
+
+        flows:
+          my_etl:
+            flow_retries: 2
+            flow_retry_delay_seconds: 60
+
+    Args:
+        config_path: Path to the YAML configuration file.
+        flow_name: Key under ``flows`` to load.
+
+    Returns:
+        ``FlowConfig`` for the named flow, using ``FlowConfig`` defaults for
+        any keys not present in the YAML section.
+
+    Raises:
+        KeyError: When ``flows`` key is missing or *flow_name* is not found.
+    """
+    raw = yaml.safe_load(Path(config_path).read_text())
+    flows = raw["flows"]
+    return flow_config_from_mapping(flows[flow_name])
+
+
+__all__ = ["FlowConfig", "flow_config_from_mapping"]

{loom_kernel-1.2.0 → loom_kernel-1.2.2}/src/loom/prefect/flow/_assemble.py

@@ -17,6 +17,7 @@ from typing import Any
 
 import prefect
 
+from loom.prefect._config import FlowConfig, flow_config_from_mapping
 from loom.prefect._meta import LOOM_ETL_META_ATTR, ETLFlowMeta
 from loom.prefect.deploy._schedule import extract_pool_config
 from loom.prefect.deploy._yaml import read_yaml
@@ -36,6 +37,7 @@ class FlowSettings:
     pool_config: dict[str, dict[str, Any]]
     tags: tuple[str, ...]
     notifiers: tuple[Notifier, ...]
+    retry_policy: FlowConfig
 
 
 def load_flow_settings(config_path: str) -> FlowSettings:
@@ -55,6 +57,7 @@ def load_flow_settings(config_path: str) -> FlowSettings:
         pool_config=extract_pool_config(raw_cfg),
         tags=coerce_tags(raw_cfg.get("tags")),
         notifiers=build_notifiers(raw_cfg.get("notifications")),
+        retry_policy=flow_config_from_mapping(raw_cfg.get("retry")),
     )
 
 
@@ -82,7 +85,8 @@ def assemble_flow(
         correlation_field: Parameter whose value seeds the run name and the
             correlation id, or ``None`` for timestamp/random naming.
         retries: Prefect flow retries; ``None`` disables retries.
-        retry_delay_seconds: Delay between Prefect flow retries.
+        retry_delay_seconds: Delay before the server reschedules the run. The
+            container exits while it waits, so an hour-scale delay is free.
 
     Returns:
         The ``@prefect.flow``-decorated callable with ``__loom_etl_meta__``

{loom_kernel-1.2.0 → loom_kernel-1.2.2}/src/loom/prefect/flow/_factory.py

@@ -10,7 +10,7 @@ import msgspec
 from loom.etl.compiler import ETLCompiler
 from loom.etl.pipeline import ETLPipeline
 from loom.prefect._config import FlowConfig, _load_flow_config
-from loom.prefect.flow._assemble import assemble_flow, load_flow_settings
+from loom.prefect.flow._assemble import FlowSettings, assemble_flow, load_flow_settings
 from loom.prefect.flow._body import build_flow_body
 from loom.prefect.flow._signature import synthesise_flow_signature
 from loom.prefect.manifest import ManifestStore
@@ -55,7 +55,7 @@ def etl_flow(
     """
     settings = load_flow_settings(config_path)
     plan = ETLCompiler().compile(pipeline)
-    flow_cfg = _resolve_flow_config(flow_config_path, pipeline)
+    flow_cfg = _resolve_flow_config(flow_config_path, pipeline, settings)
 
     flow_body = build_flow_body(
         flow_name=name,
@@ -97,10 +97,13 @@ def etl_flow(
 
 
 def _resolve_flow_config(
-    flow_config_path: str | None, pipeline: type[ETLPipeline[Any]]
+    flow_config_path: str | None,
+    pipeline: type[ETLPipeline[Any]],
+    settings: FlowSettings,
 ) -> FlowConfig:
+    """Resolve the retry policy, preferring a dedicated file when passed."""
     if flow_config_path is None:
-        return FlowConfig()
+        return settings.retry_policy
     try:
         return _load_flow_config(flow_config_path, pipeline.__name__)
     except KeyError:

{loom_kernel-1.2.0 → loom_kernel-1.2.2}/tests/unit/etl/backends/test_polars/test_backend.py

@@ -338,6 +338,40 @@ def test_writer_replace_partitions_overwrites_matching_partition(tmp_path: Path)
     assert result.filter(pl.col("year") == 2023)["v"].to_list() == [10]
 
 
+def test_writer_replace_physical_partitions_refuses_an_unpartitioned_table(
+    tmp_path: Path,
+) -> None:
+    initial = pl.DataFrame({"year": [2023, 2024], "v": [10, 20]})
+    _seed(tmp_path, "staging.flatfacts", initial)  # sin particion fisica
+    writer = PolarsTargetWriter(tmp_path)
+    spec = ReplacePartitionsSpec(
+        table_ref=TableRef("staging.flatfacts"),
+        partition_cols=("year",),
+        require_physical=True,
+    )
+    with pytest.raises(ValueError, match="partitioned by nothing but the write asked"):
+        writer.write(pl.DataFrame({"year": [2024], "v": [99]}).lazy(), spec, None)
+
+
+def test_writer_replace_physical_partitions_writes_on_a_partitioned_table(
+    tmp_path: Path,
+) -> None:
+    path = table_path(tmp_path, TableRef("staging.partfacts"))
+    path.mkdir(parents=True, exist_ok=True)
+    initial = pl.DataFrame({"year": [2023, 2024], "v": [10, 20]})
+    write_deltalake(str(path), initial, mode="overwrite", partition_by=["year"])
+    writer = PolarsTargetWriter(tmp_path)
+    spec = ReplacePartitionsSpec(
+        table_ref=TableRef("staging.partfacts"),
+        partition_cols=("year",),
+        require_physical=True,
+    )
+    writer.write(pl.DataFrame({"year": [2024], "v": [99]}).lazy(), spec, None)
+    result = _read_table(tmp_path, "staging.partfacts")
+    assert result.filter(pl.col("year") == 2024)["v"].to_list() == [99]
+    assert result.filter(pl.col("year") == 2023)["v"].to_list() == [10]
+
+
 def test_writer_replace_partitions_with_string_values(tmp_path: Path) -> None:
     initial = pl.DataFrame({"region": ["us", "eu"], "v": [1, 2]})
     _seed(tmp_path, "staging.regions", initial)

{loom_kernel-1.2.0 → loom_kernel-1.2.2}/tests/unit/etl/io/test_target.py

@@ -38,6 +38,18 @@ class TestIntoTableModes:
                 ("year", "month"),
                 False,
             ),
+            (
+                lambda t: t.replace_matching("day"),
+                ReplacePartitionsSpec,
+                ("day",),
+                False,
+            ),
+            (
+                lambda t: t.replace_physical_partitions("year", "month"),
+                ReplacePartitionsSpec,
+                ("year", "month"),
+                False,
+            ),
             (
                 lambda t: t.replace_partition(
                     year=params.run_date.year, month=params.run_date.month
@@ -74,6 +86,26 @@ class TestIntoTableModes:
         if isinstance(spec, UpsertSpec):
             assert spec.upsert_keys == ("order_id",)
 
+    def test_replace_physical_partitions_sets_the_flag(self) -> None:
+        spec = IntoTable("staging.orders").replace_physical_partitions("year")._to_spec()
+        assert isinstance(spec, ReplacePartitionsSpec)
+        assert spec.require_physical is True
+
+    def test_replace_matching_does_not_set_the_flag(self) -> None:
+        spec = IntoTable("staging.orders").replace_matching("day")._to_spec()
+        assert isinstance(spec, ReplacePartitionsSpec)
+        assert spec.require_physical is False
+
+    def test_replace_physical_partitions_raises_when_no_cols(self) -> None:
+        table = IntoTable("staging.orders")
+        with pytest.raises(ValueError, match="at least one partition column"):
+            table.replace_physical_partitions()
+
+    def test_replace_matching_raises_when_no_cols(self) -> None:
+        table = IntoTable("staging.orders")
+        with pytest.raises(ValueError, match="at least one column"):
+            table.replace_matching()
+
     def test_replace_partitions_raises_when_no_cols(self) -> None:
         table = IntoTable("staging.orders")
         with pytest.raises(ValueError, match="at least one partition column"):

{loom_kernel-1.2.0 → loom_kernel-1.2.2}/tests/unit/prefect/test_config.py

@@ -8,6 +8,8 @@ Verifies:
 - _load_flow_config() raises KeyError when flow_name is not found in YAML.
 - _load_flow_config() picks the correct flow section from multi-flow YAML.
 - _load_flow_config() reads only the flows.<flow_name> section, ignoring others.
+- flow_config_from_mapping() resolves a policy declared beside the schedule.
+- flow_config_from_mapping() refuses shapes Prefect drops at run time.
 """
 
 from __future__ import annotations
@@ -17,7 +19,7 @@ from pathlib import Path
 
 import pytest
 
-from loom.prefect._config import FlowConfig, _load_flow_config
+from loom.prefect._config import FlowConfig, _load_flow_config, flow_config_from_mapping
 
 # ---------------------------------------------------------------------------
 # FlowConfig struct tests
@@ -127,3 +129,24 @@ def test_load_flow_config_raises_when_flows_key_missing(tmp_path: Path) -> None:
 
     with pytest.raises(KeyError):
         _load_flow_config(str(config_file), "any_flow")
+
+
+def test_flow_config_from_mapping_falls_back_to_defaults() -> None:
+    assert flow_config_from_mapping(None) == FlowConfig()
+    assert flow_config_from_mapping({}) == FlowConfig()
+
+
+def test_flow_config_from_mapping_reads_an_hour_scale_delay() -> None:
+    cfg = flow_config_from_mapping({"flow_retries": 3, "flow_retry_delay_seconds": 7200})
+    assert cfg.flow_retries == 3
+    assert cfg.flow_retry_delay_seconds == 7200
+
+
+def test_flow_config_rejects_a_list_of_delays() -> None:
+    with pytest.raises(TypeError, match="single number"):
+        flow_config_from_mapping({"flow_retry_delay_seconds": [5400, 12600]})
+
+
+def test_flow_config_rejects_a_negative_delay() -> None:
+    with pytest.raises(ValueError, match="negative"):
+        flow_config_from_mapping({"flow_retry_delay_seconds": -1})

{loom_kernel-1.2.0 → loom_kernel-1.2.2}/uv.lock

@@ -1583,7 +1583,7 @@ wheels = [
 
 [[package]]
 name = "loom-kernel"
-version = "1.2.0"
+version = "1.2.2"
 source = { editable = "." }
 dependencies = [
     { name = "aiocache" },

loom_kernel-1.2.0/src/loom/prefect/_config.py

@@ -1,62 +0,0 @@
-"""Flow configuration loader for loom.prefect."""
-
-from __future__ import annotations
-
-from pathlib import Path
-
-import msgspec
-import yaml
-
-
-class FlowConfig(msgspec.Struct, frozen=True, kw_only=True):
-    """Retry and execution policy for a single ETL flow.
-
-    Args:
-        flow_retries: Number of full-flow retries Prefect will attempt before
-            declaring the run failed (each retry is a new Fargate container).
-        flow_retry_delay_seconds: Seconds Prefect waits between flow retries.
-
-    Example::
-
-        cfg = _load_flow_config("config/etl_flows.yaml", "daily_orders")
-    """
-
-    flow_retries: int = 2
-    flow_retry_delay_seconds: int = 60
-
-
-def _load_flow_config(config_path: str, flow_name: str) -> FlowConfig:
-    """Load ``FlowConfig`` for *flow_name* from a YAML file.
-
-    YAML structure::
-
-        flows:
-          my_etl:
-            flow_retries: 2
-            flow_retry_delay_seconds: 60
-
-    Args:
-        config_path: Path to the YAML configuration file.
-        flow_name: Key under ``flows`` to load.
-
-    Returns:
-        ``FlowConfig`` for the named flow, using ``FlowConfig`` defaults for
-        any keys not present in the YAML section.
-
-    Raises:
-        KeyError: When ``flows`` key is missing or *flow_name* is not found.
-    """
-    raw = yaml.safe_load(Path(config_path).read_text())
-    flows = raw["flows"]
-    section = flows[flow_name]
-    _defaults = FlowConfig()
-    return FlowConfig(
-        flow_retries=section.get("flow_retries", _defaults.flow_retries),
-        flow_retry_delay_seconds=section.get(
-            "flow_retry_delay_seconds",
-            _defaults.flow_retry_delay_seconds,
-        ),
-    )
-
-
-__all__ = ["FlowConfig"]