digitalhub-runtime-python 0.14.2__py3-none-any.whl → 0.15.0__py3-none-any.whl

digitalhub_runtime_python/__init__.py

@@ -2,28 +2,75 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 from digitalhub_runtime_python.entities._commons.enums import EntityKinds
+from digitalhub_runtime_python.entities.function.guardrail.builder import FunctionGuardrailBuilder
+from digitalhub_runtime_python.entities.function.openinference.builder import FunctionOpeninferenceBuilder
 from digitalhub_runtime_python.entities.function.python.builder import FunctionPythonBuilder
-from digitalhub_runtime_python.entities.run.build.builder import RunPythonRunBuildBuilder
-from digitalhub_runtime_python.entities.run.job.builder import RunPythonRunJobBuilder
-from digitalhub_runtime_python.entities.run.serve.builder import RunPythonRunServeBuilder
-from digitalhub_runtime_python.entities.task.build.builder import TaskPythonBuildBuilder
-from digitalhub_runtime_python.entities.task.job.builder import TaskPythonJobBuilder
-from digitalhub_runtime_python.entities.task.serve.builder import TaskPythonServeBuilder
+from digitalhub_runtime_python.entities.run.guardrail_build.builder import RunGuardrailRunBuildBuilder
+from digitalhub_runtime_python.entities.run.guardrail_serve.builder import RunGuardrailRunServeBuilder
+from digitalhub_runtime_python.entities.run.openinference_build.builder import RunOpeninferenceRunBuildBuilder
+from digitalhub_runtime_python.entities.run.openinference_serve.builder import RunOpeninferenceRunServeBuilder
+from digitalhub_runtime_python.entities.run.python_build.builder import RunPythonRunBuildBuilder
+from digitalhub_runtime_python.entities.run.python_job.builder import RunPythonRunJobBuilder
+from digitalhub_runtime_python.entities.run.python_serve.builder import RunPythonRunServeBuilder
+from digitalhub_runtime_python.entities.task.guardrail_build.builder import TaskGuardrailBuildBuilder
+from digitalhub_runtime_python.entities.task.guardrail_serve.builder import TaskGuardrailServeBuilder
+from digitalhub_runtime_python.entities.task.openinference_build.builder import TaskOpeninferenceBuildBuilder
+from digitalhub_runtime_python.entities.task.openinference_serve.builder import TaskOpeninferenceServeBuilder
+from digitalhub_runtime_python.entities.task.python_build.builder import TaskPythonBuildBuilder
+from digitalhub_runtime_python.entities.task.python_job.builder import TaskPythonJobBuilder
+from digitalhub_runtime_python.entities.task.python_serve.builder import TaskPythonServeBuilder
 from digitalhub_runtime_python.utils.utils import handler
 
 entity_builders = (
+    (EntityKinds.FUNCTION_GUARDRAIL.value, FunctionGuardrailBuilder),
+    (EntityKinds.FUNCTION_OPENINFERENCE.value, FunctionOpeninferenceBuilder),
     (EntityKinds.FUNCTION_PYTHON.value, FunctionPythonBuilder),
-    (EntityKinds.TASK_PYTHON_BUILD.value, TaskPythonBuildBuilder),
-    (EntityKinds.TASK_PYTHON_JOB.value, TaskPythonJobBuilder),
-    (EntityKinds.TASK_PYTHON_SERVE.value, TaskPythonServeBuilder),
+    (EntityKinds.RUN_GUARDRAIL_BUILD.value, RunGuardrailRunBuildBuilder),
+    (EntityKinds.RUN_GUARDRAIL_SERVE.value, RunGuardrailRunServeBuilder),
+    (EntityKinds.RUN_OPENINFERENCE_BUILD.value, RunOpeninferenceRunBuildBuilder),
+    (EntityKinds.RUN_OPENINFERENCE_SERVE.value, RunOpeninferenceRunServeBuilder),
     (EntityKinds.RUN_PYTHON_BUILD.value, RunPythonRunBuildBuilder),
     (EntityKinds.RUN_PYTHON_JOB.value, RunPythonRunJobBuilder),
     (EntityKinds.RUN_PYTHON_SERVE.value, RunPythonRunServeBuilder),
+    (EntityKinds.TASK_GUARDRAIL_BUILD.value, TaskGuardrailBuildBuilder),
+    (EntityKinds.TASK_GUARDRAIL_SERVE.value, TaskGuardrailServeBuilder),
+    (EntityKinds.TASK_OPENINFERENCE_BUILD.value, TaskOpeninferenceBuildBuilder),
+    (EntityKinds.TASK_OPENINFERENCE_SERVE.value, TaskOpeninferenceServeBuilder),
+    (EntityKinds.TASK_PYTHON_BUILD.value, TaskPythonBuildBuilder),
+    (EntityKinds.TASK_PYTHON_JOB.value, TaskPythonJobBuilder),
+    (EntityKinds.TASK_PYTHON_SERVE.value, TaskPythonServeBuilder),
 )
 
 try:
-    from digitalhub_runtime_python.runtimes.builder import RuntimePythonBuilder
+    from digitalhub_runtime_python.runtimes.builder import (
+        RuntimeGuardrailBuilder,
+        RuntimeOpeninferenceBuilder,
+        RuntimePythonBuilder,
+        RuntimePythonJobBuilder,
+    )
+
+    runtime_builders = (
+        (EntityKinds.FUNCTION_GUARDRAIL.value, RuntimeGuardrailBuilder),
+        (EntityKinds.FUNCTION_OPENINFERENCE.value, RuntimeOpeninferenceBuilder),
+        (EntityKinds.FUNCTION_PYTHON.value, RuntimePythonBuilder),
+        (EntityKinds.RUN_GUARDRAIL_BUILD.value, RuntimeGuardrailBuilder),
+        (EntityKinds.RUN_GUARDRAIL_SERVE.value, RuntimeGuardrailBuilder),
+        (EntityKinds.RUN_OPENINFERENCE_BUILD.value, RuntimeOpeninferenceBuilder),
+        (EntityKinds.RUN_OPENINFERENCE_SERVE.value, RuntimeOpeninferenceBuilder),
+        (EntityKinds.RUN_PYTHON_BUILD.value, RuntimePythonBuilder),
+        (EntityKinds.RUN_PYTHON_JOB.value, RuntimePythonJobBuilder),
+        (EntityKinds.RUN_PYTHON_SERVE.value, RuntimePythonBuilder),
+        (EntityKinds.TASK_GUARDRAIL_BUILD.value, RuntimeGuardrailBuilder),
+        (EntityKinds.TASK_GUARDRAIL_SERVE.value, RuntimeGuardrailBuilder),
+        (EntityKinds.TASK_OPENINFERENCE_BUILD.value, RuntimeOpeninferenceBuilder),
+        (EntityKinds.TASK_OPENINFERENCE_SERVE.value, RuntimeOpeninferenceBuilder),
+        (EntityKinds.TASK_PYTHON_BUILD.value, RuntimePythonBuilder),
+        (EntityKinds.TASK_PYTHON_JOB.value, RuntimePythonJobBuilder),
+        (EntityKinds.TASK_PYTHON_SERVE.value, RuntimePythonBuilder),
+    )
+except ImportError as e:
+    from digitalhub.utils.logger.logger import get_logger
 
-    runtime_builders = ((kind, RuntimePythonBuilder) for kind in [e.value for e in EntityKinds])
-except ImportError:
+    logger = get_logger(__name__)
+    logger.debug(f"Error importing runtime builders: {e}")
     runtime_builders = tuple()

digitalhub_runtime_python/entities/_base/runtime_entity/builder.py

@@ -44,3 +44,59 @@ class RuntimeEntityBuilderPython(RuntimeEntityBuilder):
             ),
         ]
     )
+
+
+class RuntimeEntityBuilderOpeninference(RuntimeEntityBuilder):
+    EXECUTABLE_KIND = EntityKinds.FUNCTION_OPENINFERENCE.value
+    TASKS_KINDS = map_actions(
+        [
+            (
+                EntityKinds.TASK_OPENINFERENCE_BUILD.value,
+                Actions.BUILD.value,
+            ),
+            (
+                EntityKinds.TASK_OPENINFERENCE_SERVE.value,
+                Actions.SERVE.value,
+            ),
+        ]
+    )
+    RUN_KINDS = map_actions(
+        [
+            (
+                EntityKinds.RUN_OPENINFERENCE_BUILD.value,
+                Actions.BUILD.value,
+            ),
+            (
+                EntityKinds.RUN_OPENINFERENCE_SERVE.value,
+                Actions.SERVE.value,
+            ),
+        ]
+    )
+
+
+class RuntimeEntityBuilderGuardrail(RuntimeEntityBuilder):
+    EXECUTABLE_KIND = EntityKinds.FUNCTION_GUARDRAIL.value
+    TASKS_KINDS = map_actions(
+        [
+            (
+                EntityKinds.TASK_GUARDRAIL_BUILD.value,
+                Actions.BUILD.value,
+            ),
+            (
+                EntityKinds.TASK_GUARDRAIL_SERVE.value,
+                Actions.SERVE.value,
+            ),
+        ]
+    )
+    RUN_KINDS = map_actions(
+        [
+            (
+                EntityKinds.RUN_GUARDRAIL_BUILD.value,
+                Actions.BUILD.value,
+            ),
+            (
+                EntityKinds.RUN_GUARDRAIL_SERVE.value,
+                Actions.SERVE.value,
+            ),
+        ]
+    )

digitalhub_runtime_python/entities/_commons/enums.py

@@ -20,6 +20,18 @@ class EntityKinds(Enum):
     RUN_PYTHON_JOB = "python+job:run"
     RUN_PYTHON_SERVE = "python+serve:run"
 
+    FUNCTION_OPENINFERENCE = "openinference"
+    TASK_OPENINFERENCE_BUILD = "openinference+build"
+    TASK_OPENINFERENCE_SERVE = "openinference+serve"
+    RUN_OPENINFERENCE_BUILD = "openinference+build:run"
+    RUN_OPENINFERENCE_SERVE = "openinference+serve:run"
+
+    FUNCTION_GUARDRAIL = "guardrail"
+    TASK_GUARDRAIL_BUILD = "guardrail+build"
+    TASK_GUARDRAIL_SERVE = "guardrail+serve"
+    RUN_GUARDRAIL_BUILD = "guardrail+build:run"
+    RUN_GUARDRAIL_SERVE = "guardrail+serve:run"
+
 
 class Actions(Enum):
     """

digitalhub_runtime_python/entities/_commons/requirement_parser/enums.py

@@ -0,0 +1,27 @@
+# SPDX-FileCopyrightText: © 2025 DSLab - Fondazione Bruno Kessler
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from enum import Enum
+
+
+class RequirementFormat(Enum):
+    """
+    Enum for requirement file formats.
+    """
+
+    PIP = "pip"
+    PYPROJECT = "pyproject"
+    CONDA = "conda"
+
+
+class RequirementFile(Enum):
+    """
+    Enum for requirement file names.
+    """
+
+    REQUIREMENTS_TXT = "requirements.txt"
+    SETUP_PY = "setup.py"
+    PYPROJECT_TOML = "pyproject.toml"
+    CONDA_ENV_YAML = "conda.yaml"
+    CONDA_ENV_YML = "conda.yml"

digitalhub_runtime_python/entities/_commons/requirement_parser/factory.py

@@ -0,0 +1,75 @@
+# SPDX-FileCopyrightText: © 2025 DSLab - Fondazione Bruno Kessler
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+from pathlib import Path
+
+from digitalhub_runtime_python.entities._commons.requirement_parser.enums import RequirementFile, RequirementFormat
+from digitalhub_runtime_python.entities._commons.requirement_parser.modules._base import BaseParser
+from digitalhub_runtime_python.entities._commons.requirement_parser.modules._conda import CondaParser
+from digitalhub_runtime_python.entities._commons.requirement_parser.modules._pip import PipParser
+from digitalhub_runtime_python.entities._commons.requirement_parser.modules._pyproject import PyProjectParser
+
+
+class RequirementParserFactory:
+    """
+    Factory for requirement parsers.
+    """
+
+    def get_parser(self, requirements_file: str) -> BaseParser:
+        """
+        Get the requirement parser based on the format.
+
+        Parameters
+        ----------
+        requirements_file : str
+            The path to the requirements file.
+
+        Returns
+        -------
+        BaseParser
+            The requirement parser.
+        """
+        req_type = self._requirements_format(requirements_file)
+        match req_type:
+            case RequirementFormat.PIP:
+                return PipParser()
+            case RequirementFormat.PYPROJECT:
+                return PyProjectParser()
+            case RequirementFormat.CONDA:
+                return CondaParser()
+            case _:
+                raise ValueError(f"No parser found for format: {requirements_file}")
+
+    @staticmethod
+    def _requirements_format(requirements_file: str) -> RequirementFormat:
+        """
+        Understand requirements file format.
+
+        Parameters
+        ----------
+        requirements_file : str
+            The path to the requirements file.
+
+        Returns
+        -------
+        RequirementFormat
+            The format of the requirements file (e.g., 'pip', 'pyproject', 'conda').
+        """
+        match Path(requirements_file).name:
+            case RequirementFile.REQUIREMENTS_TXT.value:
+                return RequirementFormat.PIP
+            case RequirementFile.SETUP_PY.value:
+                return RequirementFormat.PIP
+            case RequirementFile.PYPROJECT_TOML.value:
+                return RequirementFormat.PYPROJECT
+            case RequirementFile.CONDA_ENV_YML.value:
+                return RequirementFormat.CONDA
+            case RequirementFile.CONDA_ENV_YAML.value:
+                return RequirementFormat.CONDA
+            case _:
+                raise ValueError(
+                    f"Unsupported requirements file: {Path(requirements_file).name}."
+                    f" Supported filenames are: {', '.join([f.value for f in RequirementFile])}."
+                )

digitalhub_runtime_python/entities/_commons/requirement_parser/modules/_base.py

@@ -0,0 +1,14 @@
+# SPDX-FileCopyrightText: © 2025 DSLab - Fondazione Bruno Kessler
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from abc import abstractmethod
+
+
+class BaseParser:
+    @staticmethod
+    @abstractmethod
+    def parse_requirements(source: str) -> list[str]:
+        """
+        Parses the requirements file and returns a list of dependencies.
+        """

digitalhub_runtime_python/entities/_commons/requirement_parser/modules/_conda.py

@@ -0,0 +1,38 @@
+# SPDX-FileCopyrightText: © 2025 DSLab - Fondazione Bruno Kessler
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import yaml
+
+from digitalhub_runtime_python.entities._commons.requirement_parser.modules._base import BaseParser
+
+
+class CondaParser(BaseParser):
+    @staticmethod
+    def parse_requirements(source: str) -> list[str]:
+        """
+        Parse an environment.yml file.
+
+        Parameters
+        ----------
+        source : str
+            Path to an environment.yml file.
+
+        Returns
+        -------
+        list[str]
+            A list of requirement strings.
+        """
+        requirements = []
+
+        with open(source, "r") as f:
+            data = yaml.safe_load(f)
+
+        if not data or "dependencies" not in data:
+            return requirements
+
+        for dep in data["dependencies"]:
+            if isinstance(dep, dict) and "pip" in dep:
+                requirements.extend(dep["pip"])
+
+        return requirements

digitalhub_runtime_python/entities/_commons/requirement_parser/modules/_pip.py

@@ -0,0 +1,43 @@
+# SPDX-FileCopyrightText: © 2025 DSLab - Fondazione Bruno Kessler
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from pip._internal.network.session import PipSession
+from pip._internal.req import parse_requirements as pip_parse
+
+from digitalhub_runtime_python.entities._commons.requirement_parser.modules._base import BaseParser
+
+
+class PipParser(BaseParser):
+    @staticmethod
+    def parse_requirements(source: str) -> list[str]:
+        """
+        Parse a requirements.txt file using pip's internal parser.
+
+        Parameters
+        ----------
+        source : str
+            Path to a requirements.txt file.
+
+        Returns
+        -------
+        list[str]
+            A list of requirement strings as they would be understood by pip.
+
+        Examples
+        --------
+        >>> requirements = parse_requirements_with_pip("/path/to/requirements.txt")
+        >>> print(requirements)
+        ['numpy>=1.0', 'pandas==2.0.0', 'git+https://github.com/user/repo.git@main']
+        """
+        # Parse using pip's internal parser
+        session = PipSession()
+        parsed = pip_parse(source, session=session)
+
+        # Extract requirement strings
+        requirements = []
+        for req in parsed:
+            if req.requirement:
+                requirements.append(str(req.requirement))
+
+        return requirements

digitalhub_runtime_python/entities/_commons/requirement_parser/modules/_pyproject.py

@@ -0,0 +1,41 @@
+# SPDX-FileCopyrightText: © 2025 DSLab - Fondazione Bruno Kessler
+#
+# SPDX-License-Identifier: Apache-2.0
+
+try:
+    import tomllib
+except ImportError:
+    import tomli as tomllib
+
+from digitalhub_runtime_python.entities._commons.requirement_parser.modules._base import BaseParser
+
+
+class PyProjectParser(BaseParser):
+    @staticmethod
+    def parse_requirements(source: str) -> list[str]:
+        """
+        Parse a pyproject.toml file.
+
+        Parameters
+        ----------
+        source : str
+            Path to a pyproject.toml file.
+
+        Returns
+        -------
+        list[str]
+            A list of requirement strings.
+        """
+        requirements = []
+
+        with open(source, "rb") as f:
+            data = tomllib.load(f)
+
+        project = data.get("project", {})
+
+        # Dependencies
+        dependencies = project.get("dependencies", [])
+        if isinstance(dependencies, list):
+            requirements.extend(dependencies)
+
+        return requirements

digitalhub_runtime_python/entities/_commons/requirement_parser/parser.py

@@ -0,0 +1,96 @@
+# SPDX-FileCopyrightText: © 2025 DSLab - Fondazione Bruno Kessler
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+from pathlib import Path
+
+from pip._internal.operations import freeze
+
+from digitalhub_runtime_python.entities._commons.requirement_parser.factory import RequirementParserFactory
+
+
+class RequirementParser:
+    """
+    A utility class for parsing requirements files using pip's internal parser.
+    """
+
+    def parse(self, requirements: list[str] | str | None = None) -> list[str] | None:
+        """
+        Parse the requirements file.
+
+        Returns
+        -------
+        list[str] | None
+            A list of requirement strings or None if no requirements are provided.
+        """
+        if requirements is None:
+            return
+        elif isinstance(requirements, str):
+            self._validate_path(requirements)
+            parser = RequirementParserFactory().get_parser(requirements)
+            parsed = parser.parse_requirements(requirements)
+            return self.read_installed_packages(parsed)
+        return self.read_installed_packages(requirements)
+
+    def _validate_path(self, path: str) -> None:
+        """
+        Validate the provided path.
+        """
+        if not Path(path).exists():
+            raise FileNotFoundError(f"Requirements file not found: {path}")
+        if not Path(path).is_file():
+            raise ValueError(f"Provided path is not a file: {path}")
+
+    @staticmethod
+    def read_installed_packages(requirements: list[str] | None = None) -> list[str] | None:
+        """
+        Read installed packages in execution context.
+
+        If requirements is provided, returns only those packages with their
+        versions filled in from the environment. Package names without versions
+        in the requirements list will have their versions added if found.
+
+        Parameters
+        ----------
+        requirements : list[str]
+            Optional list of package names (e.g., ['pandas', 'torch']) or
+            requirements with versions (e.g., ['pandas==2.0.0']).
+
+        Returns
+        -------
+        list[str]
+            List of installed packages in pip freeze format (e.g., ['numpy==1.24.0', 'pandas==2.0.0']).
+        """
+        separators = ["==", ">=", "<=", ">", "<", "~=", "!="]
+
+        # Build a mapping of normalized package names to their installed versions
+        installed_map: dict[str, str] = {}
+        for pkg in freeze.freeze():
+            # Handle different separators
+            for sep in separators:
+                if sep in pkg:
+                    name, version = pkg.split(sep, 1)
+                    # Normalize package name (lowercase, replace _ with -)
+                    installed_map[name.lower().replace("_", "-")] = f"{name}{sep}{version}"
+                    break
+
+        result = []
+        for req in requirements:
+            # Check if requirement already has a version specifier
+            has_version = any(sep in req for sep in separators)
+
+            if has_version:
+                # Keep as-is if version is already specified
+                result.append(req)
+            else:
+                # Normalize the requirement name for lookup
+                normalized_name = req.lower().replace("_", "-")
+                if normalized_name in installed_map:
+                    # Use the installed version
+                    result.append(installed_map[normalized_name])
+                else:
+                    # Package not found in environment, keep without version
+                    result.append(req)
+
+        return result

digitalhub_runtime_python/entities/function/guardrail/builder.py

@@ -0,0 +1,93 @@
+# SPDX-FileCopyrightText: © 2025 DSLab - Fondazione Bruno Kessler
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+from digitalhub.entities.function._base.builder import FunctionBuilder
+
+from digitalhub_runtime_python.entities._base.runtime_entity.builder import RuntimeEntityBuilderGuardrail
+from digitalhub_runtime_python.entities._commons.enums import EntityKinds
+from digitalhub_runtime_python.entities.function.guardrail.entity import FunctionGuardrail
+from digitalhub_runtime_python.entities.function.guardrail.spec import (
+    FunctionSpecGuardrail,
+    FunctionValidatorGuardrail,
+)
+from digitalhub_runtime_python.entities.function.guardrail.status import FunctionStatusGuardrail
+from digitalhub_runtime_python.entities.function.python.utils import source_check, source_post_check
+
+
+class FunctionGuardrailBuilder(FunctionBuilder, RuntimeEntityBuilderGuardrail):
+    """
+    FunctionGuardrail builder.
+    """
+
+    ENTITY_CLASS = FunctionGuardrail
+    ENTITY_SPEC_CLASS = FunctionSpecGuardrail
+    ENTITY_SPEC_VALIDATOR = FunctionValidatorGuardrail
+    ENTITY_STATUS_CLASS = FunctionStatusGuardrail
+    ENTITY_KIND = EntityKinds.FUNCTION_GUARDRAIL.value
+
+    def build(
+        self,
+        kind: str,
+        project: str,
+        name: str,
+        uuid: str | None = None,
+        description: str | None = None,
+        labels: list[str] | None = None,
+        embedded: bool = False,
+        **kwargs,
+    ) -> FunctionGuardrail:
+        kwargs = source_check(**kwargs)
+        obj = super().build(
+            kind,
+            project,
+            name,
+            uuid,
+            description,
+            labels,
+            embedded,
+            **kwargs,
+        )
+        return source_post_check(obj)
+
+    def from_dict(self, obj: dict) -> FunctionGuardrail:
+        """
+        Create a new object from dictionary.
+
+        Parameters
+        ----------
+        obj : dict
+            Dictionary to create object from.
+
+        Returns
+        -------
+        FunctionGuardrail
+            Object instance.
+        """
+        entity = super().from_dict(obj)
+        return source_post_check(entity)
+
+    def _parse_dict(self, obj: dict) -> dict:
+        """
+        Get dictionary and parse it to a valid entity dictionary.
+
+        Parameters
+        ----------
+        obj : dict
+            Dictionary to parse.
+
+        Returns
+        -------
+        dict
+            A dictionary containing the attributes of the entity instance.
+        """
+        # Look for source in spec
+        if spec_dict := obj.get("spec", {}):
+            # Check source
+            source = spec_dict.get("source", {})
+            if source:
+                spec_dict["source"] = source_check(source=source)["source"]
+
+        return super()._parse_dict(obj)

digitalhub_runtime_python/entities/function/guardrail/entity.py

@@ -0,0 +1,69 @@
+# SPDX-FileCopyrightText: © 2025 DSLab - Fondazione Bruno Kessler
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+import typing
+
+from digitalhub.entities.function._base.entity import Function
+from digitalhub.utils.generic_utils import decode_base64_string
+from digitalhub.utils.io_utils import write_text
+from digitalhub.utils.uri_utils import has_local_scheme
+
+from digitalhub_runtime_python.entities._commons.requirement_parser.parser import RequirementParser
+
+if typing.TYPE_CHECKING:
+    from digitalhub_runtime_python.entities.function.guardrail.spec import FunctionSpecGuardrail
+    from digitalhub_runtime_python.entities.function.guardrail.status import FunctionStatusGuardrail
+
+
+class FunctionGuardrail(Function):
+    """
+    FunctionGuardrail class.
+    """
+
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+
+        self.spec: FunctionSpecGuardrail
+        self.status: FunctionStatusGuardrail
+
+    def export(self) -> str:
+        """
+        Export object as a YAML file in the context folder.
+
+        Returns
+        -------
+        str
+            Exported filepath.
+        """
+        # Strip base64 from source at following conditions:
+        # - source is local path
+        # - base64 is not None
+
+        # Check source
+        source = self.spec.source.get("source")
+        if source is not None and has_local_scheme(source):
+            # Check base64. If it is set, decode it in a local file
+            # save in variable to restore on object after export
+            base64 = self.spec.source.pop("base64", None)
+            if base64 is not None:
+                # Write local file
+                src_pth = self._context().root / source
+                write_text(src_pth, decode_base64_string(base64))
+
+                # Export and restore base64, then return
+                pth = super().export()
+                self.spec.source["base64"] = base64
+                return pth
+
+        return super().export()
+
+    def _post_create_hook_before_save(self) -> None:
+        """
+        Hook method called after the creation of the entity but before saving
+        in Core.
+        Can be overridden in subclasses to implement custom behavior.
+        """
+        self.spec.requirements = RequirementParser().parse(self.spec.requirements)