digitalhub-runtime-python 0.5.0__py3-none-any.whl

digitalhub_runtime_python/__init__.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+from digitalhub_core.entities.entity_types import EntityTypes
+from digitalhub_core.registry.registry import registry
+from digitalhub_core.registry.utils import create_info
+from digitalhub_runtime_python.utils.utils import handler
+
+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"
+
+
+# Function
+entity_type = EntityTypes.FUNCTIONS.value
+func_kind = "python"
+prefix = entity_type.removesuffix("s").capitalize()
+suffix = func_kind.capitalize()
+func_info = create_info(root_ent, entity_type, prefix, suffix, runtime_info)
+registry.register(func_kind, func_info)
+
+
+# Tasks
+entity_type = EntityTypes.TASKS.value
+for i in ["job", "build"]:
+    task_kind = f"{func_kind}+{i}"
+    prefix = entity_type.removesuffix("s").capitalize()
+    suffix = i.capitalize()
+    task_info = create_info(root_ent, entity_type, prefix, suffix, runtime_info)
+    registry.register(task_kind, task_info)
+
+
+# Runs
+entity_type = EntityTypes.RUNS.value
+run_kind = f"{func_kind}+run"
+prefix = entity_type.removesuffix("s").capitalize()
+suffix = func_kind.capitalize()
+run_info = create_info(root_ent, entity_type, prefix, suffix, runtime_info)
+registry.register(run_kind, run_info)

digitalhub_runtime_python/entities/functions/spec.py

@@ -0,0 +1,144 @@
+"""
+Function Conatiner specification module.
+"""
+from __future__ import annotations
+
+from pathlib import Path
+
+from digitalhub_core.entities.functions.spec import FunctionParams, FunctionSpec, SourceCodeStruct
+from digitalhub_core.utils.exceptions import EntityError
+from digitalhub_core.utils.generic_utils import decode_string, encode_source, encode_string
+from digitalhub_core.utils.uri_utils import map_uri_scheme
+
+
+class FunctionSpecPython(FunctionSpec):
+    """
+    Specification for a Function job.
+    """
+
+    def __init__(
+        self,
+        source: dict,
+        image: str | None = None,
+        base_image: str | None = None,
+        python_version: str | None = None,
+        requirements: list | None = None,
+    ) -> None:
+        """
+        Constructor.
+        """
+        super().__init__()
+
+        self.image = image
+        self.base_image = base_image
+        self.python_version = python_version
+        self.requirements = requirements
+
+        source = self._source_check(source)
+        self.source = SourceCodeStruct(**source)
+
+    @staticmethod
+    def _source_check(source: dict) -> dict:
+        """
+        Check source.
+
+        Parameters
+        ----------
+        source : dict
+            Source.
+
+        Returns
+        -------
+        dict
+            Checked source.
+        """
+        if source is None:
+            raise EntityError("Source must be provided.")
+
+        # Source check
+        source_path = source.get("source")
+        code = source.get("code")
+        base64 = source.get("base64")
+        handler = source.get("handler")
+        source["lang"] = "python"
+
+        if handler is None:
+            raise EntityError("Handler must be provided.")
+
+        if source_path is None and code is None and base64 is None:
+            raise EntityError("Source must be provided.")
+
+        if base64 is not None:
+            return source
+
+        if code is not None:
+            source["base64"] = encode_string(code)
+            return source
+
+        if source_path is not None:
+            if map_uri_scheme(source_path) == "local":
+                if not (Path(source_path).suffix == ".py" and Path(source_path).is_file()):
+                    raise EntityError("Source is not a valid python file.")
+                source["base64"] = encode_source(source_path)
+            else:
+                if handler is None:
+                    raise EntityError("Handler must be provided if source is not local.")
+
+        return source
+
+    def show_source_code(self) -> str:
+        """
+        Show source code.
+
+        Returns
+        -------
+        str
+            Source code.
+        """
+        if self.source.code is not None:
+            return str(self.source.code)
+        if self.source.base64 is not None:
+            try:
+                return decode_string(self.source.base64)
+            except Exception:
+                raise EntityError("Something got wrong during source code decoding.")
+        if (self.source.source is not None) and (map_uri_scheme(self.source.source) == "local"):
+            try:
+                return Path(self.source.source).read_text()
+            except Exception:
+                raise EntityError("Cannot access source code.")
+        return ""
+
+    def to_dict(self) -> dict:
+        """
+        Override to_dict to exclude code from source.
+
+        Returns
+        -------
+        dict
+            Dictionary representation of the object.
+        """
+        dict_ = super().to_dict()
+        dict_["source"] = self.source.to_dict()
+        return dict_
+
+
+class FunctionParamsPython(FunctionParams):
+    """
+    Function python parameters model.
+    """
+
+    source: dict
+    "Source code"
+
+    image: str = None
+    "Image"
+
+    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/entities/functions/status.py

@@ -0,0 +1,9 @@
+from __future__ import annotations
+
+from digitalhub_core.entities.functions.status import FunctionStatus
+
+
+class FunctionStatusPython(FunctionStatus):
+    """
+    Function Python status.
+    """

digitalhub_runtime_python/entities/runs/spec.py

@@ -0,0 +1,81 @@
+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/entities/runs/status.py

@@ -0,0 +1,9 @@
+from __future__ import annotations
+
+from digitalhub_ml.entities.runs.status import RunStatusMl
+
+
+class RunStatusPython(RunStatusMl):
+    """
+    Run Python status.
+    """

digitalhub_runtime_python/entities/tasks/models.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+
+class CorePort(BaseModel):
+    """
+    Port mapper model.
+    """
+
+    port: int
+    target_port: int
+
+
+class ContextRef(BaseModel):
+    """
+    ContextRef model.
+    """
+
+    destination: str = None
+    protocol: str = None
+    source: str = None
+
+
+class ContextSource(BaseModel):
+    """
+    ContextSource model.
+    """
+
+    base64: str = None
+    name: str = None

digitalhub_runtime_python/entities/tasks/spec.py

@@ -0,0 +1,87 @@
+"""
+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/entities/tasks/status.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+from digitalhub_core.entities.tasks.status import TaskStatus
+
+
+class TaskStatusJob(TaskStatus):
+    """
+    Task Job status.
+    """
+
+
+class TaskStatusBuild(TaskStatus):
+    """
+    Task Build status.
+    """

digitalhub_runtime_python/runtimes/kind_registry.py

@@ -0,0 +1,15 @@
+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/runtimes/runtime.py

@@ -0,0 +1,159 @@
+"""
+Runtime class for running Python functions.
+"""
+from __future__ import annotations
+
+import typing
+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
+
+
+class RuntimePython(Runtime):
+    """
+    Runtime Python class.
+    """
+
+    def __init__(self, kind_registry: KindRegistry, project: str) -> 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)
+
+    def build(self, function: dict, task: dict, run: dict) -> dict:
+        """
+        Build run spec.
+
+        Parameters
+        ----------
+        function : dict
+            The function.
+        task : dict
+            The task.
+        run : dict
+            The run.
+
+        Returns
+        -------
+        dict
+            The run spec.
+        """
+        return {
+            **function.get("spec", {}),
+            **task.get("spec", {}),
+            **run.get("spec", {}),
+        }
+
+    def run(self, run: dict) -> dict:
+        """
+        Run function.
+
+        Returns
+        -------
+        dict
+            Status of the executed run.
+        """
+        LOGGER.info("Validating task.")
+        self._validate_task(run)
+
+        LOGGER.info("Starting task.")
+        spec = run.get("spec")
+        project = run.get("project")
+
+        LOGGER.info("Configuring execution.")
+        fnc, wrapped = self._configure_execution(spec)
+
+        LOGGER.info("Composing function arguments.")
+        fnc_args = self._compose_args(fnc, spec, project)
+
+        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)
+
+        status = build_status(results, spec.get("outputs"))
+
+        # Return run status
+        LOGGER.info("Task completed, returning run status.")
+        return status
+
+    @staticmethod
+    def _get_executable(action: str) -> Callable:
+        """
+        Select function according to action.
+
+        Parameters
+        ----------
+        action : str
+            Action to execute.
+
+        Returns
+        -------
+        Callable
+            Function to execute.
+        """
+        raise NotImplementedError
+
+    ####################
+    # Configuration
+    ####################
+
+    def _configure_execution(self, spec: dict) -> tuple[Callable, bool]:
+        """
+        Configure execution.
+
+        Parameters
+        ----------
+        spec : dict
+            Run spec.
+
+        Returns
+        -------
+        Callable
+            Function to execute.
+        """
+        fnc = get_function_from_source(
+            self.root,
+            spec.get("source", {}),
+        )
+        return fnc, hasattr(fnc, "__wrapped__")
+
+    def _compose_args(self, func: Callable, spec: dict, project: str) -> dict:
+        """
+        Collect inputs.
+
+        Parameters
+        ----------
+        func : Callable
+            Function to execute.
+        spec : dict
+            Run specs.
+        project : str
+            Project name.
+
+        Returns
+        -------
+        dict
+            Parameters.
+        """
+        inputs = spec.get("inputs", {})
+        parameters = spec.get("parameters", {})
+        local_execution = spec.get("local_execution")
+        return compose_inputs(inputs, parameters, local_execution, func, project)