digitalhub 0.7.0b2__py3-none-any.whl → 0.8.0__py3-none-any.whl

digitalhub/entities/run/_base/entity.py

@@ -0,0 +1,307 @@
+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.factory.api import (
+    build_runtime,
+    build_spec,
+    build_status,
+    get_entity_type_from_kind,
+    get_executable_kind,
+)
+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
+
+
+class Run(UnversionedEntity):
+    """
+    A class representing a run.
+    """
+
+    ENTITY_TYPE = EntityTypes.RUN.value
+
+    def __init__(
+        self,
+        project: str,
+        uuid: str,
+        kind: str,
+        metadata: Metadata,
+        spec: RunSpec,
+        status: RunStatus,
+        user: str | None = None,
+    ) -> None:
+        super().__init__(project, uuid, kind, metadata, spec, status, user)
+
+        self.spec: RunSpec
+        self.status: RunStatus
+
+    ##############################
+    #  Run Methods
+    ##############################
+
+    def build(self) -> None:
+        """
+        Build run.
+
+        Returns
+        -------
+        None
+        """
+        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._set_state(State.BUILT.value)
+        self.save()
+
+    def run(self) -> Run:
+        """
+        Run run.
+
+        Returns
+        -------
+        Run
+            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._setup_execution()
+
+        try:
+            status = self._get_runtime().run(self.to_dict())
+        except Exception as e:
+            self.refresh()
+            if self.spec.local_execution:
+                self._set_state(State.ERROR.value)
+            self._set_message(str(e))
+            self.save(update=True)
+            raise e
+
+        self.refresh()
+        if not self.spec.local_execution:
+            status.pop("state", None)
+        new_status = {**self.status.to_dict(), **status}
+        self._set_status(new_status)
+        self.save(update=True)
+        return self
+
+    def wait(self, log_info: bool = True) -> Run:
+        """
+        Wait for run to finish.
+
+        Parameters
+        ----------
+        log_info : bool
+            If True, log information.
+
+        Returns
+        -------
+        Run
+            Run object.
+        """
+        start = time.time()
+        while True:
+            if log_info:
+                LOGGER.info(f"Waiting for run {self.id} to finish...")
+            self.refresh()
+            time.sleep(5)
+            if self.status.state in [
+                State.STOPPED.value,
+                State.ERROR.value,
+                State.COMPLETED.value,
+            ]:
+                if log_info:
+                    current = time.time() - start
+                    LOGGER.info(f"Run {self.id} finished in {current:.2f} seconds.")
+                return self
+
+    def logs(self) -> dict:
+        """
+        Get object from backend.
+        Returns empty dictionary if context is local.
+
+        Returns
+        -------
+        dict
+            Logs from backend.
+        """
+        if self._context().local:
+            return {}
+        return logs_api(self.project, self.ENTITY_TYPE, self.id)
+
+    def stop(self) -> None:
+        """
+        Stop run.
+
+        Returns
+        -------
+        None
+        """
+        if not self._context().local and not self.spec.local_execution:
+            return stop_api(self.project, self.ENTITY_TYPE, self.id)
+
+    def resume(self) -> None:
+        """
+        Resume run.
+
+        Returns
+        -------
+        None
+        """
+        if not self._context().local and not self.spec.local_execution:
+            return resume_api(self.project, self.ENTITY_TYPE, self.id)
+        self.run()
+
+    ##############################
+    #  Helpers
+    ##############################
+
+    def _setup_execution(self) -> None:
+        """
+        Setup run execution. In base class, nothing to do.
+
+        Returns
+        -------
+        None
+        """
+
+    def _is_ready_to_run(self) -> bool:
+        """
+        Check if run is in a state ready for running (BUILT or STOPPED).
+
+        Returns
+        -------
+        bool
+            True if run is in runnable state, False otherwise.
+        """
+        return (self.status.state == State.BUILT.value) or (self.status.state == State.STOPPED.value)
+
+    def _set_status(self, status: dict) -> None:
+        """
+        Set run status.
+
+        Parameters
+        ----------
+        status : dict
+            Status to set.
+
+        Returns
+        -------
+        None
+        """
+        self.status: RunStatus = build_status(self.kind, **status)
+
+    def _set_state(self, state: str) -> None:
+        """
+        Update run state.
+
+        Parameters
+        ----------
+        state : str
+            State to set.
+
+        Returns
+        -------
+        None
+        """
+        self.status.state = state
+
+    def _set_message(self, message: str) -> None:
+        """
+        Update run message.
+
+        Parameters
+        ----------
+        message : str
+            Message to set.
+
+        Returns
+        -------
+        None
+        """
+        self.status.message = message
+
+    def _get_runtime(self) -> Runtime:
+        """
+        Build runtime to build run or execute it.
+
+        Returns
+        -------
+        Runtime
+            Runtime object.
+        """
+        return build_runtime(self.kind, self.project)
+
+    def _get_executable(self) -> dict:
+        """
+        Get executable object from backend. Reimplemented to avoid
+        circular imports.
+
+        Returns
+        -------
+        dict
+            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_name,
+            entity_type=entity_type,
+            project=self.project,
+            entity_id=exec_id,
+        )
+
+    def _get_task(self) -> dict:
+        """
+        Get object from backend. Reimplemented to avoid
+        circular imports.
+
+        Returns
+        -------
+        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]

digitalhub/entities/run/_base/spec.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+from digitalhub.entities._base.entity.spec import Spec, SpecValidator
+from digitalhub.entities.task._base.models import K8s
+
+
+class RunSpec(Spec):
+    """RunSpec specifications."""
+
+    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
+
+
+class RunValidator(SpecValidator, K8s):
+    """
+    RunValidator validator.
+    """
+
+    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."""

digitalhub/entities/run/_base/status.py

@@ -0,0 +1,9 @@
+from __future__ import annotations
+
+from digitalhub.entities._base.entity.status import Status
+
+
+class RunStatus(Status):
+    """
+    RunStatus status.
+    """

digitalhub/entities/run/crud.py

@@ -0,0 +1,219 @@
+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
+
+if typing.TYPE_CHECKING:
+    from digitalhub.entities.run._base.entity import Run
+
+
+ENTITY_TYPE = EntityTypes.RUN.value
+
+
+def new_run(
+    project: str,
+    kind: str,
+    uuid: str | None = None,
+    labels: list[str] | None = None,
+    task: str | None = None,
+    local_execution: bool = False,
+    **kwargs,
+) -> Run:
+    """
+    Create a new object.
+
+    Parameters
+    ----------
+    project : str
+        Project name.
+    kind : str
+        Kind the object.
+    uuid : str
+        ID of the object.
+    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.
+
+    Examples
+    --------
+    >>> obj = new_run(project="my-project",
+    >>>               kind="python+run",
+    >>>               task="task-string")
+    """
+    return new_context_entity(
+        project=project,
+        kind=kind,
+        uuid=uuid,
+        labels=labels,
+        task=task,
+        local_execution=local_execution,
+        **kwargs,
+    )
+
+
+def get_run(
+    identifier: str,
+    project: str | None = None,
+    **kwargs,
+) -> Run:
+    """
+    Get object from backend.
+
+    Parameters
+    ----------
+    identifier : str
+        Entity key (store://...) or entity ID.
+    project : str
+        Project name.
+    **kwargs : dict
+        Parameters to pass to the API call.
+
+    Returns
+    -------
+    Run
+        Object instance.
+
+    Examples
+    --------
+    Using entity key:
+    >>> obj = get_run("store://my-run-key")
+
+    Using entity ID:
+    >>> obj = get_run("my-run-id"
+    >>>               project="my-project")
+    """
+    return get_unversioned_entity(
+        identifier,
+        entity_type=ENTITY_TYPE,
+        project=project,
+        **kwargs,
+    )
+
+
+def list_runs(project: str, **kwargs) -> list[Run]:
+    """
+    List all latest version objects from backend.
+
+    Parameters
+    ----------
+    project : str
+        Project name.
+    **kwargs : dict
+        Parameters to pass to the API call.
+
+    Returns
+    -------
+    list[Run]
+        List of object instances.
+
+    Examples
+    --------
+    >>> objs = list_runs(project="my-project")
+    """
+    # TODO more examples: search by function, latest for task and function
+    return list_context_entities(
+        project=project,
+        entity_type=ENTITY_TYPE,
+        **kwargs,
+    )
+
+
+def import_run(file: str) -> Run:
+    """
+    Get object from file.
+
+    Parameters
+    ----------
+    file : str
+        Path to YAML file.
+
+    Returns
+    -------
+    Run
+        Object instance.
+
+    Example
+    -------
+    >>> obj = import_run("my-run.yaml")
+    """
+    return import_context_entity(file)
+
+
+def update_run(entity: Run) -> Run:
+    """
+    Update object. Note that object spec are immutable.
+
+    Parameters
+    ----------
+    entity : Run
+        Object to update.
+
+    Returns
+    -------
+    Run
+        Entity updated.
+
+    Examples
+    --------
+    >>> obj = update_run(obj)
+    """
+    return entity.save(update=True)
+
+
+def delete_run(
+    identifier: str,
+    project: str | None = None,
+    **kwargs,
+) -> dict:
+    """
+    Delete object from backend.
+
+    Parameters
+    ----------
+    identifier : str
+        Entity key (store://...) or entity ID.
+    project : str
+        Project name.
+    **kwargs : dict
+        Parameters to pass to the API call.
+
+    Returns
+    -------
+    dict
+        Response from backend.
+
+    Examples
+    --------
+    >>> obj = delete_run("store://my-run-key")
+    >>> obj = delete_run("my-run-id", project="my-project")
+    """
+    if not identifier.startswith("store://") and project is None:
+        raise EntityError("Specify entity key or entity ID combined with project")
+    return delete_entity(
+        identifier=identifier,
+        entity_type=ENTITY_TYPE,
+        project=project,
+        entity_id=identifier,
+        **kwargs,
+    )
+
+    # TODO read logs

digitalhub/entities/secret/_base/builder.py

@@ -0,0 +1,81 @@
+from __future__ import annotations
+
+from digitalhub.entities._base.versioned.builder import VersionedBuilder
+from digitalhub.entities.secret._base.entity import Secret
+from digitalhub.entities.secret._base.spec import SecretSpec, SecretValidator
+from digitalhub.entities.secret._base.status import SecretStatus
+from digitalhub.entities.utils.entity_types import EntityTypes
+
+
+class SecretSecretBuilder(VersionedBuilder):
+    """
+    SecretSecretBuilder builder.
+    """
+
+    ENTITY_TYPE = EntityTypes.SECRET.value
+    ENTITY_CLASS = Secret
+    ENTITY_SPEC_CLASS = SecretSpec
+    ENTITY_SPEC_VALIDATOR = SecretValidator
+    ENTITY_STATUS_CLASS = SecretStatus
+    ENTITY_KIND = "secret"
+
+    def build(
+        self,
+        kind: str,
+        project: str,
+        name: str,
+        uuid: str | None = None,
+        description: str | None = None,
+        labels: list[str] | None = None,
+        **kwargs,
+    ) -> Secret:
+        """
+        Create a new object.
+
+        Parameters
+        ----------
+        project : str
+            Project name.
+        name : str
+            Object name.
+        kind : str
+            Kind the object.
+        uuid : str
+            ID of the object.
+        description : str
+            Description of the object (human readable).
+        labels : list[str]
+            List of labels.
+        **kwargs : dict
+            Spec keyword arguments.
+
+        Returns
+        -------
+        Secret
+            Object instance.
+        """
+        name = self.build_name(name)
+        uuid = self.build_uuid(uuid)
+        metadata = self.build_metadata(
+            project=project,
+            name=name,
+            description=description,
+            labels=labels,
+        )
+        path = f"secret://{name}"
+        provider = "kubernetes"
+        spec = self.build_spec(
+            path=path,
+            provider=provider,
+            **kwargs,
+        )
+        status = self.build_status()
+        return self.build_entity(
+            project=project,
+            name=name,
+            uuid=uuid,
+            kind=kind,
+            metadata=metadata,
+            spec=spec,
+            status=status,
+        )