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

digitalhub/entities/task/crud.py

@@ -0,0 +1,241 @@
+from __future__ import annotations
+
+import typing
+
+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.task.builder import task_from_dict, task_from_parameters
+from digitalhub.utils.exceptions import EntityAlreadyExistsError, EntityError
+from digitalhub.utils.io_utils import read_yaml
+
+if typing.TYPE_CHECKING:
+    from digitalhub.entities.task.entity import Task
+
+
+ENTITY_TYPE = EntityTypes.TASK.value
+
+
+def new_task(
+    project: str,
+    kind: str,
+    uuid: str | None = None,
+    labels: list[str] | None = None,
+    function: str | None = None,
+    **kwargs,
+) -> Task:
+    """
+    Create a new object.
+
+    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.
+    function : str
+        Name of the executable associated with the task.
+    **kwargs : dict
+        Spec keyword arguments.
+
+    Returns
+    -------
+    Task
+        Object instance.
+
+    Examples
+    --------
+    >>> obj = new_function(project="my-project",
+    >>>                    name="my-function",
+    >>>                    kind="python+task",
+    >>>                    task="task-string"
+    """
+    check_context(project)
+    obj = task_from_parameters(
+        project=project,
+        kind=kind,
+        uuid=uuid,
+        labels=labels,
+        function=function,
+        **kwargs,
+    )
+    obj.save()
+    return obj
+
+
+def get_task(
+    identifier: str,
+    project: str | None = None,
+    **kwargs,
+) -> Task:
+    """
+    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
+    -------
+    Task
+        Object instance.
+
+    Examples
+    --------
+    Using entity key:
+    >>> obj = get_task("store://my-task-key")
+
+    Using entity ID:
+    >>> obj = get_task("my-task-id"
+    >>>               project="my-project")
+    """
+    if not identifier.startswith("store://"):
+        raise EntityError("Task has no name. Use key instead.")
+    obj = read_entity_api_ctx(
+        identifier,
+        ENTITY_TYPE,
+        project=project,
+        entity_id=identifier,
+        **kwargs,
+    )
+    return task_from_dict(obj)
+
+
+def list_tasks(project: str, **kwargs) -> list[Task]:
+    """
+    List all latest version objects from backend.
+
+    Parameters
+    ----------
+    project : str
+        Project name.
+    **kwargs : dict
+        Parameters to pass to the API call.
+
+    Returns
+    -------
+    list[Task]
+        List of object instances.
+
+    Examples
+    --------
+    >>> objs = list_tasks(project="my-project")
+    """
+    objs = list_entity_api_ctx(
+        project=project,
+        entity_type=ENTITY_TYPE,
+        **kwargs,
+    )
+    return [task_from_dict(obj) for obj in objs]
+
+
+def import_task(file: str) -> Task:
+    """
+    Get object from file.
+
+    Parameters
+    ----------
+    file : str
+        Path to YAML file.
+
+    Returns
+    -------
+    Task
+        Object instance.
+
+    Example
+    -------
+    >>> obj = import_task("my-task.yaml")
+    """
+    dict_obj: dict = read_yaml(file)
+    obj = task_from_dict(dict_obj)
+    try:
+        obj.save()
+    except EntityAlreadyExistsError:
+        pass
+    finally:
+        return obj
+
+
+def update_task(entity: Task) -> Task:
+    """
+    Update object. Note that object spec are immutable.
+
+    Parameters
+    ----------
+    entity : Task
+        Object to update.
+
+    Returns
+    -------
+    Task
+        Entity updated.
+
+    Examples
+    --------
+    >>> obj = update_task(obj)
+    """
+    return entity.save(update=True)
+
+
+def delete_task(
+    identifier: str,
+    project: str | None = None,
+    entity_id: str | None = None,
+    delete_all_versions: bool = False,
+    cascade: bool = True,
+    **kwargs,
+) -> dict:
+    """
+    Delete object from backend.
+
+    Parameters
+    ----------
+    identifier : str
+        Entity key (store://...) or entity name.
+    project : str
+        Project name.
+    entity_id : str
+        Entity ID.
+    delete_all_versions : bool
+        Delete all versions of the named entity. If True, use entity name instead of entity key as identifier.
+    cascade : bool
+        Cascade delete.
+    **kwargs : dict
+        Parameters to pass to the API call.
+
+    Returns
+    -------
+    dict
+        Response from backend.
+
+    Examples
+    --------
+    If delete_all_versions is False:
+    >>> obj = delete_task("store://my-task-key")
+
+    Otherwise:
+    >>> obj = delete_task("task-name",
+    >>>                  project="my-project",
+    >>>                  delete_all_versions=True)
+    """
+    if not identifier.startswith("store://"):
+        raise EntityError("Task has no name. Use key instead.")
+    return delete_entity_api_ctx(
+        identifier=identifier,
+        entity_type=ENTITY_TYPE,
+        project=project,
+        entity_id=entity_id,
+        delete_all_versions=delete_all_versions,
+        cascade=cascade,
+        **kwargs,
+    )

digitalhub/entities/task/entity.py

@@ -0,0 +1,135 @@
+from __future__ import annotations
+
+import typing
+
+from digitalhub.entities._base.entity.unversioned import UnversionedEntity
+from digitalhub.entities.entity_types import EntityTypes
+from digitalhub.entities.run.crud import delete_run, get_run, new_run, run_from_parameters
+
+if typing.TYPE_CHECKING:
+    from digitalhub.entities._base.metadata import Metadata
+    from digitalhub.entities.run.entity import Run
+    from digitalhub.entities.task.spec import TaskSpec
+    from digitalhub.entities.task.status import TaskStatus
+
+
+class Task(UnversionedEntity):
+    """
+    A class representing a task.
+    """
+
+    ENTITY_TYPE = EntityTypes.TASK.value
+
+    def __init__(
+        self,
+        project: str,
+        uuid: str,
+        kind: str,
+        metadata: Metadata,
+        spec: TaskSpec,
+        status: TaskStatus,
+        user: str | None = None,
+    ) -> None:
+        super().__init__(project, uuid, kind, metadata, spec, status, user)
+        self.spec: TaskSpec
+        self.status: TaskStatus
+
+    ##############################
+    #  Task methods
+    ##############################
+
+    def run(
+        self,
+        run_kind: str,
+        local_execution: bool = False,
+        **kwargs,
+    ) -> Run:
+        """
+        Run task.
+
+        Parameters
+        ----------
+        run_kind : str
+            Kind the object.
+        local_execution : bool
+            Flag to indicate if the run will be executed locally.
+        **kwargs : dict
+            Keyword arguments.
+
+        Returns
+        -------
+        Run
+            Run object.
+        """
+        return self.new_run(
+            project=self.project,
+            task=self._get_task_string(),
+            kind=run_kind,
+            local_execution=local_execution,
+            **kwargs,
+        )
+
+    def _get_task_string(self) -> str:
+        """
+        Get task string.
+
+        Returns
+        -------
+        str
+            Task string.
+        """
+        splitted = self.spec.function.split("://")
+        return f"{self.kind}://{splitted[1]}"
+
+    ##############################
+    # CRUD Methods for Run
+    ##############################
+
+    def new_run(self, **kwargs) -> Run:
+        """
+        Create a new run.
+
+        Parameters
+        ----------
+        **kwargs : dict
+            Keyword arguments.
+
+        Returns
+        -------
+        Run
+            Run object.
+        """
+        if kwargs["local_execution"]:
+            return run_from_parameters(**kwargs)
+        return new_run(**kwargs)
+
+    def get_run(self, entity_key: str) -> Run:
+        """
+        Get run.
+
+        Parameters
+        ----------
+        entity_key : str
+            Entity key.
+
+        Returns
+        -------
+        Run
+            Run object.
+        """
+        return get_run(entity_key)
+
+    def delete_run(self, entity_key: str) -> None:
+        """
+        Delete run.
+
+        Parameters
+        ----------
+        entity_key : str
+            Entity key.
+
+        Returns
+        -------
+        None
+        """
+        delete_run(entity_key)

digitalhub/entities/task/models.py

@@ -0,0 +1,199 @@
+from __future__ import annotations
+
+from pydantic import BaseModel, Field
+from typing_extensions import Literal
+
+
+class Volume(BaseModel):
+    """
+    Volume model.
+    """
+
+    volume_type: Literal["persistent_volume_claim", "empty_dir"]
+    """Volume type."""
+
+    name: str
+    """Volume name."""
+
+    mount_path: str
+    """Volume mount path inside the container."""
+
+    spec: dict[str, str]
+    """Volume spec."""
+
+
+class NodeSelector(BaseModel):
+    """
+    NodeSelector model.
+    """
+
+    key: str
+    """Node selector key."""
+
+    value: str
+    """Node selector value."""
+
+
+class ResourceItem(BaseModel):
+    """
+    Resource item model.
+    """
+
+    requests: str = Field(default=None, regex=r"[\d]+|^([0-9])+([a-zA-Z])+$")
+    """Resource requests."""
+
+    limits: str = Field(default=None, regex=r"[\d]+|^([0-9])+([a-zA-Z])+$")
+    """Resource limits."""
+
+
+class Resource(BaseModel):
+    """
+    Resource model.
+    """
+
+    cpu: ResourceItem = None
+    """CPU resource model."""
+
+    mem: ResourceItem = None
+    """Memory resource model."""
+
+    gpu: ResourceItem = None
+    """GPU resource model."""
+
+
+class Env(BaseModel):
+    """
+    Env variable model.
+    """
+
+    name: str
+    """Env variable name."""
+
+    value: str
+    """Env variable value."""
+
+
+class Toleration(BaseModel):
+    """
+    Toleration model.
+    """
+
+    key: str = None
+    """Toleration key."""
+
+    operator: str = None
+    """Toleration operator."""
+
+    value: str = None
+    """Toleration value."""
+
+    effect: str = None
+    """Toleration effect."""
+
+    toleration_seconds: int = None
+    """Toleration seconds."""
+
+
+class V1NodeSelectorRequirement(BaseModel):
+    key: str
+    operator: str
+    values: list[str] = None
+
+
+class V1NodeSelectorTerm(BaseModel):
+    match_expressions: list[V1NodeSelectorRequirement] = None
+    match_fields: list[V1NodeSelectorRequirement] = None
+
+
+class V1NodeSelector(BaseModel):
+    node_selector_terms: list[V1NodeSelectorTerm]
+
+
+class V1PreferredSchedulingTerm(BaseModel):
+    preference: V1NodeSelector
+    weight: int
+
+
+class V1LabelSelectorRequirement(BaseModel):
+    key: str
+    operator: str
+    values: list[str] = None
+
+
+class V1LabelSelector(BaseModel):
+    match_expressions: list[V1LabelSelectorRequirement] = None
+    match_labels: dict[str, str] = None
+
+
+class V1PodAffinityTerm(BaseModel):
+    label_selector: V1LabelSelector = None
+    match_label_keys: list[str] = None
+    mismatch_label_keys: list[str] = None
+    namespace_selector: V1LabelSelector = None
+    namespaces: list[str] = None
+    topology_key: str
+
+
+class V1WeightedPodAffinityTerm(BaseModel):
+    pod_affinity_term: V1PodAffinityTerm
+    weight: int
+
+
+class V1NodeAffinity(BaseModel):
+    preferred_during_scheduling_ignored_during_execution: list[V1PreferredSchedulingTerm] = None
+    required_during_scheduling_ignored_during_execution: V1NodeSelector = None
+
+
+class V1PodAffinity(BaseModel):
+    preferred_during_scheduling_ignored_during_execution: list[V1WeightedPodAffinityTerm] = None
+    required_during_scheduling_ignored_during_execution: list[V1PodAffinityTerm] = None
+
+
+class V1PodAntiAffinity(BaseModel):
+    preferred_during_scheduling_ignored_during_execution: list[V1WeightedPodAffinityTerm] = None
+    required_during_scheduling_ignored_during_execution: list[V1PodAffinityTerm] = None
+
+
+class Affinity(BaseModel):
+    """
+    Affinity model.
+    """
+
+    node_affinity: V1NodeAffinity = None
+    """Node affinity."""
+
+    pod_affinity: V1PodAffinity = None
+    """Pod affinity."""
+
+    pod_anti_affinity: V1PodAntiAffinity = None
+    """Pod anti affinity."""
+
+
+class K8s(BaseModel):
+    """
+    Kubernetes resource model.
+    """
+
+    node_selector: list[NodeSelector] = None
+    """Node selector."""
+
+    volumes: list[Volume] = None
+    """List of volumes."""
+
+    resources: Resource = None
+    """Resources restrictions."""
+
+    affinity: Affinity = None
+    """Affinity."""
+
+    tolerations: list[Toleration] = None
+    """Tolerations."""
+
+    envs: list[Env] = None
+    """Env variables."""
+
+    secrets: list[str] = None
+    """List of secret names."""
+
+    profile: str = None
+    """Profile template."""

digitalhub/entities/task/spec.py

@@ -0,0 +1,51 @@
+from __future__ import annotations
+
+from digitalhub.entities._base.spec.base import Spec, SpecParams
+from digitalhub.entities.task.models import K8s
+
+
+class TaskSpec(Spec):
+    """Task specification."""
+
+    def __init__(self, function: str) -> None:
+        self.function = function
+
+
+class TaskSpecK8s(TaskSpec):
+    def __init__(
+        self,
+        function: str,
+        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:
+        super().__init__(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 TaskParams(SpecParams):
+    """
+    Base task model.
+    """
+
+    function: str
+    """Function string."""
+
+
+class TaskParamsK8s(TaskParams, K8s):
+    """
+    Kubernetes task model.
+    """

digitalhub/entities/task/status.py

@@ -0,0 +1,9 @@
+from __future__ import annotations
+
+from digitalhub.entities._base.status.base import Status
+
+
+class TaskStatus(Status):
+    """
+    Status class for task entities.
+    """