pipeline-frame 0.1.0__tar.gz

pipeline_frame-0.1.0/.github/workflows/publish.yml

@@ -0,0 +1,101 @@
+name: Publish
+
+on:
+  push:
+    branches:
+      - main
+    tags:
+      - "v*"
+  pull_request:
+
+jobs:
+  test:
+    name: Test on Python ${{ matrix.python-version }}
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.11", "3.12", "3.13", "3.14"]
+
+    steps:
+      - name: Check out repository
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Run tests
+        run: python -m unittest discover -s tests -v
+
+  build:
+    name: Build distributions
+    runs-on: ubuntu-latest
+    needs: test
+
+    steps:
+      - name: Check out repository
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+
+      - name: Validate tag version matches package version
+        if: startsWith(github.ref, 'refs/tags/v')
+        run: |
+          python - <<'PY'
+          import pathlib
+          import re
+
+          pyproject = pathlib.Path("pyproject.toml").read_text(encoding="utf-8")
+          match = re.search(r'^version\s*=\s*"([^"]+)"', pyproject, re.MULTILINE)
+          if match is None:
+              raise SystemExit("Could not find project version in pyproject.toml")
+
+          package_version = match.group(1)
+          tag = "${{ github.ref_name }}"
+          tag_version = tag.removeprefix("v")
+
+          if tag_version != package_version:
+              raise SystemExit(
+                  f"Tag version '{tag_version}' does not match package version '{package_version}'"
+              )
+
+          print(f"Version check passed: tag={tag}, package={package_version}")
+          PY
+
+      - name: Install build tools
+        run: python -m pip install --upgrade build twine
+
+      - name: Build distributions
+        run: python -m build
+
+      - name: Check distributions
+        run: python -m twine check dist/*
+
+      - name: Upload build artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: python-package-distributions
+          path: dist/
+
+  publish:
+    name: Publish to PyPI
+    if: startsWith(github.ref, 'refs/tags/v')
+    runs-on: ubuntu-latest
+    needs: build
+    permissions:
+      id-token: write
+
+    steps:
+      - name: Download build artifacts
+        uses: actions/download-artifact@v4
+        with:
+          name: python-package-distributions
+          path: dist/
+
+      - name: Publish distributions to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1

pipeline_frame-0.1.0/.gitignore

@@ -0,0 +1,29 @@
+# Python cache and compiled files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# Build artifacts
+build/
+dist/
+*.egg-info/
+.eggs/
+
+# Virtual environments
+.venv/
+venv/
+env/
+
+# Tool caches
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+.coverage
+htmlcov/
+
+# IDE files
+.idea/
+.vscode/
+
+# OS files
+.DS_Store

pipeline_frame-0.1.0/.python-version

@@ -0,0 +1 @@
+3.11

pipeline_frame-0.1.0/PKG-INFO

@@ -0,0 +1,93 @@
+Metadata-Version: 2.4
+Name: pipeline-frame
+Version: 0.1.0
+Summary: A lightweight in-memory pipeline framework built around before, run, and after.
+Project-URL: Homepage, https://github.com/al6nlee/pipeline-frame
+Project-URL: Repository, https://github.com/al6nlee/pipeline-frame
+Author-email: alan <al6nlee@gmail.com>
+Keywords: pipeline,pipeline-frame,workflow
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+
+# pipeline-frame
+
+`pipeline-frame` is a lightweight in-memory pipeline framework for Python 3.11+.
+
+It keeps the model intentionally narrow: every step is built around `before()`, `run()`, and `after()`.
+
+## Core idea
+
+Define a linear pipeline with `Step` instances and `|` composition:
+
+```python
+from pipeline_frame import Pipeline, PipelineContext, Step
+
+
+class A(Step):
+    def before(self, context: PipelineContext) -> None:
+        print("a.before")
+
+    def run(self, context: PipelineContext) -> None:
+        context.set("text", context.input["text"].strip())
+
+    def after(self, context: PipelineContext) -> None:
+        print("a.after")
+
+
+class B(Step):
+    def run(self, context: PipelineContext) -> None:
+        context.set_output(context.get("text").upper())
+
+
+pipeline = A() | B()
+
+result = pipeline.run({"text": "  hello world  "})
+print(result.output)
+```
+
+Execution is linear and easy to reason about:
+
+```text
+A.before()
+A.run()
+A.after()
+B.before()
+B.run()
+B.after()
+```
+
+If you want to keep an explicit pipeline name, you can also write:
+
+```python
+pipeline = Pipeline("request") | A() | B()
+```
+
+## Design goals
+
+- one core abstraction: `Pipeline`
+- one step lifecycle: `before`, `run`, `after`
+- chainable definitions with minimal ceremony
+- structured execution results
+- predictable stop-on-failure behavior
+
+## Failure behavior
+
+- if `before()` fails, the current step stops and later steps do not run
+- if `run()` fails, the current step still attempts `after()`
+- if `after()` fails, the pipeline is marked failed and later steps do not run
+- all details are available on `PipelineResult`
+
+## API overview
+
+- `Pipeline`: ordered collection of step instances
+- `Step`: base class with `before()`, `run()`, and `after()`
+- `PipelineContext`: shared input, state, output, and error
+- `PipelineResult`: execution report for one run
+
+## Development
+
+Run tests from the repository root:
+
+```bash
+python -m unittest discover -s tests -v
+```

pipeline_frame-0.1.0/README.md

@@ -0,0 +1,82 @@
+# pipeline-frame
+
+`pipeline-frame` is a lightweight in-memory pipeline framework for Python 3.11+.
+
+It keeps the model intentionally narrow: every step is built around `before()`, `run()`, and `after()`.
+
+## Core idea
+
+Define a linear pipeline with `Step` instances and `|` composition:
+
+```python
+from pipeline_frame import Pipeline, PipelineContext, Step
+
+
+class A(Step):
+    def before(self, context: PipelineContext) -> None:
+        print("a.before")
+
+    def run(self, context: PipelineContext) -> None:
+        context.set("text", context.input["text"].strip())
+
+    def after(self, context: PipelineContext) -> None:
+        print("a.after")
+
+
+class B(Step):
+    def run(self, context: PipelineContext) -> None:
+        context.set_output(context.get("text").upper())
+
+
+pipeline = A() | B()
+
+result = pipeline.run({"text": "  hello world  "})
+print(result.output)
+```
+
+Execution is linear and easy to reason about:
+
+```text
+A.before()
+A.run()
+A.after()
+B.before()
+B.run()
+B.after()
+```
+
+If you want to keep an explicit pipeline name, you can also write:
+
+```python
+pipeline = Pipeline("request") | A() | B()
+```
+
+## Design goals
+
+- one core abstraction: `Pipeline`
+- one step lifecycle: `before`, `run`, `after`
+- chainable definitions with minimal ceremony
+- structured execution results
+- predictable stop-on-failure behavior
+
+## Failure behavior
+
+- if `before()` fails, the current step stops and later steps do not run
+- if `run()` fails, the current step still attempts `after()`
+- if `after()` fails, the pipeline is marked failed and later steps do not run
+- all details are available on `PipelineResult`
+
+## API overview
+
+- `Pipeline`: ordered collection of step instances
+- `Step`: base class with `before()`, `run()`, and `after()`
+- `PipelineContext`: shared input, state, output, and error
+- `PipelineResult`: execution report for one run
+
+## Development
+
+Run tests from the repository root:
+
+```bash
+python -m unittest discover -s tests -v
+```

pipeline_frame-0.1.0/pipeline_frame/__init__.py

@@ -0,0 +1,30 @@
+from .context import PipelineContext, RunContext
+from .errors import PipelineDefinitionError, PipelineFailedError
+from .models import (
+    PhaseName,
+    PhaseResult,
+    PhaseStatus,
+    PipelineResult,
+    RunStatus,
+    StepResult,
+    StepStatus,
+)
+from .pipeline import Pipeline
+from .step import Step, StepSpec
+
+__all__ = [
+    "PhaseName",
+    "PhaseResult",
+    "PhaseStatus",
+    "Pipeline",
+    "PipelineContext",
+    "PipelineDefinitionError",
+    "PipelineFailedError",
+    "PipelineResult",
+    "RunContext",
+    "RunStatus",
+    "Step",
+    "StepSpec",
+    "StepResult",
+    "StepStatus",
+]

pipeline_frame-0.1.0/pipeline_frame/context.py

@@ -0,0 +1,27 @@
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass(slots=True)
+class PipelineContext:
+    """Mutable state shared by one pipeline run."""
+
+    input: Any = None
+    state: dict[str, Any] = field(default_factory=dict)
+    output: Any = None
+    error: BaseException | None = None
+
+    def set(self, key: str, value: Any) -> None:
+        self.state[key] = value
+
+    def get(self, key: str, default: Any = None) -> Any:
+        return self.state.get(key, default)
+
+    def set_output(self, value: Any) -> None:
+        self.output = value
+
+    def fail(self, error: BaseException) -> None:
+        self.error = error
+
+
+RunContext = PipelineContext

pipeline_frame-0.1.0/pipeline_frame/errors.py

@@ -0,0 +1,24 @@
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .models import PipelineResult
+
+
+class PipelineDefinitionError(ValueError):
+    """Raised when a pipeline definition is invalid."""
+
+
+class PipelineFailedError(RuntimeError):
+    """Raised when a pipeline run fails."""
+
+    def __init__(self, result: "PipelineResult", cause: BaseException):
+        message = f"Pipeline '{result.pipeline_name}' failed"
+        if result.failure_step and result.failure_phase:
+            message += (
+                f" during {result.failure_phase.value.lower()} "
+                f"of '{result.failure_step}'"
+            )
+        message += f": {cause}"
+        super().__init__(message)
+        self.result = result
+        self.cause = cause

pipeline_frame-0.1.0/pipeline_frame/models.py

@@ -0,0 +1,91 @@
+from dataclasses import dataclass, field
+from enum import StrEnum
+from typing import Any
+
+
+class PhaseName(StrEnum):
+    BEFORE = "BEFORE"
+    RUN = "RUN"
+    AFTER = "AFTER"
+
+
+class PhaseStatus(StrEnum):
+    PENDING = "PENDING"
+    SKIPPED = "SKIPPED"
+    RUNNING = "RUNNING"
+    SUCCESS = "SUCCESS"
+    FAILED = "FAILED"
+
+
+class RunStatus(StrEnum):
+    SUCCESS = "SUCCESS"
+    FAILED = "FAILED"
+
+
+@dataclass(slots=True)
+class PhaseResult:
+    status: PhaseStatus = PhaseStatus.PENDING
+    error: BaseException | None = None
+    started_at: float | None = None
+    finished_at: float | None = None
+
+    @property
+    def duration(self) -> float | None:
+        if self.started_at is None or self.finished_at is None:
+            return None
+        return self.finished_at - self.started_at
+
+
+@dataclass(slots=True)
+class StepResult:
+    name: str
+    before: PhaseResult = field(default_factory=PhaseResult)
+    run: PhaseResult = field(default_factory=PhaseResult)
+    after: PhaseResult = field(default_factory=PhaseResult)
+
+    @property
+    def succeeded(self) -> bool:
+        return self.run.status == PhaseStatus.SUCCESS and self.after.status in {
+            PhaseStatus.SUCCESS,
+            PhaseStatus.SKIPPED,
+        }
+
+    @property
+    def failed(self) -> bool:
+        return any(
+            phase.status == PhaseStatus.FAILED
+            for phase in (self.before, self.run, self.after)
+        )
+
+
+@dataclass(slots=True)
+class PipelineResult:
+    pipeline_name: str
+    status: RunStatus
+    input_value: Any
+    output: Any
+    state: dict[str, Any]
+    error: BaseException | None
+    step_results: dict[str, StepResult]
+    executed_steps: tuple[str, ...]
+    started_at: float
+    finished_at: float
+    failure_step: str | None = None
+    failure_phase: PhaseName | None = None
+
+    @property
+    def duration(self) -> float:
+        return self.finished_at - self.started_at
+
+    @property
+    def input(self) -> Any:
+        return self.input_value
+
+    @property
+    def failed_step_result(self) -> StepResult | None:
+        if self.failure_step is None:
+            return None
+        return self.step_results[self.failure_step]
+
+
+StepStatus = PhaseStatus

pipeline_frame-0.1.0/pipeline_frame/pipeline.py

@@ -0,0 +1,187 @@
+from __future__ import annotations
+
+import time
+from typing import Any, Self
+
+from .context import PipelineContext
+from .errors import PipelineDefinitionError, PipelineFailedError
+from .models import PhaseName, PhaseResult, PhaseStatus, PipelineResult, RunStatus, StepResult
+from .step import Step, StepSpec
+
+
+class Pipeline:
+    """A small linear pipeline centered on before, run, and after."""
+
+    def __init__(self, name: str = "pipeline"):
+        self.name = name
+        self._steps: list[StepSpec | Step] = []
+
+    def add(
+        self,
+        step: type[Step] | Step,
+        /,
+        *,
+        name: str | None = None,
+        **options: Any,
+    ) -> Self:
+        if isinstance(step, Step):
+            if name is not None or options:
+                raise TypeError("Cannot override name or options when adding a Step instance")
+
+            step_name = step.name or step.__class__.name or step.__class__.__name__
+            if any(existing.name == step_name for existing in self._steps):
+                raise PipelineDefinitionError(f"Duplicate step name: '{step_name}'")
+
+            step.name = step_name
+            self._steps.append(step)
+            return self
+
+        if not issubclass(step, Step):
+            raise TypeError("step must be a Step subclass or Step instance")
+
+        step_name = name or step.name or step.__name__
+        if any(step.name == step_name for step in self._steps):
+            raise PipelineDefinitionError(f"Duplicate step name: '{step_name}'")
+
+        self._steps.append(
+            StepSpec(
+                step_type=step,
+                name=step_name,
+                options=dict(options),
+            )
+        )
+        return self
+
+    def add_many(self, *steps: type[Step] | Step) -> Self:
+        for step in steps:
+            self.add(step)
+        return self
+
+    pipe = add
+
+    @property
+    def steps(self) -> tuple[StepSpec | Step, ...]:
+        return tuple(self._steps)
+
+    def __or__(self, other):
+        cloned = self._clone()
+        cloned.add(other)
+        return cloned
+
+    def run(self, input_value=None, /, *, raise_on_error: bool = True) -> PipelineResult:
+        if not self._steps:
+            raise PipelineDefinitionError("Pipeline must contain at least one step")
+
+        context = PipelineContext(input=input_value)
+        step_instances = [self._materialize(step) for step in self._steps]
+        step_results = {step.name: StepResult(name=step.name) for step in step_instances}
+        executed_steps: list[str] = []
+        started_at = time.perf_counter()
+        first_error: BaseException | None = None
+        failure_step: str | None = None
+        failure_phase: PhaseName | None = None
+
+        for step in step_instances:
+            step_result = step_results[step.name]
+
+            before_error = self._run_callable(step.before, context, step_result.before)
+            if before_error is not None:
+                first_error = before_error
+                failure_step = step.name
+                failure_phase = PhaseName.BEFORE
+                context.fail(first_error)
+                break
+
+            run_error = self._run_callable(step.run, context, step_result.run)
+            after_error = self._run_callable(step.after, context, step_result.after)
+            executed_steps.append(step.name)
+
+            cause = self._combine_errors(step.name, run_error, after_error)
+            if cause is None:
+                continue
+
+            first_error = cause
+            failure_step = step.name
+            failure_phase = PhaseName.RUN if run_error is not None else PhaseName.AFTER
+            context.fail(first_error)
+            break
+
+        self._finalize_pending_results(step_results)
+        finished_at = time.perf_counter()
+        status = RunStatus.FAILED if first_error is not None else RunStatus.SUCCESS
+        result = PipelineResult(
+            pipeline_name=self.name,
+            status=status,
+            input_value=context.input,
+            output=context.output,
+            state=dict(context.state),
+            error=first_error,
+            step_results=step_results,
+            executed_steps=tuple(executed_steps),
+            started_at=started_at,
+            finished_at=finished_at,
+            failure_step=failure_step,
+            failure_phase=failure_phase,
+        )
+
+        if first_error is not None and raise_on_error:
+            raise PipelineFailedError(result=result, cause=first_error)
+
+        return result
+
+    @staticmethod
+    def _run_callable(
+        action,
+        context: PipelineContext,
+        result: PhaseResult,
+    ) -> BaseException | None:
+        result.status = PhaseStatus.RUNNING
+        result.started_at = time.perf_counter()
+        try:
+            action(context)
+        except Exception as error:
+            result.status = PhaseStatus.FAILED
+            result.error = error
+            result.finished_at = time.perf_counter()
+            return error
+
+        result.status = PhaseStatus.SUCCESS
+        result.error = None
+        result.finished_at = time.perf_counter()
+        return None
+
+    @staticmethod
+    def _combine_errors(
+        step_name: str,
+        run_error: BaseException | None,
+        after_error: BaseException | None,
+    ) -> BaseException | None:
+        if run_error is None:
+            return after_error
+        if after_error is None:
+            return run_error
+        return ExceptionGroup(
+            f"Step '{step_name}' failed in run and after",
+            [run_error, after_error],
+        )
+
+    @staticmethod
+    def _finalize_pending_results(step_results: dict[str, StepResult]) -> None:
+        for result in step_results.values():
+            if result.before.status == PhaseStatus.PENDING:
+                result.before.status = PhaseStatus.SKIPPED
+            if result.run.status == PhaseStatus.PENDING:
+                result.run.status = PhaseStatus.SKIPPED
+            if result.after.status == PhaseStatus.PENDING:
+                result.after.status = PhaseStatus.SKIPPED
+
+    def _clone(self) -> "Pipeline":
+        cloned = Pipeline(self.name)
+        cloned._steps = list(self._steps)
+        return cloned
+
+    @staticmethod
+    def _materialize(step: StepSpec | Step) -> Step:
+        if isinstance(step, StepSpec):
+            return step.create()
+        return step

pipeline_frame-0.1.0/pipeline_frame/step.py

@@ -0,0 +1,47 @@
+from dataclasses import dataclass, field
+from typing import Any
+
+from .context import PipelineContext
+
+
+class Step:
+    """Base class for one linear pipeline step."""
+
+    name: str | None = None
+
+    def __init_subclass__(cls, **kwargs):
+        super().__init_subclass__(**kwargs)
+        if cls is not Step and cls.name is None:
+            cls.name = cls.__name__
+
+    def before(self, context: PipelineContext) -> None:
+        """Run before the main step logic."""
+
+    def run(self, context: PipelineContext) -> None:
+        """Run the main step logic."""
+
+    def after(self, context: PipelineContext) -> None:
+        """Run after the main step logic."""
+
+    def __or__(self, other):
+        from .pipeline import Pipeline
+
+        return Pipeline() | self | other
+
+
+@dataclass(frozen=True, slots=True)
+class StepSpec:
+    step_type: type[Step]
+    name: str
+    options: dict[str, Any] = field(default_factory=dict)
+
+    def __post_init__(self) -> None:
+        if not issubclass(self.step_type, Step):
+            raise TypeError("step_type must be a Step subclass")
+        if not self.name:
+            raise ValueError("Step name cannot be empty")
+
+    def create(self) -> Step:
+        step = self.step_type(**self.options)
+        step.name = self.name
+        return step

pipeline_frame-0.1.0/pyproject.toml

@@ -0,0 +1,22 @@
+[project]
+name = "pipeline-frame"
+version = "0.1.0"
+description = "A lightweight in-memory pipeline framework built around before, run, and after."
+readme = "README.md"
+requires-python = ">=3.11"
+authors = [
+    { name = "alan", email = "al6nlee@gmail.com" }
+]
+keywords = ["pipeline-frame", "pipeline", "workflow"]
+dependencies = []
+
+[project.urls]
+Homepage = "https://github.com/al6nlee/pipeline-frame"
+Repository = "https://github.com/al6nlee/pipeline-frame"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["pipeline_frame"]

pipeline_frame-0.1.0/tests/test_pipeline.py

@@ -0,0 +1,189 @@
+import unittest
+
+from pipeline_frame import (
+    PhaseName,
+    PhaseStatus,
+    Pipeline,
+    PipelineContext,
+    PipelineDefinitionError,
+    PipelineFailedError,
+    RunStatus,
+    Step,
+)
+
+
+def append_trace(context: PipelineContext, item: str) -> None:
+    trace = context.get("trace")
+    if trace is None:
+        trace = []
+        context.set("trace", trace)
+    trace.append(item)
+
+
+class A(Step):
+    def before(self, context: PipelineContext) -> None:
+        append_trace(context, "a.before")
+
+    def run(self, context: PipelineContext) -> None:
+        append_trace(context, "a.run")
+        context.set("text", context.input["text"].strip())
+
+    def after(self, context: PipelineContext) -> None:
+        append_trace(context, "a.after")
+
+
+class B(Step):
+    def before(self, context: PipelineContext) -> None:
+        append_trace(context, "b.before")
+
+    def run(self, context: PipelineContext) -> None:
+        append_trace(context, "b.run")
+        context.set("text", context.get("text").upper())
+
+    def after(self, context: PipelineContext) -> None:
+        append_trace(context, "b.after")
+
+
+class C(Step):
+    def before(self, context: PipelineContext) -> None:
+        append_trace(context, "c.before")
+
+    def run(self, context: PipelineContext) -> None:
+        append_trace(context, "c.run")
+        context.set_output(f"RESULT={context.get('text')}")
+
+    def after(self, context: PipelineContext) -> None:
+        append_trace(context, "c.after")
+
+
+class ExplodeOnRun(Step):
+    def before(self, context: PipelineContext) -> None:
+        append_trace(context, "explode.before")
+
+    def run(self, context: PipelineContext) -> None:
+        append_trace(context, "explode.run")
+        raise ValueError("boom")
+
+    def after(self, context: PipelineContext) -> None:
+        append_trace(context, "explode.after")
+
+
+class BrokenAfter(Step):
+    def run(self, context: PipelineContext) -> None:
+        append_trace(context, "broken.run")
+
+    def after(self, context: PipelineContext) -> None:
+        append_trace(context, "broken.after")
+        raise RuntimeError("after failed")
+
+
+class ExplodeOnBefore(Step):
+    def before(self, context: PipelineContext) -> None:
+        append_trace(context, "before.fail")
+        raise RuntimeError("before failed")
+
+
+class PipelineTests(unittest.TestCase):
+    def test_pipeline_runs_step_lifecycle_in_order(self) -> None:
+        pipeline = Pipeline("request").add(A).add(B).add(C)
+
+        result = pipeline.run({"text": "  hello  "})
+
+        self.assertEqual(result.status, RunStatus.SUCCESS)
+        self.assertEqual(result.output, "RESULT=HELLO")
+        self.assertEqual(
+            result.state["trace"],
+            [
+                "a.before",
+                "a.run",
+                "a.after",
+                "b.before",
+                "b.run",
+                "b.after",
+                "c.before",
+                "c.run",
+                "c.after",
+            ],
+        )
+        self.assertEqual(result.executed_steps, ("A", "B", "C"))
+
+    def test_run_failure_stops_later_steps_but_keeps_current_after(self) -> None:
+        pipeline = Pipeline("request").add(ExplodeOnRun).add(C)
+
+        with self.assertRaises(PipelineFailedError) as captured:
+            pipeline.run()
+
+        result = captured.exception.result
+        self.assertEqual(result.status, RunStatus.FAILED)
+        self.assertEqual(result.failure_step, "ExplodeOnRun")
+        self.assertEqual(result.failure_phase, PhaseName.RUN)
+        self.assertEqual(result.executed_steps, ("ExplodeOnRun",))
+        self.assertEqual(
+            result.state["trace"],
+            ["explode.before", "explode.run", "explode.after"],
+        )
+        self.assertEqual(result.step_results["C"].before.status, PhaseStatus.SKIPPED)
+
+    def test_after_failure_marks_run_failed(self) -> None:
+        pipeline = Pipeline("request").add(BrokenAfter)
+
+        with self.assertRaises(PipelineFailedError) as captured:
+            pipeline.run()
+
+        result = captured.exception.result
+        self.assertEqual(result.failure_step, "BrokenAfter")
+        self.assertEqual(result.failure_phase, PhaseName.AFTER)
+        self.assertEqual(
+            result.state["trace"],
+            ["broken.run", "broken.after"],
+        )
+        self.assertEqual(result.step_results["BrokenAfter"].after.status, PhaseStatus.FAILED)
+
+    def test_before_failure_stops_current_step_immediately(self) -> None:
+        pipeline = Pipeline("request").add(ExplodeOnBefore).add(C)
+
+        with self.assertRaises(PipelineFailedError) as captured:
+            pipeline.run()
+
+        result = captured.exception.result
+        self.assertEqual(result.failure_step, "ExplodeOnBefore")
+        self.assertEqual(result.failure_phase, PhaseName.BEFORE)
+        self.assertEqual(result.state["trace"], ["before.fail"])
+        self.assertEqual(result.step_results["ExplodeOnBefore"].run.status, PhaseStatus.SKIPPED)
+        self.assertEqual(result.step_results["ExplodeOnBefore"].after.status, PhaseStatus.SKIPPED)
+
+    def test_duplicate_step_names_are_rejected(self) -> None:
+        pipeline = Pipeline("request").add(A)
+
+        with self.assertRaises(PipelineDefinitionError):
+            pipeline.add(A)
+
+    def test_pipe_operator_builds_pipeline_from_instances(self) -> None:
+        result = (A() | B() | C()).run({"text": "  hello  "})
+
+        self.assertEqual(result.output, "RESULT=HELLO")
+        self.assertEqual(
+            result.state["trace"],
+            [
+                "a.before",
+                "a.run",
+                "a.after",
+                "b.before",
+                "b.run",
+                "b.after",
+                "c.before",
+                "c.run",
+                "c.after",
+            ],
+        )
+
+    def test_pipe_operator_does_not_mutate_existing_pipeline(self) -> None:
+        base = Pipeline("request")
+        extended = base | A() | B()
+
+        self.assertEqual(base.steps, ())
+        self.assertEqual(len(extended.steps), 2)
+
+
+if __name__ == "__main__":
+    unittest.main()

pipeline_frame-0.1.0/uv.lock

@@ -0,0 +1,8 @@
+version = 1
+revision = 3
+requires-python = ">=3.11"
+
+[[package]]
+name = "pipeline-frame"
+version = "0.1.0"
+source = { editable = "." }