flowgraph 0.1.2__py3-none-any.whl

flowgraph/__init__.py

@@ -0,0 +1,9 @@
+"""Headless FlowGraph workflow engine namespace."""
+
+from pkgutil import extend_path
+
+__path__ = extend_path(__path__, __name__)
+
+from .version import __version__
+
+__all__ = ["__version__"]

flowgraph/__main__.py

@@ -0,0 +1,6 @@
+"""Run the headless FlowGraph command-line interface as a module."""
+
+from flowgraph.core_cli import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

flowgraph/adapters/__init__.py

@@ -0,0 +1,141 @@
+"""Grouped catalog of workflow adapters exposed to application composition."""
+
+from dataclasses import dataclass
+
+from flowgraph.adapters.controls import AVAILABLE_NODES as CONTROL_AVAILABLE_NODES
+from flowgraph.adapters.cosapp import AVAILABLE_NODES as COSAPP_AVAILABLE_NODES
+from flowgraph.adapters.documentation import AVAILABLE_NODES as DOCUMENTATION_AVAILABLE_NODES
+from flowgraph.adapters.field_ops import AVAILABLE_NODES as FIELD_OPS_AVAILABLE_NODES
+from flowgraph.adapters.file_conversion import MESH_FILE_CONVERSION
+from flowgraph.adapters.files import (
+    READ_DIRECTORY_FILES,
+    SELECT_FILE,
+    SELECT_SERVER_FILE,
+)
+from flowgraph.adapters.filters import (
+    CREATE_MUSCAT_ELEMENT_FILTER,
+    FILTER_MESH_WITH_MUSCAT,
+)
+from flowgraph.adapters.image_tools import AVAILABLE_NODES as IMAGE_TOOLS_AVAILABLE_NODES
+from flowgraph.adapters.mesh_creation_tools import AVAILABLE_NODES as MESH_CREATION_AVAILABLE_NODES
+from flowgraph.adapters.mesh_generations import CSV_TO_MESH
+from flowgraph.adapters.mesh_ops import AVAILABLE_NODES as MESH_OPS_AVAILABLE_NODES
+from flowgraph.adapters.plaid_bridge import AVAILABLE_NODES as PLAID_AVAILABLE_NODES
+from flowgraph.adapters.readers import (
+    LOAD_CSV,
+    LOAD_MESHIO,
+    LOAD_MESHLANE,
+    LOAD_MUSCAT,
+)
+from flowgraph.adapters.remote_files import DOWNLOAD_URL
+from flowgraph.adapters.simple_sources import (
+    SET_FLOAT,
+    SET_INT,
+    SET_LIST_FLOAT,
+    SET_LIST_INT,
+    SET_LIST_STR,
+    SET_STRING,
+    SET_VEC3D,
+)
+from flowgraph.adapters.sinks import AVAILABLE_NODES as SINKS_AVAILABLE_NODES
+from flowgraph.adapters.user_code import AVAILABLE_NODES as USER_CODE_AVAILABLE_NODES
+from flowgraph.adapters.workflow import AVAILABLE_NODES as WORKFLOW_AVAILABLE_NODES
+from flowgraph.adapters.workflow_interfaces import (
+    AVAILABLE_NODES as WORKFLOW_INTERFACE_AVAILABLE_NODES,
+)
+from flowgraph.adapters.writers import WRITE_MESHIO, WRITE_MESHLANE, WRITE_MUSCAT
+from flowgraph.application.workflow_core import NodeDefinition
+
+
+@dataclass(frozen=True)
+class AdapterGroup:
+    """A named, ordered group of workflow nodes presented in one UI menu."""
+
+    label: str
+    node_definitions: tuple[NodeDefinition, ...] = ()
+    subgroups: tuple["AdapterGroup", ...] = ()
+
+    def all_node_definitions(self) -> tuple[NodeDefinition, ...]:
+        """Return definitions in this group and all nested groups."""
+        return self.node_definitions + tuple(
+            definition
+            for subgroup in self.subgroups
+            for definition in subgroup.all_node_definitions()
+        )
+
+
+@dataclass(frozen=True)
+class AdapterCatalog:
+    """Single application-facing catalog for adapter nodes and their UI metadata."""
+
+    groups: tuple[AdapterGroup, ...]
+
+    @property
+    def node_definitions(self) -> tuple[NodeDefinition, ...]:
+        """Return all adapter definitions in group and menu order."""
+        return tuple(
+            definition for group in self.groups for definition in group.all_node_definitions()
+        )
+
+    def require(self, definition_id: str) -> NodeDefinition:
+        """Return an adapter definition by ID or raise a descriptive key error."""
+        definition = next(
+            (candidate for candidate in self.node_definitions if candidate.id == definition_id),
+            None,
+        )
+        if definition is None:
+            raise KeyError(f"Unknown adapter node definition: {definition_id!r}")
+        return definition
+
+
+ADAPTERS = AdapterCatalog(
+    groups=(
+        AdapterGroup(
+            "Inputs",
+            subgroups=(
+                AdapterGroup("Scalars", (SET_STRING, SET_INT, SET_FLOAT)),
+                AdapterGroup(
+                    "Lists/Vectors", (SET_LIST_STR, SET_LIST_INT, SET_LIST_FLOAT, SET_VEC3D)
+                ),
+                AdapterGroup(
+                    "Files",
+                    (SELECT_FILE, SELECT_SERVER_FILE, DOWNLOAD_URL, READ_DIRECTORY_FILES),
+                ),
+            ),
+        ),
+        AdapterGroup(
+            "Mesh Tools",
+            subgroups=(
+                AdapterGroup(
+                    "Readers",
+                    (LOAD_MUSCAT, LOAD_MESHIO, LOAD_MESHLANE, LOAD_CSV),
+                ),
+                AdapterGroup("Mesh Gens", (CSV_TO_MESH,)),
+                AdapterGroup("Mesh Creation", MESH_CREATION_AVAILABLE_NODES),
+                AdapterGroup(
+                    "Filters",
+                    (CREATE_MUSCAT_ELEMENT_FILTER, FILTER_MESH_WITH_MUSCAT),
+                ),
+                AdapterGroup("Mesh Ops", MESH_OPS_AVAILABLE_NODES),
+                AdapterGroup("Field Ops", FIELD_OPS_AVAILABLE_NODES),
+                AdapterGroup("File Conversion", (MESH_FILE_CONVERSION,)),
+                AdapterGroup("Writers", (WRITE_MUSCAT, WRITE_MESHLANE, WRITE_MESHIO)),
+            ),
+        ),
+        AdapterGroup("Controls", CONTROL_AVAILABLE_NODES),
+        AdapterGroup("Image Tools", IMAGE_TOOLS_AVAILABLE_NODES),
+        AdapterGroup("Code", USER_CODE_AVAILABLE_NODES),
+        AdapterGroup("Workflow", WORKFLOW_INTERFACE_AVAILABLE_NODES + WORKFLOW_AVAILABLE_NODES),
+        AdapterGroup("Sinks", SINKS_AVAILABLE_NODES),
+        AdapterGroup("Doc", DOCUMENTATION_AVAILABLE_NODES),
+        AdapterGroup(
+            "External Tools",
+            subgroups=(
+                AdapterGroup("CoSApp", COSAPP_AVAILABLE_NODES),
+                AdapterGroup("Plaid", PLAID_AVAILABLE_NODES),
+            ),
+        ),
+    ),
+)
+
+__all__ = ["ADAPTERS"]

flowgraph/adapters/controls.py

@@ -0,0 +1,96 @@
+"""Headless workflow nodes whose values are presented with GUI controls."""
+
+import math
+from collections.abc import Mapping
+from typing import Any
+
+from flowgraph.application.workflow_core import (
+    NodeDefinition,
+    ParameterDefinition,
+    PortDefinition,
+    PortDirection,
+)
+
+from .data_types import FLOAT, INTEGER, ParameterKind
+
+
+def _slider_bounds(
+    parameters: Mapping[str, Any], *, integer: bool
+) -> tuple[int | float, int | float, int | float]:
+    """Validate and return a slider's minimum, maximum, and current value."""
+    minimum = parameters.get("min")
+    maximum = parameters.get("max")
+    value = parameters.get("value")
+    expected_type = int if integer else (int, float)
+
+    if (
+        isinstance(minimum, bool)
+        or not isinstance(minimum, expected_type)
+        or isinstance(maximum, bool)
+        or not isinstance(maximum, expected_type)
+        or isinstance(value, bool)
+        or not isinstance(value, expected_type)
+    ):
+        value_type = "integer" if integer else "number"
+        raise TypeError(f"The slider min, max, and value must be {value_type}s")
+
+    if integer:
+        if minimum >= maximum:
+            raise ValueError("The slider minimum must be less than its maximum")
+    else:
+        minimum = float(minimum)
+        maximum = float(maximum)
+        value = float(value)
+        if not all(math.isfinite(item) for item in (minimum, maximum, value)):
+            raise ValueError("The slider min, max, and value must be finite")
+        if minimum >= maximum:
+            raise ValueError("The slider minimum must be less than its maximum")
+
+    if not minimum <= value <= maximum:
+        raise ValueError("The slider value must be between its minimum and maximum")
+    return minimum, maximum, value
+
+
+def _float_slider(_inputs: Mapping[str, Any], parameters: Mapping[str, Any]) -> Mapping[str, Any]:
+    """Output the current finite floating-point slider value."""
+    return {"value": _slider_bounds(parameters, integer=False)[2]}
+
+
+FLOAT_SLIDER = NodeDefinition(
+    id="float-slider",
+    icon="mdi-tune-vertical",
+    label="Float Slider",
+    description="Outputs a floating-point value selected with a slider.",
+    ports=(PortDefinition("value", PortDirection.OUTPUT, FLOAT, "Value"),),
+    executor=_float_slider,
+    presentation="slider",
+    parameters=(
+        ParameterDefinition("min", ParameterKind.FLOAT, "Minimum", 0.0, "0.0"),
+        ParameterDefinition("max", ParameterKind.FLOAT, "Maximum", 1.0, "1.0"),
+        ParameterDefinition("value", ParameterKind.FLOAT, "Value", 0.5, "0.5", port=False),
+    ),
+)
+
+
+def _int_slider(_inputs: Mapping[str, Any], parameters: Mapping[str, Any]) -> Mapping[str, Any]:
+    """Output the current integer slider value."""
+    return {"value": _slider_bounds(parameters, integer=True)[2]}
+
+
+INT_SLIDER = NodeDefinition(
+    id="int-slider",
+    icon="mdi-tune-vertical",
+    label="Integer Slider",
+    description="Outputs an integer value selected with a slider.",
+    ports=(PortDefinition("value", PortDirection.OUTPUT, INTEGER, "Value"),),
+    executor=_int_slider,
+    presentation="slider",
+    parameters=(
+        ParameterDefinition("min", ParameterKind.INTEGER, "Minimum", 0, "0"),
+        ParameterDefinition("max", ParameterKind.INTEGER, "Maximum", 100, "100"),
+        ParameterDefinition("value", ParameterKind.INTEGER, "Value", 50, "50", port=False),
+    ),
+)
+
+
+AVAILABLE_NODES = (FLOAT_SLIDER, INT_SLIDER)

flowgraph/adapters/cosapp.py

@@ -0,0 +1,195 @@
+"""CoSApp workflow adapter for executing external trusted Python models."""
+
+from __future__ import annotations
+
+import importlib.util
+import json
+from collections.abc import Mapping
+from pathlib import Path
+from typing import Any
+
+from flowgraph.application.workflow_core import (
+    NodeDefinition,
+    ParameterDefinition,
+    PortDefinition,
+    PortDirection,
+)
+
+from .data_types import ANY, FILE, STRING
+
+COSAPP_RESULT_PORT = PortDefinition("result", PortDirection.OUTPUT, ANY, "CoSApp system")
+
+
+def _path_mapping(value: object, parameter_name: str) -> dict[str, str]:
+    """Parse one JSON mapping of FlowGraph port names to CoSApp attribute paths."""
+    if not isinstance(value, str):
+        raise TypeError(f"The {parameter_name} parameter must be a JSON object")
+    try:
+        parsed = json.loads(value)
+    except json.JSONDecodeError as error:
+        raise ValueError(
+            f"The {parameter_name} parameter must be valid JSON: {error.msg}"
+        ) from error
+    if not isinstance(parsed, dict):
+        raise TypeError(f"The {parameter_name} parameter must be a JSON object")
+
+    paths: dict[str, str] = {}
+    for port_name, attribute_path in parsed.items():
+        if not isinstance(port_name, str) or not port_name.strip():
+            raise ValueError(f"The {parameter_name} mapping contains an empty port name")
+        if not isinstance(attribute_path, str) or not attribute_path.strip():
+            raise ValueError(
+                f"The {parameter_name} mapping for {port_name!r} must contain a non-empty path"
+            )
+        if any(not segment.isidentifier() for segment in attribute_path.split(".")):
+            raise ValueError(
+                f"The {parameter_name} path for {port_name!r} must be dot-separated identifiers"
+            )
+        paths[port_name] = attribute_path
+    return paths
+
+
+def _ports(parameters: Mapping[str, Any]) -> tuple[PortDefinition, ...]:
+    """Return ports declared by the node's persisted CoSApp interface mappings."""
+    input_paths = _path_mapping(parameters.get("inputs", "{}"), "inputs")
+    output_paths = _path_mapping(parameters.get("outputs", "{}"), "outputs")
+    _validate_output_paths(output_paths)
+    return (
+        *(PortDefinition(name, PortDirection.INPUT, ANY, name) for name in input_paths),
+        COSAPP_RESULT_PORT,
+        *(PortDefinition(name, PortDirection.OUTPUT, ANY, name) for name in output_paths),
+    )
+
+
+def _validate_output_paths(output_paths: Mapping[str, str]) -> None:
+    """Reject output names that conflict with the permanent CoSApp result port."""
+    if "result" in output_paths:
+        raise ValueError("The outputs mapping cannot use reserved output name 'result'")
+
+
+def _load_model(module_path: object, factory_name: object) -> Any:
+    """Load and construct a root CoSApp ``System`` from a trusted Python file."""
+    if not isinstance(module_path, str) or not module_path.strip():
+        raise ValueError("The CoSApp model file must be a non-empty Python file path")
+    if not isinstance(factory_name, str) or not factory_name.strip():
+        raise ValueError("The CoSApp factory name must be a non-empty attribute name")
+
+    path = Path(module_path).expanduser()
+    if not path.is_file():
+        raise FileNotFoundError(f"CoSApp model file does not exist: {path}")
+    specification = importlib.util.spec_from_file_location(
+        f"flowgraph_cosapp_model_{abs(hash(path.resolve()))}", path
+    )
+    if specification is None or specification.loader is None:
+        raise ImportError(f"Could not load the CoSApp model file: {path}")
+    module = importlib.util.module_from_spec(specification)
+    specification.loader.exec_module(module)
+
+    factory = getattr(module, factory_name, None)
+    if not callable(factory):
+        raise TypeError(f"CoSApp model file must define callable {factory_name!r}")
+    model = factory()
+
+    try:
+        from cosapp.base import System
+    except ImportError as error:
+        raise ImportError(
+            "CoSApp is required to execute this node. Install FlowGraph with its 'cosapp' extra."
+        ) from error
+    if not isinstance(model, System):
+        raise TypeError(f"CoSApp factory {factory_name!r} must return a cosapp.base.System")
+    return model
+
+
+def _resolve_parent(model: object, path: str) -> tuple[object, str]:
+    """Return the object and final attribute addressed by a declared CoSApp path."""
+    parent = model
+    *parents, name = path.split(".")
+    for segment in parents:
+        try:
+            parent = getattr(parent, segment)
+        except AttributeError as error:
+            raise ValueError(f"CoSApp path {path!r} cannot resolve {segment!r}") from error
+    return parent, name
+
+
+def _set_path(model: object, path: str, value: Any) -> None:
+    """Set a declared CoSApp input attribute path."""
+    parent, name = _resolve_parent(model, path)
+    if not hasattr(parent, name):
+        raise ValueError(f"CoSApp input path {path!r} does not exist")
+    setattr(parent, name, value)
+
+
+def _get_path(model: object, path: str) -> Any:
+    """Read a declared CoSApp output attribute path."""
+    parent, name = _resolve_parent(model, path)
+    try:
+        return getattr(parent, name)
+    except AttributeError as error:
+        raise ValueError(f"CoSApp output path {path!r} does not exist") from error
+
+
+def _execute_cosapp(inputs: Mapping[str, Any], parameters: Mapping[str, Any]) -> Mapping[str, Any]:
+    """Construct, configure, execute, and export one CoSApp model instance."""
+    input_paths = _path_mapping(parameters.get("inputs", "{}"), "inputs")
+    output_paths = _path_mapping(parameters.get("outputs", "{}"), "outputs")
+    _validate_output_paths(output_paths)
+    model = _load_model(parameters.get("model_file"), parameters.get("factory"))
+    for port_name, path in input_paths.items():
+        _set_path(model, path, inputs[port_name])
+    model.run_drivers()
+    return {
+        "result": model,
+        **{name: _get_path(model, path) for name, path in output_paths.items()},
+    }
+
+
+COSAPP_WORKFLOW = NodeDefinition(
+    id="cosapp-workflow",
+    icon="mdi-play-network-outline",
+    label="CoSApp Workflow",
+    description="Executes a trusted external CoSApp System and exports declared result paths.",
+    ports=(COSAPP_RESULT_PORT,),
+    executor=_execute_cosapp,
+    parameters=(
+        ParameterDefinition(
+            "model_file",
+            FILE,
+            "CoSApp model file",
+            "",
+            "Path to a trusted Python file defining the CoSApp model",
+            file_patterns=("*.py",),
+            port=False,
+        ),
+        ParameterDefinition(
+            "factory",
+            STRING,
+            "Model factory",
+            "create_model",
+            "Zero-argument callable returning the root CoSApp System",
+            port=False,
+        ),
+        ParameterDefinition(
+            "inputs",
+            STRING,
+            "Input paths",
+            "{}",
+            'JSON mapping of FlowGraph input names to CoSApp paths, e.g. {"current": "source.I"}',
+            port=False,
+        ),
+        ParameterDefinition(
+            "outputs",
+            STRING,
+            "Output paths",
+            "{}",
+            'JSON mapping of FlowGraph output names to CoSApp paths, e.g. {"voltage": "circuit.n1.V"}',
+            port=False,
+        ),
+    ),
+    port_resolver=_ports,
+)
+
+AVAILABLE_NODES = (COSAPP_WORKFLOW,)
+
+__all__ = ["AVAILABLE_NODES", "COSAPP_WORKFLOW"]

flowgraph/adapters/data_types.py

@@ -0,0 +1,59 @@
+from Muscat.LinAlg.Transform import Transform
+from Muscat.MeshContainers.Filters.FilterObjects import ElementFilter
+from Muscat.MeshContainers.Filters.FilterOperators import FilterOperatorBase
+from PIL.Image import Image
+
+from flowgraph.application.workflow_core import DataType
+from flowgraph.domain.mesh_document import MeshDocument
+
+ANY = DataType("any", "Any", object)
+STRING = DataType("string", "Text", str)
+STR_SELECT = DataType("str", "select str", str)
+BOOLEAN = DataType("boolean", "Boolean", bool)
+INTEGER = DataType("integer", "Integer", int)
+FLOAT = DataType("float", "Float", float)
+LIST_STR = DataType("list[str]", "List Text", list[str])
+LIST_INT = DataType("list[int]", "List Ints", list[int])
+LIST_FLOAT = DataType("list[float]", "List Floats", list[float])
+LIST_ANY = DataType("list[any]", "List Any", list)
+FILE = DataType("filename", "Path", str)
+
+MESH_DOCUMENT = DataType("mesh-document", "Mesh document", MeshDocument)
+TABLE_DOCUMENT = DataType("table-document", "Table", dict)
+IMAGE = DataType("image", "Image", Image)
+MUSCAT_ELEMENT_FILTER = DataType(
+    "filter-like",
+    "Selector",
+    (ElementFilter, FilterOperatorBase),
+)
+VEC3D = DataType("VEC3D", "3D Vector", list[float])
+VEC2D = DataType("VEC2D", "2D Vector", list[float])
+VEC3DSTR = DataType("VEC3DSTR", "3D Text Vector", list[str])
+
+VEC3DI = DataType("VEC3D", "3D Vector", list[int])
+VEC2DI = DataType("VEC2D", "2D Vector", list[int])
+
+
+MULTI_SELECT = DataType("list[bool]", "List bool", list[bool])
+SELECT_SERVER_FILENAME = DataType("ServerFile", "Text", str)
+
+TRANSFORM_T = DataType("Transform", "Transform", Transform)
+
+
+class ParameterKind:
+    """UI-neutral editor semantics for a persisted node parameter."""
+
+    TEXT = STRING
+    STR_SELECT = STR_SELECT
+    BOOLEAN = BOOLEAN
+    INTEGER = INTEGER
+    FLOAT = FLOAT
+    LIST_STR = LIST_STR
+    LIST_INT = LIST_INT
+    LIST_FLOAT = LIST_FLOAT
+    FILE = FILE
+    VEC3D = VEC3D
+    VEC2D = VEC2D
+    VEC3DSTR = VEC3DSTR
+    MULTI_SELECT = MULTI_SELECT
+    SELECT_SERVER_FILENAME = SELECT_SERVER_FILENAME

flowgraph/adapters/documentation.py

@@ -0,0 +1,45 @@
+"""Nodes for documentation and grouping ."""
+
+from flowgraph.adapters.data_types import STRING
+from flowgraph.application.workflow_core import NodeDefinition, ParameterDefinition
+
+DOC_TITLE = NodeDefinition(
+    id="title-doc",
+    icon="",
+    label="Title",
+    description="Just a Title",
+    ports=(),
+    executor=lambda x, y: None,
+    parameters=(
+        ParameterDefinition(
+            name="title",
+            kind=STRING,
+            label="Title",
+            default="Title",
+            port=False,
+        ),
+    ),
+    presentation="title",
+)
+
+DOC_PARAGRAPH = NodeDefinition(
+    id="paragraph-doc",
+    icon="",
+    label="Paragraph",
+    description="Long-form documentation text",
+    ports=(),
+    executor=lambda x, y: None,
+    parameters=(
+        ParameterDefinition(
+            name="text",
+            kind=STRING,
+            label="Text",
+            default="Write documentation here.",
+            port=False,
+        ),
+    ),
+    presentation="paragraph",
+)
+
+
+AVAILABLE_NODES = (DOC_TITLE, DOC_PARAGRAPH)

flowgraph/adapters/field_ops.py

@@ -0,0 +1,121 @@
+"""Workflow nodes for transferring fields between meshes."""
+
+from collections.abc import Mapping
+from typing import Any
+
+import numpy as np
+from Muscat.FE.DofNumbering import ComputeDofNumbering
+from Muscat.FE.Fields.FEField import FEField
+from Muscat.FE.Spaces.FESpaces import LagrangeSpaceP0
+from Muscat.MeshContainers.Filters.FilterObjects import ElementFilter
+from Muscat.MeshContainers.Mesh import Mesh
+from Muscat.MeshTools.MeshFieldOperations import GetFieldTransferOp
+from Muscat.MeshTools.MeshTools import GetElementsCenters
+
+from flowgraph.adapters.data_types import MESH_DOCUMENT
+from flowgraph.application.workflow_core import (
+    NodeDefinition,
+    ParameterDefinition,
+    PortDefinition,
+    PortDirection,
+)
+from flowgraph.domain.mesh_document import MeshDocument
+
+from .data_types import ParameterKind
+
+
+def _transfer_fields(
+    inputs: Mapping[str, Any], _parameters: Mapping[str, Any]
+) -> Mapping[str, Any]:
+    """Transfer all nodal fields from ``source_data`` onto ``target``."""
+    source_mesh: Mesh = inputs["source_data"].mesh
+    target_mesh: Mesh = inputs["target"].mesh
+    outpout_mesh = target_mesh.View()
+
+    transfer_nodes = _parameters.get("transferNodeData", True)
+    transfer_elements = _parameters.get("transferElementData", True)
+    transfer_nodes_tags = _parameters.get("transferNodeTags", True)
+    transfer_elements_tags = _parameters.get("transferElementTags", True)
+
+    if transfer_nodes or transfer_nodes_tags:
+        field = FEField(name="source", mesh=source_mesh)
+        operator_nodal, _, _ = GetFieldTransferOp(field, target_mesh.nodes)
+        if transfer_nodes and source_mesh.nodeFields:
+            for name, data in source_mesh.nodeFields.items():
+                if name == "flowgraph_node_id" or np.issubdtype(data.dtype, np.str_):
+                    continue
+                outpout_mesh.nodeFields[name] = np.ascontiguousarray(
+                    (operator_nodal @ data).astype(data.dtype, copy=False)
+                )
+
+        if transfer_nodes_tags:
+            mask = np.zeros(source_mesh.GetNumberOfNodes())
+            for tag in source_mesh.nodesTags:
+                mask.fill(0)
+                ids = tag.GetIds()
+                mask[ids] = 1
+
+                outpout_mesh.nodesTags.CreateTag(tag.name, False).SetIds(
+                    np.where(operator_nodal.dot(mask) >= 0.999999999)[0], tag.name
+                )
+
+    if transfer_elements or transfer_elements_tags:
+        numbering = ComputeDofNumbering(source_mesh, LagrangeSpaceP0)
+        field = FEField(name="source", mesh=source_mesh, space=LagrangeSpaceP0, numbering=numbering)
+        operator_elem, _, _ = GetFieldTransferOp(
+            field, GetElementsCenters(target_mesh), elementFilter=ElementFilter()
+        )
+
+        if transfer_elements and source_mesh.elemFields:
+            for name, data in source_mesh.elemFields.items():
+                if name == "flowgraph_element_id" or np.issubdtype(data.dtype, np.str_):
+                    continue
+                outpout_mesh.elemFields[name] = np.ascontiguousarray(
+                    (operator_elem @ data).astype(data.dtype, copy=False)
+                )
+
+        if transfer_elements_tags:
+            mask = np.zeros(source_mesh.GetNumberOfElements())
+            for tagname in source_mesh.elements.GetTagsNames():
+                mask.fill(0)
+                ids = source_mesh.GetElementsInTag(tagname)
+                mask[ids] = 1
+
+                outpout_mesh.AddElementsToTag(np.where(operator_elem.dot(mask))[0], tagname)
+
+    return {"mesh_document": MeshDocument(outpout_mesh)}
+
+
+TRANSFER_FIELDS_NODE = NodeDefinition(
+    id="transfer-fields",
+    icon="mdi-swap-horizontal-bold",
+    label="Transfer Fields",
+    description="Transfers nodal fields from one mesh onto another mesh.",
+    ports=(
+        PortDefinition("source_data", PortDirection.INPUT, MESH_DOCUMENT, "Source data"),
+        PortDefinition("target", PortDirection.INPUT, MESH_DOCUMENT, "Target"),
+        PortDefinition("mesh_document", PortDirection.OUTPUT, MESH_DOCUMENT, "Mesh document"),
+    ),
+    parameters=(
+        ParameterDefinition(
+            "transferNodeData", ParameterKind.BOOLEAN, "Apply on node fields", True, port=False
+        ),
+        ParameterDefinition(
+            "transferElementData",
+            ParameterKind.BOOLEAN,
+            "Apply on element fields",
+            True,
+            port=False,
+        ),
+        ParameterDefinition(
+            "transferNodeTags", ParameterKind.BOOLEAN, "Transfer Node Tags", False, port=False
+        ),
+        ParameterDefinition(
+            "transferElementTags", ParameterKind.BOOLEAN, "Transfer Element Tags", False, port=False
+        ),
+    ),
+    executor=_transfer_fields,
+)
+
+
+AVAILABLE_NODES = (TRANSFER_FIELDS_NODE,)