digitalhub 0.8.1__py3-none-any.whl → 0.9.0__py3-none-any.whl

digitalhub/entities/project/crud.py

@@ -1,18 +1,14 @@
 from __future__ import annotations
 
-import importlib.util as imputil
 import typing
-from pathlib import Path
 
-from digitalhub.client.api import build_client, get_client
-from digitalhub.context.api import delete_context
-from digitalhub.entities._base.api_utils import delete_entity_api_base, read_entity_api_base, update_entity_api_base
-from digitalhub.entities.utils.entity_types import EntityTypes
-from digitalhub.factory.api import build_entity_from_dict, build_entity_from_params
-from digitalhub.utils.exceptions import BackendError, EntityAlreadyExistsError, EntityError
-from digitalhub.utils.io_utils import read_yaml
+from digitalhub.entities._commons.enums import EntityTypes
+from digitalhub.entities._operations.processor import processor
+from digitalhub.entities.project.utils import setup_project
+from digitalhub.utils.exceptions import BackendError
 
 if typing.TYPE_CHECKING:
+    from digitalhub.entities._base.context.entity import ContextEntity
     from digitalhub.entities.project._base.entity import Project
 
 
@@ -60,20 +56,19 @@ def new_project(
     --------
     >>> obj = new_project("my-project")
     """
-    build_client(local, config)
     if context is None:
-        context = name
-    obj = build_entity_from_params(
+        context = "./"
+    obj = processor.create_project_entity(
         name=name,
         kind="project",
         description=description,
         labels=labels,
         local=local,
+        config=config,
         context=context,
         **kwargs,
     )
-    obj.save()
-    return _setup_project(obj, setup_kwargs)
+    return setup_project(obj, setup_kwargs)
 
 
 def get_project(
@@ -108,12 +103,14 @@ def get_project(
     --------
     >>> obj = get_project("my-project")
     """
-    build_client(local, config)
-    client = get_client(local)
-    obj = read_entity_api_base(client, ENTITY_TYPE, name, **kwargs)
-    obj["local"] = local
-    project = build_entity_from_dict(obj)
-    return _setup_project(project, setup_kwargs)
+    obj = processor.read_project_entity(
+        entity_type=ENTITY_TYPE,
+        entity_name=name,
+        local=local,
+        config=config,
+        **kwargs,
+    )
+    return setup_project(obj, setup_kwargs)
 
 
 def import_project(
@@ -123,7 +120,7 @@ def import_project(
     setup_kwargs: dict | None = None,
 ) -> Project:
     """
-    Import object from a YAML file.
+    Import object from a YAML file and create a new object into the backend.
 
     Parameters
     ----------
@@ -145,42 +142,22 @@ def import_project(
     --------
     >>> obj = import_project("my-project.yaml")
     """
-    build_client(local, config)
-    dict_obj: dict = read_yaml(file)
-    dict_obj["local"] = local
-    obj = build_entity_from_dict(dict_obj)
-    obj = _setup_project(obj, setup_kwargs)
-
-    try:
-        obj.save()
-    except EntityAlreadyExistsError:
-        pass
-
-    # Import related entities
-    obj._import_entities(dict_obj)
-
-    obj.refresh()
-
-    return obj
+    obj = processor.import_project_entity(file=file, local=local, config=config)
+    return setup_project(obj, setup_kwargs)
 
 
 def load_project(
-    name: str | None = None,
-    filename: str | None = None,
+    file: str,
     local: bool = False,
     config: dict | None = None,
     setup_kwargs: dict | None = None,
-    **kwargs,
 ) -> Project:
     """
-    Load project and context from backend or file. Name or
-    filename must be provided. Name takes precedence over filename.
+    Load object from a YAML file and update an existing object into the backend.
 
     Parameters
     ----------
-    name : str
-        Project name.
-    filename : str
+    file : str
         Path to YAML file.
     local : bool
         Flag to determine if backend is local.
@@ -188,8 +165,6 @@ def load_project(
         DHCore environment configuration.
     setup_kwargs : dict
         Setup keyword arguments passed to setup_project() function.
-    **kwargs : dict
-        Keyword arguments.
 
     Returns
     -------
@@ -198,17 +173,29 @@ def load_project(
 
     Examples
     --------
-    If name is provided, load project from backend.
-    >>> obj = load_project(name="my-project")
+    >>> obj = load_project("my-project.yaml")
+    """
+    obj = processor.load_project_entity(file=file, local=local, config=config)
+    return setup_project(obj, setup_kwargs)
+
 
-    If filename is provided, load project from file.
-    >>> obj = load_project(filename="my-project.yaml")
+def list_projects(local: bool = False, **kwargs) -> list[Project]:
     """
-    if name is not None:
-        return get_project(name=name, local=local, config=config, setup_kwargs=setup_kwargs, **kwargs)
-    if filename is not None:
-        return import_project(filename, local=local, config=config, setup_kwargs=setup_kwargs)
-    raise EntityError("Either name or filename must be provided.")
+    List projects in backend.
+
+    Parameters
+    ----------
+    local : bool
+        Flag to determine if backend is local.
+    **kwargs : dict
+        Parameters to pass to the API call.
+
+    Returns
+    -------
+    list
+        List of objects.
+    """
+    return processor.list_project_entities(local=local, **kwargs)
 
 
 def get_or_create_project(
@@ -261,7 +248,7 @@ def get_or_create_project(
         )
 
 
-def update_project(entity: Project, local: bool = False, **kwargs) -> Project:
+def update_project(entity: Project, **kwargs) -> Project:
     """
     Update object. Note that object spec are immutable.
 
@@ -269,8 +256,6 @@ def update_project(entity: Project, local: bool = False, **kwargs) -> Project:
     ----------
     entity : Project
         Object to update.
-    local : bool
-        Flag to determine if backend is local.
     **kwargs : dict
         Parameters to pass to the API call.
 
@@ -283,9 +268,13 @@ def update_project(entity: Project, local: bool = False, **kwargs) -> Project:
     --------
     >>> obj = update_project(obj)
     """
-    client = get_client(local)
-    obj = update_entity_api_base(client, ENTITY_TYPE, entity.name, entity.to_dict(), **kwargs)
-    return build_entity_from_dict(obj)
+    return processor.update_project_entity(
+        entity_type=entity.ENTITY_TYPE,
+        entity_name=entity.name,
+        entity_dict=entity.to_dict(),
+        local=entity.local,
+        **kwargs,
+    )
 
 
 def delete_project(
@@ -305,8 +294,7 @@ def delete_project(
     cascade : bool
         Flag to determine if delete is cascading.
     clean_context : bool
-        Flag to determine if context will be deleted. If a context is deleted,
-        all its objects are unreacheable.
+        Flag to determine if context will be deleted.
     local : bool
         Flag to determine if backend is local.
     **kwargs : dict
@@ -321,37 +309,68 @@ def delete_project(
     --------
     >>> delete_project("my-project")
     """
-    client = get_client(local)
-    obj = delete_entity_api_base(client, ENTITY_TYPE, name, cascade=cascade, **kwargs)
-    if clean_context:
-        delete_context(name)
-    return obj
+    return processor.delete_project_entity(
+        entity_type=ENTITY_TYPE,
+        entity_name=name,
+        local=local,
+        cascade=cascade,
+        clean_context=clean_context,
+        **kwargs,
+    )
 
 
-def _setup_project(project: Project, setup_kwargs: dict | None = None) -> Project:
+def search_entity(
+    project_name: str,
+    query: str | None = None,
+    entity_types: list[str] | None = None,
+    name: str | None = None,
+    kind: str | None = None,
+    created: str | None = None,
+    updated: str | None = None,
+    description: str | None = None,
+    labels: list[str] | None = None,
+    **kwargs,
+) -> list[ContextEntity]:
     """
-    Search for setup_project.py file and launch setup hanlder as project hook.
+    Search objects from backend.
 
     Parameters
     ----------
-    project : Project
-        The project to scafold.
-    setup_kwargs : dict
-        Arguments to pass to setup handler.
+    project_name : str
+        Project name.
+    query : str
+        Search query.
+    entity_types : list[str]
+        Entity types.
+    name : str
+        Entity name.
+    kind : str
+        Entity kind.
+    created : str
+        Entity creation date.
+    updated : str
+        Entity update date.
+    description : str
+        Entity description.
+    labels : list[str]
+        Entity labels.
+    **kwargs : dict
+        Parameters to pass to the API call.
 
-    Returns
-    -------
-    Project
-        Set up project.
+        Returns
+        -------
+        list[ContextEntity]
+            List of object instances.
     """
-    setup_kwargs = setup_kwargs if setup_kwargs is not None else {}
-    check_pth = Path(project.spec.context, ".CHECK")
-    setup_pth = Path(project.spec.context, "setup_project.py")
-    if setup_pth.exists() and not check_pth.exists():
-        spec = imputil.spec_from_file_location("setup_project", setup_pth)
-        mod = imputil.module_from_spec(spec)
-        spec.loader.exec_module(mod)
-        handler = getattr(mod, "setup")
-        project = handler(project, **setup_kwargs)
-        check_pth.touch()
-    return project
+    return processor.search_entity(
+        project_name,
+        query=query,
+        entity_types=entity_types,
+        name=name,
+        kind=kind,
+        created=created,
+        updated=updated,
+        description=description,
+        labels=labels,
+        **kwargs,
+    )

digitalhub/entities/project/utils.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+import typing
+from pathlib import Path
+
+from digitalhub.utils.generic_utils import import_function
+
+if typing.TYPE_CHECKING:
+    from digitalhub.entities.project._base.entity import Project
+
+
+def setup_project(project: Project, setup_kwargs: dict | None = None) -> Project:
+    """
+    Search for setup_project.py file and launch setup hanlder as project hook.
+
+    Parameters
+    ----------
+    project : Project
+        The project to scafold.
+    setup_kwargs : dict
+        Arguments to pass to setup handler.
+
+    Returns
+    -------
+    Project
+        Set up project.
+    """
+    setup_kwargs = setup_kwargs if setup_kwargs is not None else {}
+    check_pth = Path(project.spec.context, ".CHECK")
+    setup_pth = Path(project.spec.context, "setup_project.py")
+    if setup_pth.exists() and not check_pth.exists():
+        setup_fnc = import_function(setup_pth, "setup")
+        project = setup_fnc(project, **setup_kwargs)
+        check_pth.touch()
+    return project

digitalhub/entities/run/_base/builder.py

@@ -4,7 +4,7 @@ import typing
 
 from digitalhub.entities._base.runtime_entity.builder import EntityError, RuntimeEntityBuilder
 from digitalhub.entities._base.unversioned.builder import UnversionedBuilder
-from digitalhub.entities.utils.entity_types import EntityTypes
+from digitalhub.entities._commons.enums import EntityTypes
 
 if typing.TYPE_CHECKING:
     from digitalhub.entities.run._base.entity import Run
@@ -52,9 +52,11 @@ class RunBuilder(UnversionedBuilder, RuntimeEntityBuilder):
         Run
             Object instance.
         """
+        # Check task validity
         if task is None:
             raise EntityError("Missing task in run spec")
         self._check_kind_validity(task)
+
         uuid = self.build_uuid(uuid)
         metadata = self.build_metadata(
             project=project,

digitalhub/entities/run/_base/entity.py

@@ -3,17 +3,9 @@ from __future__ import annotations
 import time
 import typing
 
-from digitalhub.entities._base.api_utils import (
-    list_entity_api_base,
-    list_entity_api_ctx,
-    logs_api,
-    read_entity_api_ctx,
-    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.entities._commons.enums import EntityTypes, State
+from digitalhub.entities._operations.processor import processor
 from digitalhub.factory.api import (
     build_runtime,
     build_spec,
@@ -68,12 +60,9 @@ class Run(UnversionedEntity):
         executable = self._get_executable()
         task = self._get_task()
         new_spec = self._get_runtime().build(executable, task, self.to_dict())
-        self.spec = build_spec(
-            self.kind,
-            **new_spec,
-        )
+        self.spec = build_spec(self.kind, **new_spec)
         self._set_state(State.BUILT.value)
-        self.save()
+        self.save(update=True)
 
     def run(self) -> Run:
         """
@@ -85,12 +74,8 @@ class Run(UnversionedEntity):
             Run object.
         """
         self.refresh()
-        if self.spec.local_execution:
-            if not self._is_ready_to_run():
-                raise EntityError("Run is not in a state to run.")
-            self._set_state(State.RUNNING.value)
-            self.save(update=True)
 
+        self._start_execution()
         self._setup_execution()
 
         try:
@@ -102,6 +87,8 @@ class Run(UnversionedEntity):
             self._set_message(str(e))
             self.save(update=True)
             raise e
+        finally:
+            self._finish_execution()
 
         self.refresh()
         if not self.spec.local_execution:
@@ -143,17 +130,14 @@ class Run(UnversionedEntity):
 
     def logs(self) -> dict:
         """
-        Get object from backend.
-        Returns empty dictionary if context is local.
+        Get run logs.
 
         Returns
         -------
         dict
-            Logs from backend.
+            Run logs.
         """
-        if self._context().local:
-            return {}
-        return logs_api(self.project, self.ENTITY_TYPE, self.id)
+        return processor.read_run_logs(self.project, self.ENTITY_TYPE, self.id)
 
     def stop(self) -> None:
         """
@@ -163,8 +147,8 @@ class Run(UnversionedEntity):
         -------
         None
         """
-        if not self._context().local and not self.spec.local_execution:
-            return stop_api(self.project, self.ENTITY_TYPE, self.id)
+        if not self.spec.local_execution:
+            return processor.stop_run(self.project, self.ENTITY_TYPE, self.id)
 
     def resume(self) -> None:
         """
@@ -174,9 +158,8 @@ class Run(UnversionedEntity):
         -------
         None
         """
-        if not self._context().local and not self.spec.local_execution:
-            return resume_api(self.project, self.ENTITY_TYPE, self.id)
-        self.run()
+        if not self.spec.local_execution:
+            return processor.resume_run(self.project, self.ENTITY_TYPE, self.id)
 
     ##############################
     #  Helpers
@@ -184,13 +167,38 @@ class Run(UnversionedEntity):
 
     def _setup_execution(self) -> None:
         """
-        Setup run execution. In base class, nothing to do.
+        Setup run execution.
 
         Returns
         -------
         None
         """
 
+    def _start_execution(self) -> None:
+        """
+        Start run execution.
+
+        Returns
+        -------
+        None
+        """
+        self._context().set_run(f"{self.key}:{self.id}")
+        if self.spec.local_execution:
+            if not self._is_ready_to_run():
+                raise EntityError("Run is not in a state to run.")
+            self._set_state(State.RUNNING.value)
+            self.save(update=True)
+
+    def _finish_execution(self) -> None:
+        """
+        Finish run execution.
+
+        Returns
+        -------
+        None
+        """
+        self._context().unset_run()
+
     def _is_ready_to_run(self) -> bool:
         """
         Check if run is in a state ready for running (BUILT or STOPPED).
@@ -269,16 +277,15 @@ class Run(UnversionedEntity):
             Executable (function or workflow) from backend.
         """
         exec_kind = get_executable_kind(self.kind)
-        entity_type = get_entity_type_from_kind(exec_kind)
-        splitted = self.spec.task.split("/")
-        exec_name = splitted[-1].split(":")[0]
-        exec_id = splitted[-1].split(":")[1]
-        return read_entity_api_ctx(
+        exec_type = get_entity_type_from_kind(exec_kind)
+        string_to_split = getattr(self.spec, exec_type)
+        exec_name, exec_id = string_to_split.split("://")[-1].split("/")[-1].split(":")
+        return processor.read_context_entity(
             exec_name,
-            entity_type=entity_type,
+            entity_type=exec_type,
             project=self.project,
             entity_id=exec_id,
-        )
+        ).to_dict()
 
     def _get_task(self) -> dict:
         """
@@ -290,18 +297,9 @@ class Run(UnversionedEntity):
         dict
             Task from backend.
         """
-        executable_kind = get_executable_kind(self.kind)
-        exec_string = f"{executable_kind}://{self.spec.task.split('://')[1]}"
-
-        # Local backend
-        if self._context().local:
-            tasks = list_entity_api_base(self._context().client, EntityTypes.TASK.value)
-            for i in tasks:
-                if i.get("spec").get("function") == exec_string:
-                    return i
-            raise EntityError("Task not found.")
-
-        # Remote backend
-        task_kind = self.spec.task.split("://")[0]
-        params = {"function": exec_string, "kind": task_kind}
-        return list_entity_api_ctx(self.project, EntityTypes.TASK.value, params=params)[0]
+        task_id = self.spec.task.split("://")[-1].split("/")[-1]
+        return processor.read_unversioned_entity(
+            task_id,
+            entity_type=EntityTypes.TASK.value,
+            project=self.project,
+        ).to_dict()

digitalhub/entities/run/_base/spec.py

@@ -12,19 +12,23 @@ class RunSpec(Spec):
         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,
         **kwargs,
     ) -> None:
         self.task = task
         self.local_execution = local_execution
         self.function = function
+        self.workflow = workflow
         self.node_selector = node_selector
         self.volumes = volumes
         self.resources = resources
@@ -33,6 +37,8 @@ class RunSpec(Spec):
         self.envs = envs
         self.secrets = secrets
         self.profile = profile
+        self.runtime_class = runtime_class
+        self.priority_class = priority_class
 
 
 class RunValidator(SpecValidator, K8s):
@@ -40,10 +46,12 @@ class RunValidator(SpecValidator, K8s):
     RunValidator validator.
     """
 
+    # Task parameters
     function: str = None
-    """The function associated with the run."""
+    workflow: str = None
 
-    task: str = None
+    # Run parameters
+    task: str
     """The task string associated with the run."""
 
     local_execution: bool = False