flowgraph 0.1.2__py3-none-any.whl

flowgraph/adapters/readers.py

@@ -0,0 +1,215 @@
+"""Workflow nodes that read external data into FlowGraph domain objects."""
+
+import logging
+from collections.abc import Mapping
+from pathlib import Path
+from typing import Any
+
+from flowgraph.application.workflow_core import (
+    NodeDefinition,
+    ParameterDefinition,
+    PortDefinition,
+    PortDirection,
+)
+from flowgraph.domain.mesh_document import MeshDocument
+
+from .data_types import MESH_DOCUMENT, STRING, TABLE_DOCUMENT, ParameterKind
+
+LOGGER = logging.getLogger(__name__)
+
+
+"""Boundary between a source file and FlowGraph's canonical Muscat document."""
+
+
+class MeshLoadError(RuntimeError):
+    """Raised when a selected mesh cannot be loaded by a reader adapter."""
+
+
+def _validate_source(
+    inputs: Mapping[str, Any], parameters: Mapping[str, Any], reader_name: str
+) -> Path:
+    """Return a usable source path or raise a reader-specific load error."""
+    configured_path = inputs.get("path", parameters.get("path", ""))
+    source = Path(configured_path).expanduser()
+
+    LOGGER.debug("Validating requested mesh path: %s", source)
+    if not source.is_file():
+        LOGGER.warning("Rejected missing/non-file mesh path: %s", source)
+        raise MeshLoadError(f"Mesh file does not exist or is not a file: {source}")
+    if not source.suffix:
+        LOGGER.warning("Rejected extensionless mesh path: %s", source)
+        raise MeshLoadError(
+            f"Mesh file has no extension; {reader_name} cannot select a reader: {source}"
+        )
+    return source
+
+
+def _load_muscat(inputs: Mapping[str, Any], parameters: Mapping[str, Any]) -> Mapping[str, Any]:
+    """Load *source* with Muscat's extension-aware universal mesh reader.
+
+    The returned :class:`~flowgraph.domain.mesh_document.MeshDocument` is the
+    canonical editable model. The caller can display its summary immediately;
+    VTK conversion remains a separate, derived projection.
+    """
+
+    source = _validate_source(inputs, parameters, "Muscat")
+
+    try:
+        from Muscat.IO.IOFactory import CreateReader, InitAllReaders
+
+        LOGGER.debug("Initialising Muscat readers for %s", source)
+        InitAllReaders()
+        reader = CreateReader(source.suffix)
+        LOGGER.info("Loading mesh with Muscat reader %s: %s", type(reader).__name__, source)
+        reader.SetFileName(str(source))
+        mesh = reader.Read()
+    except Exception as error:
+        LOGGER.exception("Muscat failed while loading %s", source)
+        raise MeshLoadError(f"Muscat could not load '{source}': {error}") from error
+
+    LOGGER.info(
+        "Muscat loaded %s (%d nodes, %d elements)",
+        source,
+        mesh.GetNumberOfNodes(),
+        mesh.GetNumberOfElements(),
+    )
+    return {"mesh": MeshDocument(mesh=mesh)}
+
+
+def _load_meshio(inputs: Mapping[str, Any], parameters: Mapping[str, Any]) -> Mapping[str, Any]:
+    """Load *source* with meshio and convert it through Muscat's bridge."""
+    source = _validate_source(inputs, parameters, "meshio")
+
+    try:
+        import meshio
+        from Muscat.Bridges.MeshIOBridge import MeshIOToMesh
+
+        LOGGER.info("Loading mesh with meshio: %s", source)
+        mesh = MeshIOToMesh(meshio.read(source))
+    except Exception as error:
+        LOGGER.exception("meshio failed while loading %s", source)
+        raise MeshLoadError(f"meshio could not load '{source}': {error}") from error
+
+    LOGGER.info(
+        "meshio loaded %s through the Muscat bridge (%d nodes, %d elements)",
+        source,
+        mesh.GetNumberOfNodes(),
+        mesh.GetNumberOfElements(),
+    )
+    return {"mesh": MeshDocument(mesh=mesh)}
+
+
+def _load_meshlane(inputs: Mapping[str, Any], parameters: Mapping[str, Any]) -> Mapping[str, Any]:
+    """Load *source* with the optional MeshLane adapter."""
+    source = _validate_source(inputs, parameters, "MeshLane")
+
+    try:
+        import meshlane
+    except ImportError as error:
+        raise MeshLoadError(
+            "MeshLane is not installed; install FlowGraph with the 'meshlane' extra"
+        ) from error
+
+    try:
+        from Muscat.Bridges.MeshlaneBridge import MeshlaneToMesh
+    except ImportError as error:
+        raise MeshLoadError(
+            "This Muscat installation has no MeshLane bridge; install FlowGraph with "
+            "the 'meshlane' extra"
+        ) from error
+
+    try:
+        LOGGER.info("Loading mesh with MeshLane: %s", source)
+        mesh = MeshlaneToMesh(meshlane.read(source))
+    except Exception as error:
+        LOGGER.exception("MeshLane failed while loading %s", source)
+        raise MeshLoadError(f"MeshLane could not load '{source}': {error}") from error
+
+    LOGGER.info(
+        "MeshLane loaded %s through the Muscat bridge (%d nodes, %d elements)",
+        source,
+        mesh.GetNumberOfNodes(),
+        mesh.GetNumberOfElements(),
+    )
+    return {"mesh": MeshDocument(mesh=mesh)}
+
+
+def load_csv(inputs: Mapping[str, Any], _parameters: Mapping[str, Any]) -> Mapping[str, Any]:
+    """
+    Load a CSV file and return a dictionary where the keys are column names and the values are numpy arrays.
+
+    Args:
+        file_path (str): The path to the CSV file.
+
+    Returns:
+        dict: A dictionary where the keys are column names and the values are numpy arrays.
+    """
+    import pandas as pd
+
+    # Read the CSV file
+    source = _validate_source(inputs, {}, "MeshLane")
+    df = pd.read_csv(source)
+
+    # Convert the DataFrame to a dictionary
+    data_dict = {col: df[col].to_numpy() for col in df.columns}
+
+    # Return the dictionary
+    return {"table": data_dict}
+
+
+LOAD_MUSCAT = NodeDefinition(
+    id="load-muscat",
+    icon="/__flowgraph_ui/LOAD_MUSCAT.svg",
+    label="Read Mesh (Muscat)",
+    description="Loads a file path into the canonical mesh document.",
+    ports=(PortDefinition("mesh", PortDirection.OUTPUT, MESH_DOCUMENT, "Mesh"),),
+    executor=_load_muscat,
+    parameters=(
+        ParameterDefinition(
+            "path", ParameterKind.FILE, "File path", "", "/path/to/mesh", port=True
+        ),
+    ),
+)
+
+
+LOAD_MESHIO = NodeDefinition(
+    id="load-meshio",
+    icon="/__flowgraph_ui/LOAD_MESHIO.svg",
+    label="Read Mesh (MeshIO)",
+    description="Loads a file with meshio through Muscat's meshio bridge.",
+    ports=(PortDefinition("mesh", PortDirection.OUTPUT, MESH_DOCUMENT, "Mesh"),),
+    executor=_load_meshio,
+    parameters=(
+        ParameterDefinition(
+            "path", ParameterKind.FILE, "File path", "", "/path/to/mesh", port=True
+        ),
+    ),
+)
+
+
+LOAD_MESHLANE = NodeDefinition(
+    id="load-meshlane",
+    icon="/__flowgraph_ui/LOAD_MESHLANE.svg",
+    label="Read Mesh (MeshLane)",
+    description="Loads a file with the optional MeshLane adapter.",
+    ports=(PortDefinition("mesh", PortDirection.OUTPUT, MESH_DOCUMENT, "Mesh"),),
+    executor=_load_meshlane,
+    parameters=(
+        ParameterDefinition(
+            "path", ParameterKind.FILE, "File path", "", "/path/to/mesh", port=True
+        ),
+    ),
+)
+
+
+LOAD_CSV = NodeDefinition(
+    id="load-csv",
+    icon="mdi-file-table-outline",
+    label="Read Table (Pandas)",
+    description="Loads a csv file with the optional Panda adapter.",
+    ports=(
+        PortDefinition("path", PortDirection.INPUT, STRING, "File path"),
+        PortDefinition("table", PortDirection.OUTPUT, TABLE_DOCUMENT, "Table"),
+    ),
+    executor=load_csv,
+)

flowgraph/adapters/remote_files.py

@@ -0,0 +1,118 @@
+"""Workflow nodes for downloading remote files to the local temporary directory."""
+
+import asyncio
+import os
+import sys
+import tempfile
+from collections.abc import Mapping
+from pathlib import Path
+from typing import Any
+from urllib.error import HTTPError
+from urllib.parse import unquote, urlparse
+from urllib.request import urlopen
+
+from flowgraph.adapters.data_types import STRING, ParameterKind
+from flowgraph.application.workflow_core import (
+    NodeDefinition,
+    ParameterDefinition,
+    PortDefinition,
+    PortDirection,
+)
+
+IS_PYODIDE = sys.platform == "emscripten" or "pyodide" in sys.modules
+
+
+class RemoteFileDownloadError(RuntimeError):
+    """Raised when a remote file cannot be downloaded to a temporary file."""
+
+
+def _download_desktop_content(url: str) -> bytes:
+    """Download URL content with CPython's blocking standard-library HTTP client."""
+    try:
+        with urlopen(url) as response:
+            return response.read()
+    except HTTPError as error:
+        raise RemoteFileDownloadError(f"Failed to fetch {url}: HTTP {error.code}") from error
+    except OSError as error:
+        raise RemoteFileDownloadError(f"Failed to fetch {url}: {error}") from error
+
+
+async def download_content(url: str) -> bytes:
+    """Download URL content in desktop Python or Pyodide.
+
+    Parameters
+    ----------
+    url:
+        HTTP(S) URL to download.
+
+    Returns
+    -------
+    bytes
+        The complete response body.
+
+    Raises
+    ------
+    RemoteFileDownloadError
+        If the request cannot be completed successfully.
+    """
+    if IS_PYODIDE:
+        from pyodide.http import pyfetch
+
+        response = await pyfetch(url)
+        if not response.ok:
+            raise RemoteFileDownloadError(f"Failed to fetch {url}: HTTP {response.status}")
+        return await response.bytes()
+
+    return await asyncio.to_thread(_download_desktop_content, url)
+
+
+def _url_suffix(url: str) -> str:
+    """Return a safe filename suffix inferred from a URL path, if one exists."""
+    suffix = Path(unquote(urlparse(url).path)).suffix
+    return suffix if suffix and len(suffix) <= 20 else ".bin"
+
+
+def _download_url(_inputs: Mapping[str, Any], parameters: Mapping[str, Any]) -> Mapping[str, Any]:
+    """Download the configured URL to a persistent file in the system temporary directory."""
+    url = parameters.get("url", "")
+    if not isinstance(url, str) or not url.strip():
+        raise ValueError("The download URL must be non-empty text")
+    if urlparse(url).scheme not in {"http", "https"}:
+        raise ValueError("The download URL must use HTTP or HTTPS")
+    descriptor, filename = tempfile.mkstemp(prefix="flowgraph-download-", suffix=_url_suffix(url))
+    destination = Path(filename)
+    try:
+        os.close(descriptor)
+        if IS_PYODIDE:
+            from pyodide.ffi import can_run_sync, run_sync
+
+            if not can_run_sync():
+                raise RemoteFileDownloadError(
+                    "Downloading URLs in Pyodide requires JavaScript Promise Integration (JSPI)"
+                )
+            content = run_sync(download_content(url))
+        else:
+            content = _download_desktop_content(url)
+        with destination.open("wb") as output:
+            output.write(content)
+    except Exception:
+        destination.unlink(missing_ok=True)
+        raise
+    return {"path": str(destination)}
+
+
+DOWNLOAD_URL = NodeDefinition(
+    id="download-url",
+    icon="mdi-cloud-upload-outline",
+    label="Download URL",
+    description="Downloads an HTTP(S) URL to a temporary file and outputs its local path.",
+    ports=(PortDefinition("path", PortDirection.OUTPUT, STRING, "File path"),),
+    executor=_download_url,
+    parameters=(
+        ParameterDefinition("url", ParameterKind.TEXT, "URL", "", "https://example.com/file.ext"),
+    ),
+)
+
+AVAILABLE_NODES = (DOWNLOAD_URL,)
+
+__all__ = ["AVAILABLE_NODES", "DOWNLOAD_URL", "RemoteFileDownloadError", "download_content"]

flowgraph/adapters/simple_sources.py

@@ -0,0 +1,199 @@
+"""Simple workflow sources that produce values without reading external data."""
+
+import ast
+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, LIST_FLOAT, LIST_INT, LIST_STR, STRING, VEC3D, ParameterKind
+
+
+def _set_string(_inputs: Mapping[str, Any], parameters: Mapping[str, Any]) -> Mapping[str, Any]:
+    """Output the configured string value, including an empty string."""
+    value = parameters.get("value", "")
+    if not isinstance(value, str):
+        raise TypeError("The configured string value must be text")
+    return {"value": value}
+
+
+SET_STRING = NodeDefinition(
+    id="set-string",
+    icon="mdi-text-box-outline",
+    label="String Input",
+    description="Outputs a configured text value.",
+    ports=(PortDefinition("value", PortDirection.OUTPUT, STRING, "Value"),),
+    executor=_set_string,
+    parameters=(ParameterDefinition("value", ParameterKind.TEXT, "Value", "", "Enter text"),),
+)
+
+
+def _set_int(_inputs: Mapping[str, Any], parameters: Mapping[str, Any]) -> Mapping[str, Any]:
+    """Output the configured integer value without accepting booleans."""
+    value = parameters.get("value", 0)
+    if isinstance(value, bool) or not isinstance(value, int):
+        raise TypeError("The configured integer value must be an integer")
+    return {"value": value}
+
+
+SET_INT = NodeDefinition(
+    id="set-int",
+    icon="mdi-numeric-1-box-outline",
+    label="Integer Input",
+    description="Outputs a configured integer value.",
+    ports=(PortDefinition("value", PortDirection.OUTPUT, INTEGER, "Value"),),
+    executor=_set_int,
+    parameters=(ParameterDefinition("value", ParameterKind.INTEGER, "Value", 0, "0"),),
+)
+
+
+def _set_float(_inputs: Mapping[str, Any], parameters: Mapping[str, Any]) -> Mapping[str, Any]:
+    """Output the configured finite floating-point value."""
+    value = parameters.get("value", 0.0)
+    if isinstance(value, bool) or not isinstance(value, (int, float)):
+        raise TypeError("The configured floating-point value must be numeric")
+    normalized = float(value)
+    if not math.isfinite(normalized):
+        raise ValueError("The configured floating-point value must be finite")
+    return {"value": normalized}
+
+
+SET_FLOAT = NodeDefinition(
+    id="set-float",
+    icon="mdi-decimal-comma",
+    label="Float Input",
+    description="Outputs a configured floating-point value.",
+    ports=(PortDefinition("value", PortDirection.OUTPUT, FLOAT, "Value"),),
+    executor=_set_float,
+    parameters=(ParameterDefinition("value", ParameterKind.FLOAT, "Value", 0.0, "0.0"),),
+)
+
+
+def _set_vec3d(_inputs: Mapping[str, Any], parameters: Mapping[str, Any]) -> Mapping[str, Any]:
+    """Output a configured finite three-dimensional vector."""
+    components = tuple(parameters.get(axis, 0.0) for axis in ("x", "y", "z"))
+    if any(isinstance(value, bool) or not isinstance(value, (int, float)) for value in components):
+        raise TypeError("The configured vector components must be numeric")
+
+    vector = [float(value) for value in components]
+    if not all(math.isfinite(value) for value in vector):
+        raise ValueError("The configured vector components must be finite")
+    return {"value": list(vector)}
+
+
+SET_VEC3D = NodeDefinition(
+    id="set-vec3d",
+    icon="mdi-axis-arrow",
+    label="3D Vector Input",
+    description="Outputs a configured three-dimensional vector.",
+    ports=(PortDefinition("value", PortDirection.OUTPUT, VEC3D, "Value"),),
+    executor=_set_vec3d,
+    parameters=(
+        ParameterDefinition("x", ParameterKind.FLOAT, "X", 0.0, "0.0"),
+        ParameterDefinition("y", ParameterKind.FLOAT, "Y", 0.0, "0.0"),
+        ParameterDefinition("z", ParameterKind.FLOAT, "Z", 0.0, "0.0"),
+    ),
+)
+
+
+def _parse_list_parameter(parameters: Mapping[str, Any]) -> list[Any]:
+    """Parse a list parameter supplied by the UI or by a workflow file."""
+    configured = parameters.get("value", "[]")
+    try:
+        value = ast.literal_eval(configured) if isinstance(configured, str) else configured
+    except (SyntaxError, TypeError, ValueError):
+        raise TypeError(f"Unable to convert {configured!r} to a list") from None
+    if not isinstance(value, list):
+        raise TypeError(f"The configured value must be a list, not {type(value).__name__}")
+    return value
+
+
+def _set_str_list(_inputs: Mapping[str, Any], parameters: Mapping[str, Any]) -> Mapping[str, Any]:
+    """Output a configured list of strings."""
+    value = _parse_list_parameter(parameters)
+    if any(not isinstance(item, str) for item in value):
+        raise TypeError("The configured string list must contain only text")
+    return {"value": value}
+
+
+SET_LIST_STR = NodeDefinition(
+    id="set-list[str]",
+    icon="mdi-format-list-bulleted-square",
+    label="String List Input",
+    description="Outputs a configured list of str.",
+    ports=(PortDefinition("value", PortDirection.OUTPUT, LIST_STR, "Value"),),
+    executor=_set_str_list,
+    parameters=(
+        ParameterDefinition("value", ParameterKind.LIST_STR, "Value", [], "['a', 'b', 'c']"),
+    ),
+)
+
+
+def _set_int_list(_inputs: Mapping[str, Any], parameters: Mapping[str, Any]) -> Mapping[str, Any]:
+    """Output a configured list of integers."""
+    value = _parse_list_parameter(parameters)
+    if any(isinstance(item, bool) or not isinstance(item, int) for item in value):
+        raise TypeError("The configured integer list must contain only integers")
+    return {"value": value}
+
+
+SET_LIST_INT = NodeDefinition(
+    id="set-list[int]",
+    icon="mdi-format-list-numbered",
+    label="Integer List Input",
+    description="Outputs a configured list of int.",
+    ports=(PortDefinition("value", PortDirection.OUTPUT, LIST_INT, "Value"),),
+    executor=_set_int_list,
+    parameters=(ParameterDefinition("value", ParameterKind.LIST_INT, "Value", [], "[1, 2, 3]"),),
+)
+
+
+def _set_float_list(_inputs: Mapping[str, Any], parameters: Mapping[str, Any]) -> Mapping[str, Any]:
+    """Output a configured finite list of floating-point values."""
+    value = _parse_list_parameter(parameters)
+    if any(isinstance(item, bool) or not isinstance(item, (int, float)) for item in value):
+        raise TypeError("The configured float list must contain only numbers")
+    normalized = [float(item) for item in value]
+    if any(not math.isfinite(item) for item in normalized):
+        raise ValueError("The configured float list must contain only finite numbers")
+    return {"value": normalized}
+
+
+SET_LIST_FLOAT = NodeDefinition(
+    id="set-list[float]",
+    icon="mdi-format-list-numbered-rtl",
+    label="Float List Input",
+    description="Outputs a configured list of float.",
+    ports=(PortDefinition("value", PortDirection.OUTPUT, LIST_FLOAT, "Value"),),
+    executor=_set_float_list,
+    parameters=(
+        ParameterDefinition("value", ParameterKind.LIST_FLOAT, "Value", [], "[1.0, 2.0, 3.0]"),
+    ),
+)
+
+
+def _select_file(_inputs: Mapping[str, Any], parameters: Mapping[str, Any]) -> Mapping[str, Any]:
+    """Output the configured path; selecting the path itself is a UI concern."""
+    path = parameters.get("path", "")
+    if not isinstance(path, str):
+        raise TypeError("The selected file path parameter must be text")
+    if len(path) == 0:
+        raise ValueError("Path can't be empty")
+    return {"path": path}
+
+
+AVAILABLE_NODES = (
+    SET_STRING,
+    SET_INT,
+    SET_FLOAT,
+    SET_VEC3D,
+    SET_LIST_STR,
+    SET_LIST_INT,
+    SET_LIST_FLOAT,
+)

flowgraph/adapters/sinks.py

@@ -0,0 +1,80 @@
+from collections.abc import Mapping
+from typing import Any
+
+from flowgraph.adapters.data_types import ANY, BOOLEAN, IMAGE, MESH_DOCUMENT, STRING
+from flowgraph.application.workflow_core import (
+    NodeDefinition,
+    ParameterDefinition,
+    ParameterOption,
+    PortDefinition,
+    PortDirection,
+)
+
+
+def _consume_mesh(_inputs: Mapping[str, Any], _parameters: Mapping[str, Any]) -> Mapping[str, Any]:
+    """Terminate a mesh branch; the application renders this resolved input."""
+    return {}
+
+
+TO_3D_VIEW = NodeDefinition(
+    id="mesh-sink",
+    icon="mdi-cube-scan",
+    label="To 3D View",
+    description="Displays an input mesh document in the 3D view.",
+    ports=(PortDefinition("mesh", PortDirection.INPUT, MESH_DOCUMENT, "Mesh"),),
+    executor=_consume_mesh,
+    parameters=(
+        ParameterDefinition(
+            "color_field",
+            STRING,
+            "Color field",
+            "",
+            "Scalar field name (empty for solid color)",
+            options=(ParameterOption("", "Solid color"),),
+            port=False,
+        ),
+        ParameterDefinition(
+            "show_representation",
+            BOOLEAN,
+            "Show representation",
+            True,
+            port=False,
+        ),
+        ParameterDefinition(
+            "show_axis_grid",
+            BOOLEAN,
+            "Show axis grid",
+            False,
+            port=False,
+        ),
+    ),
+)
+
+
+SHOW_IMAGE = NodeDefinition(
+    id="local-view",
+    icon="mdi-image-outline",
+    label="Show Image",
+    description="Displays an image in a viewport within this node.",
+    ports=(PortDefinition("input", PortDirection.INPUT, IMAGE, "Image"),),
+    executor=_consume_mesh,
+    presentation="local-view",
+)
+
+
+def _consume_value(_inputs: Mapping[str, Any], _parameters: Mapping[str, Any]) -> Mapping[str, Any]:
+    """Terminate a value branch; the application renders the resolved input."""
+    return {}
+
+
+DISPLAY_VALUE = NodeDefinition(
+    id="show-value",
+    icon="mdi-text-box-outline",
+    label="Show Value",
+    description="Displays the string representation of any input value on the workflow.",
+    ports=(PortDefinition("value", PortDirection.INPUT, ANY, "Value"),),
+    executor=_consume_value,
+    presentation="value",
+)
+
+AVAILABLE_NODES = (TO_3D_VIEW, SHOW_IMAGE, DISPLAY_VALUE)