pyflowstep 0.6.0__tar.gz → 0.7.1__tar.gz

{pyflowstep-0.6.0 → pyflowstep-0.7.1}/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.4
 Name: pyflowstep
-Version: 0.6.0
-Summary: A lightweight, typed Python library for composing functions into readable, reusable flows that can be defined as JSON.
-Keywords: flow,pipeline,composition,functional,fluent-interface,json,json-schema,workflow,dsl
+Version: 0.7.1
+Summary: A lightweight, typed Python library for composing functions into readable, reusable flows that can be defined as JSON or TOML.
+Keywords: flow,pipeline,composition,functional,fluent-interface,json,json-schema,toml,workflow,dsl
 Author: aaltatan
 Author-email: aaltatan <a.altatan@gmail.com>
 License-Expression: GPL-3.0-only
@@ -16,6 +16,7 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Typing :: Typed
 Requires-Dist: pyargprocessors>=0.1.0
+Requires-Dist: pyvocabulary>=0.1.0
 Requires-Python: >=3.12
 Project-URL: Homepage, https://github.com/aaltatan/pyflowstep
 Project-URL: Repository, https://github.com/aaltatan/pyflowstep
@@ -695,15 +696,42 @@ login = compiler.compile(
 login(Page())
 ```
 
-The compiler takes already-parsed data. Reading JSON, YAML, a database row or an API payload is up to you:
+`compile` takes already-parsed data, so a database row or an API payload works too.
+
+### Flow files
+
+`compile_file` picks a parser by the file suffix. JSON and TOML are built in:
 
 ```python
-import json
-from pathlib import Path
+login = compiler.compile_file("login.json")  # a list of steps, as above
+login = compiler.compile_file("login.toml")
+```
+
+A TOML flow lists its steps as `[[steps]]` tables:
+
+```toml
+[[steps]]
+name = "navigate"
+args = ["https://example.com/login"]
 
-login = compiler.compile(json.loads(Path("login.json").read_text()))
+[[steps]]
+name = "click"
+kwargs = { selector = "button[type=submit]" }
 ```
 
+Add any other format by registering a parser that turns the file text into a list of steps:
+
+```python
+import yaml
+
+from pyflowstep import register_flow_format
+
+register_flow_format(".yaml", yaml.safe_load)
+register_flow_format(".yml", yaml.safe_load)
+```
+
+An unregistered suffix raises `UnsupportedFlowFormatError`; a file that does not parse raises `InvalidFlowDefinitionError`. Errors from a file carry an extra `in <path>` note. `load_flow_definition(path)` returns the parsed data without compiling it.
+
 Each step dictionary has this shape — only `name` is required:
 
 ```json
@@ -719,7 +747,7 @@ at $[1]
 
 | Problem                                          | Exception                                              |
 | ------------------------------------------------ | ------------------------------------------------------ |
-| Not a list / malformed step dict                 | `InvalidFlowDefinitionError`                           |
+| Not a list / malformed step dict / bad file      | `InvalidFlowDefinitionError`                           |
 | Unknown or hidden step name                      | `StepDoesNotExistError` (lists the available steps)    |
 | Missing / extra / duplicated arguments           | `MissingArgumentError`, `TooManyArgumentsError`, ...   |
 | A processor rejects a value                      | `ProcessArgumentError` (from `pyargprocessors`)        |

{pyflowstep-0.6.0 → pyflowstep-0.7.1}/README.md

@@ -671,15 +671,42 @@ login = compiler.compile(
 login(Page())
 ```
 
-The compiler takes already-parsed data. Reading JSON, YAML, a database row or an API payload is up to you:
+`compile` takes already-parsed data, so a database row or an API payload works too.
+
+### Flow files
+
+`compile_file` picks a parser by the file suffix. JSON and TOML are built in:
 
 ```python
-import json
-from pathlib import Path
+login = compiler.compile_file("login.json")  # a list of steps, as above
+login = compiler.compile_file("login.toml")
+```
+
+A TOML flow lists its steps as `[[steps]]` tables:
+
+```toml
+[[steps]]
+name = "navigate"
+args = ["https://example.com/login"]
 
-login = compiler.compile(json.loads(Path("login.json").read_text()))
+[[steps]]
+name = "click"
+kwargs = { selector = "button[type=submit]" }
 ```
 
+Add any other format by registering a parser that turns the file text into a list of steps:
+
+```python
+import yaml
+
+from pyflowstep import register_flow_format
+
+register_flow_format(".yaml", yaml.safe_load)
+register_flow_format(".yml", yaml.safe_load)
+```
+
+An unregistered suffix raises `UnsupportedFlowFormatError`; a file that does not parse raises `InvalidFlowDefinitionError`. Errors from a file carry an extra `in <path>` note. `load_flow_definition(path)` returns the parsed data without compiling it.
+
 Each step dictionary has this shape — only `name` is required:
 
 ```json
@@ -695,7 +722,7 @@ at $[1]
 
 | Problem                                          | Exception                                              |
 | ------------------------------------------------ | ------------------------------------------------------ |
-| Not a list / malformed step dict                 | `InvalidFlowDefinitionError`                           |
+| Not a list / malformed step dict / bad file      | `InvalidFlowDefinitionError`                           |
 | Unknown or hidden step name                      | `StepDoesNotExistError` (lists the available steps)    |
 | Missing / extra / duplicated arguments           | `MissingArgumentError`, `TooManyArgumentsError`, ...   |
 | A processor rejects a value                      | `ProcessArgumentError` (from `pyargprocessors`)        |

{pyflowstep-0.6.0 → pyflowstep-0.7.1}/pyproject.toml

@@ -1,11 +1,14 @@
 [project]
 name = "pyflowstep"
-version = "0.6.0"
-description = "A lightweight, typed Python library for composing functions into readable, reusable flows that can be defined as JSON."
+version = "0.7.1"
+description = "A lightweight, typed Python library for composing functions into readable, reusable flows that can be defined as JSON or TOML."
 readme = "README.md"
 license = "GPL-3.0-only"
 requires-python = ">=3.12"
-dependencies = ["pyargprocessors>=0.1.0"]
+dependencies = [
+    "pyargprocessors>=0.1.0",
+    "pyvocabulary>=0.1.0",
+]
 keywords = [
     "flow",
     "pipeline",
@@ -14,6 +17,7 @@ keywords = [
     "fluent-interface",
     "json",
     "json-schema",
+    "toml",
     "workflow",
     "dsl",
 ]
@@ -118,3 +122,7 @@ extend-immutable-calls = [
     "T201",
     "INP001",
 ]
+
+[tool.pyright]
+venvPath = "."
+venv = ".venv"

{pyflowstep-0.6.0 → pyflowstep-0.7.1}/pyproject.toml.orig

@@ -1,7 +1,7 @@
 [project]
 name = "pyflowstep"
-version = "0.6.0"
-description = "A lightweight, typed Python library for composing functions into readable, reusable flows that can be defined as JSON."
+version = "0.7.1"
+description = "A lightweight, typed Python library for composing functions into readable, reusable flows that can be defined as JSON or TOML."
 readme = "README.md"
 authors = [
     { name = "aaltatan", email = "a.altatan@gmail.com" }
@@ -10,6 +10,7 @@ license = "GPL-3.0-only"
 requires-python = ">=3.12"
 dependencies = [
     "pyargprocessors>=0.1.0",
+    "pyvocabulary>=0.1.0",
 ]
 keywords = [
     "flow",
@@ -19,6 +20,7 @@ keywords = [
     "fluent-interface",
     "json",
     "json-schema",
+    "toml",
     "workflow",
     "dsl",
 ]
@@ -93,3 +95,8 @@ extend-immutable-calls = [
 [tool.ruff.lint.per-file-ignores]
 "tests/**" = ["S101", "PLR2004", "ANN", "ARG", "INP001", "E501"]
 "examples/**" = ["T201", "INP001"]
+
+
+[tool.pyright]
+venvPath = "."
+venv = ".venv"

{pyflowstep-0.6.0 → pyflowstep-0.7.1}/src/pyflowstep/__init__.py

@@ -1,98 +1,105 @@
-"""Compose functions into readable, reusable, JSON-definable flows.
-
-`pyflowstep` is a functional replacement for the fluent-interface (method chaining)
-pattern. Instead of adding chainable methods to a class, you write small step
-functions and compose them with `>>`:
-
-```python
->>> from pyflowstep import step
->>> @step
-... def add(total: int, amount: int) -> int:
-...     return total + amount
->>> @step
-... def double(total: int) -> int:
-...     return total * 2
->>> (add(3) >> double() >> add(1))(0)
-7
-
-```
-
-Steps collected in a `StepsRegistry` can also be described as JSON
-(`get_flow_json_schema`) and compiled from JSON (`FlowCompiler`).
-
-Raw JSON values become typed arguments with the `Process` marker of
-`pyargprocessors`, written next to the parameter:
-
-```python
->>> from typing import Annotated
->>> from pyargprocessors import Process
->>> @step
-... def scale(total: int, factor: Annotated[int, Process(int)]) -> int:
-...     return total * factor
->>> scale("3")(2)
-6
-
-```
-"""
-
-from .compilers import FlowCompiler, FlowDefinition, StepDict, validate_step_dict
-from .dependencies import Depends, override_dependencies
-from .exceptions import (
-    ArgumentError,
-    InvalidDependencyError,
-    InvalidFlowDefinitionError,
-    InvalidInputError,
-    InvalidStepError,
-    InvalidStepNameError,
-    MissingArgumentError,
-    MissingInputError,
-    MultipleValuesArgumentError,
-    PositionalOnlyArgumentError,
-    PyflowstepError,
-    StepAlreadyRegisteredError,
-    StepDoesNotExistError,
-    TooManyArgumentsError,
-    UnexpectedKeywordArgumentError,
-)
-from .flow import Action, Flow, compose
-from .inputs import Input
-from .json_schema import get_flow_json_schema, get_json_schema, get_step_json_schema
-from .registry import StepsRegistry
-from .steps import StepFactory, StepFn, TapFn, step, tap
-
-__all__ = [
-    "Action",
-    "ArgumentError",
-    "Depends",
-    "Flow",
-    "FlowCompiler",
-    "FlowDefinition",
-    "Input",
-    "InvalidDependencyError",
-    "InvalidFlowDefinitionError",
-    "InvalidInputError",
-    "InvalidStepError",
-    "InvalidStepNameError",
-    "MissingArgumentError",
-    "MissingInputError",
-    "MultipleValuesArgumentError",
-    "PositionalOnlyArgumentError",
-    "PyflowstepError",
-    "StepAlreadyRegisteredError",
-    "StepDict",
-    "StepDoesNotExistError",
-    "StepFactory",
-    "StepFn",
-    "StepsRegistry",
-    "TapFn",
-    "TooManyArgumentsError",
-    "UnexpectedKeywordArgumentError",
-    "compose",
-    "get_flow_json_schema",
-    "get_json_schema",
-    "get_step_json_schema",
-    "override_dependencies",
-    "step",
-    "tap",
-    "validate_step_dict",
-]
+"""Compose functions into readable, reusable, JSON-definable flows.
+
+`pyflowstep` is a functional replacement for the fluent-interface (method chaining)
+pattern. Instead of adding chainable methods to a class, you write small step
+functions and compose them with `>>`:
+
+```python
+>>> from pyflowstep import step
+>>> @step
+... def add(total: int, amount: int) -> int:
+...     return total + amount
+>>> @step
+... def double(total: int) -> int:
+...     return total * 2
+>>> (add(3) >> double() >> add(1))(0)
+7
+
+```
+
+Steps collected in a `StepsRegistry` can also be described as JSON
+(`get_flow_json_schema`) and compiled from JSON or TOML files (`FlowCompiler`);
+`register_flow_format` adds other file formats.
+
+Raw JSON values become typed arguments with the `Process` marker of
+`pyargprocessors`, written next to the parameter:
+
+```python
+>>> from typing import Annotated
+>>> from pyargprocessors import Process
+>>> @step
+... def scale(total: int, factor: Annotated[int, Process(int)]) -> int:
+...     return total * factor
+>>> scale("3")(2)
+6
+
+```
+"""
+
+from .compilers import FlowCompiler, FlowDefinition, StepDict, validate_step_dict
+from .dependencies import Depends, override_dependencies
+from .exceptions import (
+    ArgumentError,
+    InvalidDependencyError,
+    InvalidFlowDefinitionError,
+    InvalidInputError,
+    InvalidStepError,
+    InvalidStepNameError,
+    MissingArgumentError,
+    MissingInputError,
+    MultipleValuesArgumentError,
+    PositionalOnlyArgumentError,
+    PyflowstepError,
+    StepAlreadyRegisteredError,
+    StepDoesNotExistError,
+    TooManyArgumentsError,
+    UnexpectedKeywordArgumentError,
+    UnsupportedFlowFormatError,
+)
+from .flow import Action, Flow, compose
+from .inputs import Input
+from .json_schema import get_flow_json_schema, get_json_schema, get_step_json_schema
+from .loaders import FlowParser, load_flow_definition, register_flow_format
+from .registry import StepsRegistry
+from .steps import StepFactory, StepFn, TapFn, step, tap
+
+__all__ = [
+    "Action",
+    "ArgumentError",
+    "Depends",
+    "Flow",
+    "FlowCompiler",
+    "FlowDefinition",
+    "FlowParser",
+    "Input",
+    "InvalidDependencyError",
+    "InvalidFlowDefinitionError",
+    "InvalidInputError",
+    "InvalidStepError",
+    "InvalidStepNameError",
+    "MissingArgumentError",
+    "MissingInputError",
+    "MultipleValuesArgumentError",
+    "PositionalOnlyArgumentError",
+    "PyflowstepError",
+    "StepAlreadyRegisteredError",
+    "StepDict",
+    "StepDoesNotExistError",
+    "StepFactory",
+    "StepFn",
+    "StepsRegistry",
+    "TapFn",
+    "TooManyArgumentsError",
+    "UnexpectedKeywordArgumentError",
+    "UnsupportedFlowFormatError",
+    "compose",
+    "get_flow_json_schema",
+    "get_json_schema",
+    "get_step_json_schema",
+    "load_flow_definition",
+    "override_dependencies",
+    "register_flow_format",
+    "step",
+    "tap",
+    "validate_step_dict",
+]