flowgraph 0.1.2__py3-none-any.whl

flowgraph/adapters/mesh_ops.py

@@ -0,0 +1,362 @@
+"""Workflow nodes for mesh transformations and tag operations."""
+
+from collections.abc import Mapping
+from typing import Any
+
+import numpy as np
+from Muscat.LinAlg.Transform import Transform
+from Muscat.MeshContainers import ElementsDescription as ED
+from Muscat.MeshContainers.ElementsContainers import AllElements, ElementsContainer
+from Muscat.MeshContainers.Filters.FilterObjects import ElementFilter
+from Muscat.MeshContainers.Filters.FilterOperators import FilterOperatorBase
+from Muscat.MeshTools.MeshCreationTools import QuadToLin
+from Muscat.Types import MuscatIndex
+from scipy.spatial import Delaunay
+
+from flowgraph.adapters.data_types import MESH_DOCUMENT, MUSCAT_ELEMENT_FILTER, TRANSFORM_T
+from flowgraph.application.workflow_core import (
+    NodeDefinition,
+    ParameterDefinition,
+    ParameterOption,
+    PortDefinition,
+    PortDirection,
+)
+from flowgraph.domain.mesh_document import MeshDocument
+
+from .data_types import ParameterKind
+
+
+def _transform_mesh(_inputs: Mapping[str, Any], parameters: Mapping[str, Any]) -> Mapping[str, Any]:
+    """Build a :class:`Muscat.LinAlg.Transform.Transform` from node parameters."""
+    res = Transform()
+    res.keepNormalized = parameters.get("keepNormalized", True)
+    res.keepOrthogonal = parameters.get("keepOrthogonal", True)
+    res.SetOffset(parameters.get("translation", [0, 0, 0]))
+    res.SetFirst(parameters.get("first", [1, 0, 0]))
+    res.SetSecond(parameters.get("second", [0, 1, 0]))
+
+    return {"Transform": res}
+
+
+def _apply_transform(inputs: Mapping[str, Any], parameters: Mapping[str, Any]) -> Mapping[str, Any]:
+    """Apply a Muscat transform to a mesh document without mutating its input."""
+    document: MeshDocument = inputs["mesh"]
+    transform: Transform = inputs["Transform"]
+    inverse = parameters.get("inverse", False)
+
+    transformed_document = MeshDocument(document.mesh.View())
+    apply_transform = transform.ApplyInvTransform if inverse else transform.ApplyTransform
+    apply_transform_direction = (
+        transform.ApplyInvTransformDirection if inverse else transform.ApplyTransformDirection
+    )
+    transformed_document.mesh.nodes = np.ascontiguousarray(
+        apply_transform(transformed_document.mesh.nodes)
+    )
+
+    if parameters.get("onVectorFields", True):
+        for fields in (
+            transformed_document.mesh.nodeFields,
+            transformed_document.mesh.elemFields,
+        ):
+            for name, field in fields.items():
+                if np.ndim(field) == 2 and np.shape(field)[1] == 3:
+                    fields[name] = np.ascontiguousarray(apply_transform_direction(field))
+
+    return {"mesh": transformed_document}
+
+
+def _delaunay_3d(inputs: Mapping[str, Any], _parameters: Mapping[str, Any]) -> Mapping[str, Any]:
+    """Tetrahedralize a document's points while preserving node metadata."""
+    source = inputs["meshDocument"]
+    points = np.asarray(source.mesh.nodes)
+    triangulation = Delaunay(points)
+
+    mesh = source.mesh.View()
+    mesh.elements = AllElements()
+    mesh.elemFields = {}
+    elements = ElementsContainer(ED.ElementType.Tetrahedron_4)
+    elements.AddNewElements(np.asarray(triangulation.simplices, dtype=MuscatIndex))
+    mesh.elements.AddContainer(elements)
+    return {"meshDocument": MeshDocument(mesh)}
+
+
+def _quad_to_lin(inputs: Mapping[str, Any], parameters: Mapping[str, Any]) -> Mapping[str, Any]:
+    """Convert a quadratic mesh document to a linear mesh document."""
+    input_document: MeshDocument = inputs["inputMesh"]
+    mesh = QuadToLin(
+        input_document.mesh,
+        divideQuadElements=parameters.get("divideQuadElements", True),
+        linearizedMiddlePoints=parameters.get("linearizedMiddlePoints", False),
+    )
+    return {"outputMesh": MeshDocument(mesh)}
+
+
+_TAG_ENTITIES = ("element", "node")
+_TAG_ENTITY_OPTIONS = tuple(ParameterOption(entity, entity.title()) for entity in _TAG_ENTITIES)
+
+
+def _tag_collections(document: MeshDocument, entity: str):
+    """Return the Muscat tag collections for a node or element tag domain."""
+    if entity not in _TAG_ENTITIES:
+        raise ValueError(f"tag entity must be one of {_TAG_ENTITIES!r}, got {entity!r}")
+    if entity == "node":
+        return (document.mesh.nodesTags,)
+    return tuple(elements.tags for elements in document.mesh.elements.values())
+
+
+def _validate_tag_name(name: Any, parameter: str) -> str:
+    if not isinstance(name, str) or not name.strip():
+        raise ValueError(f"{parameter} must be a non-empty string")
+    return name.strip()
+
+
+def _require_tag(collections, name: str) -> None:
+    if not any(name in collection for collection in collections):
+        raise ValueError(f"Tag {name!r} does not exist")
+
+
+def _copy_document(document: MeshDocument) -> MeshDocument:
+    return MeshDocument(document.mesh.View())
+
+
+def _rename_tag(inputs: Mapping[str, Any], parameters: Mapping[str, Any]) -> Mapping[str, Any]:
+    """Rename a node or element tag without mutating the input document."""
+    document = _copy_document(inputs["mesh"])
+    collections = _tag_collections(document, parameters.get("entity", "element"))
+    name = _validate_tag_name(parameters.get("tag"), "tag")
+    new_name = _validate_tag_name(parameters.get("newTag"), "newTag")
+    _require_tag(collections, name)
+    if name != new_name and any(new_name in collection for collection in collections):
+        raise ValueError(f"Tag {new_name!r} already exists")
+    for collection in collections:
+        if name in collection:
+            collection.RenameTag(name, new_name)
+    return {"mesh": document}
+
+
+def _merge_tags(inputs: Mapping[str, Any], parameters: Mapping[str, Any]) -> Mapping[str, Any]:
+    """Merge source node or element tags into a destination tag."""
+    document = _copy_document(inputs["mesh"])
+    collections = _tag_collections(document, parameters.get("entity", "element"))
+    target = _validate_tag_name(parameters.get("targetTag"), "targetTag")
+    sources = parameters.get("sourceTags")
+    if not isinstance(sources, list) or not sources:
+        raise ValueError("sourceTags must be a non-empty list of strings")
+    source_names = [_validate_tag_name(source, "sourceTags item") for source in sources]
+    if len(set(source_names)) != len(source_names):
+        raise ValueError("sourceTags must not contain duplicates")
+    if target in source_names:
+        raise ValueError("targetTag must not be one of sourceTags")
+    for source in source_names:
+        _require_tag(collections, source)
+    for collection in collections:
+        matching = [collection[source] for source in source_names if source in collection]
+        if matching:
+            destination = collection.CreateTag(target, False)
+            for source in matching:
+                destination.Merge(source)
+            collection.DeleteTags(source_names)
+    return {"mesh": document}
+
+
+def _remove_tag(inputs: Mapping[str, Any], parameters: Mapping[str, Any]) -> Mapping[str, Any]:
+    """Remove a node or element tag without mutating the input document."""
+    document = _copy_document(inputs["mesh"])
+    collections = _tag_collections(document, parameters.get("entity", "element"))
+    name = _validate_tag_name(parameters.get("tag"), "tag")
+    _require_tag(collections, name)
+    for collection in collections:
+        collection.DeleteTags(name)
+    return {"mesh": document}
+
+
+def _create_tag(inputs: Mapping[str, Any], parameters: Mapping[str, Any]) -> Mapping[str, Any]:
+    """Create a tag containing the entities selected by an element filter."""
+    document = _copy_document(inputs["mesh"])
+    name = _validate_tag_name(parameters.get("tagName"), "tagName")
+    element_filter: ElementFilter | FilterOperatorBase = inputs["filter"]
+    overwrite = parameters.get("overwrite", False)
+
+    if parameters.get("nodeTag", False):
+        if name in document.mesh.nodesTags and not overwrite:
+            raise ValueError(f"Tag {name!r} already exists")
+        document.mesh.nodesTags.CreateTag(name).SetIds(
+            element_filter.GetNodesIndices(document.mesh)
+        )
+    else:
+        element_types = tuple(document.mesh.elements.keys())
+        if (
+            any(name in document.mesh.elements[element_type].tags for element_type in element_types)
+            and not overwrite
+        ):
+            raise ValueError(f"Tag {name!r} already exists")
+        for element_type in element_types:
+            ids = element_filter.GetIdsToTreat(document.mesh, element_type)
+            document.mesh.elements[element_type].tags.CreateTag(name).SetIds(ids)
+
+    return {"mesh": document}
+
+
+def _tag_parameters(*, merge: bool = False, rename: bool = False):
+    parameters = [
+        ParameterDefinition(
+            "entity",
+            ParameterKind.STR_SELECT,
+            "Tag entity",
+            "element",
+            options=_TAG_ENTITY_OPTIONS,
+            port=False,
+        ),
+    ]
+    if merge:
+        parameters.extend(
+            [
+                ParameterDefinition("sourceTags", ParameterKind.LIST_STR, "Source tags", []),
+                ParameterDefinition("targetTag", ParameterKind.TEXT, "Target tag", "merged"),
+            ]
+        )
+    else:
+        parameters.append(ParameterDefinition("tag", ParameterKind.TEXT, "Tag", ""))
+        if rename:
+            parameters.append(ParameterDefinition("newTag", ParameterKind.TEXT, "New tag", ""))
+    return tuple(parameters)
+
+
+def _tag_node(node_id: str, label: str, executor, parameters) -> NodeDefinition:
+    icons = {
+        "Rename Tag": "mdi-tag-edit-outline",
+        "Merge Tags": "mdi-tag-multiple-outline",
+        "Remove Tag": "mdi-tag-remove-outline",
+    }
+    return NodeDefinition(
+        id=node_id,
+        icon=icons[label],
+        label=label,
+        description=f"{label} for node or element tags.",
+        ports=(
+            PortDefinition("mesh", PortDirection.INPUT, MESH_DOCUMENT, "Mesh"),
+            PortDefinition("mesh", PortDirection.OUTPUT, MESH_DOCUMENT, "Mesh"),
+        ),
+        parameters=parameters,
+        executor=executor,
+    )
+
+
+RENAME_TAG_NODE = _tag_node("rename-tag", "Rename Tag", _rename_tag, _tag_parameters(rename=True))
+MERGE_TAGS_NODE = _tag_node("merge-tags", "Merge Tags", _merge_tags, _tag_parameters(merge=True))
+REMOVE_TAG_NODE = _tag_node("remove-tag", "Remove Tag", _remove_tag, _tag_parameters())
+
+CREATE_TAG_NODE = NodeDefinition(
+    id="create-tag",
+    icon="mdi-tag-plus-outline",
+    label="Create Tag",
+    description="Creates a node or element tag from an element filter.",
+    ports=(
+        PortDefinition("mesh", PortDirection.INPUT, MESH_DOCUMENT, "Mesh"),
+        PortDefinition("filter", PortDirection.INPUT, MUSCAT_ELEMENT_FILTER, "Element Filter"),
+        PortDefinition("mesh", PortDirection.OUTPUT, MESH_DOCUMENT, "Mesh"),
+    ),
+    parameters=(
+        ParameterDefinition("tagName", ParameterKind.TEXT, "Tag name", ""),
+        ParameterDefinition(
+            "nodeTag", ParameterKind.BOOLEAN, "Node tag (Element tag if False)", False, port=False
+        ),
+        ParameterDefinition(
+            "overwrite", ParameterKind.BOOLEAN, "Overwrite tag if exists", False, port=False
+        ),
+    ),
+    executor=_create_tag,
+)
+
+
+TRANSFORM_NODE = NodeDefinition(
+    id="transform",
+    icon="mdi-axis-arrow-lock",
+    label="Mesh Transform",
+    description="Creates a Muscat coordinate transformation.",
+    ports=(PortDefinition("Transform", PortDirection.OUTPUT, TRANSFORM_T, "Transform"),),
+    executor=_transform_mesh,
+    parameters=(
+        ParameterDefinition("translation", ParameterKind.VEC3D, "Translation", [0, 0, 0]),
+        ParameterDefinition("first", ParameterKind.VEC3D, "First direction", [1, 0, 0]),
+        ParameterDefinition("second", ParameterKind.VEC3D, "Second direction", [0, 1, 0]),
+        ParameterDefinition(
+            "keepNormalized", ParameterKind.BOOLEAN, "Keep normalized", True, port=False
+        ),
+        ParameterDefinition(
+            "keepOrthogonal", ParameterKind.BOOLEAN, "Keep orthogonal", True, port=False
+        ),
+    ),
+)
+
+APPLY_TRANSFORM_NODE = NodeDefinition(
+    id="apply-transform",
+    icon="mdi-vector-combine",
+    label="Apply Transform",
+    description="Applies a coordinate transformation to a mesh.",
+    ports=(
+        PortDefinition("mesh", PortDirection.INPUT, MESH_DOCUMENT, "Mesh"),
+        PortDefinition("Transform", PortDirection.INPUT, TRANSFORM_T, "Transform"),
+        PortDefinition("mesh", PortDirection.OUTPUT, MESH_DOCUMENT, "Transformed mesh"),
+    ),
+    parameters=(
+        ParameterDefinition(
+            "onVectorFields", ParameterKind.BOOLEAN, "Apply on Vector Fields", True, port=False
+        ),
+        ParameterDefinition(
+            "inverse", ParameterKind.BOOLEAN, "Apply inverse transform", False, port=False
+        ),
+    ),
+    executor=_apply_transform,
+)
+
+DELAUNAY_3D_NODE = NodeDefinition(
+    id="delaunay-3d",
+    icon="mdi-vector-triangle",
+    label="Delaunay 3D",
+    description="Create a 3D tetrahedralization from the mesh document's points.",
+    ports=(
+        PortDefinition("meshDocument", PortDirection.INPUT, MESH_DOCUMENT, "Mesh document"),
+        PortDefinition("meshDocument", PortDirection.OUTPUT, MESH_DOCUMENT, "Mesh document"),
+    ),
+    executor=_delaunay_3d,
+)
+
+QUAD_TO_LIN_NODE = NodeDefinition(
+    id="quad-to-lin",
+    icon="mdi-vector-square-remove",
+    label="Quad To Lin",
+    description="Convert quadratic mesh elements to linear elements.",
+    ports=(
+        PortDefinition("inputMesh", PortDirection.INPUT, MESH_DOCUMENT, "Input mesh"),
+        PortDefinition("outputMesh", PortDirection.OUTPUT, MESH_DOCUMENT, "Output mesh"),
+    ),
+    parameters=(
+        ParameterDefinition(
+            "divideQuadElements",
+            ParameterKind.BOOLEAN,
+            "Divide quadratic elements",
+            True,
+            port=False,
+        ),
+        ParameterDefinition(
+            "linearizedMiddlePoints",
+            ParameterKind.BOOLEAN,
+            "Linearize middle points",
+            False,
+            port=False,
+        ),
+    ),
+    executor=_quad_to_lin,
+)
+
+AVAILABLE_NODES = (
+    TRANSFORM_NODE,
+    APPLY_TRANSFORM_NODE,
+    DELAUNAY_3D_NODE,
+    QUAD_TO_LIN_NODE,
+    RENAME_TAG_NODE,
+    MERGE_TAGS_NODE,
+    REMOVE_TAG_NODE,
+    CREATE_TAG_NODE,
+)

flowgraph/adapters/paraview.py

@@ -0,0 +1,39 @@
+"""Simple workflow sink to send the files to paraview."""
+
+import json
+import socket
+from collections.abc import Mapping
+from typing import Any
+
+from flowgraph.adapters.readers import MESH_DOCUMENT
+from flowgraph.application.workflow_core import (
+    DataType,
+    NodeDefinition,
+    PortDefinition,
+    PortDirection,
+)
+
+STRING = DataType("string", "Text", str)
+
+
+def SendMeshToParaView(
+    inputs: Mapping[str, Any], parameters: Mapping[str, Any]
+) -> Mapping[str, Any]:
+
+    data = {"command": "test", "value": 123}
+    host = parameters.get("host", "127.0.0.1")
+    port = int(parameters.get("port", 9999))
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
+        sock.connect((host, port))
+        sock.sendall(json.dumps(data).encode("utf-8"))
+    return {}
+
+
+PARAIEW_BRIDGE = NodeDefinition(
+    id="write-muscat",
+    icon="mdi-file-export-outline",
+    label="Write with Muscat",
+    description="Writes the canonical mesh document to a filename selected by extension.",
+    ports=(PortDefinition("mesh", PortDirection.INPUT, MESH_DOCUMENT, "Mesh"),),
+    executor=SendMeshToParaView,
+)

flowgraph/adapters/plaid_bridge.py

@@ -0,0 +1,205 @@
+"""Workflow nodes backed by the Plaid external dataset library."""
+
+from collections.abc import Mapping
+from typing import Any
+
+from flowgraph.application.workflow_core import (
+    DataType,
+    NodeDefinition,
+    ParameterDefinition,
+    PortDefinition,
+    PortDirection,
+)
+from flowgraph.domain.mesh_document import MeshDocument
+
+from .data_types import MESH_DOCUMENT, ParameterKind
+
+PLAID_SAMPLE = DataType("plaid-dataset", "Plaid sample", object)
+PLAID_INFO = DataType("plaid-info", "Plaid info", object)
+PLAID_DATA_PRODUCTION = DataType("plaid-data-production", "Plaid data production", object)
+PLAID_OPTIONAL_STRING = DataType("plaid-optional-string", "Optional Text", (str, type(None)))
+PLAID_OPTIONAL_TABLE = DataType("plaid-optional-table", "Optional Table", (dict, type(None)))
+
+
+def _load_plaid_sample(
+    _inputs: Mapping[str, Any], parameters: Mapping[str, Any]
+) -> Mapping[str, Any]:
+    """Load one sample from a Plaid dataset stored on disk."""
+    path = parameters.get("path", "")
+
+    if not isinstance(path, str) or not path:
+        raise ValueError("The Plaid dataset path must be a non-empty string")
+
+    try:
+        from plaid.storage.reader import init_from_disk, load_infos_from_disk
+    except ImportError as error:
+        raise RuntimeError(
+            "The Plaid library is required to load Plaid samples; "
+            "install the package providing plaid.storage.reader. "
+            "> uv pip install pyplaid"
+        ) from error
+
+    infos = load_infos_from_disk(path)
+    datasetdict, converterdict = init_from_disk(path)
+
+    return {"dataset": (datasetdict, converterdict), "infos": infos}
+
+
+LOAD_PLAID_DATASET = NodeDefinition(
+    id="load-plaid-dataset",
+    icon="mdi-database-arrow-down-outline",
+    label="Load Plaid Dataset",
+    description="Loads dataset from a Plaid dataset on disk.",
+    ports=(
+        PortDefinition("dataset", PortDirection.OUTPUT, PLAID_SAMPLE, "Sample"),
+        PortDefinition("infos", PortDirection.OUTPUT, PLAID_INFO, "Infos"),
+    ),
+    executor=_load_plaid_sample,
+    parameters=(ParameterDefinition("path", ParameterKind.FILE, "Path", "", "/path/to/plaid"),),
+)
+
+
+def _extract_plaid_sample(
+    inputs: Mapping[str, Any], parameters: Mapping[str, Any]
+) -> Mapping[str, Any]:
+    """Convert one stored Plaid dataset item into a Plaid ``Sample``."""
+    dataset_and_converters = inputs.get("dataset")
+    infos = inputs.get("infos")
+    split = parameters.get("split", "")
+    sample_number = parameters.get("sample_number", 0)
+
+    if (
+        not isinstance(dataset_and_converters, tuple)
+        or len(dataset_and_converters) != 2
+        or not isinstance(dataset_and_converters[0], Mapping)
+        or not isinstance(dataset_and_converters[1], Mapping)
+    ):
+        raise TypeError("The PLAID_SAMPLE input must contain dataset and converter mappings")
+    if infos is None:
+        raise ValueError("The PLAID_INFO input is required")
+    if not isinstance(split, str) or not split:
+        raise ValueError("The Plaid split must be a non-empty string")
+    if isinstance(sample_number, bool) or not isinstance(sample_number, int):
+        raise TypeError("The Plaid sample number must be an integer")
+    if sample_number < 0:
+        raise ValueError("The Plaid sample number must not be negative")
+
+    datasetdict, converterdict = dataset_and_converters
+    try:
+        dataset = datasetdict[split]
+        converter = converterdict[split]
+        sample = converter.to_plaid(dataset, sample_number)
+    except (KeyError, IndexError, TypeError, ValueError, OSError) as error:
+        raise ValueError(
+            f"Could not extract Plaid sample: split={split!r}, sample_number={sample_number}"
+        ) from error
+
+    return {"sample": sample}
+
+
+EXTRACT_PLAID_SAMPLE = NodeDefinition(
+    id="extract-plaid-sample",
+    icon="mdi-database-search-outline",
+    label="Extract Plaid sample",
+    description="Converts one item from a loaded Plaid dataset into a Plaid Sample.",
+    ports=(
+        PortDefinition("dataset", PortDirection.INPUT, PLAID_SAMPLE, "PLAID_SAMPLE"),
+        PortDefinition("infos", PortDirection.INPUT, PLAID_INFO, "PLAID_INFO"),
+        PortDefinition("sample", PortDirection.OUTPUT, PLAID_SAMPLE, "Sample"),
+    ),
+    executor=_extract_plaid_sample,
+    parameters=(
+        ParameterDefinition("split", ParameterKind.TEXT, "Split", "", "train"),
+        ParameterDefinition("sample_number", ParameterKind.INTEGER, "Sample number", 0, "0"),
+    ),
+)
+
+
+def _extract_plaid_time_step(
+    inputs: Mapping[str, Any], parameters: Mapping[str, Any]
+) -> Mapping[str, Any]:
+    """Extract one Plaid sample time step as a FlowGraph mesh document."""
+    sample = inputs.get("sample")
+    time = parameters.get("time", 0.0)
+
+    if sample is None:
+        raise ValueError("The PLAID_SAMPLE input is required")
+    if isinstance(time, bool) or not isinstance(time, (int, float)):
+        raise TypeError("The Plaid time step must be numeric")
+
+    try:
+        from Muscat.Bridges.CGNSBridge import CGNSToMesh
+
+        tree = sample.get_tree(time=float(time), only_mesh=False)
+        if tree is None:
+            raise ValueError(f"Plaid sample has no mesh at time step {time}")
+        mesh = CGNSToMesh(tree)
+        return {"mesh": MeshDocument(mesh=mesh)}
+    except (AttributeError, TypeError, ValueError, IndexError, KeyError) as error:
+        raise ValueError(f"Could not extract Plaid time step {time}: {error}") from error
+
+
+EXTRACT_PLAID_TIME_STEP = NodeDefinition(
+    id="extract-plaid-time-step",
+    icon="mdi-calendar-clock-outline",
+    label="Extract Plaid time step",
+    description="Converts one Plaid sample time step into a FlowGraph mesh document.",
+    ports=(
+        PortDefinition("sample", PortDirection.INPUT, PLAID_SAMPLE, "PLAID_SAMPLE"),
+        PortDefinition("mesh", PortDirection.OUTPUT, MESH_DOCUMENT, "Mesh"),
+    ),
+    executor=_extract_plaid_time_step,
+    parameters=(ParameterDefinition("time", ParameterKind.FLOAT, "Time step", 0.0, "0.0"),),
+)
+
+
+def _extract_plaid_info(
+    inputs: Mapping[str, Any], _parameters: Mapping[str, Any]
+) -> Mapping[str, Any]:
+    """Expose each top-level attribute of a Plaid ``Infos`` object."""
+    infos = inputs.get("infos")
+    if infos is None:
+        raise ValueError("The PLAID_INFO input is required")
+
+    return {
+        "owner": getattr(infos, "owner", None),
+        "license": getattr(infos, "license", None),
+        "data_production": getattr(infos, "data_production", None),
+        "data_description": getattr(infos, "data_description", None),
+        "num_samples": getattr(infos, "num_samples", None),
+        "storage_backend": getattr(infos, "storage_backend", None),
+    }
+
+
+EXTRACT_PLAID_INFO = NodeDefinition(
+    id="extract-plaid-info",
+    icon="mdi-information-outline",
+    label="Extract Plaid info",
+    description="Exposes the top-level attributes of a Plaid dataset info object.",
+    ports=(
+        PortDefinition("infos", PortDirection.INPUT, PLAID_INFO, "PLAID_INFO"),
+        PortDefinition("owner", PortDirection.OUTPUT, PLAID_OPTIONAL_STRING, "Owner"),
+        PortDefinition("license", PortDirection.OUTPUT, PLAID_OPTIONAL_STRING, "License"),
+        PortDefinition(
+            "data_production", PortDirection.OUTPUT, PLAID_DATA_PRODUCTION, "Data production"
+        ),
+        PortDefinition(
+            "data_description", PortDirection.OUTPUT, PLAID_OPTIONAL_STRING, "Data description"
+        ),
+        PortDefinition(
+            "num_samples", PortDirection.OUTPUT, PLAID_OPTIONAL_TABLE, "Number of samples"
+        ),
+        PortDefinition(
+            "storage_backend", PortDirection.OUTPUT, PLAID_OPTIONAL_STRING, "Storage backend"
+        ),
+    ),
+    executor=_extract_plaid_info,
+)
+
+
+AVAILABLE_NODES = (
+    LOAD_PLAID_DATASET,
+    EXTRACT_PLAID_SAMPLE,
+    EXTRACT_PLAID_TIME_STEP,
+    EXTRACT_PLAID_INFO,
+)