digitalhub 0.8.0__py3-none-any.whl → 0.8.0b1__py3-none-any.whl

digitalhub/entities/run/builder.py

@@ -0,0 +1,77 @@
+from __future__ import annotations
+
+from digitalhub.entities._builders.metadata import build_metadata
+from digitalhub.entities._builders.spec import build_spec
+from digitalhub.entities._builders.status import build_status
+from digitalhub.entities._builders.uuid import build_uuid
+from digitalhub.entities.run.entity import Run
+
+
+def run_from_parameters(
+    project: str,
+    kind: str,
+    uuid: str | None = None,
+    labels: list[str] | None = None,
+    task: str | None = None,
+    local_execution: bool = False,
+    **kwargs,
+) -> Run:
+    """
+    Create run.
+
+    Parameters
+    ----------
+    project : str
+        Project name.
+    kind : str
+        Kind the object.
+    uuid : str
+        ID of the object (UUID4, e.g. 40f25c4b-d26b-4221-b048-9527aff291e2).
+    labels : list[str]
+        List of labels.
+    task : str
+        Name of the task associated with the run.
+    local_execution : bool
+        Flag to determine if object has local execution.
+    **kwargs : dict
+        Spec keyword arguments.
+
+    Returns
+    -------
+    Run
+        Object instance.
+    """
+    uuid = build_uuid(uuid)
+    metadata = build_metadata(
+        kind=kind,
+        project=project,
+        name=uuid,
+        labels=labels,
+    )
+    spec = build_spec(kind, task=task, local_execution=local_execution, **kwargs)
+    status = build_status(kind)
+    return Run(
+        project=project,
+        uuid=uuid,
+        kind=kind,
+        metadata=metadata,
+        spec=spec,
+        status=status,
+    )
+
+
+def run_from_dict(obj: dict) -> Run:
+    """
+    Create a new object from dictionary.
+
+    Parameters
+    ----------
+    obj : dict
+        Dictionary to create object from.
+
+    Returns
+    -------
+    Run
+        Object instance.
+    """
+    return Run.from_dict(obj)

digitalhub/entities/run/crud.py

@@ -2,18 +2,15 @@ from __future__ import annotations
 
 import typing
 
-from digitalhub.entities._base.crud import (
-    delete_entity,
-    get_unversioned_entity,
-    import_context_entity,
-    list_context_entities,
-    new_context_entity,
-)
-from digitalhub.entities.utils.entity_types import EntityTypes
-from digitalhub.utils.exceptions import EntityError
+from digitalhub.context.builder import check_context
+from digitalhub.entities._base.crud import delete_entity_api_ctx, list_entity_api_ctx, read_entity_api_ctx
+from digitalhub.entities.entity_types import EntityTypes
+from digitalhub.entities.run.builder import run_from_dict, run_from_parameters
+from digitalhub.utils.exceptions import EntityAlreadyExistsError, EntityError
+from digitalhub.utils.io_utils import read_yaml
 
 if typing.TYPE_CHECKING:
-    from digitalhub.entities.run._base.entity import Run
+    from digitalhub.entities.run.entity import Run
 
 
 ENTITY_TYPE = EntityTypes.RUN.value
@@ -38,7 +35,7 @@ def new_run(
     kind : str
         Kind the object.
     uuid : str
-        ID of the object.
+        ID of the object (UUID4, e.g. 40f25c4b-d26b-4221-b048-9527aff291e2).
     labels : list[str]
         List of labels.
     task : str
@@ -55,11 +52,13 @@ def new_run(
 
     Examples
     --------
-    >>> obj = new_run(project="my-project",
-    >>>               kind="python+run",
-    >>>               task="task-string")
+    >>> obj = new_function(project="my-project",
+    >>>                    name="my-function",
+    >>>                    kind="python+run",
+    >>>                    task="task-string"
     """
-    return new_context_entity(
+    check_context(project)
+    obj = run_from_parameters(
         project=project,
         kind=kind,
         uuid=uuid,
@@ -68,6 +67,8 @@ def new_run(
         local_execution=local_execution,
         **kwargs,
     )
+    obj.save()
+    return obj
 
 
 def get_run(
@@ -101,12 +102,16 @@ def get_run(
     >>> obj = get_run("my-run-id"
     >>>               project="my-project")
     """
-    return get_unversioned_entity(
+    if not identifier.startswith("store://") and project is None:
+        raise EntityError("Specify entity key or entity ID combined with project")
+    obj = read_entity_api_ctx(
         identifier,
-        entity_type=ENTITY_TYPE,
+        ENTITY_TYPE,
         project=project,
+        entity_id=identifier,
         **kwargs,
     )
+    return run_from_dict(obj)
 
 
 def list_runs(project: str, **kwargs) -> list[Run]:
@@ -130,11 +135,12 @@ def list_runs(project: str, **kwargs) -> list[Run]:
     >>> objs = list_runs(project="my-project")
     """
     # TODO more examples: search by function, latest for task and function
-    return list_context_entities(
+    objs = list_entity_api_ctx(
         project=project,
         entity_type=ENTITY_TYPE,
         **kwargs,
     )
+    return [run_from_dict(obj) for obj in objs]
 
 
 def import_run(file: str) -> Run:
@@ -155,7 +161,14 @@ def import_run(file: str) -> Run:
     -------
     >>> obj = import_run("my-run.yaml")
     """
-    return import_context_entity(file)
+    dict_obj: dict = read_yaml(file)
+    obj = run_from_dict(dict_obj)
+    try:
+        obj.save()
+    except EntityAlreadyExistsError:
+        pass
+    finally:
+        return obj
 
 
 def update_run(entity: Run) -> Run:
@@ -208,7 +221,7 @@ def delete_run(
     """
     if not identifier.startswith("store://") and project is None:
         raise EntityError("Specify entity key or entity ID combined with project")
-    return delete_entity(
+    return delete_entity_api_ctx(
         identifier=identifier,
         entity_type=ENTITY_TYPE,
         project=project,

digitalhub/entities/run/{_base/entity.py → entity.py}

@@ -2,8 +2,11 @@ from __future__ import annotations
 
 import time
 import typing
+from typing import Any
 
-from digitalhub.entities._base.api_utils import (
+import requests
+
+from digitalhub.entities._base.crud import (
     list_entity_api_base,
     list_entity_api_ctx,
     logs_api,
@@ -11,24 +14,22 @@ from digitalhub.entities._base.api_utils import (
     resume_api,
     stop_api,
 )
-from digitalhub.entities._base.unversioned.entity import UnversionedEntity
-from digitalhub.entities.utils.entity_types import EntityTypes
-from digitalhub.entities.utils.state import State
-from digitalhub.factory.api import (
-    build_runtime,
-    build_spec,
-    build_status,
-    get_entity_type_from_kind,
-    get_executable_kind,
-)
+from digitalhub.entities._base.entity.unversioned import UnversionedEntity
+from digitalhub.entities._base.state import State
+from digitalhub.entities._builders.spec import build_spec
+from digitalhub.entities._builders.status import build_status
+from digitalhub.entities.entity_types import EntityTypes
+from digitalhub.registry.registry import registry
+from digitalhub.runtimes.builder import build_runtime
 from digitalhub.utils.exceptions import EntityError
 from digitalhub.utils.logger import LOGGER
 
 if typing.TYPE_CHECKING:
-    from digitalhub.entities._base.entity.metadata import Metadata
-    from digitalhub.entities.run._base.spec import RunSpec
-    from digitalhub.entities.run._base.status import RunStatus
-    from digitalhub.runtimes._base import Runtime
+    from digitalhub.entities._base.entity.material import MaterialEntity
+    from digitalhub.entities._base.metadata import Metadata
+    from digitalhub.entities.run.spec import RunSpec
+    from digitalhub.entities.run.status import RunStatus
+    from digitalhub.runtimes.base import Runtime
 
 
 class Run(UnversionedEntity):
@@ -65,9 +66,10 @@ class Run(UnversionedEntity):
         -------
         None
         """
-        executable = self._get_executable()
-        task = self._get_task()
-        new_spec = self._get_runtime().build(executable, task, self.to_dict())
+        runtime = self._get_runtime()
+        executable = self._get_executable(runtime)
+        task = self._get_task(runtime)
+        new_spec = runtime.build(executable, task, self.to_dict())
         self.spec = build_spec(
             self.kind,
             **new_spec,
@@ -91,7 +93,11 @@ class Run(UnversionedEntity):
             self._set_state(State.RUNNING.value)
             self.save(update=True)
 
-        self._setup_execution()
+        # Try to get inputs if they exist
+        try:
+            self.spec.inputs = self.inputs(as_dict=True)
+        except EntityError:
+            pass
 
         try:
             status = self._get_runtime().run(self.to_dict())
@@ -141,6 +147,116 @@ class Run(UnversionedEntity):
                     LOGGER.info(f"Run {self.id} finished in {current:.2f} seconds.")
                 return self
 
+    def inputs(self, as_dict: bool = False) -> list[dict]:
+        """
+        Get inputs passed in spec as objects or as dictionaries.
+
+        Parameters
+        ----------
+        as_dict : bool
+            If True, return inputs as dictionaries.
+
+        Returns
+        -------
+        list[dict]
+            List of input objects.
+        """
+        try:
+            return self.spec.get_inputs(as_dict=as_dict)
+        except AttributeError:
+            msg = f"Run of type {self.kind} has no inputs."
+            raise EntityError(msg)
+
+    def results(self) -> dict:
+        """
+        Get results from runtime execution.
+
+        Returns
+        -------
+        dict
+            Results.
+        """
+        try:
+            return self.status.get_results()
+        except AttributeError:
+            msg = f"Run of type {self.kind} has no results."
+            raise EntityError(msg)
+
+    def result(self, key: str) -> Any:
+        """
+        Get result from runtime execution by key.
+
+        Parameters
+        ----------
+        key : str
+            Key of the result.
+
+        Returns
+        -------
+        Any
+            Result.
+        """
+        return self.results().get(key)
+
+    def outputs(self, as_key: bool = False, as_dict: bool = False) -> dict:
+        """
+        Get run objects results.
+
+        Parameters
+        ----------
+        as_key : bool
+            If True, return results as keys.
+        as_dict : bool
+            If True, return results as dictionaries.
+
+        Returns
+        -------
+        dict
+            List of output objects.
+        """
+        try:
+            return self.status.get_outputs(as_key=as_key, as_dict=as_dict)
+        except AttributeError:
+            msg = f"Run of type {self.kind} has no outputs."
+            raise EntityError(msg)
+
+    def output(self, key: str, as_key: bool = False, as_dict: bool = False) -> MaterialEntity | dict | str | None:
+        """
+        Get run object result by key.
+
+        Parameters
+        ----------
+        key : str
+            Key of the result.
+        as_key : bool
+            If True, return result as key.
+        as_dict : bool
+            If True, return result as dictionary.
+
+        Returns
+        -------
+        Entity | dict | str | None
+            Result.
+        """
+        return self.outputs(as_key=as_key, as_dict=as_dict).get(key)
+
+    def values(self) -> dict:
+        """
+        Get values from runtime execution.
+
+        Returns
+        -------
+        dict
+            Values from backend.
+        """
+        try:
+            value_list = getattr(self.spec, "values", [])
+            value_list = value_list if value_list is not None else []
+            return self.status.get_values(value_list)
+        except AttributeError:
+            msg = f"Run of type {self.kind} has no values."
+            raise EntityError(msg)
+
     def logs(self) -> dict:
         """
         Get object from backend.
@@ -165,6 +281,11 @@ class Run(UnversionedEntity):
         """
         if not self._context().local and not self.spec.local_execution:
             return stop_api(self.project, self.ENTITY_TYPE, self.id)
+        try:
+            self.status.stop()
+        except AttributeError:
+            raise EntityError("Stop is not supported in local execution.")
+            return
 
     def resume(self) -> None:
         """
@@ -176,20 +297,45 @@ class Run(UnversionedEntity):
         """
         if not self._context().local and not self.spec.local_execution:
             return resume_api(self.project, self.ENTITY_TYPE, self.id)
-        self.run()
 
-    ##############################
-    #  Helpers
-    ##############################
+        try:
+            self.status.resume()
+        except AttributeError:
+            raise EntityError("Resume is not supported in local execution.")
+            return
+        # re-run
+        # TODO verify the logic and order
+        self.run()
 
-    def _setup_execution(self) -> None:
+    def invoke(self, **kwargs) -> requests.Response:
         """
-        Setup run execution. In base class, nothing to do.
+        Invoke run.
+
+        Parameters
+        ----------
+        kwargs
+            Keyword arguments to pass to the request.
 
         Returns
         -------
-        None
+        requests.Response
+            Response from service.
         """
+        try:
+            if not self._context().local and not self.spec.local_execution:
+                local = False
+            else:
+                local = True
+            if kwargs is None:
+                kwargs = {}
+            return self.status.invoke(local, **kwargs)
+        except AttributeError:
+            msg = f"Run of type {self.kind} has no invoke operation."
+            raise EntityError(msg)
+
+    ##############################
+    #  Helpers
+    ##############################
 
     def _is_ready_to_run(self) -> bool:
         """
@@ -258,18 +404,22 @@ class Run(UnversionedEntity):
         """
         return build_runtime(self.kind, self.project)
 
-    def _get_executable(self) -> dict:
+    def _get_executable(self, runtime: Runtime) -> dict:
         """
-        Get executable object from backend. Reimplemented to avoid
-        circular imports.
+        Get object from backend. Reimplemented to avoid circular imports.
+
+        Parameters
+        ----------
+        runtime : Runtime
+            Runtime object.
 
         Returns
         -------
         dict
             Executable (function or workflow) from backend.
         """
-        exec_kind = get_executable_kind(self.kind)
-        entity_type = get_entity_type_from_kind(exec_kind)
+        exec_kind = runtime.get_executable_kind()
+        entity_type = registry.get_entity_type(exec_kind)
         splitted = self.spec.task.split("/")
         exec_name = splitted[-1].split(":")[0]
         exec_id = splitted[-1].split(":")[1]
@@ -280,17 +430,21 @@ class Run(UnversionedEntity):
             entity_id=exec_id,
         )
 
-    def _get_task(self) -> dict:
+    def _get_task(self, runtime: Runtime) -> dict:
         """
-        Get object from backend. Reimplemented to avoid
-        circular imports.
+        Get object from backend. Reimplemented to avoid circular imports.
+
+        Parameters
+        ----------
+        runtime : Runtime
+            Runtime object.
 
         Returns
         -------
         dict
             Task from backend.
         """
-        executable_kind = get_executable_kind(self.kind)
+        executable_kind = runtime.get_executable_kind()
         exec_string = f"{executable_kind}://{self.spec.task.split('://')[1]}"
 
         # Local backend

digitalhub/entities/run/spec.py

@@ -0,0 +1,153 @@
+from __future__ import annotations
+
+import typing
+
+from digitalhub.entities._base.spec.base import Spec, SpecParams
+from digitalhub.entities.artifact.crud import get_artifact
+from digitalhub.entities.dataitem.crud import get_dataitem
+from digitalhub.entities.entity_types import EntityTypes
+from digitalhub.entities.model.crud import get_model
+from digitalhub.entities.task.models import K8s
+from digitalhub.entities.utils import parse_entity_key
+
+if typing.TYPE_CHECKING:
+    from digitalhub.entities._base.entity.base import Entity
+
+
+ENTITY_FUNC = {
+    EntityTypes.ARTIFACT.value: get_artifact,
+    EntityTypes.DATAITEM.value: get_dataitem,
+    EntityTypes.MODEL.value: get_model,
+}
+
+
+class RunSpec(Spec):
+    """Run specification."""
+
+    def __init__(
+        self,
+        task: str,
+        local_execution: bool = False,
+        function: str | None = None,
+        node_selector: dict | None = None,
+        volumes: list | None = None,
+        resources: dict | None = None,
+        affinity: dict | None = None,
+        tolerations: list | None = None,
+        envs: list | None = None,
+        secrets: list | None = None,
+        profile: str | None = None,
+        **kwargs,
+    ) -> None:
+        self.task = task
+        self.local_execution = local_execution
+        self.function = function
+        self.node_selector = node_selector
+        self.volumes = volumes
+        self.resources = resources
+        self.affinity = affinity
+        self.tolerations = tolerations
+        self.envs = envs
+        self.secrets = secrets
+        self.profile = profile
+
+    def get_inputs(self, as_dict: bool = False) -> dict:
+        """
+        Get inputs.
+
+        Returns
+        -------
+        dict
+            The inputs.
+        """
+        inputs = {}
+        if not hasattr(self, "inputs") or self.inputs is None:
+            return inputs
+
+        for parameter, item in self.inputs.items():
+            parameter_type = self._parse_parameter(parameter)
+
+            # Get entity from key
+            if parameter_type == "key":
+                key = self._collect_key(item)
+                entity = self._collect_entity(key)
+                if as_dict:
+                    entity = entity.to_dict()
+                inputs[parameter] = entity
+
+            # Create entity from parameter
+            elif parameter_type == "create":
+                raise NotImplementedError
+
+        return inputs
+
+    @staticmethod
+    def _parse_parameter(parameter: str) -> str:
+        """
+        Parse parameter.
+
+        Parameters
+        ----------
+        parameter : str
+            Parameter.
+
+        Returns
+        -------
+        str
+            The parsed parameter.
+        """
+        if len(parameter.split(":")) == 1:
+            return "key"
+        return "create"
+
+    @staticmethod
+    def _collect_key(item: str | dict) -> str:
+        """
+        Collect key from item.
+
+        Parameters
+        ----------
+        item : str | dict
+            Key or dict representation of the entity.
+
+        Returns
+        -------
+        str
+            The key.
+        """
+        if isinstance(item, str):
+            return item
+        return item.get("key")
+
+    @staticmethod
+    def _collect_entity(key: str) -> Entity:
+        """
+        Collect entity from key.
+
+        Parameters
+        ----------
+        key : str
+            Key of the entity.
+
+        Returns
+        -------
+        Entity
+            The entity.
+        """
+        _, entity_type, _, _, _ = parse_entity_key(key)
+        return ENTITY_FUNC[entity_type](key)
+
+
+class RunParams(SpecParams, K8s):
+    """
+    Run parameters.
+    """
+
+    function: str = None
+    """The function associated with the run."""
+
+    task: str = None
+    """The task string associated with the run."""
+
+    local_execution: bool = False
+    """Flag to indicate if the run will be executed locally."""