digitalhub-runtime-python 0.15.2__tar.gz → 0.16.0b0__tar.gz

{digitalhub_runtime_python-0.15.2 → digitalhub_runtime_python-0.16.0b0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: digitalhub-runtime-python
-Version: 0.15.2
+Version: 0.16.0b0
 Summary: Python runtime for DHCore
 Project-URL: Homepage, https://github.com/scc-digitalhub/digitalhub-sdk-runtime-python
 Author-email: Fondazione Bruno Kessler <digitalhub@fbk.eu>, Matteo Martini <mmartini@fbk.eu>

{digitalhub_runtime_python-0.15.2 → digitalhub_runtime_python-0.16.0b0}/digitalhub_runtime_python/__init__.py

@@ -3,10 +3,14 @@
 # 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.hydra.builder import FunctionHydraBuilder
 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.guardrail_build.builder import RunGuardrailRunBuildBuilder
 from digitalhub_runtime_python.entities.run.guardrail_serve.builder import RunGuardrailRunServeBuilder
+from digitalhub_runtime_python.entities.run.hydra_build.builder import RunHydraRunBuildBuilder
+from digitalhub_runtime_python.entities.run.hydra_job.builder import RunHydraRunJobBuilder
+from digitalhub_runtime_python.entities.run.hydra_subtask.builder import RunHydraRunSubtaskBuilder
 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
@@ -14,6 +18,9 @@ from digitalhub_runtime_python.entities.run.python_job.builder import RunPythonR
 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.hydra_build.builder import TaskHydraBuildBuilder
+from digitalhub_runtime_python.entities.task.hydra_job.builder import TaskHydraJobBuilder
+from digitalhub_runtime_python.entities.task.hydra_subtask.builder import TaskHydraSubtaskBuilder
 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
@@ -25,6 +32,7 @@ entity_builders = (
     (EntityKinds.FUNCTION_GUARDRAIL.value, FunctionGuardrailBuilder),
     (EntityKinds.FUNCTION_OPENINFERENCE.value, FunctionOpeninferenceBuilder),
     (EntityKinds.FUNCTION_PYTHON.value, FunctionPythonBuilder),
+    (EntityKinds.FUNCTION_HYDRA.value, FunctionHydraBuilder),
     (EntityKinds.RUN_GUARDRAIL_BUILD.value, RunGuardrailRunBuildBuilder),
     (EntityKinds.RUN_GUARDRAIL_SERVE.value, RunGuardrailRunServeBuilder),
     (EntityKinds.RUN_OPENINFERENCE_BUILD.value, RunOpeninferenceRunBuildBuilder),
@@ -32,6 +40,9 @@ entity_builders = (
     (EntityKinds.RUN_PYTHON_BUILD.value, RunPythonRunBuildBuilder),
     (EntityKinds.RUN_PYTHON_JOB.value, RunPythonRunJobBuilder),
     (EntityKinds.RUN_PYTHON_SERVE.value, RunPythonRunServeBuilder),
+    (EntityKinds.RUN_HYDRA_BUILD.value, RunHydraRunBuildBuilder),
+    (EntityKinds.RUN_HYDRA_JOB.value, RunHydraRunJobBuilder),
+    (EntityKinds.RUN_HYDRA_SUBTASK.value, RunHydraRunSubtaskBuilder),
     (EntityKinds.TASK_GUARDRAIL_BUILD.value, TaskGuardrailBuildBuilder),
     (EntityKinds.TASK_GUARDRAIL_SERVE.value, TaskGuardrailServeBuilder),
     (EntityKinds.TASK_OPENINFERENCE_BUILD.value, TaskOpeninferenceBuildBuilder),
@@ -39,6 +50,9 @@ entity_builders = (
     (EntityKinds.TASK_PYTHON_BUILD.value, TaskPythonBuildBuilder),
     (EntityKinds.TASK_PYTHON_JOB.value, TaskPythonJobBuilder),
     (EntityKinds.TASK_PYTHON_SERVE.value, TaskPythonServeBuilder),
+    (EntityKinds.TASK_HYDRA_BUILD.value, TaskHydraBuildBuilder),
+    (EntityKinds.TASK_HYDRA_JOB.value, TaskHydraJobBuilder),
+    (EntityKinds.TASK_HYDRA_SUBTASK.value, TaskHydraSubtaskBuilder),
 )
 
 try:
@@ -47,12 +61,16 @@ try:
         RuntimeOpeninferenceBuilder,
         RuntimePythonBuilder,
         RuntimePythonJobBuilder,
+        RuntimeHydraBuilder,
+        RuntimeHydraSubtaskBuilder,
+        RuntimeHydraJobBuilder,
     )
 
     runtime_builders = (
         (EntityKinds.FUNCTION_GUARDRAIL.value, RuntimeGuardrailBuilder),
         (EntityKinds.FUNCTION_OPENINFERENCE.value, RuntimeOpeninferenceBuilder),
         (EntityKinds.FUNCTION_PYTHON.value, RuntimePythonBuilder),
+        (EntityKinds.FUNCTION_HYDRA.value, RuntimeHydraBuilder),
         (EntityKinds.RUN_GUARDRAIL_BUILD.value, RuntimeGuardrailBuilder),
         (EntityKinds.RUN_GUARDRAIL_SERVE.value, RuntimeGuardrailBuilder),
         (EntityKinds.RUN_OPENINFERENCE_BUILD.value, RuntimeOpeninferenceBuilder),
@@ -60,6 +78,9 @@ try:
         (EntityKinds.RUN_PYTHON_BUILD.value, RuntimePythonBuilder),
         (EntityKinds.RUN_PYTHON_JOB.value, RuntimePythonJobBuilder),
         (EntityKinds.RUN_PYTHON_SERVE.value, RuntimePythonBuilder),
+        (EntityKinds.RUN_HYDRA_BUILD.value, RuntimeHydraBuilder),
+        (EntityKinds.RUN_HYDRA_JOB.value, RuntimeHydraJobBuilder),
+        (EntityKinds.RUN_HYDRA_SUBTASK.value, RuntimeHydraSubtaskBuilder),
         (EntityKinds.TASK_GUARDRAIL_BUILD.value, RuntimeGuardrailBuilder),
         (EntityKinds.TASK_GUARDRAIL_SERVE.value, RuntimeGuardrailBuilder),
         (EntityKinds.TASK_OPENINFERENCE_BUILD.value, RuntimeOpeninferenceBuilder),
@@ -67,6 +88,9 @@ try:
         (EntityKinds.TASK_PYTHON_BUILD.value, RuntimePythonBuilder),
         (EntityKinds.TASK_PYTHON_JOB.value, RuntimePythonJobBuilder),
         (EntityKinds.TASK_PYTHON_SERVE.value, RuntimePythonBuilder),
+        (EntityKinds.TASK_HYDRA_BUILD.value, RuntimeHydraBuilder),
+        (EntityKinds.TASK_HYDRA_JOB.value, RuntimeHydraJobBuilder),
+        (EntityKinds.TASK_HYDRA_SUBTASK.value, RuntimeHydraSubtaskBuilder),
     )
 except ImportError as e:
     from digitalhub.utils.logger.logger import get_logger

{digitalhub_runtime_python-0.15.2 → digitalhub_runtime_python-0.16.0b0}/digitalhub_runtime_python/entities/_base/runtime_entity/builder.py

@@ -100,3 +100,38 @@ class RuntimeEntityBuilderGuardrail(RuntimeEntityBuilder):
             ),
         ]
     )
+
+class RuntimeEntityBuilderHydra(RuntimeEntityBuilder):
+    EXECUTABLE_KIND = EntityKinds.FUNCTION_HYDRA.value
+    TASKS_KINDS = map_actions(
+        [
+            (
+                EntityKinds.TASK_HYDRA_BUILD.value,
+                Actions.BUILD.value,
+            ),
+            (
+                EntityKinds.TASK_HYDRA_JOB.value,
+                Actions.JOB.value,
+            ),
+            (
+                EntityKinds.TASK_HYDRA_SUBTASK.value,
+                Actions.SUBTASK.value,
+            ),
+        ]
+    )
+    RUN_KINDS = map_actions(
+        [
+            (
+                EntityKinds.RUN_HYDRA_BUILD.value,
+                Actions.BUILD.value,
+            ),
+            (
+                EntityKinds.RUN_HYDRA_JOB.value,
+                Actions.JOB.value,
+            ),
+            (
+                EntityKinds.RUN_HYDRA_SUBTASK.value,
+                Actions.SUBTASK.value,
+            ),
+        ]
+    )

{digitalhub_runtime_python-0.15.2 → digitalhub_runtime_python-0.16.0b0}/digitalhub_runtime_python/entities/_commons/enums.py

@@ -32,6 +32,13 @@ class EntityKinds(Enum):
     RUN_GUARDRAIL_BUILD = "guardrail+build:run"
     RUN_GUARDRAIL_SERVE = "guardrail+serve:run"
 
+    FUNCTION_HYDRA = "hydra"
+    TASK_HYDRA_BUILD = "hydra+build"
+    TASK_HYDRA_JOB = "hydra+job"
+    TASK_HYDRA_SUBTASK = "hydra+subtask"
+    RUN_HYDRA_BUILD = "hydra+build:run"
+    RUN_HYDRA_JOB = "hydra+job:run"
+    RUN_HYDRA_SUBTASK = "hydra+subtask:run"
 
 class Actions(Enum):
     """
@@ -41,3 +48,4 @@ class Actions(Enum):
     BUILD = "build"
     JOB = "job"
     SERVE = "serve"
+    SUBTASK = "subtask"

digitalhub_runtime_python-0.16.0b0/digitalhub_runtime_python/entities/function/hydra/builder.py

@@ -0,0 +1,92 @@
+# 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 RuntimeEntityBuilderHydra
+from digitalhub_runtime_python.entities._commons.enums import EntityKinds
+from digitalhub_runtime_python.entities.function.hydra.entity import FunctionHydra
+from digitalhub_runtime_python.entities.function.hydra.spec import FunctionSpecHydra, FunctionValidatorHydra
+from digitalhub_runtime_python.entities.function.hydra.status import FunctionStatusHydra
+
+from digitalhub_runtime_python.entities.function.python.utils import source_check, source_post_check
+from digitalhub_runtime_python.entities.function.hydra.utils import config_check
+
+class FunctionHydraBuilder(FunctionBuilder, RuntimeEntityBuilderHydra):
+    """
+    FunctionHydra builder.
+    """
+
+    ENTITY_CLASS = FunctionHydra
+    ENTITY_SPEC_CLASS = FunctionSpecHydra
+    ENTITY_SPEC_VALIDATOR = FunctionValidatorHydra
+    ENTITY_STATUS_CLASS = FunctionStatusHydra
+    ENTITY_KIND = EntityKinds.FUNCTION_HYDRA.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,
+    ) -> FunctionHydra:
+        kwargs = source_check(**kwargs)
+        kwargs = config_check(**kwargs)
+        obj = super().build(
+            kind,
+            project,
+            name,
+            uuid,
+            description,
+            labels,
+            embedded,
+            **kwargs,
+        )
+        return source_post_check(obj)
+
+    def from_dict(self, obj: dict) -> FunctionHydra:
+        """
+        Create a new object from dictionary.
+
+        Parameters
+        ----------
+        obj : dict
+            Dictionary to create object from.
+
+        Returns
+        -------
+        FunctionHydra
+            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-0.16.0b0/digitalhub_runtime_python/entities/function/hydra/entity.py

@@ -0,0 +1,81 @@
+# 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.hydra.spec import FunctionSpecHydra
+    from digitalhub_runtime_python.entities.function.hydra.status import FunctionStatusHydra
+
+
+class FunctionHydra(Function):
+    """
+    FunctionHydra class.
+    """
+
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+
+        self.spec: FunctionSpecHydra
+        self.status: FunctionStatusHydra
+
+    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
+
+        config = self.spec.config
+        # Check base64. If it is set, decode it in a local file
+        # save in variable to restore on object after export
+        if config is not None:
+            base64 = config.pop("base64", None)
+            if base64 is not None:
+                # Write local file
+                config_pth = self._context().root / "config.yaml"
+                write_text(config_pth, decode_base64_string(base64))
+
+                # Export and restore base64, then return
+                self.spec.config = base64
+
+        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)

digitalhub_runtime_python-0.16.0b0/digitalhub_runtime_python/entities/function/hydra/models.py

@@ -0,0 +1,60 @@
+# SPDX-FileCopyrightText: © 2025 DSLab - Fondazione Bruno Kessler
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+from enum import Enum
+
+from pydantic import BaseModel, ConfigDict, Field
+
+class Lang(Enum):
+    """
+    Source code language.
+    """
+
+    PYTHON = "python"
+
+
+class SourceValidator(BaseModel):
+    """
+    Source code params.
+    """
+
+    model_config = ConfigDict(use_enum_values=True)
+
+    source: str = None
+    "Pointer to source code."
+
+    handler: str = None
+    "Function entrypoint."
+
+    init_function: str = None
+    """Handler for init function."""
+
+    complete_function: str = None
+    """Handler for complete function."""
+
+    code: str = None
+    "Source code (plain text)."
+
+    base64: str = None
+    "Source code (base64 encoded)."
+
+    lang: Lang = Field(default=Lang.PYTHON.value)
+    "Source code language (hint)."
+
+class ConfigValidator(BaseModel):
+    """
+    Config params.
+    """
+    model_config = ConfigDict(use_enum_values=True)
+
+    source: str = None
+    "Pointer to source code."
+
+    path: str = None
+    "Config path."
+
+    base64: str = None
+    "Config (base64 encoded)."

digitalhub_runtime_python-0.16.0b0/digitalhub_runtime_python/entities/function/hydra/spec.py

@@ -0,0 +1,58 @@
+# SPDX-FileCopyrightText: © 2025 DSLab - Fondazione Bruno Kessler
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+from digitalhub.entities.function._base.spec import FunctionSpec, FunctionValidator
+
+from digitalhub_runtime_python.entities.function.python.models import PythonVersion
+from digitalhub_runtime_python.entities.function.hydra.models import ConfigValidator, SourceValidator
+
+
+class FunctionSpecHydra(FunctionSpec):
+    """
+    FunctionSpecHydra specifications.
+    """
+
+    def __init__(
+        self,
+        source: dict | None = None,
+        config: dict | None = None,
+        image: str | None = None,
+        base_image: str | None = None,
+        python_version: str | None = None,
+        requirements: list | None = None,
+    ) -> None:
+        super().__init__()
+
+        self.image = image
+        self.base_image = base_image
+        self.python_version = python_version
+        self.requirements = requirements
+        self.source = source
+        self.config = config
+
+
+class FunctionValidatorHydra(FunctionValidator):
+    """
+    FunctionValidatorHydra validator.
+    """
+
+    source: SourceValidator
+    """Source code validator"""
+
+    config: ConfigValidator
+    """Config validator"""
+
+    python_version: PythonVersion
+    "Python version"
+
+    image: str | None = None
+    "Image where the function will be executed"
+
+    base_image: str | None = None
+    "Base image used to build the image where the function will be executed"
+
+    requirements: list[str] | str | None = None
+    "Requirements list to be installed in the image where the function will be executed"

digitalhub_runtime_python-0.16.0b0/digitalhub_runtime_python/entities/function/hydra/status.py

@@ -0,0 +1,13 @@
+# SPDX-FileCopyrightText: © 2025 DSLab - Fondazione Bruno Kessler
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+from digitalhub.entities.function._base.status import FunctionStatus
+
+
+class FunctionStatusHydra(FunctionStatus):
+    """
+    FunctionStatusHydra status.
+    """

digitalhub_runtime_python-0.16.0b0/digitalhub_runtime_python/entities/function/hydra/utils.py

@@ -0,0 +1,111 @@
+# SPDX-FileCopyrightText: © 2025 DSLab - Fondazione Bruno Kessler
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+import typing
+from pathlib import Path
+
+from digitalhub.utils.exceptions import EntityError
+from digitalhub.utils.generic_utils import encode_string, read_source
+from digitalhub.utils.uri_utils import has_local_scheme
+
+def config_check(**kwargs) -> dict:
+    """
+    Check config.
+
+    Parameters
+    ----------
+    **kwargs
+        Keyword arguments.
+
+    Returns
+    -------
+    dict
+        Checked config.
+    """
+    # either config_src or config or config_base64 may be provided
+    config_src = kwargs.pop("config_src", None)
+    config_base64 = kwargs.pop("config_base64", None)
+    config_content = kwargs.pop("config_content", None)
+    config = kwargs.pop("config", None)
+    config_path = kwargs.pop("config_path", None)
+
+    if config is not None:
+        config_src = config.pop("source", None)
+        config_base64 = config.pop("base64", None)
+        config_content = None
+        config_path = config.pop("path", None)
+
+    config = _check_params(
+        config_src=config_src,
+        config_content=config_content,
+        config_base64=config_base64,
+        path=config_path,
+    )
+
+    if config is not None:
+        kwargs["config"] = config
+        return kwargs
+
+    return kwargs
+
+
+def _check_params(
+    config_src: str | None = None,
+    config_content: str | None = None,
+    config_base64: str | None = None,
+    path: str | None = None,
+) -> dict:
+    """
+    Check config.
+
+    Parameters
+    ----------
+    config_src : str
+        Config source.
+    config_content : str
+        Config.
+    config_base64 : str
+        Config base64.
+    path : str
+        Config path.
+
+    Returns
+    -------
+    dict
+        Checked config.
+    """
+    config = {}
+
+    if path is not None:
+        config["path"] = path
+
+    if config_src is None and config_content is None and config_base64 is None:
+        raise EntityError("Config must be provided.")
+
+    if config_src is not None:
+        # Check local source
+        if has_local_scheme(config_src):
+            path_src = Path(config_src)
+
+            if not path_src.exists():
+                raise EntityError(f"Source {config_src} does not exist.")
+
+            # If source is a folder, zip it and upload it
+            if not path_src.is_file():
+                raise EntityError(f"Source {config_src} should be a file.")
+
+            # If source is a file, read it and encode it in base64
+            config["base64"] = read_source(config_src)
+        else:
+            config["source"] = config_src
+
+    if config_base64 is not None:
+        config["base64"] = config_base64
+
+    if config_content is not None:
+        config["base64"] = encode_string(config_content)
+
+    return config

digitalhub_runtime_python-0.16.0b0/digitalhub_runtime_python/entities/run/hydra_build/builder.py

@@ -0,0 +1,25 @@
+# SPDX-FileCopyrightText: © 2025 DSLab - Fondazione Bruno Kessler
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+from digitalhub.entities.run._base.builder import RunBuilder
+
+from digitalhub_runtime_python.entities._base.runtime_entity.builder import RuntimeEntityBuilderHydra
+from digitalhub_runtime_python.entities._commons.enums import EntityKinds
+from digitalhub_runtime_python.entities.run.hydra_build.entity import RunHydraRunBuild
+from digitalhub_runtime_python.entities.run.hydra_build.spec import RunSpecHydraRunBuild, RunValidatorHydraRunBuild
+from digitalhub_runtime_python.entities.run.hydra_build.status import RunStatusHydraRunBuild
+
+
+class RunHydraRunBuildBuilder(RunBuilder, RuntimeEntityBuilderHydra):
+    """
+    RunHydraRunBuildBuilder runner.
+    """
+
+    ENTITY_CLASS = RunHydraRunBuild
+    ENTITY_SPEC_CLASS = RunSpecHydraRunBuild
+    ENTITY_SPEC_VALIDATOR = RunValidatorHydraRunBuild
+    ENTITY_STATUS_CLASS = RunStatusHydraRunBuild
+    ENTITY_KIND = EntityKinds.RUN_HYDRA_BUILD.value

digitalhub_runtime_python-0.16.0b0/digitalhub_runtime_python/entities/run/hydra_build/entity.py

@@ -0,0 +1,25 @@
+# SPDX-FileCopyrightText: © 2025 DSLab - Fondazione Bruno Kessler
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+import typing
+
+from digitalhub_runtime_python.entities.run._base.entity import RunBaseRun
+
+if typing.TYPE_CHECKING:
+    from digitalhub_runtime_python.entities.run.hydra_build.spec import RunSpecHydraRunBuild
+    from digitalhub_runtime_python.entities.run.hydra_build.status import RunStatusHydraRunBuild
+
+    
+class RunHydraRunBuild(RunBaseRun):
+    """
+    RunHydraRunBuild class.
+    """
+
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+
+        self.spec: RunSpecHydraRunBuild
+        self.status: RunStatusHydraRunBuild

digitalhub_runtime_python-0.16.0b0/digitalhub_runtime_python/entities/run/hydra_build/spec.py

@@ -0,0 +1,15 @@
+# SPDX-FileCopyrightText: © 2025 DSLab - Fondazione Bruno Kessler
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+from digitalhub_runtime_python.entities.run._base.spec import RunSpecBaseRun, RunValidatorBaseRun
+
+
+class RunSpecHydraRunBuild(RunSpecBaseRun):
+    """RunSpecHydraRunBuild specifications."""
+
+
+class RunValidatorHydraRunBuild(RunValidatorBaseRun):
+    """RunValidatorHydraRunBuild validator."""

digitalhub_runtime_python-0.16.0b0/digitalhub_runtime_python/entities/run/hydra_build/status.py

@@ -0,0 +1,13 @@
+# SPDX-FileCopyrightText: © 2025 DSLab - Fondazione Bruno Kessler
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+from digitalhub_runtime_python.entities.run._base.status import RunStatusBaseRun
+
+
+class RunStatusHydraRunBuild(RunStatusBaseRun):
+    """
+    RunStatusHydraRunBuild status.
+    """

digitalhub_runtime_python-0.16.0b0/digitalhub_runtime_python/entities/run/hydra_job/builder.py

@@ -0,0 +1,25 @@
+# SPDX-FileCopyrightText: © 2025 DSLab - Fondazione Bruno Kessler
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+from digitalhub.entities.run._base.builder import RunBuilder
+
+from digitalhub_runtime_python.entities._base.runtime_entity.builder import RuntimeEntityBuilderHydra
+from digitalhub_runtime_python.entities._commons.enums import EntityKinds
+from digitalhub_runtime_python.entities.run.hydra_job.entity import RunHydraRunJob
+from digitalhub_runtime_python.entities.run.hydra_job.spec import RunSpecHydraRunJob, RunValidatorHydraRunJob
+from digitalhub_runtime_python.entities.run.hydra_job.status import RunStatusHydraRunJob
+
+
+class RunHydraRunJobBuilder(RunBuilder, RuntimeEntityBuilderHydra):
+    """
+    RunHydraRunJobBuilder runner.
+    """
+
+    ENTITY_CLASS = RunHydraRunJob
+    ENTITY_SPEC_CLASS = RunSpecHydraRunJob
+    ENTITY_SPEC_VALIDATOR = RunValidatorHydraRunJob
+    ENTITY_STATUS_CLASS = RunStatusHydraRunJob
+    ENTITY_KIND = EntityKinds.RUN_HYDRA_JOB.value