flowgraph 0.1.2__tar.gz

flowgraph-0.1.2/LICENSE

@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2026, Felipe Bordeu
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

flowgraph-0.1.2/PKG-INFO

@@ -0,0 +1,150 @@
+Metadata-Version: 2.4
+Name: flowgraph
+Version: 0.1.2
+Summary: Headless typed workflow engine and execution runtime
+Author: Felipe Bordeu
+Maintainer: Felipe Bordeu
+License-Expression: BSD-3-Clause
+Project-URL: Homepage, https://github.com/FBW-Engineering-Solutions/FlowGraph
+Project-URL: Repository, https://github.com/FBW-Engineering-Solutions/FlowGraph.git
+Project-URL: Issues, https://github.com/FBW-Engineering-Solutions/FlowGraph/issues
+Keywords: workflow,graph,mesh,scientific-computing,automation
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: vtk>=9.2
+Requires-Dist: muscat>=2.5.2
+Requires-Dist: meshio>=5.3
+Requires-Dist: meshlane>=5.5.0
+Requires-Dist: scipy>=1.10
+Requires-Dist: pandas
+Requires-Dist: h5py
+Requires-Dist: pillow>=10.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: pytest-cov>=5.0; extra == "dev"
+Requires-Dist: ruff>=0.6; extra == "dev"
+Provides-Extra: ml
+Requires-Dist: pyplaid; extra == "ml"
+Provides-Extra: cosapp
+Requires-Dist: cosapp>=1.6.1; extra == "cosapp"
+Provides-Extra: ci
+Requires-Dist: cosapp>=1.6.1; extra == "ci"
+Requires-Dist: pycgns; extra == "ci"
+Dynamic: license-file
+
+# FlowGraph Core
+
+`FlowGraph` is the GUI-free Python workflow engine. It provides typed workflow
+composition, validation, persistence, execution, adapters, mesh and image data
+operations, browser-WASM execution support, and metadata-only catalog export
+for compatible external clients.
+
+> **Alpha status:** FlowGraph Core `0.1.x` is an alpha series for evaluation,
+> development, experimentation, and early adopter feedback. APIs and workflow
+> behavior may change before `1.0.0`. See [`Release Policy`](docs/policies/release-policy.md).
+
+## Development
+
+```bash
+uv sync --extra dev
+uv run pytest
+uv run ruff check .
+```
+
+See [`Contributing`](.github/CONTRIBUTING.md) for prerequisites, development
+workflow, testing, documentation, and pull-request expectations.
+
+## Headless workflows
+
+The `flowgraph` command is headless and has no GUI runtime dependency:
+
+```bash
+uv run flowgraph inspect workflow.json
+uv run flowgraph run workflow.json --input name=value
+uv run flowgraph run workflow.json --override node-id.parameter=value
+uv run flowgraph run workflow.json --json-output results.json
+```
+
+Workflows use the versioned `flowgraph-workflow` JSON format. Core validation and
+execution are UI-independent.
+
+## Package artifacts
+
+Build the portable, pure-Python source distribution and wheel with:
+
+```bash
+uv build --out-dir dist/
+```
+
+The resulting wheel is compatible with all supported Python platforms. See
+`packaging/README.md` for release details.
+
+The initial supported publication channels are GitHub source releases and
+PyPI. Conda, Docker, operating-system package managers, and third-party mirrors
+are not supported release channels at this time. See
+[`Release Channels`](docs/policies/release-channels.md) for the release policy.
+
+FlowGraph Core declares Python 3.11 or newer. CI covers Python 3.11 and 3.13 on
+GitHub-hosted Ubuntu, Windows, and macOS runners; a platform/version combination
+is supported only after its release-candidate job passes. See
+[`Support Policy`](docs/policies/support-policy.md) for compatibility, deprecation,
+maintenance, and unsupported-use policies.
+
+## Catalog export
+
+FlowGraph can export non-executable node metadata for tools that need to author
+or structurally validate workflow JSON:
+
+```bash
+uv run python -m flowgraph.application.workflow_web_catalog node-catalog.json
+```
+
+The catalog intentionally excludes node executors and other callable runtime
+behavior.
+
+## Documentation and support
+
+- [`Architecture`](docs/architecture.md) describes the core boundaries and workflow
+  model.
+- [`Support Policy`](docs/policies/support-policy.md) describes supported environments and
+  compatibility expectations.
+- [`SECURITY.md`](SECURITY.md) explains private vulnerability reporting and the
+  security boundaries of workflows and adapters.
+- [`Changelog`](docs/changelog.md) records release changes and known limitations.
+- [`docs/workflow-format.md`](docs/workflow-format.md) documents persistence,
+  compatibility, and capability boundaries.
+
+## Optional integrations
+
+The `ml` extra enables the PyPlaid adapter and the `cosapp` extra enables the
+CoSApp adapter. Neither extra is part of the minimum core support guarantee.
+Install an extra only when its upstream dependency, license terms, platform
+requirements, and integration behavior have been reviewed for the target
+release:
+
+```bash
+uv sync --extra ml
+uv sync --extra cosapp
+```
+
+Optional adapters may execute external tools or user-provided models. Treat
+their workflows as trusted input and test the exact dependency versions before
+production use.
+
+## License
+
+FlowGraph Core is licensed under the [BSD 3-Clause License](LICENSE). Release
+compliance requires review of the exact dependency lockfile, build artifacts,
+third-party notices, native dependencies, and applicable license obligations.

flowgraph-0.1.2/README.md

@@ -0,0 +1,104 @@
+# FlowGraph Core
+
+`FlowGraph` is the GUI-free Python workflow engine. It provides typed workflow
+composition, validation, persistence, execution, adapters, mesh and image data
+operations, browser-WASM execution support, and metadata-only catalog export
+for compatible external clients.
+
+> **Alpha status:** FlowGraph Core `0.1.x` is an alpha series for evaluation,
+> development, experimentation, and early adopter feedback. APIs and workflow
+> behavior may change before `1.0.0`. See [`Release Policy`](docs/policies/release-policy.md).
+
+## Development
+
+```bash
+uv sync --extra dev
+uv run pytest
+uv run ruff check .
+```
+
+See [`Contributing`](.github/CONTRIBUTING.md) for prerequisites, development
+workflow, testing, documentation, and pull-request expectations.
+
+## Headless workflows
+
+The `flowgraph` command is headless and has no GUI runtime dependency:
+
+```bash
+uv run flowgraph inspect workflow.json
+uv run flowgraph run workflow.json --input name=value
+uv run flowgraph run workflow.json --override node-id.parameter=value
+uv run flowgraph run workflow.json --json-output results.json
+```
+
+Workflows use the versioned `flowgraph-workflow` JSON format. Core validation and
+execution are UI-independent.
+
+## Package artifacts
+
+Build the portable, pure-Python source distribution and wheel with:
+
+```bash
+uv build --out-dir dist/
+```
+
+The resulting wheel is compatible with all supported Python platforms. See
+`packaging/README.md` for release details.
+
+The initial supported publication channels are GitHub source releases and
+PyPI. Conda, Docker, operating-system package managers, and third-party mirrors
+are not supported release channels at this time. See
+[`Release Channels`](docs/policies/release-channels.md) for the release policy.
+
+FlowGraph Core declares Python 3.11 or newer. CI covers Python 3.11 and 3.13 on
+GitHub-hosted Ubuntu, Windows, and macOS runners; a platform/version combination
+is supported only after its release-candidate job passes. See
+[`Support Policy`](docs/policies/support-policy.md) for compatibility, deprecation,
+maintenance, and unsupported-use policies.
+
+## Catalog export
+
+FlowGraph can export non-executable node metadata for tools that need to author
+or structurally validate workflow JSON:
+
+```bash
+uv run python -m flowgraph.application.workflow_web_catalog node-catalog.json
+```
+
+The catalog intentionally excludes node executors and other callable runtime
+behavior.
+
+## Documentation and support
+
+- [`Architecture`](docs/architecture.md) describes the core boundaries and workflow
+  model.
+- [`Support Policy`](docs/policies/support-policy.md) describes supported environments and
+  compatibility expectations.
+- [`SECURITY.md`](SECURITY.md) explains private vulnerability reporting and the
+  security boundaries of workflows and adapters.
+- [`Changelog`](docs/changelog.md) records release changes and known limitations.
+- [`docs/workflow-format.md`](docs/workflow-format.md) documents persistence,
+  compatibility, and capability boundaries.
+
+## Optional integrations
+
+The `ml` extra enables the PyPlaid adapter and the `cosapp` extra enables the
+CoSApp adapter. Neither extra is part of the minimum core support guarantee.
+Install an extra only when its upstream dependency, license terms, platform
+requirements, and integration behavior have been reviewed for the target
+release:
+
+```bash
+uv sync --extra ml
+uv sync --extra cosapp
+```
+
+Optional adapters may execute external tools or user-provided models. Treat
+their workflows as trusted input and test the exact dependency versions before
+production use.
+
+## License
+
+FlowGraph Core is licensed under the [BSD 3-Clause License](LICENSE). Release
+compliance requires review of the exact dependency lockfile, build artifacts,
+third-party notices, native dependencies, and applicable license obligations.

flowgraph-0.1.2/pyproject.toml

@@ -0,0 +1,83 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "flowgraph"
+version = "0.1.2"
+description = "Headless typed workflow engine and execution runtime"
+readme = "README.md"
+requires-python = ">=3.11"
+license = "BSD-3-Clause"
+license-files = ["LICENSE"]
+authors = [{ name = "Felipe Bordeu" }]
+maintainers = [{ name = "Felipe Bordeu" }]
+keywords = ["workflow", "graph", "mesh", "scientific-computing", "automation"]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Intended Audience :: Developers",
+  "Intended Audience :: Science/Research",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Programming Language :: Python :: 3.14",
+  "Operating System :: OS Independent",
+  "Topic :: Scientific/Engineering",
+  "Topic :: Software Development :: Libraries :: Python Modules",
+]
+dependencies = [
+  "vtk>=9.2",
+  "muscat>=2.5.2",
+  "meshio>=5.3",
+  "meshlane>=5.5.0",
+  "scipy>=1.10",
+  "pandas",
+  "h5py",
+  "pillow>=10.0",
+]
+
+[project.optional-dependencies]
+dev = [
+  "pytest>=8.0",
+  "pytest-cov>=5.0",
+  "ruff>=0.6",
+]
+ml = [
+  "pyplaid",
+]
+cosapp = [
+  "cosapp>=1.6.1",
+]
+ci = [
+  "cosapp>=1.6.1",
+  "pycgns",
+]
+
+[project.urls]
+Homepage = "https://github.com/FBW-Engineering-Solutions/FlowGraph"
+Repository = "https://github.com/FBW-Engineering-Solutions/FlowGraph.git"
+Issues = "https://github.com/FBW-Engineering-Solutions/FlowGraph/issues"
+
+[project.scripts]
+flowgraph = "flowgraph.core_cli:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools]
+package-dir = { "" = "src" }
+
+[tool.setuptools.package-data]
+"flowgraph" = [
+  "testdata/*",
+]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = [".", "src"]
+
+[tool.ruff]
+target-version = "py311"
+line-length = 100
+

flowgraph-0.1.2/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

flowgraph-0.1.2/src/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-0.1.2/src/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-0.1.2/src/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-0.1.2/src/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)