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

digitalhub/entities/secret/_base/entity.py

@@ -0,0 +1,74 @@
+from __future__ import annotations
+
+import typing
+
+from digitalhub.entities._base.api_utils import get_data_api, set_data_api
+from digitalhub.entities._base.versioned.entity import VersionedEntity
+from digitalhub.entities.utils.entity_types import EntityTypes
+
+if typing.TYPE_CHECKING:
+    from digitalhub.entities._base.entity.metadata import Metadata
+    from digitalhub.entities.secret._base.spec import SecretSpec
+    from digitalhub.entities.secret._base.status import SecretStatus
+
+
+class Secret(VersionedEntity):
+    """
+    A class representing a secret.
+    """
+
+    ENTITY_TYPE = EntityTypes.SECRET.value
+
+    def __init__(
+        self,
+        project: str,
+        name: str,
+        uuid: str,
+        kind: str,
+        metadata: Metadata,
+        spec: SecretSpec,
+        status: SecretStatus,
+        user: str | None = None,
+    ) -> None:
+        super().__init__(project, name, uuid, kind, metadata, spec, status, user)
+        self.spec: SecretSpec
+        self.status: SecretStatus
+
+    ##############################
+    #  Secret methods
+    ##############################
+
+    def set_secret_value(self, value: str) -> None:
+        """
+        Update the secret value with a new one.
+
+        Parameters
+        ----------
+        value : str
+            Value of the secret.
+
+        Returns
+        -------
+        None
+        """
+        if self._context().local:
+            raise NotImplementedError("set_secret() is not implemented for local projects.")
+
+        obj = {self.name: value}
+        set_data_api(self.project, self.ENTITY_TYPE, obj)
+
+    def read_secret_value(self) -> dict:
+        """
+        Read the secret value from backend.
+
+        Returns
+        -------
+        str
+            Value of the secret.
+        """
+        if self._context().local:
+            raise NotImplementedError("read_secret() is not implemented for local projects.")
+
+        params = {"keys": self.name}
+        data = get_data_api(self.project, self.ENTITY_TYPE, params=params)
+        return data[self.name]

digitalhub/entities/secret/_base/spec.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+from digitalhub.entities._base.entity.spec import Spec, SpecValidator
+
+
+class SecretSpec(Spec):
+    """
+    SecretSpec specifications.
+    """
+
+    def __init__(self, path: str | None = None, provider: str | None = None, **kwargs) -> None:
+        """
+        Constructor.
+
+        Parameters
+        ----------
+        path : str
+            Path to the secret.
+        provider : str
+            Provider of the secret.
+        """
+        self.path = path
+        self.provider = provider
+
+
+class SecretValidator(SpecValidator):
+    """
+    SecretValidator validator.
+    """
+
+    path: str = None
+    """Path to the secret."""
+
+    provider: str = None
+    """Provider of the secret."""

digitalhub/entities/secret/_base/status.py

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

digitalhub/entities/secret/crud.py

@@ -0,0 +1,290 @@
+from __future__ import annotations
+
+import typing
+
+from digitalhub.context.api import check_context
+from digitalhub.entities._base.crud import (
+    delete_entity,
+    get_context_entity_versions,
+    get_versioned_entity,
+    import_context_entity,
+    list_context_entities,
+    new_context_entity,
+)
+from digitalhub.entities.utils.entity_types import EntityTypes
+from digitalhub.utils.exceptions import EntityNotExistsError
+
+if typing.TYPE_CHECKING:
+    from digitalhub.entities.secret._base.entity import Secret
+
+
+ENTITY_TYPE = EntityTypes.SECRET.value
+
+
+def new_secret(
+    project: str,
+    name: str,
+    uuid: str | None = None,
+    description: str | None = None,
+    labels: list[str] | None = None,
+    embedded: bool = False,
+    secret_value: str | None = None,
+    **kwargs,
+) -> Secret:
+    """
+    Create a new object.
+
+    Parameters
+    ----------
+    project : str
+        Project name.
+    name : str
+        Object name.
+    uuid : str
+        ID of the object.
+    description : str
+        Description of the object (human readable).
+    labels : list[str]
+        List of labels.
+    embedded : bool
+        Flag to determine if object spec must be embedded in project spec.
+    secret_value : str
+        Value of the secret.
+    **kwargs : dict
+        Spec keyword arguments.
+
+    Returns
+    -------
+    Secret
+        Object instance.
+
+    Examples
+    --------
+    >>> obj = new_secret(project="my-project",
+    >>>                  name="my-secret",
+    >>>                  secret_value="my-secret-value")
+    """
+    check_context(project)
+
+    if secret_value is None:
+        raise ValueError("secret_value must be provided.")
+    obj: Secret = new_context_entity(
+        project=project,
+        name=name,
+        kind="secret",
+        uuid=uuid,
+        description=description,
+        labels=labels,
+        embedded=embedded,
+        **kwargs,
+    )
+    obj.set_secret_value(value=secret_value)
+    return obj
+
+
+def get_secret(
+    identifier: str,
+    project: str | None = None,
+    entity_id: str | None = None,
+    **kwargs,
+) -> Secret:
+    """
+    Get object from backend.
+
+    Parameters
+    ----------
+    identifier : str
+        Entity key (store://...) or entity name.
+    project : str
+        Project name.
+    entity_id : str
+        Entity ID.
+    **kwargs : dict
+        Parameters to pass to the API call.
+
+    Returns
+    -------
+    Secret
+        Object instance.
+
+    Examples
+    --------
+    Using entity key:
+    >>> obj = get_secret("store://my-secret-key")
+
+    Using entity name:
+    >>> obj = get_secret("my-secret-name"
+    >>>                  project="my-project",
+    >>>                  entity_id="my-secret-id")
+    """
+    if not identifier.startswith("store://"):
+        secrets = list_secrets(project=project, **kwargs)
+        for secret in secrets:
+            if secret.name == identifier:
+                return secret
+        else:
+            raise EntityNotExistsError(f"Secret {identifier} not found.")
+
+    return get_versioned_entity(
+        identifier,
+        entity_type=ENTITY_TYPE,
+        project=project,
+        entity_id=entity_id,
+        **kwargs,
+    )
+
+
+def get_secret_versions(
+    identifier: str,
+    project: str | None = None,
+    **kwargs,
+) -> list[Secret]:
+    """
+    Get object versions from backend.
+
+    Parameters
+    ----------
+    identifier : str
+        Entity key (store://...) or entity name.
+    project : str
+        Project name.
+    **kwargs : dict
+        Parameters to pass to the API call.
+
+    Returns
+    -------
+    list[Secret]
+        List of object instances.
+
+    Examples
+    --------
+    Using entity key:
+    >>> objs = get_secret_versions("store://my-secret-key")
+
+    Using entity name:
+    >>> objs = get_secret_versions("my-secret-name",
+    >>>                            project="my-project")
+    """
+    return get_context_entity_versions(
+        identifier,
+        entity_type=ENTITY_TYPE,
+        project=project,
+        **kwargs,
+    )
+
+
+def list_secrets(project: str, **kwargs) -> list[Secret]:
+    """
+    List all latest version objects from backend.
+
+    Parameters
+    ----------
+    project : str
+        Project name.
+    **kwargs : dict
+        Parameters to pass to the API call.
+
+    Returns
+    -------
+    list[Secret]
+        List of object instances.
+
+    Examples
+    --------
+    >>> objs = list_secrets(project="my-project")
+    """
+    return list_context_entities(
+        project=project,
+        entity_type=ENTITY_TYPE,
+        **kwargs,
+    )
+
+
+def import_secret(file: str) -> Secret:
+    """
+    Import object from a YAML file.
+
+    Parameters
+    ----------
+    file : str
+        Path to YAML file.
+
+    Returns
+    -------
+    Secret
+        Object instance.
+
+    Examples
+    --------
+    >>> obj = import_secret("my-secret.yaml")
+    """
+    return import_context_entity(file)
+
+
+def update_secret(entity: Secret) -> Secret:
+    """
+    Update object. Note that object spec are immutable.
+
+    Parameters
+    ----------
+    entity : Secret
+        Object to update.
+
+    Returns
+    -------
+    Secret
+        Entity updated.
+
+    Examples
+    --------
+    >>> obj = update_secret(obj)
+    """
+    return entity.save(update=True)
+
+
+def delete_secret(
+    identifier: str,
+    project: str | None = None,
+    entity_id: str | None = None,
+    delete_all_versions: bool = False,
+    **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.
+    **kwargs : dict
+        Parameters to pass to the API call.
+
+    Returns
+    -------
+    dict
+        Response from backend.
+
+    Examples
+    --------
+    If delete_all_versions is False:
+    >>> obj = delete_secret("store://my-secret-key")
+
+    Otherwise:
+    >>> obj = delete_secret("my-secret-name"
+    >>>                     project="my-project",
+    >>>                     delete_all_versions=True)
+    """
+    return delete_entity(
+        identifier=identifier,
+        entity_type=ENTITY_TYPE,
+        project=project,
+        entity_id=entity_id,
+        delete_all_versions=delete_all_versions,
+        **kwargs,
+    )

digitalhub/entities/task/_base/builder.py

@@ -0,0 +1,91 @@
+from __future__ import annotations
+
+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
+
+if typing.TYPE_CHECKING:
+    from digitalhub.entities.task._base.entity import Task
+
+
+class TaskBuilder(UnversionedBuilder, RuntimeEntityBuilder):
+    """
+    Task builder.
+    """
+
+    ENTITY_TYPE = EntityTypes.TASK.value
+
+    def build(
+        self,
+        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.
+        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.
+        """
+        if function is None:
+            raise EntityError("function must be provided")
+
+        self._check_kind_validity(function)
+        uuid = self.build_uuid(uuid)
+        metadata = self.build_metadata(
+            project=project,
+            name=uuid,
+            labels=labels,
+        )
+        spec = self.build_spec(
+            function=function,
+            **kwargs,
+        )
+        status = self.build_status()
+        return self.build_entity(
+            project=project,
+            uuid=uuid,
+            kind=kind,
+            metadata=metadata,
+            spec=spec,
+            status=status,
+        )
+
+    def _check_kind_validity(self, function: str) -> None:
+        """
+        Check kind validity.
+
+        Parameters
+        ----------
+        function : str
+            Function string.
+
+        Returns
+        -------
+        None
+        """
+        function_kind = function.split("://")[0]
+        if self.EXECUTABLE_KIND != function_kind:
+            raise EntityError(f"Invalid task '{self.ENTITY_KIND}' for function kind '{function_kind}'")

digitalhub/entities/task/_base/entity.py

@@ -0,0 +1,136 @@
+from __future__ import annotations
+
+import typing
+
+from digitalhub.entities._base.unversioned.entity import UnversionedEntity
+from digitalhub.entities.run.crud import delete_run, get_run, new_run
+from digitalhub.entities.utils.entity_types import EntityTypes
+from digitalhub.factory.api import build_entity_from_params
+
+if typing.TYPE_CHECKING:
+    from digitalhub.entities._base.entity.metadata import Metadata
+    from digitalhub.entities.run._base.entity import Run
+    from digitalhub.entities.task._base.spec import TaskSpec
+    from digitalhub.entities.task._base.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 build_entity_from_params(**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)