stageflow-framework 0.9.0__tar.gz → 0.11.0__tar.gz

stageflow_framework-0.11.0/PKG-INFO

@@ -0,0 +1,186 @@
+Metadata-Version: 2.4
+Name: stageflow-framework
+Version: 0.11.0
+Summary: StageFlow: pipeline framework for stages
+Author-email: лень <pzrnqt1vrss@protonmail.com>
+License-Expression: MIT
+Project-URL: Repository, https://github.com/leo-need-more-coffee/stageflow
+Project-URL: Issues, https://github.com/leo-need-more-coffee/stageflow/issues
+Keywords: pipeline,workflow,orchestration,state-machine,cel
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pyyaml
+Requires-Dist: jsonschema>=4.0.0
+Requires-Dist: immutables>=0.20
+Requires-Dist: common-expression-language>=0.9
+Provides-Extra: dev
+Requires-Dist: flake8; extra == "dev"
+Requires-Dist: build; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+Provides-Extra: docs
+Requires-Dist: mkdocs-material; extra == "docs"
+Requires-Dist: mkdocs-static-i18n; extra == "docs"
+Dynamic: license-file
+
+<div align="center">
+
+# StageFlow
+
+**Pipelines described in JSON, executed in Python — and debuggable node by node.**
+
+[![tests](https://github.com/leo-need-more-coffee/stageflow/actions/workflows/tests.yml/badge.svg)](https://github.com/leo-need-more-coffee/stageflow/actions/workflows/tests.yml)
+[![PyPI](https://img.shields.io/pypi/v/stageflow-framework)](https://pypi.org/project/stageflow-framework/)
+[![Python](https://img.shields.io/pypi/pyversions/stageflow-framework)](https://pypi.org/project/stageflow-framework/)
+[![docs](https://img.shields.io/badge/docs-stageflow-blue)](https://leo-need-more-coffee.github.io/stageflow/)
+[![license](https://img.shields.io/badge/license-MIT-green)](LICENSE)
+
+[Documentation](https://leo-need-more-coffee.github.io/stageflow/) ·
+[Tutorial](https://leo-need-more-coffee.github.io/stageflow/tutorial/) ·
+[Документация на русском](https://leo-need-more-coffee.github.io/stageflow/ru/)
+
+</div>
+
+A pipeline is a graph of nodes in JSON. The work happens in stages — Python
+classes you write. Between them travels one immutable frame of variables, and
+everything the graph does with that frame is visible in the JSON: branching,
+retries, error handling, concurrency, nested graphs.
+
+Because the pipeline is data, it can be stored, diffed, generated, validated
+before it runs — and drawn:
+
+![A pipeline open in the StageFlow editor](docs/img/tut-final.png)
+
+That is the [editor](https://github.com/leo-need-more-coffee/stageflow-ui): a
+separate static page that draws and debugs a graph while this core executes it.
+
+## Install
+
+```bash
+pip install stageflow-framework
+```
+
+Python 3.11+.
+
+## A pipeline in 30 seconds
+
+```python
+import asyncio
+
+from stageflow import BaseStage, Pipeline, Session, register_stage
+
+
+@register_stage("HelloStage")
+class HelloStage(BaseStage):
+    """
+    description: "Greets whoever the pipeline points at"
+    arguments:
+      name: string
+    outputs:
+      greeting: string
+    """
+
+    async def run(self):
+        name = self.get_arguments().get("name", "world")
+        self.set_outputs({"greeting": f"Hello, {name}!"})
+
+
+pipeline = Pipeline.from_dict({
+    "nodes": [
+        {"id": "start", "type": "entry",
+         "variables": {"user_name": "Alice"}, "next": "hello"},
+        {"id": "hello", "type": "stage", "stage": "HelloStage",
+         "arguments": {"vars": {"name": "user_name"}},
+         "outputs": {"greeting": "greeting"}, "next": "finish"},
+        {"id": "finish", "type": "terminal",
+         "result": {"status": "ok"}, "artifacts": ["greeting"]},
+    ],
+})
+pipeline.validate()
+
+result = asyncio.run(Session(id="demo", pipeline=pipeline).run())
+print(result.result)     # {'status': 'ok'}
+print(result.artifacts)  # {'greeting': 'Hello, Alice!'}
+```
+
+The docstring is the stage's specification. `validate()` checks the graph
+against it, so a wrong argument name is an error before anything runs.
+
+## What the graph can do
+
+| | |
+|---|---|
+| **Nine node types** | `entry`, `stage`, `condition`, `switch`, `parallel`, `try`, `map`, `subpipeline`, `terminal` |
+| **One immutable frame** | variables travel along the path; a write produces a new frame, so branches never collide |
+| **CEL expressions** | in conditions, in switch cases, and in any argument or output through the `.$` suffix |
+| **Errors as roads** | `retry` on a node, `try`/`except` over a region of the graph derived from its shape |
+| **Real concurrency** | `parallel` branches with their own frames and explicit merge rules |
+| **Loops over data** | `map` runs a region of the graph once per element, sequentially or at once |
+| **Nested graphs** | a `subpipeline` starts with a fresh frame and returns artifacts |
+| **Gradual typing** | declare the variables that matter; checked at validation and on every write |
+| **Step debugging** | stop between nodes, read and edit the frame, replay the event stream |
+
+## Documentation
+
+The [tutorial](https://leo-need-more-coffee.github.io/stageflow/tutorial/)
+builds one working pipeline step by step, with screenshots from the editor.
+The reference covers the rest:
+
+[Quick start](https://leo-need-more-coffee.github.io/stageflow/quick-start/) ·
+[Node types](https://leo-need-more-coffee.github.io/stageflow/node-types/) ·
+[Data model](https://leo-need-more-coffee.github.io/stageflow/data-model/) ·
+[Expressions](https://leo-need-more-coffee.github.io/stageflow/expressions/) ·
+[Errors](https://leo-need-more-coffee.github.io/stageflow/errors/) ·
+[Variable typing](https://leo-need-more-coffee.github.io/stageflow/variable-typing/) ·
+[Session control](https://leo-need-more-coffee.github.io/stageflow/session-control/) ·
+[Step debugging](https://leo-need-more-coffee.github.io/stageflow/step-debugging/)
+
+One page per node type:
+[entry](https://leo-need-more-coffee.github.io/stageflow/entry-node/) ·
+[stage](https://leo-need-more-coffee.github.io/stageflow/stage-node/) ·
+[condition](https://leo-need-more-coffee.github.io/stageflow/condition-node/) ·
+[switch](https://leo-need-more-coffee.github.io/stageflow/switch-node/) ·
+[parallel](https://leo-need-more-coffee.github.io/stageflow/parallel-branches/) ·
+[try](https://leo-need-more-coffee.github.io/stageflow/try-node/) ·
+[map](https://leo-need-more-coffee.github.io/stageflow/map-node/) ·
+[subpipeline](https://leo-need-more-coffee.github.io/stageflow/subpipeline-node/) ·
+[terminal](https://leo-need-more-coffee.github.io/stageflow/terminal-node/)
+
+Sources are in [`docs/`](docs) (`*.md` English, `*.ru.md` Russian) and publish
+themselves on every push to `main`.
+
+## The rest of the project
+
+| Repository | What it is |
+|---|---|
+| **stageflow** | this one: the core that runs the pipelines |
+| [stageflow-ui](https://github.com/leo-need-more-coffee/stageflow-ui) | the editor: a static page that draws and debugs a graph |
+| [stageflow-example](https://github.com/leo-need-more-coffee/stageflow-example) | a working backend for the editor: a support bot in four pipelines |
+
+## Development
+
+```bash
+pip install -e ".[dev]"
+python -m unittest discover -s tests
+```
+
+Pipelines can be tested declaratively:
+
+```python
+from stageflow.testing import PipelineTestSpec, run_pipeline_test
+```
+
+Releases are tag-driven: the tag has to match `project.version` in
+`pyproject.toml`, and the workflow publishes to PyPI.
+
+## License
+
+MIT — see [LICENSE](LICENSE).

stageflow_framework-0.11.0/README.md

@@ -0,0 +1,153 @@
+<div align="center">
+
+# StageFlow
+
+**Pipelines described in JSON, executed in Python — and debuggable node by node.**
+
+[![tests](https://github.com/leo-need-more-coffee/stageflow/actions/workflows/tests.yml/badge.svg)](https://github.com/leo-need-more-coffee/stageflow/actions/workflows/tests.yml)
+[![PyPI](https://img.shields.io/pypi/v/stageflow-framework)](https://pypi.org/project/stageflow-framework/)
+[![Python](https://img.shields.io/pypi/pyversions/stageflow-framework)](https://pypi.org/project/stageflow-framework/)
+[![docs](https://img.shields.io/badge/docs-stageflow-blue)](https://leo-need-more-coffee.github.io/stageflow/)
+[![license](https://img.shields.io/badge/license-MIT-green)](LICENSE)
+
+[Documentation](https://leo-need-more-coffee.github.io/stageflow/) ·
+[Tutorial](https://leo-need-more-coffee.github.io/stageflow/tutorial/) ·
+[Документация на русском](https://leo-need-more-coffee.github.io/stageflow/ru/)
+
+</div>
+
+A pipeline is a graph of nodes in JSON. The work happens in stages — Python
+classes you write. Between them travels one immutable frame of variables, and
+everything the graph does with that frame is visible in the JSON: branching,
+retries, error handling, concurrency, nested graphs.
+
+Because the pipeline is data, it can be stored, diffed, generated, validated
+before it runs — and drawn:
+
+![A pipeline open in the StageFlow editor](docs/img/tut-final.png)
+
+That is the [editor](https://github.com/leo-need-more-coffee/stageflow-ui): a
+separate static page that draws and debugs a graph while this core executes it.
+
+## Install
+
+```bash
+pip install stageflow-framework
+```
+
+Python 3.11+.
+
+## A pipeline in 30 seconds
+
+```python
+import asyncio
+
+from stageflow import BaseStage, Pipeline, Session, register_stage
+
+
+@register_stage("HelloStage")
+class HelloStage(BaseStage):
+    """
+    description: "Greets whoever the pipeline points at"
+    arguments:
+      name: string
+    outputs:
+      greeting: string
+    """
+
+    async def run(self):
+        name = self.get_arguments().get("name", "world")
+        self.set_outputs({"greeting": f"Hello, {name}!"})
+
+
+pipeline = Pipeline.from_dict({
+    "nodes": [
+        {"id": "start", "type": "entry",
+         "variables": {"user_name": "Alice"}, "next": "hello"},
+        {"id": "hello", "type": "stage", "stage": "HelloStage",
+         "arguments": {"vars": {"name": "user_name"}},
+         "outputs": {"greeting": "greeting"}, "next": "finish"},
+        {"id": "finish", "type": "terminal",
+         "result": {"status": "ok"}, "artifacts": ["greeting"]},
+    ],
+})
+pipeline.validate()
+
+result = asyncio.run(Session(id="demo", pipeline=pipeline).run())
+print(result.result)     # {'status': 'ok'}
+print(result.artifacts)  # {'greeting': 'Hello, Alice!'}
+```
+
+The docstring is the stage's specification. `validate()` checks the graph
+against it, so a wrong argument name is an error before anything runs.
+
+## What the graph can do
+
+| | |
+|---|---|
+| **Nine node types** | `entry`, `stage`, `condition`, `switch`, `parallel`, `try`, `map`, `subpipeline`, `terminal` |
+| **One immutable frame** | variables travel along the path; a write produces a new frame, so branches never collide |
+| **CEL expressions** | in conditions, in switch cases, and in any argument or output through the `.$` suffix |
+| **Errors as roads** | `retry` on a node, `try`/`except` over a region of the graph derived from its shape |
+| **Real concurrency** | `parallel` branches with their own frames and explicit merge rules |
+| **Loops over data** | `map` runs a region of the graph once per element, sequentially or at once |
+| **Nested graphs** | a `subpipeline` starts with a fresh frame and returns artifacts |
+| **Gradual typing** | declare the variables that matter; checked at validation and on every write |
+| **Step debugging** | stop between nodes, read and edit the frame, replay the event stream |
+
+## Documentation
+
+The [tutorial](https://leo-need-more-coffee.github.io/stageflow/tutorial/)
+builds one working pipeline step by step, with screenshots from the editor.
+The reference covers the rest:
+
+[Quick start](https://leo-need-more-coffee.github.io/stageflow/quick-start/) ·
+[Node types](https://leo-need-more-coffee.github.io/stageflow/node-types/) ·
+[Data model](https://leo-need-more-coffee.github.io/stageflow/data-model/) ·
+[Expressions](https://leo-need-more-coffee.github.io/stageflow/expressions/) ·
+[Errors](https://leo-need-more-coffee.github.io/stageflow/errors/) ·
+[Variable typing](https://leo-need-more-coffee.github.io/stageflow/variable-typing/) ·
+[Session control](https://leo-need-more-coffee.github.io/stageflow/session-control/) ·
+[Step debugging](https://leo-need-more-coffee.github.io/stageflow/step-debugging/)
+
+One page per node type:
+[entry](https://leo-need-more-coffee.github.io/stageflow/entry-node/) ·
+[stage](https://leo-need-more-coffee.github.io/stageflow/stage-node/) ·
+[condition](https://leo-need-more-coffee.github.io/stageflow/condition-node/) ·
+[switch](https://leo-need-more-coffee.github.io/stageflow/switch-node/) ·
+[parallel](https://leo-need-more-coffee.github.io/stageflow/parallel-branches/) ·
+[try](https://leo-need-more-coffee.github.io/stageflow/try-node/) ·
+[map](https://leo-need-more-coffee.github.io/stageflow/map-node/) ·
+[subpipeline](https://leo-need-more-coffee.github.io/stageflow/subpipeline-node/) ·
+[terminal](https://leo-need-more-coffee.github.io/stageflow/terminal-node/)
+
+Sources are in [`docs/`](docs) (`*.md` English, `*.ru.md` Russian) and publish
+themselves on every push to `main`.
+
+## The rest of the project
+
+| Repository | What it is |
+|---|---|
+| **stageflow** | this one: the core that runs the pipelines |
+| [stageflow-ui](https://github.com/leo-need-more-coffee/stageflow-ui) | the editor: a static page that draws and debugs a graph |
+| [stageflow-example](https://github.com/leo-need-more-coffee/stageflow-example) | a working backend for the editor: a support bot in four pipelines |
+
+## Development
+
+```bash
+pip install -e ".[dev]"
+python -m unittest discover -s tests
+```
+
+Pipelines can be tested declaratively:
+
+```python
+from stageflow.testing import PipelineTestSpec, run_pipeline_test
+```
+
+Releases are tag-driven: the tag has to match `project.version` in
+`pyproject.toml`, and the workflow publishes to PyPI.
+
+## License
+
+MIT — see [LICENSE](LICENSE).

{stageflow_framework-0.9.0 → stageflow_framework-0.11.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "stageflow-framework"
-version = "0.9.0"
+version = "0.11.0"
 description = "StageFlow: pipeline framework for stages"
 readme = "README.md"
 license = "MIT"
@@ -41,6 +41,10 @@ dev = [
     "build",
     "twine",
 ]
+docs = [
+    "mkdocs-material",
+    "mkdocs-static-i18n",
+]
 
 [tool.setuptools.packages.find]
 where = ["."]

{stageflow_framework-0.9.0 → stageflow_framework-0.11.0}/stageflow/__init__.py

@@ -1,4 +1,5 @@
 from . import builtins  # noqa: F401
+from .capabilities import __version__, capabilities
 from .core import (
     BaseStage,
     CelEngine,
@@ -9,6 +10,7 @@ from .core import (
     Event,
     EventSpec,
     InputSpec,
+    MapNode,
     Node,
     ParallelNode,
     Pipeline,
@@ -49,6 +51,8 @@ from .exceptions import (
 )
 
 __all__ = [
+    "__version__",
+    "capabilities",
     "Pipeline",
     "Session",
     "SessionResult",
@@ -67,6 +71,7 @@ __all__ = [
     "ConditionNode",
     "SwitchNode",
     "ParallelNode",
+    "MapNode",
     "SubPipelineNode",
     "TerminalNode",
     "Retrier",

{stageflow_framework-0.9.0 → stageflow_framework-0.11.0}/stageflow/builtins/_args.py

@@ -8,7 +8,7 @@ from ..exceptions import StageContractError
 def require_list(stage_name: str, field: str, value: Any) -> list:
     if not isinstance(value, list):
         raise StageContractError(
-            f"{stage_name}: '{field}' должен быть списком, получен {type(value).__name__}"
+            f"{stage_name}: '{field}' must be a list, got {type(value).__name__}"
         )
     return value
 
@@ -16,7 +16,7 @@ def require_list(stage_name: str, field: str, value: Any) -> list:
 def require_dict(stage_name: str, field: str, value: Any) -> dict:
     if not isinstance(value, dict):
         raise StageContractError(
-            f"{stage_name}: '{field}' должен быть объектом, получен {type(value).__name__}"
+            f"{stage_name}: '{field}' must be an object, got {type(value).__name__}"
         )
     return value
 
@@ -24,12 +24,12 @@ def require_dict(stage_name: str, field: str, value: Any) -> dict:
 def require_number(stage_name: str, field: str, value: Any) -> int | float:
     if isinstance(value, bool) or not isinstance(value, (int, float)):
         raise StageContractError(
-            f"{stage_name}: '{field}' должен быть числом, получен {type(value).__name__}"
+            f"{stage_name}: '{field}' must be a number, got {type(value).__name__}"
         )
     return value
 
 
 def require_present(stage_name: str, field: str, value: Any) -> Any:
     if value is None:
-        raise StageContractError(f"{stage_name}: требуется аргумент '{field}'")
+        raise StageContractError(f"{stage_name}: argument '{field}' is required")
     return value

{stageflow_framework-0.9.0 → stageflow_framework-0.11.0}/stageflow/builtins/lists.py

@@ -29,7 +29,7 @@ class AppendListStage(BaseStage):
     async def run(self):
         args = self.get_arguments()
         if "value" not in args:
-            raise StageContractError("AppendListStage: требуется аргумент 'value'")
+            raise StageContractError("AppendListStage: argument 'value' is required")
         value = args["value"]
         base = require_list("AppendListStage", "list", args.get("list") or [])
         self.set_outputs({"list": [*base, value]})
@@ -63,7 +63,7 @@ class ExtendListStage(BaseStage):
         items = args.get("items", [])
         if not isinstance(items, (list, tuple)):
             raise StageContractError(
-                f"ExtendListStage: 'items' должен быть списком, получен {type(items).__name__}"
+                f"ExtendListStage: 'items' must be a list, got {type(items).__name__}"
             )
         self.set_outputs({"list": [*base, *items]})
 
@@ -95,7 +95,7 @@ class FilterListStage(BaseStage):
         args = self.get_arguments()
         condition = args.pop("condition", None)
         if condition is None:
-            raise StageContractError("FilterListStage: требуется аргумент 'condition'")
+            raise StageContractError("FilterListStage: argument 'condition' is required")
         items = require_list("FilterListStage", "items", args.pop("items", []))
         scope = Context(vars=args)
         result = [item for item in items if self.session.cel.eval(condition, scope, item=item)]
@@ -159,13 +159,13 @@ class PopListStage(BaseStage):
         args = self.get_arguments()
         items = require_list("PopListStage", "items", args.get("items", []))
         if not items:
-            raise StageContractError("PopListStage: нельзя извлечь элемент из пустого списка")
+            raise StageContractError("PopListStage: cannot pop from an empty list")
         index = args.get("index", -1)
         remaining = list(items)
         try:
             popped = remaining.pop(index)
         except IndexError:
             raise StageContractError(
-                f"PopListStage: индекс {index} вне списка длины {len(items)}"
+                f"PopListStage: index {index} is out of range for a list of length {len(items)}"
             ) from None
         self.set_outputs({"list": remaining, "popped": popped})

{stageflow_framework-0.9.0 → stageflow_framework-0.11.0}/stageflow/builtins/strings.py

@@ -9,13 +9,13 @@ class _NameOnlyFormatter(string.Formatter):
     def get_field(self, field_name, args, kwargs):
         if not field_name.isidentifier():
             raise StageContractError(
-                f"TemplateStage: плейсхолдер '{{{field_name}}}' — не имя аргумента; "
-                "атрибуты, индексы и позиционные номера в шаблоне запрещены"
+                f"TemplateStage: placeholder '{{{field_name}}}' is not an argument name; "
+                "attributes, indexes and positional numbers are not allowed"
             )
         if field_name not in kwargs:
             raise StageContractError(
-                f"TemplateStage: шаблон ссылается на '{field_name}', "
-                f"но такого аргумента нет (есть: {sorted(kwargs)})"
+                f"TemplateStage: template references '{field_name}', "
+                f"but there is no such argument (available: {sorted(kwargs)})"
             )
         return kwargs[field_name], field_name
 

{stageflow_framework-0.9.0 → stageflow_framework-0.11.0}/stageflow/builtins/vars.py

@@ -23,7 +23,7 @@ class SetValueStage(BaseStage):
     async def run(self):
         args = self.get_arguments()
         if "value" not in args:
-            raise StageContractError("SetValueStage: требуется аргумент 'value'")
+            raise StageContractError("SetValueStage: argument 'value' is required")
         self.set_outputs({"value": args["value"]})
 
 

stageflow_framework-0.11.0/stageflow/capabilities.py

@@ -0,0 +1,56 @@
+"""What this build of StageFlow can do, in a form a client can read.
+
+A visual editor is written against one version of the core and then pointed at
+whatever backend the user has running. A version number alone does not answer
+the question it actually has — "can I offer a `map` node here?" — because the
+answer depends on the build, not on a range of releases someone has to keep a
+table of. So the core answers it directly: here are the node types I execute.
+
+A backend is expected to hand this to its clients (the example backend serves
+it at `GET /api/meta`); the shape is small and additive on purpose.
+"""
+
+from __future__ import annotations
+
+from importlib.metadata import PackageNotFoundError, version as _package_version
+from typing import Any
+
+from .core.nodes import get_node_types
+from .core.stage import get_stages
+
+DISTRIBUTION = "stageflow-framework"
+
+
+def _installed_version() -> str:
+    """The version of the installed distribution.
+
+    Running from a source checkout that was never installed there is nothing
+    to read it from, and guessing would be worse than saying so: a client that
+    sees "0.0.0+unknown" knows not to compare it with anything, while a made-up
+    number would be compared and believed.
+    """
+    try:
+        return _package_version(DISTRIBUTION)
+    except PackageNotFoundError:  # pragma: no cover - only in a bare checkout
+        return "0.0.0+unknown"
+
+
+__version__ = _installed_version()
+
+
+def capabilities() -> dict[str, Any]:
+    """The language this build understands.
+
+    - `stageflow` — the version of the core, for a human reading a log;
+    - `node_types` — the types a pipeline may use here, sorted. This is the
+      field a client should branch on: a name that is not in the list will be
+      rejected by `Pipeline.from_dict` with `Unknown node type`.
+    - `stages` — how many stages are registered. The specs themselves are a
+      separate, much larger answer (`get_stages`), so this is only a hint that
+      a registry is there at all.
+    """
+    return {
+        "stageflow": __version__,
+        "node_types": sorted(get_node_types()),
+        "stages": len(get_stages()),
+    }

{stageflow_framework-0.9.0 → stageflow_framework-0.11.0}/stageflow/core/__init__.py

@@ -6,6 +6,7 @@ from .inputs import InputHub
 from .nodes import (
     ConditionNode,
     EntryNode,
+    MapNode,
     Node,
     ParallelNode,
     Retrier,
@@ -48,6 +49,7 @@ __all__ = [
     "ExceptHandler",
     "EntryNode",
     "StageNode",
+    "MapNode",
     "ConditionNode",
     "SwitchNode",
     "ParallelNode",

{stageflow_framework-0.9.0 → stageflow_framework-0.11.0}/stageflow/core/cel.py

@@ -28,8 +28,8 @@ class CelEngine:
         self._compiled: dict[str, Any] = {}
         if _BACKEND is None:  # pragma: no cover
             raise ExpressionError(
-                "Не найден ни один CEL-байндинг. Поставь "
-                "'common-expression-language' (рекомендуется) или 'cel-python'."
+                "No CEL backend found. Install "
+                "'common-expression-language' (recommended) or 'cel-python'."
             )
 
     @property
@@ -46,7 +46,7 @@ class CelEngine:
                     env = _celpy.Environment()
                     program = env.program(env.compile(expr))
             except Exception as exc:  # noqa: BLE001
-                raise ExpressionError(f"Не удалось скомпилировать CEL {expr!r}: {exc}") from exc
+                raise ExpressionError(f"Cannot compile CEL {expr!r}: {exc}") from exc
             self._compiled[expr] = program
         return program
 
@@ -72,4 +72,4 @@ class CelEngine:
                 return program.execute(activation)
             return program.evaluate(activation)  # pragma: no cover
         except Exception as exc:  # noqa: BLE001
-            raise ExpressionError(f"Ошибка вычисления CEL {expr!r}: {exc}") from exc
+            raise ExpressionError(f"Cannot evaluate CEL {expr!r}: {exc}") from exc

{stageflow_framework-0.9.0 → stageflow_framework-0.11.0}/stageflow/core/context.py

@@ -39,8 +39,8 @@ class Context:
     def from_dict(cls, data: dict[str, Any]) -> "Context":
         if "local" in data and "vars" not in data:
             raise PipelineDefinitionError(
-                "Снапшот содержит скоуп 'local' (до 0.7.0); "
-                "фрейм теперь называется 'vars'"
+                "Snapshot contains the 'local' scope (pre-0.7.0); "
+                "the frame is now called 'vars'"
             )
         return cls(vars=data.get("vars", {}))
 

{stageflow_framework-0.9.0 → stageflow_framework-0.11.0}/stageflow/core/debug.py

@@ -124,7 +124,7 @@ class StepDebugger:
         for name, value in values.items():
             try:
                 if types is not None:
-                    types.check_write(name, value, f"отладчик перед узлом '{self.node}'")
+                    types.check_write(name, value, f"debugger before node '{self.node}'")
             except Exception as exc:  # noqa: BLE001
                 self._emit("var_rejected", name=name, error=str(exc))
                 continue

{stageflow_framework-0.9.0 → stageflow_framework-0.11.0}/stageflow/core/nodes/__init__.py

@@ -1,6 +1,7 @@
 from .base import Node, get_node_types, register_node
 from .branching import ConditionNode, SwitchNode
 from .entry import EntryNode
+from .map_block import MapNode
 from .parallel import ParallelNode
 from .recovery import Retrier, run_with_retry
 from .stage import StageNode
@@ -18,6 +19,7 @@ __all__ = [
     "ExceptHandler",
     "EntryNode",
     "StageNode",
+    "MapNode",
     "ConditionNode",
     "SwitchNode",
     "ParallelNode",

{stageflow_framework-0.9.0 → stageflow_framework-0.11.0}/stageflow/core/nodes/base.py

@@ -77,10 +77,10 @@ class Node:
         errors: list[str] = []
         for src, dst in self.expose.items():
             malformed = False
-            for path, side in ((src, "источник"), (dst, "назначение")):
+            for path, side in ((src, "source"), (dst, "destination")):
                 if not isinstance(path, str) or not path.isidentifier():
                     errors.append(
-                        f"{self.id}: expose {side} '{path}' должен быть именем переменной"
+                        f"{self.id}: expose {side} '{path}' must be a variable name"
                     )
                     malformed = True
             if malformed:
@@ -90,8 +90,8 @@ class Node:
             dst_type = ts.declared(dst)
             if src_type and dst_type and not ts.expose_compatible(src_type, dst_type):
                 errors.append(
-                    f"{self.id}: expose {src} -> {dst}: несовместимые типы "
-                    f"'{src_type}' и '{dst_type}'"
+                    f"{self.id}: expose {src} -> {dst}: incompatible types "
+                    f"'{src_type}' and '{dst_type}'"
                 )
         return errors