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

digitalhub/entities/dataitem/spec.py

@@ -0,0 +1,61 @@
+from __future__ import annotations
+
+from pydantic import Field
+
+from digitalhub.entities._base.spec.material import MaterialParams, MaterialSpec
+from digitalhub.entities.dataitem.models import TableSchema
+
+
+class DataitemSpec(MaterialSpec):
+    """
+    Dataitem specifications.
+    """
+
+
+class DataitemParams(MaterialParams):
+    """
+    Dataitem parameters.
+    """
+
+
+class DataitemSpecDataitem(DataitemSpec):
+    """
+    Dataitem dataitem specifications.
+    """
+
+
+class DataitemParamsDataitem(DataitemParams):
+    """
+    Dataitem dataitem parameters.
+    """
+
+
+class DataitemSpecTable(DataitemSpec):
+    """
+    Dataitem table specifications.
+    """
+
+    def __init__(self, path: str, schema: dict | None = None) -> None:
+        super().__init__(path)
+        self.schema = schema
+
+
+class DataitemParamsTable(DataitemParams):
+    """
+    Dataitem table parameters.
+    """
+
+    schema_: TableSchema = Field(default=None, alias="schema")
+    """The schema of the dataitem in table schema format."""
+
+
+class DataitemSpecIceberg(DataitemSpec):
+    """
+    Dataitem iceberg specifications.
+    """
+
+
+class DataitemParamsIceberg(DataitemParams):
+    """
+    Dataitem iceberg parameters.
+    """

digitalhub/entities/dataitem/status.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+from digitalhub.entities._base.status.material import MaterialStatus
+
+
+class DataitemStatus(MaterialStatus):
+    """
+    Status class for dataitem entities.
+    """
+
+    def __init__(
+        self,
+        state: str,
+        message: str | None = None,
+        files: list[dict] | None = None,
+        preview: dict | None = None,
+        **kwargs,
+    ) -> None:
+        super().__init__(state, message, files)
+        self.preview = preview
+
+
+class DataitemStatusDataitem(DataitemStatus):
+    """
+    Status class for dataitem dataitem entities.
+    """
+
+
+class DataitemStatusTable(DataitemStatus):
+    """
+    Status class for dataitem table entities.
+    """
+
+
+class DataitemStatusIceberg(DataitemStatus):
+    """
+    Status class for dataitem iceberg entities.
+    """

digitalhub/entities/entity_types.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+from enum import Enum
+
+
+class EntityTypes(Enum):
+    """
+    Entity types.
+    """
+
+    PROJECT = "project"
+    ARTIFACT = "artifact"
+    DATAITEM = "dataitem"
+    MODEL = "model"
+    SECRET = "secret"
+    FUNCTION = "function"
+    WORKFLOW = "workflow"
+    TASK = "task"
+    RUN = "run"

digitalhub/entities/function/builder.py

@@ -0,0 +1,86 @@
+from __future__ import annotations
+
+from digitalhub.entities._builders.metadata import build_metadata
+from digitalhub.entities._builders.name import build_name
+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.function.entity import Function
+
+
+def function_from_parameters(
+    project: str,
+    name: str,
+    kind: str,
+    uuid: str | None = None,
+    description: str | None = None,
+    labels: list[str] | None = None,
+    embedded: bool = True,
+    **kwargs,
+) -> Function:
+    """
+    Create a new Function instance and persist it to the backend.
+
+    Parameters
+    ----------
+    project : str
+        Project name.
+    name : str
+        Object name.
+    kind : str
+        Kind the object.
+    uuid : str
+        ID of the object (UUID4, e.g. 40f25c4b-d26b-4221-b048-9527aff291e2).
+    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.
+    **kwargs : dict
+        Spec keyword arguments.
+
+    Returns
+    -------
+    Function
+        Object instance.
+    """
+    name = build_name(name)
+    uuid = build_uuid(uuid)
+    spec = build_spec(kind, **kwargs)
+    metadata = build_metadata(
+        kind,
+        project=project,
+        name=name,
+        version=uuid,
+        description=description,
+        labels=labels,
+        embedded=embedded,
+    )
+    status = build_status(kind)
+    return Function(
+        project=project,
+        name=name,
+        uuid=uuid,
+        kind=kind,
+        metadata=metadata,
+        spec=spec,
+        status=status,
+    )
+
+
+def function_from_dict(obj: dict) -> Function:
+    """
+    Create a new object from dictionary.
+
+    Parameters
+    ----------
+    obj : dict
+        Dictionary to create object from.
+
+    Returns
+    -------
+    Function
+        Function object.
+    """
+    return Function.from_dict(obj)

digitalhub/entities/function/crud.py

@@ -0,0 +1,305 @@
+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,
+    read_entity_api_ctx_versions,
+)
+from digitalhub.entities.entity_types import EntityTypes
+from digitalhub.entities.function.builder import function_from_dict, function_from_parameters
+from digitalhub.utils.exceptions import EntityAlreadyExistsError
+from digitalhub.utils.io_utils import read_yaml
+
+if typing.TYPE_CHECKING:
+    from digitalhub.entities.function.entity import Function
+
+ENTITY_TYPE = EntityTypes.FUNCTION.value
+
+
+def new_function(
+    project: str,
+    name: str,
+    kind: str,
+    uuid: str | None = None,
+    description: str | None = None,
+    labels: list[str] | None = None,
+    embedded: bool = True,
+    **kwargs,
+) -> Function:
+    """
+    Create a Function instance with the given parameters.
+
+    Parameters
+    ----------
+    project : str
+        Project name.
+    name : str
+        Object name.
+    kind : str
+        Kind the object.
+    uuid : str
+        ID of the object (UUID4, e.g. 40f25c4b-d26b-4221-b048-9527aff291e2).
+    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.
+    **kwargs : dict
+        Spec keyword arguments.
+
+    Returns
+    -------
+    Function
+        Object instance.
+
+    Examples
+    --------
+    >>> obj = new_function(project="my-project",
+    >>>                    name="my-function",
+    >>>                    kind="python",
+    >>>                    code_src="function.py",
+    >>>                    handler="function-handler")
+    """
+    check_context(project)
+    obj = function_from_parameters(
+        project=project,
+        name=name,
+        kind=kind,
+        uuid=uuid,
+        description=description,
+        labels=labels,
+        embedded=embedded,
+        **kwargs,
+    )
+    obj.save()
+    return obj
+
+
+def get_function(
+    identifier: str,
+    project: str | None = None,
+    entity_id: str | None = None,
+    **kwargs,
+) -> Function:
+    """
+    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
+    -------
+    Function
+        Object instance.
+
+    Examples
+    --------
+    Using entity key:
+    >>> obj = get_function("store://my-function-key")
+
+    Using entity name:
+    >>> obj = get_function("my-function-name"
+    >>>                    project="my-project",
+    >>>                    entity_id="my-function-id")
+    """
+    obj = read_entity_api_ctx(
+        identifier,
+        ENTITY_TYPE,
+        project=project,
+        entity_id=entity_id,
+        **kwargs,
+    )
+    return function_from_dict(obj)
+
+
+def get_function_versions(
+    identifier: str,
+    project: str | None = None,
+    **kwargs,
+) -> list[Function]:
+    """
+    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[Function]
+        List of object instances.
+
+    Examples
+    --------
+    Using entity key:
+    >>> obj = get_function_versions("store://my-function-key")
+
+    Using entity name:
+    >>> obj = get_function_versions("my-function-name"
+    >>>                             project="my-project")
+    """
+    obj = read_entity_api_ctx_versions(
+        identifier,
+        entity_type=ENTITY_TYPE,
+        project=project,
+        **kwargs,
+    )
+    return [function_from_dict(o) for o in obj]
+
+
+def list_functions(project: str, **kwargs) -> list[Function]:
+    """
+    List all latest version objects from backend.
+
+    Parameters
+    ----------
+    project : str
+        Project name.
+    **kwargs : dict
+        Parameters to pass to the API call.
+
+    Returns
+    -------
+    list[Function]
+        List of object instances.
+
+    Examples
+    --------
+    >>> objs = list_functions(project="my-project")
+    """
+    objs = list_entity_api_ctx(
+        project=project,
+        entity_type=ENTITY_TYPE,
+        **kwargs,
+    )
+    return [function_from_dict(obj) for obj in objs]
+
+
+def import_function(file: str) -> Function:
+    """
+    Get object from file.
+
+    Parameters
+    ----------
+    file : str
+        Path to YAML file.
+
+    Returns
+    -------
+    Function
+        Object instance.
+
+    Examples
+    --------
+    >>> obj = import_function("my-function.yaml")
+    """
+    dict_obj: dict | list[dict] = read_yaml(file)
+    if isinstance(dict_obj, list):
+        fnc_dict = dict_obj[0]
+        tsk_dicts = dict_obj[1:]
+    else:
+        fnc_dict = dict_obj
+        tsk_dicts = []
+
+    check_context(fnc_dict.get("project"))
+    obj = function_from_dict(fnc_dict)
+
+    obj.import_tasks(tsk_dicts)
+
+    try:
+        obj.save()
+    except EntityAlreadyExistsError:
+        pass
+    finally:
+        return obj
+
+
+def update_function(entity: Function) -> Function:
+    """
+    Update object. Note that object spec are immutable.
+
+    Parameters
+    ----------
+    entity : Function
+        Object to update.
+
+    Returns
+    -------
+    Function
+        Entity updated.
+
+    Examples
+    --------
+    >>> obj = update_function(obj)
+    """
+    return entity.save(update=True)
+
+
+def delete_function(
+    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_function("store://my-function-key")
+
+    Otherwise:
+    >>> obj = delete_function("function-name",
+    >>>                       project="my-project",
+    >>>                       delete_all_versions=True)
+    """
+    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/function/entity.py

@@ -0,0 +1,101 @@
+from __future__ import annotations
+
+import typing
+from concurrent.futures import ThreadPoolExecutor
+
+from digitalhub.entities._base.entity.executable import ExecutableEntity
+from digitalhub.entities.entity_types import EntityTypes
+from digitalhub.runtimes.builder import get_kind_registry
+from digitalhub.utils.exceptions import BackendError
+
+if typing.TYPE_CHECKING:
+    from digitalhub.entities._base.metadata import Metadata
+    from digitalhub.entities.function.spec import FunctionSpec
+    from digitalhub.entities.function.status import FunctionStatus
+    from digitalhub.entities.run.entity import Run
+
+
+class Function(ExecutableEntity):
+    """
+    A class representing a function.
+    """
+
+    ENTITY_TYPE = EntityTypes.FUNCTION.value
+
+    def __init__(
+        self,
+        project: str,
+        name: str,
+        uuid: str,
+        kind: str,
+        metadata: Metadata,
+        spec: FunctionSpec,
+        status: FunctionStatus,
+        user: str | None = None,
+    ) -> None:
+        super().__init__(project, name, uuid, kind, metadata, spec, status, user)
+
+        self.spec: FunctionSpec
+        self.status: FunctionStatus
+
+    ##############################
+    #  Function Methods
+    ##############################
+
+    def run(
+        self,
+        action: str,
+        local_execution: bool = False,
+        wait: bool = False,
+        log_info: bool = True,
+        **kwargs,
+    ) -> Run:
+        """
+        Run function. This method creates a new run and executes it.
+
+        Parameters
+        ----------
+        action : str
+            Action to execute.
+        local_execution : bool
+            Flag to determine if object has local execution.
+        wait : bool
+            Flag to wait for execution.
+        log_info : bool
+            Flag to log information while waiting.
+        **kwargs : dict
+            Keyword arguments passed to Run builder.
+
+        Returns
+        -------
+        Run
+            Run instance.
+        """
+        # Get kind registry
+        kind_reg = get_kind_registry(self.kind)
+
+        # Get task and run kind
+        task_kind = kind_reg.get_task_kind_from_action(action=action)
+        run_kind = kind_reg.get_run_kind()
+
+        # Create or update new task
+        task = self._get_or_create_task(task_kind)
+
+        # Run function from task
+        run = task.run(run_kind, local_execution, **kwargs)
+
+        # If execution is done by DHCore backend, return the object
+        if not local_execution:
+            if self._context().local:
+                raise BackendError("Cannot run remote function with local backend.")
+            if wait:
+                return run.wait(log_info=log_info)
+            return run
+
+        # If local execution, build and launch run.
+        # Detach the run from the main thread
+        run.build()
+        with ThreadPoolExecutor(max_workers=1) as executor:
+            result = executor.submit(run.run)
+            r = result.result()
+        return r