sim-atlas-toolkit 0.0.1__tar.gz

sim_atlas_toolkit-0.0.1/LICENSE

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2026, Sebastian Eibl
+
+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.

sim_atlas_toolkit-0.0.1/PKG-INFO

@@ -0,0 +1,27 @@
+Metadata-Version: 2.4
+Name: sim-atlas-toolkit
+Version: 0.0.1
+Summary: Tools for parsing and storing workflow nodes with support for pyiron and Python functions
+Keywords: pyiron
+Author: Sebastian Eibl
+Author-email: Sebastian Eibl <sebastian.eibl@mpcdf.mpg.de>
+License-Expression: BSD-3-Clause
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Dist: pydantic>=2
+Requires-Dist: requests>=2
+Maintainer: Sebastian Eibl
+Maintainer-email: Sebastian Eibl <sebastian.eibl@mpcdf.mpg.de>
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+

sim_atlas_toolkit-0.0.1/pyproject.toml

@@ -0,0 +1,78 @@
+[project]
+name = "sim-atlas-toolkit"
+version = "0.0.1"
+description = "Tools for parsing and storing workflow nodes with support for pyiron and Python functions"
+authors = [
+  { name = "Sebastian Eibl", email = "sebastian.eibl@mpcdf.mpg.de"},
+]
+maintainers = [
+  { name = "Sebastian Eibl", email = "sebastian.eibl@mpcdf.mpg.de"},
+]
+readme = "README.md"
+requires-python = ">=3.11"
+license = "BSD-3-Clause"
+license-files = ["LICEN[CS]E*"]
+keywords = ["pyiron"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Science/Research",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Scientific/Engineering",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+dependencies = [
+    "pydantic>=2",
+    "requests>=2",
+]
+
+[project.scripts]
+sim-atlas-upload = "sim_atlas_toolkit.cli:main"
+
+[dependency-groups]
+dev = [
+    "pyiron-workflow>=0.15.6",
+    "pytest>=8",
+    "pyright>=1.1.407",
+    "python-workflow-definition>=0.1.0",
+    "ruff>=0.14.6",
+]
+
+[build-system]
+requires = ["uv_build>=0.9.13,<0.10.0"]
+build-backend = "uv_build"
+
+[tool.ruff.lint]
+select = [
+    # pycodestyle
+    "E",
+    # Pyflakes
+    "F",
+    # pyupgrade
+    "UP",
+    # flake8-bugbear
+    "B",
+    # flake8-simplify
+    "SIM",
+    # isort
+    "I",
+    # flake8-comprehensions
+    "C4",
+    # eradicate
+    "ERA",
+    # pylint
+    "PL",
+]
+ignore = [
+    "E501",  # line too long
+]
+
+[tool.pyright]
+typeCheckingMode = "strict"
+reportMissingTypeStubs = false
+

sim_atlas_toolkit-0.0.1/src/sim_atlas_toolkit/__init__.py

@@ -0,0 +1,3 @@
+from .node_store import NodeStore
+
+__all__ = ["NodeStore"]

sim_atlas_toolkit-0.0.1/src/sim_atlas_toolkit/cli.py

@@ -0,0 +1,99 @@
+from __future__ import annotations
+
+import argparse
+import importlib
+import logging
+import os
+
+from .node_store import NodeStore
+
+DEFAULT_API_URL_ENV = "SIM_ATLAS_API_URL"
+DEFAULT_API_TOKEN_ENV = "SIM_ATLAS_API_TOKEN"
+
+logger = logging.getLogger("SimAtlas")
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="sim-atlas-upload",
+        description=(
+            "Upload one or more Python modules to a Sim Atlas backend. "
+            "Values can be provided via CLI flags or environment variables."
+        ),
+    )
+    parser.add_argument(
+        "modules",
+        nargs="+",
+        help="Module name(s) to upload, for example 'mypackage.mymodule'.",
+    )
+    parser.add_argument(
+        "--api-url",
+        default=os.getenv(DEFAULT_API_URL_ENV),
+        help=(f"Backend API base URL. Defaults to ${DEFAULT_API_URL_ENV} if omitted."),
+    )
+    parser.add_argument(
+        "--api-token",
+        default=os.getenv(DEFAULT_API_TOKEN_ENV),
+        help=(
+            f"API token sent as x-api-key. Defaults to ${DEFAULT_API_TOKEN_ENV} "
+            "if omitted."
+        ),
+    )
+    parser.add_argument(
+        "--recursive",
+        choices=["no", "import", "filesystem"],
+        default="no",
+        help="Recursion strategy for module traversal.",
+    )
+    parser.add_argument(
+        "--update-existing",
+        action="store_true",
+        help="Update existing nodes if they already exist.",
+    )
+    parser.add_argument(
+        "--verbose",
+        action="store_true",
+        help="Enable verbose logging.",
+    )
+    return parser
+
+
+def main() -> int:
+    parser = _build_parser()
+    args = parser.parse_args()
+
+    logging.basicConfig(level=logging.DEBUG if args.verbose else logging.INFO)
+
+    if not args.api_url:
+        parser.error(
+            f"Missing API URL. Provide --api-url or set {DEFAULT_API_URL_ENV}."
+        )
+
+    # Fail fast on import errors so CLI can return a non-zero exit code.
+    missing_modules: list[str] = []
+    for module_name in args.modules:
+        try:
+            importlib.import_module(module_name)
+        except Exception as exc:  # noqa: BLE001
+            missing_modules.append(module_name)
+            logger.error("Failed to import module %s: %s", module_name, exc)
+
+    if missing_modules:
+        logger.error(
+            "Aborting upload because one or more modules could not be imported."
+        )
+        return 1
+
+    store = NodeStore(api_url=args.api_url, api_key=args.api_token)
+    for module_name in args.modules:
+        store.upload_module(
+            module_name,
+            update_existing=args.update_existing,
+            recursive=args.recursive,
+        )
+
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

sim_atlas_toolkit-0.0.1/src/sim_atlas_toolkit/models.py

@@ -0,0 +1,112 @@
+from enum import StrEnum
+
+from pydantic import BaseModel
+
+
+class ArtifactType(StrEnum):
+    FUNCTION = "function"
+    WORKFLOW = "workflow"
+
+
+class Annotation(BaseModel):
+    has_default_value: bool = False
+    label: str | None = None
+    datatype: str | None = None
+    unit: str | None = None
+    quantity: str | None = None
+    description: str | None = None
+
+
+class FunctionRequest(BaseModel):
+    author_name: str = "unknown"
+    author_email: str = "unknown"
+
+    name: str
+    artifact_type: str = "function"
+    category: str
+    keywords: list[str]
+
+    homepage_url: str = ""
+    documentation_url: str = ""
+    source_url: str = ""
+
+    python_import: str
+    dependencies: list[str] | None = None
+
+    source_code: str
+
+    docstring: str
+    inputs: list[Annotation]
+    outputs: list[Annotation]
+
+
+class FunctionResponse(BaseModel):
+    author_name: str
+    author_email: str
+
+    creator_name: str
+    creator_email: str
+    creation_timestamp: str
+
+    id: str
+    name: str
+    artifact_type: str
+    category: str
+    keywords: list[str]
+
+    homepage_url: str | None = None
+    documentation_url: str | None = None
+    source_url: str | None = None
+
+    python_import: str
+    dependencies: list[str] | None = None
+
+    source_code: str
+
+    docstring: str
+    brief_description: str | None = None
+    description: str | None = None
+    inputs: list[Annotation]
+    outputs: list[Annotation]
+
+
+class ScoredSearchItem(BaseModel):
+    score: float
+    node: FunctionResponse
+
+
+class SearchResults(BaseModel):
+    data: list[ScoredSearchItem]
+    page: int
+    limit: int
+    total_items: int
+    total_pages: int
+
+
+class ScoredSearchResponse(BaseModel):
+    results: SearchResults
+    aggregations: dict[str, dict[str, int]] | None = None
+
+
+class FunctionMetadata(FunctionResponse):
+    embedding: list[float] | None = None
+
+
+class Filter(BaseModel):
+    category: str | None = None
+    artifact_type: list[ArtifactType] | None = None
+    author: list[str] | None = None
+    keywords: list[str] | None = None
+    datatypes: list[str] | None = None
+    units: list[str] | None = None
+    quantities: list[str] | None = None
+
+
+class FilterOptions(BaseModel):
+    category: dict[str, list[str]]
+    artifact_type: list[ArtifactType]
+    author: list[str]
+    keywords: list[str]
+    datatypes: list[str]
+    units: list[str]
+    quantities: list[str]

sim_atlas_toolkit-0.0.1/src/sim_atlas_toolkit/node_store.py

@@ -0,0 +1,187 @@
+import contextlib
+import importlib
+import importlib.metadata
+import inspect
+import logging
+from collections.abc import Callable
+from http import HTTPStatus
+from pathlib import Path
+from types import ModuleType
+from typing import Any, Literal
+
+import requests
+
+from sim_atlas_toolkit.parsers.metadata import Metadata
+
+from .models import (
+    FunctionRequest,
+)
+from .parser import get_metadata
+
+logger = logging.getLogger("SimAtlas")
+
+
+class NodeStore:
+    def __init__(self, api_url: str, api_key: str | None = None) -> None:
+        self.api_url = api_url
+        self.api_key = api_key
+
+    def upload_module(  # noqa: PLR0912
+        self,
+        module: str | ModuleType,
+        update_existing: bool = False,
+        parsers: list[Callable[[Any], list[Metadata]]] | None = None,
+        recursive: Literal["no", "import", "filesystem"] = "no",
+        **kwargs: dict[str, Any],
+    ) -> None:
+        try:
+            if isinstance(module, str):
+                module = importlib.import_module(module)
+        except Exception as e:
+            logger.error(f"Failed to import module {module}: {e}")
+            return
+
+        if recursive == "filesystem":
+            module_path = Path(module.__path__[0])
+            submodule_paths = module_path.glob("**/*.py")
+            submodule_paths = (
+                path for path in submodule_paths if not path.name.startswith("_")
+            )
+            submodule_paths = (
+                ".".join(
+                    [module.__name__]
+                    + str(path.relative_to(module_path).with_suffix("")).split("/")
+                )
+                for path in submodule_paths
+            )
+            for submodule_path in submodule_paths:
+                self.upload_module(
+                    submodule_path,
+                    update_existing=update_existing,
+                    parsers=parsers,
+                    recursive="no",
+                    **kwargs,
+                )
+
+        if hasattr(module, "__all__"):
+            items = ((k, getattr(module, k)) for k in module.__all__)
+        else:
+            items = module.__dict__.items()
+
+        num_uploads = 0
+        successful_uploads = 0
+        for k, v in items:
+            if inspect.ismodule(v):
+                if recursive == "import" and v.__name__.startswith(module.__name__):
+                    self.upload_module(
+                        v,
+                        update_existing=update_existing,
+                        parsers=parsers,
+                        recursive=recursive,
+                        **kwargs,
+                    )
+                continue
+
+            if not hasattr(v, "__module__"):
+                continue
+
+            if not v.__module__.startswith(module.__name__):
+                continue
+
+            if k.startswith("_"):
+                continue
+
+            try:
+                responses = self.upload(
+                    v, update_existing=update_existing, parsers=parsers, **kwargs
+                )
+                num_uploads += len(responses)
+                for response in responses:
+                    if response.status_code == HTTPStatus.CREATED:
+                        successful_uploads += 1
+                    else:
+                        logger.debug(
+                            f"Failed to upload {k}: {response.status_code} {response.text}"
+                        )
+            except Exception as e:
+                logger.debug(f"Failed to upload {k}: {v}\n{e}")
+                continue
+
+        logger.info(f"{successful_uploads}/{num_uploads} uploaded from {module}")
+
+    def upload(  # noqa: PLR0912
+        self,
+        obj: Any,
+        update_existing: bool = False,
+        parsers: list[Callable[[Any], list[Metadata]]] | None = None,
+        **kwargs: dict[str, Any],
+    ) -> list[requests.Response]:
+        headers: dict[str, str] = {}
+        if self.api_key:
+            headers["x-api-key"] = self.api_key
+
+        if isinstance(obj, FunctionRequest):
+            response = requests.post(
+                f"{self.api_url}/artifacts",
+                json=obj.model_dump(),
+                headers=headers,
+            )
+            return [response]
+
+        if inspect.ismodule(obj):
+            raise ValueError(
+                "Will not automatically upload modules. Use upload_module instead."
+            )
+
+        general_metadata: dict[str, Any] = {}
+
+        with contextlib.suppress(Exception):
+            if dependencies := importlib.metadata.requires(
+                obj.__module__.partition(".")[0]
+            ):
+                general_metadata["dependencies"] = dependencies
+
+        try:
+            package_metadata = importlib.metadata.metadata(
+                obj.__module__.partition(".")[0]
+            ).json
+        except Exception as _:
+            package_metadata = {}
+
+        if author := package_metadata.get("author"):
+            general_metadata["author_name"] = author
+        if email := package_metadata.get("author_email"):
+            general_metadata["author_email"] = email
+
+        with contextlib.suppress(Exception):
+            project_url = package_metadata.get("project_url")
+            if project_url is not None:
+                for item in project_url:
+                    key, url = item.split(", ")
+                    if key.lower() in ["homepage"]:
+                        general_metadata["homepage_url"] = url
+                        continue
+                    if key.lower() in ["documentation"]:
+                        general_metadata["documentation_url"] = url
+                        continue
+                    if key.lower() in ["source", "code", "repository", "github"]:
+                        general_metadata["source_url"] = url
+                        continue
+
+        metadata_list = get_metadata(obj, parsers)
+        responses: list[requests.Response] = []
+        for metadata in metadata_list:
+            metadata_dict = metadata.model_dump()
+            metadata_dict.update(general_metadata)
+            metadata_dict.update(kwargs)
+
+            request_data = FunctionRequest.model_validate(metadata_dict)
+
+            responses.append(
+                requests.post(
+                    f"{self.api_url}/artifacts",
+                    json=request_data.model_dump(),
+                    headers=headers,
+                )
+            )
+        return responses

sim_atlas_toolkit-0.0.1/src/sim_atlas_toolkit/parser.py

@@ -0,0 +1,30 @@
+from collections.abc import Callable
+from typing import Any
+
+from .parsers import (
+    dataclass_node,
+    pyiron_core,
+    pyiron_workflow,
+    python_function,
+    python_workflow_definition,
+)
+from .parsers.metadata import Metadata
+
+
+def get_metadata(
+    obj: Any, parsers: list[Callable[[Any], list[Metadata]]] | None
+) -> list[Metadata]:
+    if parsers is None:
+        parsers = [
+            dataclass_node.parse,
+            pyiron_workflow.parse,
+            pyiron_core.parse,
+            python_workflow_definition.parse,
+            python_function.parse,
+        ]
+
+    for parser in parsers:
+        if metadata := parser(obj):
+            return metadata
+
+    raise ValueError(f"No parser available for the given object: {type(obj)}")

sim_atlas_toolkit-0.0.1/src/sim_atlas_toolkit/parsers/dataclass_node.py

@@ -0,0 +1,93 @@
+import dataclasses
+import inspect
+import textwrap
+from typing import Any, get_type_hints
+
+from ..models import Annotation, ArtifactType
+from .metadata import Metadata, parse_annotation
+
+
+def _field_annotations(cls: type) -> list[Annotation]:
+    try:
+        hints = get_type_hints(cls, include_extras=True)
+    except Exception:
+        hints = {}
+
+    result: list[Annotation] = []
+    for f in dataclasses.fields(cls):  # type: ignore[arg-type]
+        if not f.init:
+            continue
+        tp = hints.get(f.name)
+        has_default = (
+            f.default is not dataclasses.MISSING
+            or f.default_factory is not dataclasses.MISSING  # type: ignore[misc]
+        )
+        ann = parse_annotation(tp) if tp is not None else Annotation()
+        result.append(
+            Annotation(
+                label=ann.label if ann.label is not None else f.name,
+                datatype=ann.datatype,
+                unit=ann.unit,
+                quantity=ann.quantity,
+                has_default_value=has_default,
+            )
+        )
+    return result
+
+
+def parse(obj: Any) -> list[Metadata]:
+    if not (dataclasses.is_dataclass(obj) and isinstance(obj, type)):
+        return []
+
+    module: str = obj.__module__
+    qualname: str = obj.__qualname__
+    python_import = f"{module}.{qualname}"
+
+    try:
+        raw_source = textwrap.dedent(inspect.getsource(obj).replace("\\r\\n", ""))
+    except OSError:
+        return []
+
+    pack_note = (
+        f"# NOTE: This is a virtual PACK node for {qualname}.\n"
+        "# It takes the dataclass fields as individual inputs and constructs the dataclass instance.\n"
+        "# The source code below is shown for reference only.\n"
+    )
+    unpack_note = (
+        f"# NOTE: This is a virtual UNPACK node for {qualname}.\n"
+        "# It takes a dataclass instance as input and exposes its fields as individual outputs.\n"
+        "# The source code below is shown for reference only.\n"
+    )
+    pack_source = pack_note + raw_source
+    unpack_source = unpack_note + raw_source
+
+    category = module.replace(".", ">")
+    raw_doc = inspect.getdoc(obj) or ""
+
+    field_annotations = _field_annotations(obj)
+    dataclass_annotation = Annotation(label=qualname, datatype=python_import)
+
+    return [
+        Metadata(
+            name=f"[PACK] {python_import}",
+            artifact_type=ArtifactType.FUNCTION,
+            python_import=python_import,
+            category=category,
+            source_code=pack_source,
+            docstring=f"[PACK] {qualname}: {raw_doc}",
+            keywords=["pack"],
+            inputs=field_annotations,
+            outputs=[dataclass_annotation],
+        ),
+        Metadata(
+            name=f"[UNPACK] {python_import}",
+            artifact_type=ArtifactType.FUNCTION,
+            python_import=python_import,
+            category=category,
+            source_code=unpack_source,
+            docstring=f"[UNPACK] {qualname}: {raw_doc}",
+            keywords=["unpack"],
+            inputs=[dataclass_annotation],
+            outputs=field_annotations,
+        ),
+    ]

sim_atlas_toolkit-0.0.1/src/sim_atlas_toolkit/parsers/metadata.py

@@ -0,0 +1,82 @@
+import inspect
+import types
+from typing import Annotated, Any, Union, get_args, get_origin
+
+from pydantic import BaseModel
+
+from ..models import Annotation, ArtifactType
+
+
+class Metadata(BaseModel):
+    name: str | None = None
+    artifact_type: ArtifactType
+    category: str
+
+    python_import: str | None
+    source_code: str
+
+    keywords: list[str]
+
+    docstring: str
+    inputs: list[Annotation]
+    outputs: list[Annotation]
+
+
+def type_to_str(tp: Any) -> str:
+    """Recursively convert a Python type annotation to a canonical string.
+
+    Examples:
+        int              -> "int"
+        type(None)       -> "None"
+        list[int]        -> "list[int]"
+        dict[str, float] -> "dict[str, float]"
+        int | float      -> "int | float"
+        Optional[int]    -> "int | None"
+    """
+    if tp is type(None):
+        return "None"
+
+    origin = get_origin(tp)
+    args = get_args(tp)
+
+    # Union: PEP 604 (int | float) or typing.Union / Optional
+    if origin is Union or isinstance(tp, types.UnionType):
+        return " | ".join(type_to_str(a) for a in args)
+
+    # Generic alias: list[int], dict[str, float], etc.
+    if origin is not None and args:
+        name = getattr(origin, "__name__", str(origin))
+        return f"{name}[{', '.join(type_to_str(a) for a in args)}]"
+
+    # Simple type
+    return getattr(tp, "__name__", str(tp))
+
+
+def parse_annotation(annotation: Any) -> Annotation:
+    """Parse a type annotation to extract datatype, unit, and quantity.
+
+    Args:
+        annotation: The type annotation to parse.
+
+    Returns:
+        Annotation: The parsed annotation details.
+    """
+    if annotation is None:
+        return Annotation()
+
+    if annotation == inspect.Parameter.empty:
+        return Annotation()
+
+    origin = get_origin(annotation)
+    if origin is not Annotated:
+        return Annotation(datatype=type_to_str(annotation))
+
+    args = get_args(annotation)
+    result = Annotation(datatype=type_to_str(args[0]))
+    for arg in args[1:]:
+        if isinstance(arg, dict):
+            result.label = arg.get("label", result.label)  # type: ignore
+            result.unit = arg.get("unit", result.unit)  # type: ignore
+            result.quantity = arg.get("quantity", result.quantity)  # type: ignore
+            result.description = arg.get("description", result.description)  # type: ignore
+    return result

sim_atlas_toolkit-0.0.1/src/sim_atlas_toolkit/parsers/pyiron_core.py

@@ -0,0 +1,35 @@
+import inspect
+from typing import Any
+
+from ..models import Annotation, ArtifactType
+from .metadata import Metadata
+
+
+def parse(obj: Any) -> list[Metadata]:
+    if not hasattr(obj, "__globals__"):
+        return []
+    if obj.__globals__["__name__"] != "pyiron_core.pyiron_workflow.simple_workflow":
+        return []
+
+    source_code = inspect.getsource(obj)
+
+    instance = obj()
+
+    inputs = [Annotation(label=k, datatype=v.type) for k, v in instance.inputs.items()]
+    outputs = [
+        Annotation(label=k, datatype=v.type) for k, v in instance.outputs.items()
+    ]
+
+    return [
+        Metadata(
+            name=f"{instance._func.__module__}.{instance._func.__qualname__}",
+            artifact_type=ArtifactType.FUNCTION,
+            python_import=f"{instance._func.__module__}.{instance._func.__qualname__}",
+            category=f"{instance._func.__module__}".replace(".", ">"),
+            source_code=source_code,
+            docstring=instance._func.__doc__ or "",
+            keywords=["pyiron_core_node"],
+            inputs=inputs,
+            outputs=outputs,
+        )
+    ]

sim_atlas_toolkit-0.0.1/src/sim_atlas_toolkit/parsers/pyiron_workflow.py

@@ -0,0 +1,49 @@
+# pyright: basic
+
+import inspect
+from typing import Any
+
+from ..models import Annotation, ArtifactType
+from .metadata import Metadata, parse_annotation
+
+
+def parse(node: Any) -> list[Metadata]:
+    if not isinstance(node, type):
+        return []
+
+    try:
+        from pyiron_workflow.api import NOT_DATA  # noqa: PLC0415
+        from pyiron_workflow.nodes.function import Function  # noqa: PLC0415
+    except ImportError:
+        return []
+
+    if not issubclass(node, Function):
+        return []
+
+    source_code = inspect.getsource(node.node_function)
+
+    inputs: list[Annotation] = []
+    outputs: list[Annotation] = []
+    for k, v in node.preview_inputs().items():
+        ann = parse_annotation(v[0])
+        ann.label = k
+        ann.has_default_value = v[1] != NOT_DATA
+        inputs.append(ann)
+    for k, v in node.preview_outputs().items():
+        ann = parse_annotation(v)
+        ann.label = k
+        outputs.append(ann)
+
+    return [
+        Metadata(
+            name=f"{node.node_function.__module__}.{node.node_function.__qualname__}",
+            artifact_type=ArtifactType.FUNCTION,
+            python_import=f"{node.node_function.__module__}.{node.node_function.__qualname__}",
+            category=f"{node.node_function.__module__}".replace(".", ">"),
+            source_code=source_code,
+            docstring=node.node_function.__doc__ or "",
+            keywords=["pyiron_workflow_function"],
+            inputs=inputs,
+            outputs=outputs,
+        )
+    ]

sim_atlas_toolkit-0.0.1/src/sim_atlas_toolkit/parsers/python_function.py

@@ -0,0 +1,69 @@
+import inspect
+import textwrap
+from typing import Annotated, Any, get_args, get_origin
+
+from ..models import Annotation, ArtifactType
+from .metadata import Metadata, parse_annotation
+
+
+def _parse_arguments(sig: inspect.Signature) -> list[Annotation]:
+    arguments: list[Annotation] = []
+    for param_name, param in sig.parameters.items():
+        ann = parse_annotation(param.annotation)
+        ann.label = param_name
+        arguments.append(ann)
+    return arguments
+
+
+def _parse_and_unpack_annotation(annotation: Any) -> list[Annotation]:
+    origin = get_origin(annotation)
+    args = get_args(annotation)
+
+    # unpack one level of Annotated
+    if origin is Annotated:
+        origin = get_origin(args[0])
+        args = get_args(args[0])
+
+    if origin is tuple:
+        annotations: list[Annotation] = []
+        for i, arg in enumerate(args):
+            ann = parse_annotation(arg)
+            ann.label = ann.label if ann.label is not None else str(i)
+            annotations.append(ann)
+        return annotations
+
+    ann = parse_annotation(annotation)
+    if not ann.label:
+        ann.label = "return"
+    return [ann]
+
+
+def parse(obj: Any) -> list[Metadata]:
+    if not (inspect.isfunction(obj) or inspect.isbuiltin(obj)):
+        return []
+
+    if inspect.isbuiltin(obj):
+        source_code = f"{obj.__name__}{inspect.signature(obj)}"
+    else:
+        source_code = inspect.getsource(obj)
+    source_code = textwrap.dedent(source_code.replace("\\r\\n", ""))
+
+    sig = inspect.signature(obj)
+    inputs = _parse_arguments(sig)
+
+    return_annotation = sig.return_annotation
+    outputs = _parse_and_unpack_annotation(return_annotation)
+
+    return [
+        Metadata(
+            name=f"{obj.__module__}.{obj.__qualname__}",
+            artifact_type=ArtifactType.FUNCTION,
+            python_import=f"{obj.__module__}.{obj.__qualname__}",
+            category=f"{obj.__module__}".replace(".", ">"),
+            source_code=source_code,
+            docstring=inspect.getdoc(obj) or "",
+            keywords=[],
+            inputs=inputs,
+            outputs=outputs,
+        )
+    ]

sim_atlas_toolkit-0.0.1/src/sim_atlas_toolkit/parsers/python_workflow_definition.py

@@ -0,0 +1,45 @@
+# pyright: basic
+
+from typing import Any
+
+from ..models import Annotation, ArtifactType
+from .metadata import Metadata
+
+
+def parse(obj: Any) -> list[Metadata]:
+    try:
+        from python_workflow_definition.models import (  # noqa: PLC0415
+            PythonWorkflowDefinitionInputNode,
+            PythonWorkflowDefinitionOutputNode,
+            PythonWorkflowDefinitionWorkflow,
+        )
+    except ImportError:
+        return []
+
+    if not isinstance(obj, PythonWorkflowDefinitionWorkflow):
+        return []
+
+    source_code: str = obj.model_dump_json(indent=2)
+
+    inputs: list[Annotation] = []
+    outputs: list[Annotation] = []
+    for node in obj.nodes:
+        if isinstance(node, PythonWorkflowDefinitionInputNode):
+            ann = Annotation(label=node.name)
+            inputs.append(ann)
+        if isinstance(node, PythonWorkflowDefinitionOutputNode):
+            ann = Annotation(label=node.name)
+            outputs.append(ann)
+
+    return [
+        Metadata(
+            artifact_type=ArtifactType.FUNCTION,
+            python_import="",
+            category="workflow",
+            source_code=source_code,
+            docstring="",
+            keywords=[],
+            inputs=inputs,
+            outputs=outputs,
+        )
+    ]