flowrep 0.5.2__tar.gz → 0.6.0__tar.gz

{flowrep-0.5.2 → flowrep-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flowrep
-Version: 0.5.2
+Version: 0.6.0
 Summary: flowrep - Your premier tool for workflow representations
 Project-URL: Homepage, https://pyiron.org/
 Project-URL: Documentation, https://flowrep.readthedocs.io
@@ -47,8 +47,10 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Scientific/Engineering
 Requires-Python: <3.15,>=3.11
+Requires-Dist: packaging<=26.2,>=24.2
 Requires-Dist: pydantic<2.13.0,>=2.12.0
 Requires-Dist: pyiron-snippets<2.0.0,>=1.3.0
+Requires-Dist: typing-extensions<4.17.0,>=4.14.1
 Provides-Extra: notebooks
 Requires-Dist: numpy==2.4.6; extra == 'notebooks'
 Provides-Extra: pwd
@@ -292,10 +294,10 @@ We can look at the template it will follow, e.g., by peeking at the part of the
 used for the "while" condition:
 
 ```python
->>> recipe_json["nodes"]["double_until_0"]["nodes"]["while_0"]["case"]["condition"]["node"]["type"]
+>>> recipe_json["nodes"]["double_until_0"]["nodes"]["while_0"]["case"]["condition"]["recipe"]["type"]
 'atomic'
 
->>> recipe_json["nodes"]["double_until_0"]["nodes"]["while_0"]["case"]["condition"]["node"]["reference"]["info"]["qualname"]
+>>> recipe_json["nodes"]["double_until_0"]["nodes"]["while_0"]["case"]["condition"]["recipe"]["reference"]["info"]["qualname"]
 'is_less_than_target'
 
 ```

{flowrep-0.5.2 → flowrep-0.6.0}/docs/README.md

@@ -230,10 +230,10 @@ We can look at the template it will follow, e.g., by peeking at the part of the
 used for the "while" condition:
 
 ```python
->>> recipe_json["nodes"]["double_until_0"]["nodes"]["while_0"]["case"]["condition"]["node"]["type"]
+>>> recipe_json["nodes"]["double_until_0"]["nodes"]["while_0"]["case"]["condition"]["recipe"]["type"]
 'atomic'
 
->>> recipe_json["nodes"]["double_until_0"]["nodes"]["while_0"]["case"]["condition"]["node"]["reference"]["info"]["qualname"]
+>>> recipe_json["nodes"]["double_until_0"]["nodes"]["while_0"]["case"]["condition"]["recipe"]["reference"]["info"]["qualname"]
 'is_less_than_target'
 
 ```

{flowrep-0.5.2 → flowrep-0.6.0}/pyproject.toml

@@ -1,5 +1,5 @@
 [build-system]
-requires = [ "hatchling==1.30.1", "hatch-vcs==0.5.0",]
+requires = [ "hatchling==1.31.0", "hatch-vcs==0.5.0",]
 build-backend = "hatchling.build"
 
 [project]
@@ -9,7 +9,7 @@ readme = "docs/README.md"
 keywords = [ "pyiron",]
 requires-python = ">=3.11, <3.15"
 classifiers = [ "Development Status :: 4 - Beta", "Topic :: Scientific/Engineering", "License :: OSI Approved :: BSD License", "Intended Audience :: Science/Research", "Operating System :: OS Independent", "Programming Language :: Python :: 3.11", "Programming Language :: Python :: 3.12", "Programming Language :: Python :: 3.13", "Programming Language :: Python :: 3.14",]
-dependencies = [ "pydantic>=2.12.0,<2.13.0", "pyiron_snippets>=1.3.0,<2.0.0",]
+dependencies = [ "packaging>=24.2,<=26.2", "pydantic>=2.12.0,<2.13.0", "pyiron_snippets>=1.3.0,<2.0.0", "typing-extensions>=4.14.1,<4.17.0",]
 dynamic = [ "version",]
 [[project.authors]]
 name = "Sam Waseda"

{flowrep-0.5.2 → flowrep-0.6.0}/src/flowrep/__init__.py

@@ -7,9 +7,10 @@ attribute onto a function at definition time, and parsers (`parse_atomic`,
 import importlib.metadata
 
 from flowrep.api import atomic as atomic
+from flowrep.api import dataclass as dataclass
 from flowrep.api import parse_atomic as parse_atomic
-from flowrep.api import parse_workflow as parse_workflow
 from flowrep.api import schemas as schemas
+from flowrep.api import std as std
 from flowrep.api import tools as tools
 from flowrep.api import workflow as workflow
 

{flowrep-0.5.2 → flowrep-0.6.0}/src/flowrep/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.5.2'
-__version_tuple__ = version_tuple = (0, 5, 2)
+__version__ = version = '0.6.0'
+__version_tuple__ = version_tuple = (0, 6, 0)
 
 __commit_id__ = commit_id = None

{flowrep-0.5.2 → flowrep-0.6.0}/src/flowrep/api/__init__.py

@@ -7,9 +7,11 @@ tools list is likely to be useful for all power users, while schemas are intende
 primarily benefit downstream developers (e.g. WfMS creators).
 """
 
+import flowrep.std as std
 from flowrep.api import schemas as schemas
 from flowrep.api import tools as tools
 from flowrep.api.tools import atomic as atomic
+from flowrep.api.tools import dataclass as dataclass
 from flowrep.api.tools import parse_atomic as parse_atomic
 from flowrep.api.tools import parse_workflow as parse_workflow
 from flowrep.api.tools import workflow as workflow

{flowrep-0.5.2 → flowrep-0.6.0}/src/flowrep/api/schemas.py

@@ -22,7 +22,8 @@ from flowrep.edge_models import OutputTarget as OutputTarget
 from flowrep.edge_models import SourceHandle as SourceHandle
 from flowrep.edge_models import TargetHandle as TargetHandle
 from flowrep.prospective.atomic_recipe import AtomicRecipe as AtomicRecipe
-from flowrep.prospective.atomic_recipe import UnpackMode as UnpackMode
+from flowrep.prospective.constant_recipe import JSONABLE as JSONABLE
+from flowrep.prospective.constant_recipe import ConstantRecipe as ConstantRecipe
 from flowrep.prospective.for_recipe import ForEachRecipe as ForEachRecipe
 from flowrep.prospective.helper_models import ConditionalCase as ConditionalCase
 from flowrep.prospective.helper_models import ExceptionCase as ExceptionCase
@@ -36,6 +37,7 @@ from flowrep.prospective.workflow_recipe import WorkflowRecipe as WorkflowRecipe
 from flowrep.retrospective.datastructures import NOT_DATA as NOT_DATA
 from flowrep.retrospective.datastructures import AtomicData as AtomicData
 from flowrep.retrospective.datastructures import CompositeData as CompositeData
+from flowrep.retrospective.datastructures import ConstantData as ConstantData
 from flowrep.retrospective.datastructures import DagData as DagData
 from flowrep.retrospective.datastructures import FlowControlData as FlowControlData
 from flowrep.retrospective.datastructures import ForEachData as ForEachData

{flowrep-0.5.2 → flowrep-0.6.0}/src/flowrep/api/tools.py

@@ -10,8 +10,10 @@ from flowrep.converters.python_workflow_definition import flowrep2pwd as flowrep
 from flowrep.converters.python_workflow_definition import pwd2flowrep as pwd2flowrep
 from flowrep.parsers.atomic_parser import atomic as atomic
 from flowrep.parsers.atomic_parser import parse_atomic as parse_atomic
+from flowrep.parsers.dataclass_parser import dataclass as dataclass
 from flowrep.parsers.workflow_parser import parse_workflow as parse_workflow
 from flowrep.parsers.workflow_parser import workflow as workflow
+from flowrep.prospective.constant_recipe import is_jsonable as is_jsonable
 from flowrep.retrospective.datastructures import recipe2data as recipe2data
 from flowrep.retrospective.storage import LexicalBagBrowser as LexicalBagBrowser
 from flowrep.wfms import run_recipe as run_recipe

{flowrep-0.5.2 → flowrep-0.6.0}/src/flowrep/base_models.py

@@ -18,6 +18,7 @@ class RecipeElementType(StrEnum):
     WHILE = "while"
     IF = "if"
     TRY = "try"
+    CONSTANT = "constant"
 
 
 class IOTypes(StrEnum):
@@ -61,6 +62,30 @@ def validate_unique(v: list[T], message: str | None = None) -> list[T]:
     return v
 
 
+def ensure_class_signature_from_init(cls: type, context: str) -> None:
+    """Reject classes whose constructor signature comes from ``__new__``.
+
+    Flowrep derives a class's input parameter names and defaults from
+    ``inspect.signature(cls)`` but reads their annotations from
+    ``cls.__init__``. For classes that define their signature via ``__new__``
+    (e.g. :class:`typing.NamedTuple`, or any class overriding ``__new__``
+    without a corresponding ``__init__``), these two sources disagree and
+    annotations would silently be dropped. Fail loudly instead.
+
+    Args:
+        cls: The class being introspected.
+        context: A short label for the caller (e.g. ``"@atomic"`` or a fully
+            qualified name) used in the error message.
+    """
+    if cls.__init__ is object.__init__ and cls.__new__ is not object.__new__:  # type: ignore[misc, comparison-overlap]
+        raise TypeError(
+            f"{context} cannot introspect {cls.__name__!r}: its constructor "
+            f"signature is defined via __new__ (e.g. NamedTuple or a custom "
+            f"__new__), so flowrep cannot read input annotations from __init__. "
+            f"Define an __init__ with annotated parameters instead."
+        )
+
+
 UniqueList = Annotated[list[T], pydantic.AfterValidator(validate_unique)]
 # We want the ordered property of a list -- especially during round-trip serialization
 # But also the "one of each element" property of a list

{flowrep-0.5.2 → flowrep-0.6.0}/src/flowrep/compiler/flow_control.py

@@ -69,10 +69,14 @@ def emit_flow_control(
         for port in node.outputs
         if (label, port) in required_by_handle
     }
-    # Allocate output symbols for all outputs, using required names where available.
+    # A flow-control node's output port is always named after an enclosing *symbol* the
+    # author wrote -- an accumulator, a branch assignment, a loop variable -- so the port
+    # name is a pin, not a hint. `reserve` rather than `fresh`: minting `b_0` for a symbol
+    # the source calls `b` would break the round trip, and would collide with the same
+    # symbol pinned elsewhere (a `while` inside a `try` surfaces one `b` through both).
     out_syms: dict[str, str] = {}
     for port in node.outputs:
-        name = required.get(port) or alloc.fresh(port)
+        name = required.get(port) or alloc.reserve(port)
         produced[(label, port)] = name
         out_syms[port] = name
 
@@ -106,7 +110,7 @@ def _emit_for_each(
     lines = [f"{out_syms[port]} = []" for port in node.outputs]
 
     body_label = node.body_node.label
-    body = node.body_node.node
+    body = node.body_node.recipe
 
     def collection_symbol(body_port: str) -> str:
         """Return the enclosing-scope symbol that feeds a body port."""
@@ -178,7 +182,7 @@ def _render_condition(
     alloc: function.NameAllocator,
 ) -> str:
     """Render a condition call as an inline expression (no assignment)."""
-    cond_node = case_condition.node
+    cond_node = case_condition.recipe
     cond_label = case_condition.label
     call_path = statements.node_call_path(cond_node, cond_label, emitter, alloc)
     if call_path is None:
@@ -244,7 +248,7 @@ def _emit_if(
         lines.append(f"{keyword} {cond_expr}:")
         body = _emit_branch(
             case.body.label,
-            case.body.node,
+            case.body.recipe,
             node,
             in_resolver,
             out_syms,
@@ -256,7 +260,7 @@ def _emit_if(
         lines.append("else:")
         body = _emit_branch(
             node.else_case.label,
-            node.else_case.node,
+            node.else_case.recipe,
             node,
             in_resolver,
             out_syms,
@@ -290,7 +294,7 @@ def _emit_try(
     # try body
     try_lines = _emit_branch(
         node.try_node.label,
-        node.try_node.node,
+        node.try_node.recipe,
         node,
         in_resolver,
         out_syms,
@@ -309,7 +313,7 @@ def _emit_try(
         lines.append(header)
         body = _emit_branch(
             case.body.label,
-            case.body.node,
+            case.body.recipe,
             node,
             in_resolver,
             out_syms,
@@ -332,7 +336,7 @@ def _emit_while(
     cond_expr = _render_condition(case.condition, node, in_resolver, emitter, alloc)
 
     body_label = case.body.label
-    body = case.body.node
+    body = case.body.recipe
 
     # Map body inputs to enclosing-scope symbols (unwired defaults are omitted).
     body_in_syms: dict[str, str] = {}

{flowrep-0.5.2 → flowrep-0.6.0}/src/flowrep/compiler/function.py

@@ -118,51 +118,69 @@ def referenced_top_level_bindings(
                         yield info.module.split(".")[0]
 
 
-def _inlined_loop_variables(recipe: workflow_recipe.WorkflowRecipe) -> set[str]:
-    """Loop-variable names emitted into this workflow's own scope.
-
-    For-loop variables are pinned to body-port names and bypass the allocator, so
-    reserving them prevents allocator-minted symbols from shadowing them. Descends
-    through inlined flow-control bodies; stops at reference-free WorkflowRecipe peer
-    nodes (emitted as nested defs with their own scope) and referenced nodes.
+def _inlined_pinned_symbols(recipe: workflow_recipe.WorkflowRecipe) -> set[str]:
+    """Every name the emitter is *forced* to use as a symbol in this function's scope.
+
+    Python's flow control introduces no scope, so every inlined ``for``/``if``/``while``/
+    ``try`` body shares one flat namespace with the enclosing ``def``. Most symbols in it
+    are the allocator's to choose, but some are pinned: round-tripping requires a symbol
+    to carry a port name verbatim, or re-parsing regenerates a different port. Pinned
+    names bypass the allocator, so it must learn them *up front* -- a pin emitted later
+    cannot retroactively protect a name the allocator already minted.
+
+    The pins are flow-control output ports, for-loop variables, for-body output ports, and
+    the input ports of flow-control nodes (which force the feeding sibling's output symbol
+    to match).
+
+    Descends through inlined flow-control bodies; stops at reference-free WorkflowRecipe
+    peer nodes (emitted as nested defs, with their own scope) and referenced nodes.
     """
-    names: set[str] = set()
+    names: set[str] = set(statements.flow_control_input_requirements(recipe).values())
     for node in recipe.nodes.values():
-        _collect_loop_variables(node, names)
+        _collect_pinned_symbols(node, names)
     return names
 
 
-def _collect_loop_variables(
+def _collect_pinned_symbols(
     node: union_types.RecipeDiscrimination, names: set[str]
 ) -> None:
+    if not isinstance(node, flow_control.FLOW_CONTROL_TYPES):
+        return  # atomic / referenced / reference-free workflow peer: not inlined here
+
+    # Every flow-control output port is named for an enclosing symbol, and
+    # `emit_flow_control` pins it to that name.
+    names.update(node.outputs)
+
     if isinstance(node, for_recipe.ForEachRecipe):
         names.update(node.iterated_ports)
-        _collect_loop_variables_from_body(node.body_node.node, names)
+        # `_emit_for_each` pins every body output to its port name.
+        names.update(node.body_node.recipe.outputs)
+        _collect_pinned_symbols_from_body(node.body_node.recipe, names)
     elif isinstance(node, if_recipe.IfRecipe):
         for body_case in node.cases:
-            _collect_loop_variables_from_body(body_case.body.node, names)
+            _collect_pinned_symbols_from_body(body_case.body.recipe, names)
         if node.else_case is not None:
-            _collect_loop_variables_from_body(node.else_case.node, names)
+            _collect_pinned_symbols_from_body(node.else_case.recipe, names)
     elif isinstance(node, try_recipe.TryRecipe):
-        _collect_loop_variables_from_body(node.try_node.node, names)
+        _collect_pinned_symbols_from_body(node.try_node.recipe, names)
         for exception_case in node.exception_cases:
-            _collect_loop_variables_from_body(exception_case.body.node, names)
+            _collect_pinned_symbols_from_body(exception_case.body.recipe, names)
     elif isinstance(node, while_recipe.WhileRecipe):
-        _collect_loop_variables_from_body(node.case.body.node, names)
-    # atomic / referenced / reference-free workflow peer node: not inlined here
+        _collect_pinned_symbols_from_body(node.case.body.recipe, names)
 
 
-def _collect_loop_variables_from_body(
+def _collect_pinned_symbols_from_body(
     body: union_types.RecipeDiscrimination, names: set[str]
 ) -> None:
     """Recurse into an inlined body: a WorkflowRecipe's own nodes, or a nested
     flow-control node. Both are emitted into the current scope."""
     if isinstance(body, workflow_recipe.WorkflowRecipe):
+        names.update(statements.flow_control_input_requirements(body).values())
         for node in body.nodes.values():
-            _collect_loop_variables(node, names)
+            _collect_pinned_symbols(node, names)
     elif isinstance(body, flow_control.FLOW_CONTROL_TYPES):
-        _collect_loop_variables(body, names)
-    # single atomic body: no loop variables
+        _collect_pinned_symbols(body, names)
+    # single atomic body: nothing pinned beyond what the caller already reserved
 
 
 def emit_nested_workflow_node(
@@ -319,10 +337,10 @@ def emit_workflow_function(
 ) -> FunctionBuilder:
     alloc = NameAllocator()
     in_syms = {port: alloc.reserve(port) for port in recipe.inputs}
-    # Loop variables are pinned to body-port names and bypass the allocator; reserve
-    # them so node-output symbols never collide with (and get shadowed by) them.
-    for loop_variable in _inlined_loop_variables(recipe):
-        alloc.reserve(loop_variable)
+    # Pinned symbols bypass the allocator, so it has to know them before it mints
+    # anything, or a fresh name can land on one and be silently overwritten.
+    for pinned in _inlined_pinned_symbols(recipe):
+        alloc.reserve(pinned)
     params = _render_params(recipe, signature, emitter)
     lines, out_syms = statements.emit_workflow_body(recipe, in_syms, {}, emitter, alloc)
     # Output port names are pinned via the decorator (see FunctionBuilder.render),

{flowrep-0.5.2 → flowrep-0.6.0}/src/flowrep/compiler/statements.py

@@ -2,14 +2,15 @@ from __future__ import annotations
 
 import re
 from collections.abc import Callable
-from typing import TypeAlias, cast
+from typing import Any, TypeAlias, cast
 
 from pyiron_snippets import versions
 
-from flowrep import base_models, edge_models, subgraph_validation
-from flowrep.compiler import flow_control, function
+from flowrep import base_models, edge_models, std, subgraph_validation
+from flowrep.compiler import flow_control, function, sugar
 from flowrep.prospective import (
     atomic_recipe,
+    constant_recipe,
     union_types,
     workflow_recipe,
 )
@@ -103,6 +104,23 @@ def _set_call_path_from_info(
     return call_path
 
 
+def _identity_materialization(value: Any, emitter: function.Emitter) -> str:
+    """Render an ``identity`` call wrapping a constant that cannot be inlined.
+
+    A bare ``name = <literal>`` statement no longer re-parses (constants are only
+    valid as call arguments), so a constant feeding a workflow output or a bare
+    flow-control body is emitted as ``identity(x=<literal>)``. The
+    ``flowrep.prospective.std`` import is hoisted via ``_set_call_path_from_info``.
+    On re-parse this canonicalises to a std ``identity`` atomic node fed by an
+    inlined constant argument, which then round-trips exactly.
+    """
+    call_path = _set_call_path_from_info(
+        std.identity.flowrep_recipe.reference.info,  # type: ignore[attr-defined]
+        emitter.module_imports,
+    )
+    return f"{call_path}(x={value!r})"
+
+
 def _topological_nodes(
     recipe: workflow_recipe.WorkflowRecipe,
 ) -> list[str]:
@@ -114,7 +132,7 @@ def _topological_nodes(
     )
 
 
-def _flow_control_input_requirements(
+def flow_control_input_requirements(
     recipe: workflow_recipe.WorkflowRecipe,
 ) -> dict[tuple[str, str], str]:
     """Required source-symbol names imposed by flow-control node inputs.
@@ -192,9 +210,26 @@ def emit_workflow_body(
     produced: dict[tuple[str, str], str] = {}
     lines: list[str] = []
 
+    # Constants feeding a workflow output cannot be inlined (a bare `return <literal>`
+    # is not re-parseable, and a bare `sym = <literal>` statement is no longer
+    # re-parseable either), so they are wrapped as `sym = identity(x=<literal>)` below
+    # and resolved to that symbol everywhere.
+    materialized_constants = {
+        src.node
+        for src in recipe.output_edges.values()
+        if isinstance(src, edge_models.SourceHandle)
+        and isinstance(recipe.nodes.get(src.node), constant_recipe.ConstantRecipe)
+    }
+
     def resolve(source) -> str:
         if isinstance(source, edge_models.InputSource):
             return in_syms[source.port]
+        source_node = recipe.nodes[source.node]
+        if (
+            isinstance(source_node, constant_recipe.ConstantRecipe)
+            and source.node not in materialized_constants
+        ):
+            return repr(source_node.constant)
         return produced[(source.node, source.port)]
 
     # Map (node, port) -> required symbol name for outputs the parent pins.
@@ -214,8 +249,14 @@ def emit_workflow_body(
 
     # Flow-control nodes derive their input port names from the enclosing symbols
     # feeding them, so each such source must be named after the port for the port
-    # names (and while-loop reassignments) to round-trip.
-    for handle, name in _flow_control_input_requirements(recipe).items():
+    # names (and while-loop reassignments) to round-trip. A constant peer feeding a
+    # flow-control input is normal now (a literal condition argument injects
+    # a constant peer routed through a synthetic flow-control input port). Such a
+    # peer is never also a workflow-output source, so its required_by_handle entry
+    # stays inert and it is inlined in the topo loop below -- which is why the
+    # conflict branch immediately below remains unreachable in parser-produced
+    # recipes.
+    for handle, name in flow_control_input_requirements(recipe).items():
         if (  # pragma: no cover - twin of the output-edge guard above; only a
             # hand-built recipe (one a parser never emits) can name a source for
             # both a flow-control input and an output differently. See
@@ -229,8 +270,101 @@ def emit_workflow_body(
             )
         required_by_handle[handle] = name
 
+    def _port_source(
+        label: str, port: str
+    ) -> edge_models.SourceHandle | edge_models.InputSource | None:
+        target = edge_models.TargetHandle(node=label, port=port)
+        return recipe.input_edges.get(target) or recipe.edges.get(target)
+
+    def _obj_is_symbolic(label: str, obj_port: str) -> bool:
+        """True if the access node's object resolves to a symbol we can subscript or
+        write '.' after.
+
+        An object fed by an *inlined* constant would sugar to nonsense (``5 .a``), or --
+        for an item -- to legal syntax that re-parses to a different recipe (``[1, 2][0]``
+        is not rooted at a symbol). Either way such a node keeps the plain-call emission.
+        The parser cannot produce one.
+        """
+        source = _port_source(label, obj_port)
+        if source is None:
+            return False
+        if isinstance(source, edge_models.InputSource):
+            return True
+        peer = recipe.nodes[source.node]
+        if isinstance(peer, constant_recipe.ConstantRecipe):
+            return source.node in materialized_constants
+        return True
+
+    # A recognised getattr or getitem node is emitted as native syntax -- `sym = obj.attr`
+    # or `sym = obj[key]` -- always as its own statement, never inlined into a consumer's
+    # argument list.
+    #
+    # Inlining would be prettier (`f(dc.a)`, `dc.a.val`, `d['a']['b']`) but it is not
+    # safe. The parser injects an access node together with any `ConstantRecipe` peer,
+    # and constant labels come from one shared `constant_N` counter over the whole
+    # workflow. Inlining moves an access node's creation to its consumer's statement,
+    # which reorders that constant relative to every *other* constant in the workflow
+    # (e.g. a literal call argument) and permutes the counter. The recipe would still
+    # execute identically, but it would not re-parse to an equal one. Emitting one
+    # statement per access, in topological order, reproduces the parser's injection order
+    # exactly, so the round trip is exact.
+    #
+    # Materialising also gives the efficiency guarantee for free: one node, one
+    # statement, one symbol -- an access consumed by several nodes stays a single
+    # node on re-parse rather than being duplicated into each consumer.
+    sugared_attrs: dict[str, str] = {
+        label: attr_name
+        for label, node in recipe.nodes.items()
+        if sugar.is_std_getattr(node)
+        and (attr_name := sugar.attribute_name(label, recipe)) is not None
+        and _obj_is_symbolic(label, sugar.ATTR_OBJ_PORT)
+    }
+
+    # The key-source check is the getitem analogue of `attribute_name` returning None: it
+    # refuses a hand-built recipe whose key edge is missing, which would otherwise reach
+    # `resolve(None)`. No syntax check is needed -- `resolve` renders a constant key as a
+    # literal and any other key as its symbol, and both are legal between brackets.
+    sugared_items: set[str] = {
+        label
+        for label, node in recipe.nodes.items()
+        if sugar.is_std_getitem(node)
+        and _port_source(label, sugar.KEY_PORT) is not None
+        and _obj_is_symbolic(label, sugar.ITEM_OBJ_PORT)
+    }
+
     for label in _topological_nodes(recipe):
         node = recipe.nodes[label]
+        if isinstance(node, constant_recipe.ConstantRecipe):
+            if label not in materialized_constants:
+                continue  # inline at the consumer call site via `resolve`
+            constant_label = constant_recipe.ConstantRecipe.std_label
+            name = required_by_handle.get((label, constant_label)) or alloc.fresh(
+                _output_name_suggestion(label, constant_label, 1)
+            )
+            produced[(label, constant_label)] = name
+            lines.append(
+                f"{name} = {_identity_materialization(node.constant, emitter)}"
+            )
+            continue
+
+        if label in sugared_attrs:
+            name = required_by_handle.get((label, sugar.ATTR_PORT)) or alloc.fresh(
+                _output_name_suggestion(label, sugar.ATTR_PORT, 1)
+            )
+            produced[(label, sugar.ATTR_PORT)] = name
+            obj = resolve(_port_source(label, sugar.ATTR_OBJ_PORT))
+            lines.append(f"{name} = {obj}.{sugared_attrs[label]}")
+            continue
+
+        if label in sugared_items:
+            name = required_by_handle.get((label, sugar.ITEM_PORT)) or alloc.fresh(
+                _output_name_suggestion(label, sugar.ITEM_PORT, 1)
+            )
+            produced[(label, sugar.ITEM_PORT)] = name
+            obj = resolve(_port_source(label, sugar.ITEM_OBJ_PORT))
+            key = resolve(_port_source(label, sugar.KEY_PORT))
+            lines.append(f"{name} = {obj}[{key}]")
+            continue
 
         call_path = node_call_path(node, label, emitter, alloc)
         if call_path is not None:
@@ -282,6 +416,15 @@ def emit_body(
         return flow_control.emit_flow_control_body(
             recipe, label, in_syms, required, emitter, alloc
         )
+    if isinstance(recipe, constant_recipe.ConstantRecipe):
+        constant_label = constant_recipe.ConstantRecipe.std_label
+        name = required.get(constant_label) or alloc.fresh(
+            _output_name_suggestion(label, constant_label, 1)
+        )
+        return (
+            [f"{name} = {_identity_materialization(recipe.constant, emitter)}"],
+            {constant_label: name},
+        )
     return _emit_single_node_body(recipe, label, in_syms, required, alloc, emitter)
 
 

flowrep-0.6.0/src/flowrep/compiler/sugar.py

@@ -0,0 +1,86 @@
+from __future__ import annotations
+
+import keyword
+from typing import Any, cast
+
+from flowrep import edge_models, std
+from flowrep.prospective import (
+    atomic_recipe,
+    constant_recipe,
+    union_types,
+    workflow_recipe,
+)
+
+# `LabeledRecipe.recipe` is a discriminated union; the cast narrows it for mypy.
+_GETATTR = cast(atomic_recipe.AtomicRecipe, std.get_attr.flowrep_recipe)  # type: ignore[attr-defined]
+_GETATTR_FQN = _GETATTR.reference.info.fully_qualified_name
+
+# Port names are derived from the recipe, never spelled out: editing `std.get_attr` or
+# `std.getitem` must not require editing strings anywhere else in the source. The two
+# object ports differ -- `obj` for get_attr, `a` for getitem, which inherits
+# `operator.getitem(a, b)`'s signature -- so each is named for its own link kind.
+ATTR_OBJ_PORT, NAME_PORT = _GETATTR.inputs
+(ATTR_PORT,) = _GETATTR.outputs
+
+# `LabeledRecipe.recipe` is a discriminated union; the cast narrows it for mypy.
+_GETITEM = cast(atomic_recipe.AtomicRecipe, std.getitem.flowrep_recipe)  # type: ignore[attr-defined]
+_GETITEM_FQN = _GETITEM.reference.info.fully_qualified_name
+
+ITEM_OBJ_PORT, KEY_PORT = _GETITEM.inputs
+(ITEM_PORT,) = _GETITEM.outputs
+
+
+def is_std_getattr(node: union_types.RecipeDiscrimination) -> bool:
+    """True if *node* is the standard-library attribute-access recipe.
+
+    Matched on the referenced function's fully qualified name rather than on
+    ``VersionInfo`` equality, so a recipe serialised under a different flowrep
+    version is still recognised.
+    """
+    return (
+        isinstance(node, atomic_recipe.AtomicRecipe)
+        and node.reference.info.fully_qualified_name == _GETATTR_FQN
+        and node.inputs == _GETATTR.inputs
+        and node.outputs == _GETATTR.outputs
+    )
+
+
+def is_std_getitem(node: union_types.RecipeDiscrimination) -> bool:
+    """True if *node* is the standard-library item-access recipe.
+
+    Matched on the referenced function's fully qualified name rather than on
+    ``VersionInfo`` equality, so a recipe serialised under a different flowrep
+    version is still recognised.
+    """
+    return (
+        isinstance(node, atomic_recipe.AtomicRecipe)
+        and node.reference.info.fully_qualified_name == _GETITEM_FQN
+        and node.inputs == _GETITEM.inputs
+        and node.outputs == _GETITEM.outputs
+    )
+
+
+def is_attribute_syntax(value: Any) -> bool:
+    """True if *value* can be written after a ``.`` in Python source.
+
+    Deliberately laxer than :func:`base_models.is_valid_label`, which also
+    excludes the reserved port names ``inputs``/``outputs``. Those are perfectly
+    legal attributes, and ``dc.inputs`` must compile back to ``dc.inputs``.
+    """
+    return (
+        isinstance(value, str) and value.isidentifier() and not keyword.iskeyword(value)
+    )
+
+
+def attribute_name(label: str, recipe: workflow_recipe.WorkflowRecipe) -> str | None:
+    """The identifier fed to *label*'s ``name`` port by a constant peer, else None."""
+    source = recipe.edges.get(edge_models.TargetHandle(node=label, port=NAME_PORT))
+    if source is None:
+        return None
+    peer = recipe.nodes.get(source.node)
+    if not isinstance(peer, constant_recipe.ConstantRecipe):
+        return None
+    constant = peer.constant
+    if isinstance(constant, str) and is_attribute_syntax(constant):
+        return constant
+    return None