digitalhub-runtime-python 0.8.1__tar.gz → 0.9.0__tar.gz

{digitalhub_runtime_python-0.8.1 → digitalhub_runtime_python-0.9.0}/LICENSE.txt

@@ -186,7 +186,7 @@ APPENDIX: How to apply the Apache License to your work.
    same "printed page" as the copyright notice for easier
    identification within third-party archives.
 
-Copyright [yyyy] [name of copyright owner]
+Copyright 2024 DSLab, Fondazione Bruno Kessler
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.

{digitalhub_runtime_python-0.8.1 → digitalhub_runtime_python-0.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: digitalhub-runtime-python
-Version: 0.8.1
+Version: 0.9.0
 Summary: Python runtime for DHCore
 Author-email: Fondazione Bruno Kessler <dslab@fbk.eu>, Matteo Martini <mmartini@fbk.eu>
 License:                               Apache License
@@ -191,7 +191,7 @@ License:                               Apache License
            same "printed page" as the copyright notice for easier
            identification within third-party archives.
         
-        Copyright [yyyy] [name of copyright owner]
+        Copyright 2024 DSLab, Fondazione Bruno Kessler
         
         Licensed under the Apache License, Version 2.0 (the "License");
         you may not use this file except in compliance with the License.
@@ -229,6 +229,6 @@ Classifier: Programming Language :: Python :: 3.11
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE.txt
-Requires-Dist: digitalhub[full]<0.9,>=0.8.0
+Requires-Dist: digitalhub[full]<0.10,>=0.9.0b
 
 # SDK for DHCore

{digitalhub_runtime_python-0.8.1 → digitalhub_runtime_python-0.9.0}/digitalhub_runtime_python/__init__.py

@@ -1,5 +1,4 @@
-from __future__ import annotations
-
+from digitalhub_runtime_python.entities._commons.enums import EntityKinds
 from digitalhub_runtime_python.entities.function.python.builder import FunctionPythonBuilder
 from digitalhub_runtime_python.entities.run.python_run.builder import RunPythonRunBuilder
 from digitalhub_runtime_python.entities.task.python_build.builder import TaskPythonBuildBuilder
@@ -8,16 +7,16 @@ from digitalhub_runtime_python.entities.task.python_serve.builder import TaskPyt
 from digitalhub_runtime_python.utils.utils import handler
 
 entity_builders = (
-    (FunctionPythonBuilder.ENTITY_KIND, FunctionPythonBuilder),
-    (TaskPythonBuildBuilder.ENTITY_KIND, TaskPythonBuildBuilder),
-    (TaskPythonJobBuilder.ENTITY_KIND, TaskPythonJobBuilder),
-    (TaskPythonServeBuilder.ENTITY_KIND, TaskPythonServeBuilder),
-    (RunPythonRunBuilder.ENTITY_KIND, RunPythonRunBuilder),
+    (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_PYTHON.value, RunPythonRunBuilder),
 )
 
 try:
     from digitalhub_runtime_python.runtimes.builder import RuntimePythonBuilder
 
-    runtime_builders = ((kind, RuntimePythonBuilder) for kind in FunctionPythonBuilder().get_all_kinds())
+    runtime_builders = ((kind, RuntimePythonBuilder) for kind in [e.value for e in EntityKinds])
 except ImportError:
     runtime_builders = tuple()

digitalhub_runtime_python-0.9.0/digitalhub_runtime_python/entities/_base/runtime_entity/builder.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+from digitalhub.entities._base.runtime_entity.builder import RuntimeEntityBuilder
+from digitalhub.entities.task._base.utils import build_task_actions
+
+from digitalhub_runtime_python.entities._commons.enums import EntityKinds, TaskActions
+
+
+class RuntimeEntityBuilderPython(RuntimeEntityBuilder):
+    EXECUTABLE_KIND = EntityKinds.FUNCTION_PYTHON.value
+    TASKS_KINDS = build_task_actions(
+        [
+            (
+                EntityKinds.TASK_PYTHON_JOB.value,
+                TaskActions.JOB.value,
+            ),
+            (
+                EntityKinds.TASK_PYTHON_BUILD.value,
+                TaskActions.BUILD.value,
+            ),
+            (
+                EntityKinds.TASK_PYTHON_SERVE.value,
+                TaskActions.SERVE.value,
+            ),
+        ]
+    )
+    RUN_KIND = EntityKinds.RUN_PYTHON.value

digitalhub_runtime_python-0.9.0/digitalhub_runtime_python/entities/_commons/enums.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+from enum import Enum
+
+
+class EntityKinds(Enum):
+    """
+    Entity kinds.
+    """
+
+    FUNCTION_PYTHON = "python"
+    TASK_PYTHON_BUILD = "python+build"
+    TASK_PYTHON_JOB = "python+job"
+    TASK_PYTHON_SERVE = "python+serve"
+    RUN_PYTHON = "python+run"
+
+
+class TaskActions(Enum):
+    """
+    Task actions.
+    """
+
+    BUILD = "build"
+    JOB = "job"
+    SERVE = "serve"

digitalhub_runtime_python-0.9.0/digitalhub_runtime_python/entities/function/python/builder.py

@@ -0,0 +1,90 @@
+from __future__ import annotations
+
+from digitalhub.entities.function._base.builder import FunctionBuilder
+
+from digitalhub_runtime_python.entities._base.runtime_entity.builder import RuntimeEntityBuilderPython
+from digitalhub_runtime_python.entities._commons.enums import EntityKinds
+from digitalhub_runtime_python.entities.function.python.entity import FunctionPython
+from digitalhub_runtime_python.entities.function.python.spec import FunctionSpecPython, FunctionValidatorPython
+from digitalhub_runtime_python.entities.function.python.status import FunctionStatusPython
+from digitalhub_runtime_python.entities.function.python.utils import source_check, source_post_check
+
+
+class FunctionPythonBuilder(FunctionBuilder, RuntimeEntityBuilderPython):
+    """
+    FunctionPython builder.
+    """
+
+    ENTITY_CLASS = FunctionPython
+    ENTITY_SPEC_CLASS = FunctionSpecPython
+    ENTITY_SPEC_VALIDATOR = FunctionValidatorPython
+    ENTITY_STATUS_CLASS = FunctionStatusPython
+    ENTITY_KIND = EntityKinds.FUNCTION_PYTHON.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,
+    ) -> FunctionPython:
+        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, validate: bool = True) -> FunctionPython:
+        """
+        Create a new object from dictionary.
+
+        Parameters
+        ----------
+        obj : dict
+            Dictionary to create object from.
+        validate : bool
+            Flag to indicate if arguments must be validated.
+
+        Returns
+        -------
+        FunctionPython
+            Object instance.
+        """
+        entity = super().from_dict(obj, validate=validate)
+        return source_post_check(entity)
+
+    def _parse_dict(self, obj: dict, validate: bool = True) -> dict:
+        """
+        Get dictionary and parse it to a valid entity dictionary.
+
+        Parameters
+        ----------
+        entity : str
+            Entity type.
+        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, validate=validate)

digitalhub_runtime_python-0.9.0/digitalhub_runtime_python/entities/function/python/entity.py

@@ -0,0 +1,67 @@
+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
+
+if typing.TYPE_CHECKING:
+    from digitalhub.entities._base.entity.metadata import Metadata
+
+    from digitalhub_runtime_python.entities.function.python.spec import FunctionSpecPython
+    from digitalhub_runtime_python.entities.function.python.status import FunctionStatusPython
+
+
+class FunctionPython(Function):
+    """
+    FunctionPython class.
+    """
+
+    def __init__(
+        self,
+        project: str,
+        name: str,
+        uuid: str,
+        kind: str,
+        metadata: Metadata,
+        spec: FunctionSpecPython,
+        status: FunctionStatusPython,
+        user: str | None = None,
+    ) -> None:
+        super().__init__(project, name, uuid, kind, metadata, spec, status, user)
+
+        self.spec: FunctionSpecPython
+        self.status: FunctionStatusPython
+
+    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()

digitalhub_runtime_python-0.9.0/digitalhub_runtime_python/entities/function/python/models.py

@@ -0,0 +1,49 @@
+from __future__ import annotations
+
+from enum import Enum
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class PythonVersion(Enum):
+    """
+    Python version supported.
+    """
+
+    PYTHON3_9 = "PYTHON3_9"
+    PYTHON3_10 = "PYTHON3_10"
+    PYTHON3_11 = "PYTHON3_11"
+
+
+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."""
+
+    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)."

digitalhub_runtime_python-0.9.0/digitalhub_runtime_python/entities/function/python/spec.py

@@ -0,0 +1,48 @@
+from __future__ import annotations
+
+from digitalhub.entities.function._base.spec import FunctionSpec, FunctionValidator
+
+from digitalhub_runtime_python.entities.function.python.models import PythonVersion, SourceValidator
+
+
+class FunctionSpecPython(FunctionSpec):
+    """
+    FunctionSpecPython specifications.
+    """
+
+    def __init__(
+        self,
+        source: 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
+
+
+class FunctionValidatorPython(FunctionValidator):
+    """
+    FunctionValidatorPython validator.
+    """
+
+    source: SourceValidator
+    """Source code validator"""
+
+    python_version: PythonVersion
+    "Python version"
+
+    image: str = None
+    "Image where the function will be executed"
+
+    base_image: str = None
+    "Base image used to build the image where the function will be executed"
+
+    requirements: list[str] = None
+    "Requirements list to be installed in the image where the function will be executed"

digitalhub_runtime_python-0.9.0/digitalhub_runtime_python/entities/function/python/utils.py

@@ -0,0 +1,152 @@
+from __future__ import annotations
+
+import typing
+from pathlib import Path
+
+from digitalhub.stores.api import get_store
+from digitalhub.utils.exceptions import EntityError
+from digitalhub.utils.file_utils import eval_py_type, eval_zip_type
+from digitalhub.utils.generic_utils import encode_source, encode_string
+from digitalhub.utils.s3_utils import get_s3_bucket
+from digitalhub.utils.uri_utils import has_local_scheme
+
+from digitalhub_runtime_python.entities.function.python.models import Lang
+
+if typing.TYPE_CHECKING:
+    from digitalhub_runtime_python.entities.function.python.entity import FunctionPython
+
+
+def source_check(**kwargs) -> dict:
+    """
+    Check source code.
+
+    Parameters
+    ----------
+    **kwargs
+        Keyword arguments.
+
+    Returns
+    -------
+    dict
+        Checked source.
+    """
+    source: dict = kwargs.pop("source", None)
+    code_src = kwargs.pop("code_src", None)
+    code = kwargs.pop("code", None)
+    base64 = kwargs.pop("base64", None)
+    handler = kwargs.pop("handler", None)
+    init_function = kwargs.pop("init_function", None)
+    lang = kwargs.pop("lang", None)
+
+    if source is not None:
+        code_src = source.pop("source", None)
+        code = source.pop("code", None)
+        base64 = source.pop("base64", None)
+        handler = source.pop("handler", None)
+        init_function = source.pop("init_function", None)
+        lang = source.pop("lang", None)
+
+    kwargs["source"] = _check_params(
+        code_src=code_src,
+        code=code,
+        base64=base64,
+        handler=handler,
+        init_function=init_function,
+        lang=lang,
+    )
+    return kwargs
+
+
+def _check_params(
+    code_src: str | None = None,
+    code: str | None = None,
+    base64: str | None = None,
+    handler: str | None = None,
+    init_function: str | None = None,
+    lang: str | None = None,
+) -> dict:
+    """
+    Check source.
+
+    Parameters
+    ----------
+    code_src : str
+        Source code source.
+    code : str
+        Source code.
+    base64 : str
+        Source code base64.
+    handler : str
+        Function handler.
+    init_function : str
+        Init function.
+    lang : str
+        Source code language.
+
+    Returns
+    -------
+    dict
+        Checked source.
+    """
+    source = {}
+
+    if handler is None:
+        raise EntityError("Handler must be provided.")
+    source["handler"] = handler
+
+    if init_function is not None:
+        source["init_function"] = init_function
+
+    if lang is None:
+        source["lang"] = Lang.PYTHON.value
+
+    if code_src is None and code is None and base64 is None:
+        raise EntityError("Source must be provided.")
+
+    if code_src is not None:
+        source["source"] = code_src
+
+    if base64 is not None:
+        source["base64"] = base64
+
+    if code is not None:
+        source["base64"] = encode_string(code)
+
+    return source
+
+
+def source_post_check(exec: FunctionPython) -> FunctionPython:
+    """
+    Post check source.
+
+    Parameters
+    ----------
+    exec : FunctionPython
+        Executable.
+
+    Returns
+    -------
+    FunctionPython
+        Updated executable.
+    """
+    code_src = exec.spec.source.get("source", None)
+    base64 = exec.spec.source.get("base64", None)
+    if code_src is None or base64 is not None:
+        return exec
+
+    # Check local source
+    if has_local_scheme(code_src) and Path(code_src).is_file():
+        # Check py
+        if eval_py_type(code_src):
+            exec.spec.source["base64"] = encode_source(code_src)
+
+        # Check zip
+        elif eval_zip_type(code_src):
+            filename = Path(code_src).name
+            dst = f"zip+s3://{get_s3_bucket()}/{exec.project}/{exec.ENTITY_TYPE}/{exec.name}/{exec.id}/{filename}"
+            get_store(dst).upload(code_src, dst)
+            exec.spec.source["source"] = dst
+            if ":" not in exec.spec.source["handler"]:
+                exec.spec.source["handler"] = f"{Path(code_src).stem}:{exec.spec.source['handler']}"
+
+    return exec

{digitalhub_runtime_python-0.8.1 → digitalhub_runtime_python-0.9.0}/digitalhub_runtime_python/entities/run/python_run/builder.py

@@ -1,12 +1,13 @@
 from __future__ import annotations
 
+from digitalhub.entities.run._base.builder import RunBuilder
+
 from digitalhub_runtime_python.entities._base.runtime_entity.builder import RuntimeEntityBuilderPython
+from digitalhub_runtime_python.entities._commons.enums import EntityKinds
 from digitalhub_runtime_python.entities.run.python_run.entity import RunPythonRun
 from digitalhub_runtime_python.entities.run.python_run.spec import RunSpecPythonRun, RunValidatorPythonRun
 from digitalhub_runtime_python.entities.run.python_run.status import RunStatusPythonRun
 
-from digitalhub.entities.run._base.builder import RunBuilder
-
 
 class RunPythonRunBuilder(RunBuilder, RuntimeEntityBuilderPython):
     """
@@ -17,4 +18,4 @@ class RunPythonRunBuilder(RunBuilder, RuntimeEntityBuilderPython):
     ENTITY_SPEC_CLASS = RunSpecPythonRun
     ENTITY_SPEC_VALIDATOR = RunValidatorPythonRun
     ENTITY_STATUS_CLASS = RunStatusPythonRun
-    ENTITY_KIND = "python+run"
+    ENTITY_KIND = EntityKinds.RUN_PYTHON.value

{digitalhub_runtime_python-0.8.1 → digitalhub_runtime_python-0.9.0}/digitalhub_runtime_python/entities/run/python_run/entity.py

@@ -5,22 +5,23 @@ import typing
 from typing import Any
 
 import requests
-from digitalhub_runtime_python.entities.run.python_run.utils import get_getter_for_material
-
+from digitalhub.entities._commons.enums import Relationship, State
+from digitalhub.entities._commons.utils import get_entity_type_from_key
 from digitalhub.entities.run._base.entity import Run
-from digitalhub.entities.utils.state import State
-from digitalhub.entities.utils.utils import get_entity_type_from_key
 from digitalhub.factory.api import get_action_from_task_kind
 from digitalhub.utils.exceptions import EntityError
 from digitalhub.utils.logger import LOGGER
 
-if typing.TYPE_CHECKING:
-    from digitalhub_runtime_python.entities.run.python_run.spec import RunSpecPythonRun
-    from digitalhub_runtime_python.entities.run.python_run.status import RunStatusPythonRun
+from digitalhub_runtime_python.entities._commons.enums import TaskActions
+from digitalhub_runtime_python.entities.run.python_run.utils import get_getter_for_material
 
+if typing.TYPE_CHECKING:
     from digitalhub.entities._base.entity.metadata import Metadata
     from digitalhub.entities._base.material.entity import MaterialEntity
 
+    from digitalhub_runtime_python.entities.run.python_run.spec import RunSpecPythonRun
+    from digitalhub_runtime_python.entities.run.python_run.status import RunStatusPythonRun
+
 
 class RunPythonRun(Run):
     """
@@ -51,7 +52,15 @@ class RunPythonRun(Run):
         None
         """
         self.refresh()
-        self.spec.inputs = self.inputs(as_dict=True)
+        inputs = self.inputs(as_dict=True)
+        if self.spec.local_execution:
+            for _, v in inputs.items():
+                self.add_relationship(
+                    relation=Relationship.CONSUMES.value,
+                    dest=v.get("key"),
+                )
+        self.save(update=True)
+        self.spec.inputs = inputs
 
     def wait(self, log_info: bool = True) -> Run:
         """
@@ -70,7 +79,7 @@ class RunPythonRun(Run):
         task_kind = self.spec.task.split("://")[0]
         action = get_action_from_task_kind(self.kind, task_kind)
 
-        if action == "serve":
+        if action == TaskActions.SERVE.value:
             serve_timeout = 300
             start = time.time()
 

{digitalhub_runtime_python-0.8.1 → digitalhub_runtime_python-0.9.0}/digitalhub_runtime_python/entities/run/python_run/spec.py

@@ -11,14 +11,17 @@ class RunSpecPythonRun(RunSpec):
         task: str,
         local_execution: bool = False,
         function: str | None = None,
-        node_selector: dict | None = None,
-        volumes: list | None = None,
+        workflow: str | None = None,
+        node_selector: list[dict] | None = None,
+        volumes: list[dict] | None = None,
         resources: dict | None = None,
         affinity: dict | None = None,
-        tolerations: list | None = None,
-        envs: list | None = None,
-        secrets: list | None = None,
+        tolerations: list[dict] | None = None,
+        envs: list[dict] | None = None,
+        secrets: list[str] | None = None,
         profile: str | None = None,
+        runtime_class: str | None = None,
+        priority_class: str | None = None,
         source: dict | None = None,
         image: str | None = None,
         base_image: str | None = None,
@@ -30,7 +33,6 @@ class RunSpecPythonRun(RunSpec):
         replicas: int | None = None,
         instructions: dict | None = None,
         inputs: dict | None = None,
-        outputs: dict | None = None,
         parameters: dict | None = None,
         **kwargs,
     ) -> None:
@@ -38,6 +40,7 @@ class RunSpecPythonRun(RunSpec):
             task,
             local_execution,
             function,
+            workflow,
             node_selector,
             volumes,
             resources,
@@ -46,6 +49,8 @@ class RunSpecPythonRun(RunSpec):
             envs,
             secrets,
             profile,
+            runtime_class,
+            priority_class,
             **kwargs,
         )
         self.source = source
@@ -59,7 +64,6 @@ class RunSpecPythonRun(RunSpec):
         self.replicas = replicas
         self.instructions = instructions
         self.inputs = inputs
-        self.outputs = outputs
         self.parameters = parameters
 
 
@@ -86,5 +90,7 @@ class RunValidatorPythonRun(RunValidator):
 
     # Run parameters
     inputs: dict = None
-    outputs: dict = None
+    """Run inputs."""
+
     parameters: dict = None
+    """Run parameters."""

{digitalhub_runtime_python-0.8.1 → digitalhub_runtime_python-0.9.0}/digitalhub_runtime_python/entities/run/python_run/utils.py

@@ -2,10 +2,10 @@ from __future__ import annotations
 
 from typing import Callable
 
+from digitalhub.entities._commons.enums import EntityTypes
 from digitalhub.entities.artifact.crud import get_artifact
 from digitalhub.entities.dataitem.crud import get_dataitem
 from digitalhub.entities.model.crud import get_model
-from digitalhub.entities.utils.entity_types import EntityTypes
 
 
 def get_getter_for_material(entity_type: str) -> Callable: