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

digitalhub/entities/dataitem/table/models.py

@@ -0,0 +1,62 @@
+from __future__ import annotations
+
+from enum import Enum
+
+from pydantic import BaseModel, Field
+
+
+class FieldType(str, Enum):
+    """
+    Field type enum.
+    """
+
+    STRING = "string"
+    NUMBER = "number"
+    INTEGER = "integer"
+    BOOLEAN = "boolean"
+    OBJECT = "object"
+    ARRAY = "array"
+    DATE = "date"
+    TIME = "time"
+    DATETIME = "datetime"
+    YEAR = "year"
+    YEARMONTH = "yearmonth"
+    DURATION = "duration"
+    GEOPOINT = "geopoint"
+    GEOJSON = "geojson"
+    ANY = "any"
+
+
+class TableSchemaFieldEntry(BaseModel):
+    """
+    Table schema field entry model.
+    """
+
+    name: str
+    """Field name."""
+
+    type_: FieldType = Field(alias="type")
+    """Field type."""
+
+    title: str = None
+    """Field title."""
+
+    format_: str = Field(default=None, alias="format")
+    """Field format."""
+
+    example: str = None
+    """Field example."""
+
+    description: str = None
+    """Field description."""
+
+    class Config:
+        use_enum_values = True
+
+
+class TableSchema(BaseModel):
+    """
+    Table schema model.
+    """
+
+    fields: list[TableSchemaFieldEntry]

digitalhub/entities/dataitem/table/spec.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+from pydantic import Field
+
+from digitalhub.entities.dataitem._base.spec import DataitemSpec, DataitemValidator
+from digitalhub.entities.dataitem.table.models import TableSchema
+
+
+class DataitemSpecTable(DataitemSpec):
+    """
+    DataitemSpecTable specifications.
+    """
+
+    def __init__(self, path: str, schema: dict | None = None) -> None:
+        super().__init__(path)
+        self.schema = schema
+
+
+class DataitemValidatorTable(DataitemValidator):
+    """
+    DataitemValidatorTable validator.
+    """
+
+    schema_: TableSchema = Field(default=None, alias="schema")
+    """The schema of the dataitem in table schema format."""

digitalhub/entities/dataitem/table/status.py

@@ -0,0 +1,9 @@
+from __future__ import annotations
+
+from digitalhub.entities.dataitem._base.status import DataitemStatus
+
+
+class DataitemStatusTable(DataitemStatus):
+    """
+    DataitemStatusTable status.
+    """

digitalhub/entities/function/_base/builder.py

@@ -0,0 +1,79 @@
+from __future__ import annotations
+
+import typing
+
+from digitalhub.entities._base.runtime_entity.builder import RuntimeEntityBuilder
+from digitalhub.entities._base.versioned.builder import VersionedBuilder
+from digitalhub.entities.utils.entity_types import EntityTypes
+
+if typing.TYPE_CHECKING:
+    from digitalhub.entities.function._base.entity import Function
+
+
+class FunctionBuilder(VersionedBuilder, RuntimeEntityBuilder):
+    """
+    Function builder.
+    """
+
+    ENTITY_TYPE = EntityTypes.FUNCTION.value
+
+    def build(
+        self,
+        kind: str,
+        project: str,
+        name: str,
+        uuid: str | None = None,
+        description: str | None = None,
+        labels: list[str] | None = None,
+        embedded: bool = False,
+        **kwargs,
+    ) -> Function:
+        """
+        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.
+        embedded : bool
+            Flag to determine if object spec must be embedded in project spec.
+        **kwargs : dict
+            Spec keyword arguments.
+
+        Returns
+        -------
+        Function
+            Object instance.
+        """
+        name = self.build_name(name)
+        uuid = self.build_uuid(uuid)
+        metadata = self.build_metadata(
+            project=project,
+            name=name,
+            description=description,
+            labels=labels,
+            embedded=embedded,
+        )
+        spec = self.build_spec(
+            **kwargs,
+        )
+        status = self.build_status()
+        return self.build_entity(
+            project=project,
+            name=name,
+            uuid=uuid,
+            kind=kind,
+            metadata=metadata,
+            spec=spec,
+            status=status,
+        )

digitalhub/entities/function/_base/entity.py

@@ -0,0 +1,98 @@
+from __future__ import annotations
+
+import typing
+from concurrent.futures import ThreadPoolExecutor
+
+from digitalhub.entities._base.executable.entity import ExecutableEntity
+from digitalhub.entities.utils.entity_types import EntityTypes
+from digitalhub.factory.api import get_run_kind, get_task_kind_from_action
+from digitalhub.utils.exceptions import BackendError
+
+if typing.TYPE_CHECKING:
+    from digitalhub.entities._base.entity.metadata import Metadata
+    from digitalhub.entities.function._base.spec import FunctionSpec
+    from digitalhub.entities.function._base.status import FunctionStatus
+    from digitalhub.entities.run._base.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 task and run kind
+        task_kind = get_task_kind_from_action(self.kind, action)
+        run_kind = get_run_kind(self.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

digitalhub/entities/function/_base/models.py

@@ -0,0 +1,118 @@
+from __future__ import annotations
+
+from abc import abstractmethod
+from pathlib import Path
+
+from pydantic import BaseModel
+
+from digitalhub.utils.exceptions import EntityError
+from digitalhub.utils.generic_utils import decode_string
+from digitalhub.utils.uri_utils import map_uri_scheme
+
+
+class SourceCodeStruct:
+    """
+    Source code struct.
+    """
+
+    def __init__(
+        self,
+        source: str | None = None,
+        code: str | None = None,
+        base64: str | None = None,
+        handler: str | None = None,
+        lang: str | None = None,
+    ) -> None:
+        self.source = source
+        self.code = code
+        self.base64 = base64
+        self.handler = handler
+        self.lang = lang
+
+    @staticmethod
+    @abstractmethod
+    def source_check(source: dict) -> dict:
+        """
+        Check source.
+
+        Parameters
+        ----------
+        source : dict
+            Source.
+
+        Returns
+        -------
+        dict
+            Checked source.
+        """
+
+    def show_source_code(self) -> str:
+        """
+        Show source code.
+
+        Returns
+        -------
+        str
+            Source code.
+        """
+        if self.code is not None:
+            return self.code
+        if self.base64 is not None:
+            try:
+                return decode_string(self.base64)
+            except Exception:
+                raise EntityError("Something got wrong during source code decoding.")
+        if (self.source is not None) and (map_uri_scheme(self.source) == "local"):
+            try:
+                return Path(self.source).read_text()
+            except Exception:
+                raise EntityError("Cannot access source code.")
+        return ""
+
+    def to_dict(self) -> dict:
+        """
+        Convert to dictionary.
+
+        Returns
+        -------
+        dict
+            Dictionary representation of the object.
+        """
+        dict_ = {}
+        if self.source is not None:
+            dict_["source"] = self.source
+        if self.base64 is not None:
+            dict_["base64"] = self.base64
+        if self.handler is not None:
+            dict_["handler"] = self.handler
+        if self.lang is not None:
+            dict_["lang"] = self.lang
+
+        return dict_
+
+    def __repr__(self) -> str:
+        return str(self.to_dict())
+
+
+class SourceCodeValidator(BaseModel):
+    """
+    Source code params.
+    """
+
+    source: dict = None
+    "Source code details as dictionary"
+
+    code_src: str = None
+    "Pointer to source code"
+
+    handler: str = None
+    "Function entrypoint"
+
+    code: str = None
+    "Source code (plain text)"
+
+    base64: str = None
+    "Source code (base64 encoded)"
+
+    lang: str = None
+    "Source code language (hint)"

digitalhub/entities/function/_base/spec.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+from digitalhub.entities._base.entity.spec import Spec, SpecValidator
+
+
+class FunctionSpec(Spec):
+    """
+    FunctionSpec specifications.
+    """
+
+
+class FunctionValidator(SpecValidator):
+    """
+    FunctionValidator validator.
+    """

digitalhub/entities/function/_base/status.py

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

digitalhub/entities/function/crud.py

@@ -0,0 +1,279 @@
+from __future__ import annotations
+
+import typing
+
+from digitalhub.entities._base.crud import (
+    delete_entity,
+    get_context_entity_versions,
+    get_versioned_entity,
+    import_executable_entity,
+    list_context_entities,
+    new_context_entity,
+)
+from digitalhub.entities.utils.entity_types import EntityTypes
+
+if typing.TYPE_CHECKING:
+    from digitalhub.entities.function._base.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 = False,
+    **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.
+    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")
+    """
+    return new_context_entity(
+        project=project,
+        name=name,
+        kind=kind,
+        uuid=uuid,
+        description=description,
+        labels=labels,
+        embedded=embedded,
+        **kwargs,
+    )
+
+
+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")
+    """
+    return get_versioned_entity(
+        identifier,
+        entity_type=ENTITY_TYPE,
+        project=project,
+        entity_id=entity_id,
+        **kwargs,
+    )
+
+
+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")
+    """
+    return get_context_entity_versions(
+        identifier,
+        entity_type=ENTITY_TYPE,
+        project=project,
+        **kwargs,
+    )
+
+
+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")
+    """
+    return list_context_entities(
+        project=project,
+        entity_type=ENTITY_TYPE,
+        **kwargs,
+    )
+
+
+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")
+    """
+    return import_executable_entity(file)
+
+
+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(
+        identifier=identifier,
+        entity_type=ENTITY_TYPE,
+        project=project,
+        entity_id=entity_id,
+        delete_all_versions=delete_all_versions,
+        cascade=cascade,
+        **kwargs,
+    )