digitalhub-runtime-python 0.5.0__tar.gz → 0.5.0b5__tar.gz

{digitalhub_runtime_python-0.5.0 → digitalhub_runtime_python-0.5.0b5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: digitalhub-runtime-python
-Version: 0.5.0
+Version: 0.5.0b5
 Summary: Python runtime for DHCore
 Author-email: Fondazione Bruno Kessler <dslab@fbk.eu>, Matteo Martini <mmartini@fbk.eu>
 License:                               Apache License

{digitalhub_runtime_python-0.5.0 → digitalhub_runtime_python-0.5.0b5}/digitalhub_runtime_python/__init__.py

@@ -9,8 +9,6 @@ root = "digitalhub_runtime_python"
 runtime_info = {
     "module": f"{root}.runtimes.runtime",
     "class_name": "RuntimePython",
-    "kind_registry_module": f"{root}.runtimes.kind_registry",
-    "kind_registry_class_name": "kind_registry",
 }
 
 root_ent = f"{root}.entities"

digitalhub_runtime_python-0.5.0b5/digitalhub_runtime_python/entities/functions/metadata.py

@@ -0,0 +1,9 @@
+from __future__ import annotations
+
+from digitalhub_core.entities.functions.metadata import FunctionMetadata
+
+
+class FunctionMetadataPython(FunctionMetadata):
+    """
+    Function Python metadata.
+    """

{digitalhub_runtime_python-0.5.0 → digitalhub_runtime_python-0.5.0b5}/digitalhub_runtime_python/entities/functions/spec.py

@@ -21,7 +21,6 @@ class FunctionSpecPython(FunctionSpec):
         source: dict,
         image: str | None = None,
         base_image: str | None = None,
-        python_version: str | None = None,
         requirements: list | None = None,
     ) -> None:
         """
@@ -31,7 +30,6 @@ class FunctionSpecPython(FunctionSpec):
 
         self.image = image
         self.base_image = base_image
-        self.python_version = python_version
         self.requirements = requirements
 
         source = self._source_check(source)
@@ -137,8 +135,5 @@ class FunctionParamsPython(FunctionParams):
     base_image: str = None
     "Base image"
 
-    python_version: str = None
-    "Python version"
-
     requirements: list = None
     "Requirements list, as used by the runtime"

digitalhub_runtime_python-0.5.0b5/digitalhub_runtime_python/entities/runs/metadata.py

@@ -0,0 +1,9 @@
+from __future__ import annotations
+
+from digitalhub_core.entities.runs.metadata import RunMetadata
+
+
+class RunMetadataPython(RunMetadata):
+    """
+    Run Python metadata.
+    """

digitalhub_runtime_python-0.5.0b5/digitalhub_runtime_python/entities/runs/spec.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+from digitalhub_ml.entities.runs.spec import RunParamsMl, RunSpecMl
+
+
+class RunSpecPython(RunSpecMl):
+    """Run Python specification."""
+
+    def __init__(
+        self,
+        task: str,
+        inputs: dict | None = None,
+        outputs: dict | None = None,
+        parameters: dict | None = None,
+        values: list | None = None,
+        local_execution: bool = False,
+        **kwargs,
+    ) -> None:
+        """
+        Constructor.
+        """
+        super().__init__(task, inputs, outputs, parameters, values, local_execution)
+
+        # Set function and task parameters
+        self._any_setter(**kwargs)
+
+
+class RunParamsPython(RunParamsMl):
+    """Run Python parameters."""
+
+    # Function parameters
+    source: dict = None
+    image: str = None
+    base_image: str = None
+    requirements: list = None
+
+    # Task parameters
+    function: str = None
+    node_selector: list[dict] = None
+    volumes: list[dict] = None
+    resources: list[dict] = None
+    affinity: dict = None
+    tolerations: list[dict] = None
+    env: list[dict] = None
+    secrets: list[str] = None
+    backoff_limit: int = None
+    schedule: str = None
+    replicas: int = None
+
+    # Task build
+    context_refs: list[dict] = None
+    context_sources: list[dict] = None
+    instructions: list[str] = None

digitalhub_runtime_python-0.5.0b5/digitalhub_runtime_python/entities/tasks/metadata.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+from digitalhub_core.entities.tasks.metadata import TaskMetadata
+
+
+class TaskMetadataJob(TaskMetadata):
+    """
+    Task Job metadata.
+    """
+
+
+class TaskMetadataBuild(TaskMetadata):
+    """
+    Task Build metadata.
+    """

digitalhub_runtime_python-0.5.0b5/digitalhub_runtime_python/entities/tasks/spec.py

@@ -0,0 +1,103 @@
+"""
+Task Python specification module.
+"""
+from __future__ import annotations
+
+from digitalhub_core.entities.tasks.models import K8s
+from digitalhub_core.entities.tasks.spec import TaskParams, TaskSpec
+from digitalhub_runtime_python.entities.tasks.models import ContextRef, ContextSource
+
+
+class TaskSpecPythonBase(TaskSpec):
+    """Task Python specification for Kubernetes."""
+
+    def __init__(
+        self,
+        function: str,
+        k8s: dict | None = None,
+    ) -> None:
+        """
+        Constructor.
+        """
+        super().__init__(function)
+        if k8s is None:
+            k8s = {}
+        k8s = K8s(**k8s).dict(by_alias=True)
+        self.node_selector = k8s.get("node_selector")
+        self.volumes = k8s.get("volumes")
+        self.resources = k8s.get("resources")
+        self.affinity = k8s.get("affinity")
+        self.tolerations = k8s.get("tolerations")
+        self.envs = k8s.get("envs")
+        self.secrets = k8s.get("secrets")
+        self.backoff_limit = k8s.get("backoff_limit")
+        self.schedule = k8s.get("schedule")
+        self.replicas = k8s.get("replicas")
+
+
+class TaskSpecJob(TaskSpecPythonBase):
+    """Task Job specification."""
+
+    def __init__(
+        self,
+        function: str,
+        k8s: dict | None = None,
+    ) -> None:
+        """
+        Constructor.
+        """
+        super().__init__(function, k8s)
+
+        k8s = k8s if k8s is not None else {}
+
+        self.backoff_limit = k8s.get("backoff_limit")
+        self.schedule = k8s.get("schedule")
+
+
+class TaskParamsJob(TaskParams):
+    """
+    TaskParamsJob model.
+    """
+
+    k8s: K8s = None
+    """Kubernetes resources."""
+
+
+class TaskSpecBuild(TaskSpecPythonBase):
+    """Task Build specification."""
+
+    def __init__(
+        self,
+        function: str,
+        k8s: dict | None = None,
+        context_refs: list | None = None,
+        context_sources: list | None = None,
+        instructions: list | None = None,
+    ) -> None:
+        """
+        Constructor.
+        """
+        super().__init__(function, k8s)
+
+        k8s = k8s if k8s is not None else {}
+        self.context_refs = context_refs
+        self.context_sources = context_sources
+        self.instructions = instructions
+
+
+class TaskParamsBuild(TaskParams):
+    """
+    TaskParamsBuild model.
+    """
+
+    k8s: K8s = None
+    """Kubernetes resources."""
+
+    context_refs: list[ContextRef] = None
+    """Context references."""
+
+    context_sources: list[ContextSource] = None
+    """Context sources."""
+
+    instructions: list[str] = None
+    """Build instructions."""

{digitalhub_runtime_python-0.5.0 → digitalhub_runtime_python-0.5.0b5}/digitalhub_runtime_python/runtimes/runtime.py

@@ -3,18 +3,15 @@ Runtime class for running Python functions.
 """
 from __future__ import annotations
 
-import typing
+from pathlib import Path
 from typing import Callable
 
-from digitalhub_core.context.builder import get_context
 from digitalhub_core.runtimes.base import Runtime
 from digitalhub_core.utils.logger import LOGGER
 from digitalhub_runtime_python.utils.configuration import get_function_from_source
-from digitalhub_runtime_python.utils.inputs import compose_inputs
-from digitalhub_runtime_python.utils.outputs import build_status, parse_outputs
-
-if typing.TYPE_CHECKING:
-    from digitalhub_core.runtimes.kind_registry import KindRegistry
+from digitalhub_runtime_python.utils.functions import run_python
+from digitalhub_runtime_python.utils.inputs import get_inputs_parameters
+from digitalhub_runtime_python.utils.outputs import build_status
 
 
 class RuntimePython(Runtime):
@@ -22,17 +19,15 @@ class RuntimePython(Runtime):
     Runtime Python class.
     """
 
-    def __init__(self, kind_registry: KindRegistry, project: str) -> None:
+    allowed_actions = ["job", "nuclio"]
+
+    def __init__(self) -> None:
         """
         Constructor.
         """
-        super().__init__(kind_registry, project)
-        ctx = get_context(self.project)
-        self.root = ctx.runtime_dir
-        self.tmp_dir = ctx.tmp_dir
-
-        self.root.mkdir(parents=True, exist_ok=True)
-        self.tmp_dir.mkdir(parents=True, exist_ok=True)
+        super().__init__()
+        self.root_path = Path("digitalhub_runtime_python")
+        self.tmp_path = self.root_path / "temp"
 
     def build(self, function: dict, task: dict, run: dict) -> dict:
         """
@@ -68,27 +63,28 @@ class RuntimePython(Runtime):
             Status of the executed run.
         """
         LOGGER.info("Validating task.")
-        self._validate_task(run)
+        action = self._validate_task(run)
+        executable = self._get_executable(action)
 
         LOGGER.info("Starting task.")
         spec = run.get("spec")
         project = run.get("project")
 
-        LOGGER.info("Configuring execution.")
-        fnc, wrapped = self._configure_execution(spec)
+        LOGGER.info("Collecting inputs.")
+        fnc_args = self._collect_inputs(spec)
 
-        LOGGER.info("Composing function arguments.")
-        fnc_args = self._compose_args(fnc, spec, project)
+        LOGGER.info("Configuring execution.")
+        fnc = self._configure_execution(spec)
 
         LOGGER.info("Executing run.")
-        if wrapped:
-            results: dict = self._execute(fnc, project, **fnc_args)
-        else:
-            exec_result = self._execute(fnc, **fnc_args)
-            LOGGER.info("Collecting outputs.")
-            results = parse_outputs(exec_result, list(spec.get("outputs", {})), project)
+        results = self._execute(executable, fnc, project, **fnc_args)
 
-        status = build_status(results, spec.get("outputs"))
+        LOGGER.info("Collecting outputs.")
+        status = build_status(
+            results,
+            spec.get("outputs", {}),
+            spec.get("values", {}),
+        )
 
         # Return run status
         LOGGER.info("Task completed, returning run status.")
@@ -109,51 +105,57 @@ class RuntimePython(Runtime):
         Callable
             Function to execute.
         """
+        if action == "job":
+            return run_python
         raise NotImplementedError
 
     ####################
-    # Configuration
+    # Inputs
     ####################
 
-    def _configure_execution(self, spec: dict) -> tuple[Callable, bool]:
+    def _collect_inputs(self, spec: dict) -> dict:
         """
-        Configure execution.
+        Collect inputs.
 
         Parameters
         ----------
         spec : dict
-            Run spec.
+            Run specs.
+        project : str
+            Project name.
 
         Returns
         -------
-        Callable
-            Function to execute.
+        dict
+            Parameters.
         """
-        fnc = get_function_from_source(
-            self.root,
-            spec.get("source", {}),
+        LOGGER.info("Getting inputs.")
+        self.tmp_path.mkdir(parents=True, exist_ok=True)
+        return get_inputs_parameters(
+            spec.get("inputs", {}),
+            spec.get("parameters", {}),
+            self.tmp_path,
         )
-        return fnc, hasattr(fnc, "__wrapped__")
 
-    def _compose_args(self, func: Callable, spec: dict, project: str) -> dict:
+    ####################
+    # Configuration
+    ####################
+
+    def _configure_execution(self, spec: dict) -> Callable:
         """
-        Collect inputs.
+        Configure execution.
 
         Parameters
         ----------
-        func : Callable
-            Function to execute.
         spec : dict
-            Run specs.
-        project : str
-            Project name.
+            Run spec.
 
         Returns
         -------
-        dict
-            Parameters.
+        Callable
+            Function to execute.
         """
-        inputs = spec.get("inputs", {})
-        parameters = spec.get("parameters", {})
-        local_execution = spec.get("local_execution")
-        return compose_inputs(inputs, parameters, local_execution, func, project)
+        return get_function_from_source(
+            self.root_path,
+            spec.get("source", {}),
+        )

{digitalhub_runtime_python-0.5.0 → digitalhub_runtime_python-0.5.0b5}/digitalhub_runtime_python/utils/configuration.py

@@ -13,7 +13,6 @@ from digitalhub_core.utils.generic_utils import (
 )
 from digitalhub_core.utils.git_utils import clone_repository
 from digitalhub_core.utils.logger import LOGGER
-from digitalhub_core.utils.uri_utils import map_uri_scheme
 
 
 def get_function_from_source(path: Path, source_spec: dict) -> Callable:
@@ -34,35 +33,14 @@ def get_function_from_source(path: Path, source_spec: dict) -> Callable:
     """
     try:
         function_code = save_function_source(path, source_spec)
-        handler_path, function_name = parse_handler(source_spec["handler"])
-        function_path = (function_code / handler_path).with_suffix(".py")
-        return import_function(function_path, function_name)
+        handler = source_spec["handler"]
+        return import_function(function_code, handler)
     except Exception as e:
         msg = f"Some error occurred while getting function. Exception: {e.__class__}. Error: {e.args}"
         LOGGER.exception(msg)
         raise RuntimeError(msg) from e
 
 
-def parse_handler(handler: str) -> tuple:
-    """
-    Parse handler.
-
-    Parameters
-    ----------
-    handler : str
-        Function handler
-
-    Returns
-    -------
-    str
-        Function handler.
-    """
-    parsed = handler.split(":")
-    if len(parsed) == 1:
-        return Path(""), parsed[0]
-    return Path(*parsed[0].split(".")), parsed[1]
-
-
 def save_function_source(path: Path, source_spec: dict) -> Path:
     """
     Save function source.
@@ -85,45 +63,38 @@ def save_function_source(path: Path, source_spec: dict) -> Path:
     # Get relevant information
     base64 = source_spec.get("base64")
     source = source_spec.get("source")
+    handler = source_spec.get("handler")
 
-    scheme = None
-    if source is not None:
-        scheme = map_uri_scheme(source)
-
-    # Base64
     if base64 is not None:
-        filename = "main.py"
-        if scheme == "local":
-            filename = Path(source).name
-
-        base64_path = path / filename
-        base64_path.write_text(decode_base64(base64))
+        path = path / "main.py"
+        path.write_text(decode_base64(base64))
+        return path
 
-        if scheme is None or scheme == "local":
-            return base64_path
-
-    # Git repo
-    if scheme == "git":
-        get_repository(path, source)
+    scheme = source.split("://")[0]
 
     # Http(s) or s3 presigned urls
-    elif scheme == "remote":
+    if scheme in ["http", "https"]:
         filename = path / "archive.zip"
         get_remote_source(source, filename)
         unzip(path, filename)
+        return path / handler
+
+    # Git repo
+    if scheme == "git+https":
+        path = path / "repository"
+        get_repository(path, source)
+        return path / handler
 
     # S3 path
-    elif scheme == "s3":
+    if scheme == "zip+s3":
         filename = path / "archive.zip"
         bucket, key = get_bucket_and_key(source)
         get_s3_source(bucket, key, filename)
         unzip(path, filename)
+        return path / handler
 
     # Unsupported scheme
-    else:
-        raise RuntimeError(f"Unsupported scheme: {scheme}")
-
-    return path
+    raise RuntimeError(f"Unsupported scheme: {scheme}")
 
 
 def get_remote_source(source: str, filename: Path) -> None:

digitalhub_runtime_python-0.5.0b5/digitalhub_runtime_python/utils/functions.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+from typing import Callable
+
+
+def run_python(func: Callable, *args, **kwargs) -> dict:
+    """
+    Execute function.
+
+    Parameters
+    ----------
+    func : Callable
+        Function.
+    args : tuple
+        Function arguments.
+    kwargs : dict
+        Function keyword arguments.
+
+    Returns
+    -------
+    dict
+        Outputs from the function.
+    """
+    return func(*args, **kwargs)

digitalhub_runtime_python-0.5.0b5/digitalhub_runtime_python/utils/inputs.py

@@ -0,0 +1,153 @@
+from __future__ import annotations
+
+import typing
+from pathlib import Path
+
+from digitalhub_core.entities.artifacts.crud import artifact_from_dict
+from digitalhub_core.utils.exceptions import EntityError
+from digitalhub_core.utils.generic_utils import parse_entity_key
+from digitalhub_core.utils.logger import LOGGER
+from digitalhub_data.entities.dataitems.crud import dataitem_from_dict
+from digitalhub_ml.entities.models.crud import model_from_dict
+
+if typing.TYPE_CHECKING:
+    from digitalhub_core.entities._base.entity import Entity
+    from digitalhub_core.entities.artifacts.entity import Artifact
+    from digitalhub_data.entities.dataitems.entity._base import Dataitem
+    from digitalhub_ml.entities.models.entity import Model
+    from pandas import DataFrame
+
+
+def persist_dataitem(dataitem: Dataitem, tmp_dir: Path) -> str:
+    """
+    Persist dataitem locally.
+
+    Parameters
+    ----------
+    dataitem : Dataitem
+        The dataitem to persist.
+    tmp_dir : Path
+        Temporary download directory.
+
+    Returns
+    -------
+    str
+        Temporary dataitem path.
+
+    Raises
+    ------
+    EntityError
+        If the dataitem cannot be persisted.
+    """
+    name = dataitem.name
+    try:
+        LOGGER.info(f"Persisting dataitem '{name}' locally.")
+        tmp_path = tmp_dir / f"{name}.csv"
+        dataframe: DataFrame = dataitem.as_df()
+        dataframe.to_csv(tmp_path, sep=",", index=False)
+        return str(tmp_path)
+    except Exception as e:
+        msg = f"Error during dataitem '{name}' collection. Exception: {e.__class__}. Error: {e.args}"
+        LOGGER.exception(msg)
+        raise EntityError(msg) from e
+
+
+def persist_artifact(artifact: Artifact, tmp_dir: Path) -> str:
+    """
+    Persist artifact locally.
+
+    Parameters
+    ----------
+    artifact : Artifact
+        The artifact object.
+    tmp_dir : Path
+        Temporary directory.
+
+    Returns
+    -------
+    str
+        Temporary artifact path.
+
+    Raises
+    ------
+    EntityError
+        If the artifact cannot be persisted.
+    """
+    name = artifact.name
+    try:
+        LOGGER.info(f"Persisting artifact '{name}' locally.")
+        filename = Path(artifact.spec.path).name
+        dst = tmp_dir / filename
+        tmp_path = artifact.download(dst=dst)
+        return str(tmp_path)
+    except Exception as e:
+        msg = f"Error during artifact '{name}' collection. Exception: {e.__class__}. Error: {e.args}"
+        LOGGER.exception(msg)
+        raise EntityError(msg) from e
+
+
+def persist_model(model: Model, tmp_dir: Path) -> str:
+    """
+    Persist model locally.
+
+    Parameters
+    ----------
+    model : Model
+        The model object.
+    tmp_dir : Path
+        Temporary directory.
+
+    Returns
+    -------
+    str
+        Temporary model path.
+
+    Raises
+    ------
+    EntityError
+        If the model cannot be persisted.
+    """
+    name = model.name
+    try:
+        LOGGER.info(f"Persisting model '{name}' locally.")
+        filename = Path(model.spec.path).name
+        dst = tmp_dir / filename
+        tmp_path = model.download(dst=dst)
+        return str(tmp_path)
+    except Exception as e:
+        msg = f"Error during model '{name}' collection. Exception: {e.__class__}. Error: {e.args}"
+        LOGGER.exception(msg)
+        raise EntityError(msg) from e
+
+
+def get_inputs_parameters(inputs: dict[str, Entity], parameters: dict, tmp_dir: Path) -> dict:
+    """
+    Set inputs.
+
+    Parameters
+    ----------
+    inputs : dict[str, Entity]
+        Run inputs.
+    parameters : dict
+        Run parameters.
+    tmp_dir : Path
+        Temporary directory for storing dataitms and artifacts.
+
+    Returns
+    -------
+    dict
+        Mlrun inputs.
+    """
+    inputs_objects = {}
+    for k, v in inputs.items():
+        _, entity_type, _, _, _ = parse_entity_key(v.get("key"))
+        if entity_type == "dataitems":
+            v = dataitem_from_dict(v)
+            inputs_objects[k] = persist_dataitem(v, tmp_dir)
+        elif entity_type == "artifacts":
+            v = artifact_from_dict(v)
+            inputs_objects[k] = persist_artifact(v, tmp_dir)
+        elif entity_type == "models":
+            v = model_from_dict(v)
+            inputs_objects[k] = persist_model(v, tmp_dir)
+    return {**inputs_objects, **parameters}

{digitalhub_runtime_python-0.5.0 → digitalhub_runtime_python-0.5.0b5}/digitalhub_runtime_python/utils/outputs.py

@@ -1,16 +1,19 @@
 from __future__ import annotations
 
 import pickle
+import typing
 from typing import Any
 
 from digitalhub_core.entities._base.status import State
 from digitalhub_core.entities.artifacts.crud import new_artifact
-from digitalhub_core.entities.artifacts.entity import Artifact
 from digitalhub_core.utils.logger import LOGGER
 from digitalhub_data.entities.dataitems.crud import new_dataitem
-from digitalhub_data.entities.dataitems.entity.table import DataitemTable
 from digitalhub_data.readers.registry import DATAFRAME_TYPES
 
+if typing.TYPE_CHECKING:
+    from digitalhub_core.entities.artifacts.entity import Artifact
+    from digitalhub_data.entities.dataitems.entity.table import DataitemTable
+
 
 def collect_outputs(results: Any, outputs: list[str], project_name: str) -> dict:
     """
@@ -49,32 +52,6 @@ def collect_outputs(results: Any, outputs: list[str], project_name: str) -> dict
     return objects
 
 
-def parse_outputs(results: Any, run_outputs: list, project_name: str) -> dict:
-    """
-    Parse outputs.
-
-    Parameters
-    ----------
-    results : Any
-        Function outputs.
-    project : Project
-        Project object.
-
-    Returns
-    -------
-    dict
-        Function outputs.
-    """
-    results_list = listify_results(results)
-    out_list = []
-    for idx, _ in enumerate(results_list):
-        try:
-            out_list.append(run_outputs.pop(0))
-        except IndexError:
-            out_list.append(f"output_{idx}")
-    return collect_outputs(results, out_list, project_name)
-
-
 def listify_results(results: Any) -> list:
     """
     Listify results.
@@ -165,6 +142,7 @@ def build_and_load_artifact(name: str, project_name: str, data: Any) -> Artifact
 def build_status(
     parsed_execution: dict,
     mapped_outputs: dict | None = None,
+    values_list: list | None = None,
 ) -> dict:
     """
     Collect outputs.
@@ -175,24 +153,31 @@ def build_status(
         Parsed execution dict.
     mapped_outputs : dict
         Mapped outputs.
+    values_list : list
+        Values list.
 
     Returns
     -------
     dict
         Status dict.
     """
-    results = {}
     outputs = {}
     if mapped_outputs is None:
         mapped_outputs = {}
 
+    results = {}
+    if values_list is None:
+        values_list = []
+
     try:
-        for key, _ in mapped_outputs.items():
+        for key, value in mapped_outputs.items():
             if key in parsed_execution:
-                if isinstance(parsed_execution[key], (DataitemTable, Artifact)):
-                    outputs[key] = parsed_execution[key].key
-                else:
-                    results[key] = parsed_execution[key]
+                outputs[key] = parsed_execution[key].key
+
+        for value in values_list:
+            if value in parsed_execution:
+                results[value] = parsed_execution[value]
+
         return {
             "state": State.COMPLETED.value,
             "outputs": outputs,

{digitalhub_runtime_python-0.5.0 → digitalhub_runtime_python-0.5.0b5}/digitalhub_runtime_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: digitalhub-runtime-python
-Version: 0.5.0
+Version: 0.5.0b5
 Summary: Python runtime for DHCore
 Author-email: Fondazione Bruno Kessler <dslab@fbk.eu>, Matteo Martini <mmartini@fbk.eu>
 License:                               Apache License

{digitalhub_runtime_python-0.5.0 → digitalhub_runtime_python-0.5.0b5}/digitalhub_runtime_python.egg-info/SOURCES.txt

@@ -9,19 +9,22 @@ digitalhub_runtime_python.egg-info/requires.txt
 digitalhub_runtime_python.egg-info/top_level.txt
 digitalhub_runtime_python/entities/__init__.py
 digitalhub_runtime_python/entities/functions/__init__.py
+digitalhub_runtime_python/entities/functions/metadata.py
 digitalhub_runtime_python/entities/functions/spec.py
 digitalhub_runtime_python/entities/functions/status.py
 digitalhub_runtime_python/entities/runs/__init__.py
+digitalhub_runtime_python/entities/runs/metadata.py
 digitalhub_runtime_python/entities/runs/spec.py
 digitalhub_runtime_python/entities/runs/status.py
 digitalhub_runtime_python/entities/tasks/__init__.py
+digitalhub_runtime_python/entities/tasks/metadata.py
 digitalhub_runtime_python/entities/tasks/models.py
 digitalhub_runtime_python/entities/tasks/spec.py
 digitalhub_runtime_python/entities/tasks/status.py
 digitalhub_runtime_python/runtimes/__init__.py
-digitalhub_runtime_python/runtimes/kind_registry.py
 digitalhub_runtime_python/runtimes/runtime.py
 digitalhub_runtime_python/utils/configuration.py
+digitalhub_runtime_python/utils/functions.py
 digitalhub_runtime_python/utils/inputs.py
 digitalhub_runtime_python/utils/outputs.py
 digitalhub_runtime_python/utils/utils.py

{digitalhub_runtime_python-0.5.0 → digitalhub_runtime_python-0.5.0b5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "digitalhub-runtime-python"
-version = "0.5.0"
+version = "0.5.0b5"
 description = "Python runtime for DHCore"
 readme = "README.md"
 authors = [
@@ -39,7 +39,7 @@ line-length = 120
 convention = "numpy"
 
 [tool.bumpver]
-current_version = "0.5.0"
+current_version = "0.5.0b5"
 version_pattern = "MAJOR.MINOR.PATCH[PYTAGNUM]"
 commit_message  = "Bump version {old_version} -> {new_version}"
 commit          = false

digitalhub_runtime_python-0.5.0/digitalhub_runtime_python/entities/runs/spec.py

@@ -1,81 +0,0 @@
-from __future__ import annotations
-
-from digitalhub_ml.entities.runs.spec import RunParamsMl, RunSpecMl
-
-
-class RunSpecPython(RunSpecMl):
-    """Run Python specification."""
-
-    def __init__(
-        self,
-        task: str,
-        local_execution: bool = False,
-        **kwargs,
-    ) -> None:
-        """
-        Constructor.
-        """
-        super().__init__(task, local_execution)
-
-        self.source = kwargs.get("source")
-        self.image = kwargs.get("image")
-        self.base_image = kwargs.get("base_image")
-        self.python_version = kwargs.get("python_version")
-        self.requirements = kwargs.get("requirements")
-
-        self.function = kwargs.get("function")
-        self.node_selector = kwargs.get("node_selector")
-        self.volumes = kwargs.get("volumes")
-        self.resources = kwargs.get("resources")
-        self.affinity = kwargs.get("affinity")
-        self.tolerations = kwargs.get("tolerations")
-        self.env = kwargs.get("env")
-        self.secrets = kwargs.get("secrets")
-        self.backoff_limit = kwargs.get("backoff_limit")
-        self.schedule = kwargs.get("schedule")
-        self.replicas = kwargs.get("replicas")
-
-        # Task job
-
-        # Task build
-        self.instructions = kwargs.get("instructions")
-
-        self.inputs = kwargs.get("inputs")
-        self.outputs = kwargs.get("outputs")
-        self.parameters = kwargs.get("parameters")
-
-
-class RunParamsPython(RunParamsMl):
-    """Run Python parameters."""
-
-    # Function parameters
-    source: dict = None
-    image: str = None
-    base_image: str = None
-    python_version: str = None
-    requirements: list = None
-
-    # Task parameters
-    function: str = None
-    node_selector: list[dict] = None
-    volumes: list[dict] = None
-    resources: list[dict] = None
-    affinity: dict = None
-    tolerations: list[dict] = None
-    env: list[dict] = None
-    secrets: list[str] = None
-
-    # Task job
-    backoff_limit: int = None
-
-    # Task serve
-    service_type: str = None
-    replicas: int = None
-
-    # Task build
-    instructions: list[str] = None
-
-    # Run parameters
-    inputs: dict = None
-    outputs: dict = None
-    parameters: dict = None

digitalhub_runtime_python-0.5.0/digitalhub_runtime_python/entities/tasks/spec.py

@@ -1,87 +0,0 @@
-"""
-Task Python specification module.
-"""
-from __future__ import annotations
-
-from typing import Literal
-
-from digitalhub_core.entities.tasks.spec import TaskParamsK8s, TaskSpecK8s
-
-
-class TaskSpecJob(TaskSpecK8s):
-    """Task Job specification."""
-
-    def __init__(
-        self,
-        function: str,
-        **kwargs,
-    ) -> None:
-        """
-        Constructor.
-        """
-        super().__init__(function, **kwargs)
-
-        self.backoff_limit = kwargs.get("backoff_limit")
-
-
-class TaskParamsJob(TaskParamsK8s):
-    """
-    TaskParamsJob model.
-    """
-
-    backoff_limit: int = None
-    """Backoff limit."""
-
-
-class TaskSpecBuild(TaskSpecK8s):
-    """Task Build specification."""
-
-    def __init__(
-        self,
-        function: str,
-        instructions: list | None = None,
-        **kwargs,
-    ) -> None:
-        """
-        Constructor.
-        """
-        super().__init__(function, **kwargs)
-
-        self.instructions = instructions
-
-
-class TaskParamsBuild(TaskParamsK8s):
-    """
-    TaskParamsBuild model.
-    """
-
-    instructions: list[str] = None
-    """Build instructions."""
-
-
-class TaskSpecServe(TaskSpecK8s):
-    """Task Serve specification."""
-
-    def __init__(
-        self,
-        function: str,
-        replicas: int | None = None,
-        service_type: str | None = None,
-        **kwargs,
-    ) -> None:
-        """
-        Constructor.
-        """
-        super().__init__(function, **kwargs)
-
-        self.replicas = replicas
-        self.service_type = service_type
-
-
-class TaskParamsServe(TaskParamsK8s):
-    """
-    TaskParamsServe model.
-    """
-
-    replicas: int = None
-    service_type: Literal["ClusterIP", "NodePort", "LoadBalancer"] = "NodePort"

digitalhub_runtime_python-0.5.0/digitalhub_runtime_python/runtimes/kind_registry.py

@@ -1,15 +0,0 @@
-from __future__ import annotations
-
-from digitalhub_core.runtimes.kind_registry import KindRegistry
-
-kind_registry = KindRegistry(
-    {
-        "executable": {"kind": "python"},
-        "task": [
-            {"kind": "python+job", "action": "job"},
-            {"kind": "python+serve", "action": "serve"},
-            {"kind": "python+build", "action": "build"},
-        ],
-        "run": {"kind": "python+run"},
-    }
-)

digitalhub_runtime_python-0.5.0/digitalhub_runtime_python/utils/inputs.py

@@ -1,149 +0,0 @@
-from __future__ import annotations
-
-import inspect
-import typing
-from typing import Any, Callable
-
-from digitalhub_core.context.builder import get_context
-from digitalhub_core.entities.artifacts.crud import artifact_from_dict
-from digitalhub_core.utils.generic_utils import parse_entity_key
-from digitalhub_core.utils.logger import LOGGER
-from digitalhub_data.entities.dataitems.crud import dataitem_from_dict
-from digitalhub_ml.entities.entity_types import EntityTypes
-from digitalhub_ml.entities.models.crud import model_from_dict
-from digitalhub_ml.entities.projects.crud import get_project
-
-if typing.TYPE_CHECKING:
-    from digitalhub_core.entities._base.entity import Entity
-    from digitalhub_core.entities.projects.entity import Project
-
-
-def get_project_(project_name: str) -> Project:
-    """
-    Get project.
-
-    Parameters
-    ----------
-    project_name : str
-        Project name.
-
-    Returns
-    -------
-    Project
-        Project.
-    """
-    try:
-        ctx = get_context(project_name)
-        return get_project(project_name, local=ctx.local)
-    except Exception as e:
-        msg = f"Error during project collection. Exception: {e.__class__}. Error: {e.args}"
-        LOGGER.exception(msg)
-        raise RuntimeError(msg)
-
-
-def get_entity_inputs(inputs: dict) -> dict[str, Entity]:
-    """
-    Set inputs.
-
-    Parameters
-    ----------
-    inputs : dict
-        Run inputs.
-    parameters : dict
-        Run parameters.
-    tmp_dir : Path
-        Temporary directory for storing dataitms and artifacts.
-
-    Returns
-    -------
-    dict
-        Mlrun inputs.
-    """
-    try:
-        inputs_objects = {}
-        for k, v in inputs.items():
-            _, entity_type, _, _, _ = parse_entity_key(v.get("key"))
-            if entity_type == EntityTypes.DATAITEMS.value:
-                inputs_objects[k] = dataitem_from_dict(v)
-            elif entity_type == EntityTypes.ARTIFACTS.value:
-                inputs_objects[k] = artifact_from_dict(v)
-            elif entity_type == EntityTypes.MODELS.value:
-                inputs_objects[k] = model_from_dict(v)
-        return inputs_objects
-    except Exception as e:
-        msg = f"Error during inputs collection. Exception: {e.__class__}. Error: {e.args}"
-        LOGGER.exception(msg)
-        raise RuntimeError(msg) from e
-
-
-def compose_inputs(
-    inputs: dict,
-    parameters: dict,
-    local_execution: bool,
-    func: Callable,
-    project: str | Project,
-    context: Any | None = None,
-    event: Any | None = None,
-) -> dict:
-    """
-    Compose inputs.
-
-    Parameters
-    ----------
-    inputs : dict
-        Run inputs.
-    parameters : dict
-        Run parameters.
-    local_execution : bool
-        Local execution.
-    func : Callable
-        Function to execute.
-    project : str
-        Project name.
-    context : nuclio_sdk.Context
-        Nuclio context.
-    event : nuclio_sdk.Event
-        Nuclio event.
-
-    Returns
-    -------
-    dict
-        Function inputs.
-    """
-    try:
-        entity_inputs = get_entity_inputs(inputs)
-        fnc_args = {**parameters, **entity_inputs}
-
-        fnc_parameters = inspect.signature(func).parameters
-        LOGGER.info(f"Function parameters: {'project' in fnc_parameters}")
-
-        _has_project = "project" in fnc_parameters
-        _has_context = "context" in fnc_parameters
-        _has_event = "event" in fnc_parameters
-
-        if _has_project:
-            if _has_context:
-                fnc_args["project"] = context.project
-            elif isinstance(project, str):
-                fnc_args["project"] = get_project_(project)
-            else:
-                fnc_args["project"] = project
-
-        if _has_context:
-            if context is not None and not local_execution:
-                fnc_args["context"] = context
-            else:
-                raise RuntimeError("Context is not available on local execution.")
-
-        if _has_event:
-            if event is not None and not local_execution:
-                fnc_args["event"] = event
-            else:
-                raise RuntimeError("Event is not available on local execution.")
-
-        return fnc_args
-
-    except Exception as e:
-        msg = f"Error during function arguments compostion. Exception: {e.__class__}. Error: {e.args}"
-        LOGGER.exception(msg)
-        raise RuntimeError(msg) from e