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

digitalhub/runtimes/base.py

@@ -0,0 +1,164 @@
+from __future__ import annotations
+
+import typing
+from abc import abstractmethod
+from typing import Any, Callable
+
+from digitalhub.utils.exceptions import EntityError
+from digitalhub.utils.logger import LOGGER
+
+if typing.TYPE_CHECKING:
+    from digitalhub.runtimes.kind_registry import KindRegistry
+
+
+class Runtime:
+    """
+    Base Runtime class.
+
+    Runtimes are the entities responsible for the actual execution
+    of a given run. They are highly specialized components which
+    can translate the representation of a given execution as expressed
+    in the run into an actual execution operation performed via
+    libraries, code, external tools etc.
+    """
+
+    def __init__(self, kind_registry: KindRegistry, project: str) -> None:
+        self.kind_registry = kind_registry
+        self.project = project
+
+    @abstractmethod
+    def build(self, executable: dict, task: dict, run: dict) -> dict:
+        """
+        Build run spec.
+        """
+
+    @abstractmethod
+    def run(self, run: dict) -> dict:
+        """
+        Execute run task.
+        """
+
+    @staticmethod
+    @abstractmethod
+    def _get_executable(action: str) -> Callable:
+        """
+        Get executable from action.
+        """
+
+    ##############################
+    # Private methods
+    ##############################
+
+    def _validate_task(self, run: dict) -> str:
+        """
+        Check if task is allowed. This presumes that the
+        runtime holds a list of allowed actions in the self.allowed_actions
+        attribute.
+
+        Parameters
+        ----------
+        run : dict
+            Run object dictionary.
+
+        Returns
+        -------
+        str
+            Action to execute.
+        """
+        try:
+            task_kind = run["spec"]["task"].split(":")[0]
+        except (KeyError, IndexError):
+            msg = "Malformed run spec."
+            LOGGER.exception(msg)
+            raise RuntimeError(msg)
+
+        try:
+            return self.get_action_from_task_kind(task_kind)
+        except EntityError:
+            msg = f"Task {task_kind} not allowed."
+            LOGGER.exception(msg)
+            raise RuntimeError(msg)
+
+    @staticmethod
+    def _execute(func: Callable, *args, **kwargs) -> Any:
+        """
+        Execute function.
+
+        Parameters
+        ----------
+        func : Callable
+            Function to execute.
+        *args
+            Function arguments.
+        **kwargs : dict
+            Function keyword arguments.
+
+        Returns
+        -------
+        Any
+            Function result.
+        """
+        try:
+            return func(*args, **kwargs)
+        except Exception:
+            msg = "Something got wrong during function execution."
+            LOGGER.exception(msg)
+            raise RuntimeError(msg)
+
+    ##############################
+    # Wrapper registry methods
+    ##############################
+
+    def get_executable_kind(self) -> str:
+        """
+        Get executable kind.
+
+        Returns
+        -------
+        str
+            Executable kind.
+        """
+        return self.kind_registry.get_executable_kind()
+
+    def get_task_kind_from_action(self, action: str) -> str:
+        """
+        Get task kind from action.
+
+        Parameters
+        ----------
+        action : str
+            Task action.
+
+        Returns
+        -------
+        str
+            Task kind.
+        """
+        return self.kind_registry.get_task_kind_from_action(action)
+
+    def get_action_from_task_kind(self, kind: str) -> str:
+        """
+        Get action from task.
+
+        Parameters
+        ----------
+        kind : str
+            Task kind.
+
+        Returns
+        -------
+        str
+            Action.
+        """
+        return self.kind_registry.get_action_from_task_kind(kind)
+
+    def get_run_kind(self) -> str:
+        """
+        Get run kind.
+
+        Returns
+        -------
+        str
+            Run kind.
+        """
+        return self.kind_registry.get_run_kind()

digitalhub/runtimes/builder.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+import typing
+
+from digitalhub.registry.registry import registry
+from digitalhub.registry.utils import import_class
+
+if typing.TYPE_CHECKING:
+    from digitalhub.registry.models import RegistryEntry
+    from digitalhub.runtimes.base import Runtime
+    from digitalhub.runtimes.kind_registry import KindRegistry
+
+
+def build_runtime(kind: str, project: str) -> Runtime:
+    """
+    Build runtime object. The builder takes in input a kind.
+    This kind can derive from functions, tasks, or runs, and
+    is inserted in the global kind registry where the runtimes
+    pakages are registered.
+    The builder requires the module path where the Runtime
+    subclass is defined and the class name. It requires also
+    the kind registry module, kind registry class and the project
+    name.
+
+    Parameters
+    ----------
+    kind : str
+        The type of runtime to build.
+    project : str
+        The project name.
+
+    Returns
+    -------
+    Runtime
+        Runtime object.
+    """
+    infos: RegistryEntry = getattr(registry, kind)
+    cls = import_class(infos.runtime.module, infos.runtime.class_name)
+    kind_registry = get_kind_registry(kind)
+    return cls(kind_registry, project)
+
+
+def get_kind_registry(kind: str) -> KindRegistry:
+    """
+    Get kind registry.
+
+    Returns
+    -------
+    KindRegistry
+        Kind registry.
+    """
+    infos: RegistryEntry = getattr(registry, kind)
+    return import_class(infos.runtime.kind_registry_module, infos.runtime.kind_registry_class_name)

digitalhub/runtimes/kind_registry.py

@@ -0,0 +1,170 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+from digitalhub.utils.exceptions import EntityError
+
+
+class TaskModel(BaseModel):
+    """
+    Task model.
+    """
+
+    kind: str
+    action: str
+
+
+class RunModel(BaseModel):
+    """
+    Run model.
+    """
+
+    kind: str
+
+
+class ExecutableModel(BaseModel):
+    """
+    Executable model.
+    """
+
+    kind: str
+
+
+class DataModel(BaseModel):
+    """
+    Data model.
+    """
+
+    executable: ExecutableModel
+    task: list[TaskModel]
+    run: RunModel
+
+
+class KindRegistry:
+
+    """
+    Kind registry module for runtimes.
+    """
+
+    def __init__(self, data: dict[str, dict[str, str]]) -> None:
+        """
+        Constructor.
+
+        Parameters
+        ----------
+        data : dict[str, dict[str, str]]
+            Data to validate.
+
+        Examples
+        --------
+        >>> data = {
+        ...     "executable": {
+        ...         "kind": "executable-kind"
+        ...     },
+        ...     "run": {
+        ...         "kind": "run-kind"
+        ...     },
+        ...     "task": [
+        ...         {"kind": "task-kind-0", "action": "action-0"},
+        ...         {"kind": "task-kind-1", "action": "action-1"},
+        ...         {"kind": "task-kind-2", "action": "action-2"},
+        ...     ]
+        ... }
+        """
+        validated_data = self._validate_data(data)
+        self.data = validated_data
+
+    def _validate_data(self, data: dict[str, dict[str, str]]) -> DataModel:
+        """
+        Validate data.
+
+        Parameters
+        ----------
+        data : dict[str, dict[str, str]]
+            Data to validate.
+
+        Raises
+        ------
+        EntityError
+            If data is not valid.
+        """
+        try:
+            return DataModel(**data)
+        except Exception as e:
+            raise EntityError("Invalid data.") from e
+
+    def get_task_kind_from_action(self, action: str) -> str:
+        """
+        Get task kind from action.
+
+        Parameters
+        ----------
+        action : str
+            Task action.
+
+        Returns
+        -------
+        str
+            Task kind.
+
+        Raises
+        ------
+        EntityError
+            If action is not allowed.
+        """
+        try:
+            for task in self.data.task:
+                if task.action == action:
+                    return task.kind
+        except StopIteration:
+            msg = f"Action {action} not allowed."
+            raise EntityError(msg)
+
+    def get_action_from_task_kind(self, kind: str) -> str:
+        """
+        Get action from task.
+
+        Parameters
+        ----------
+        kind : str
+            Task kind.
+
+        Returns
+        -------
+        str
+            Action.
+
+        Raises
+        ------
+        EntityError
+            If task is not allowed.
+        """
+        try:
+            for task in self.data.task:
+                if task.kind == kind:
+                    return task.action
+        except StopIteration:
+            msg = f"Task {kind} not allowed."
+            raise EntityError(msg)
+
+    def get_run_kind(self) -> str:
+        """
+        Get run kind.
+
+        Returns
+        -------
+        str
+            Run kind.
+        """
+        return self.data.run.kind
+
+    def get_executable_kind(self) -> str:
+        """
+        Get executable kind.
+
+        Returns
+        -------
+        str
+            Executable kind.
+        """
+        return self.data.executable.kind

digitalhub/stores/builder.py

@@ -0,0 +1,257 @@
+from __future__ import annotations
+
+import os
+import typing
+
+from pydantic import ValidationError
+
+from digitalhub.stores.objects.base import StoreParameters
+from digitalhub.stores.objects.local import LocalStore, LocalStoreConfig
+from digitalhub.stores.objects.remote import RemoteStore, RemoteStoreConfig
+from digitalhub.stores.objects.s3 import S3Store, S3StoreConfig
+from digitalhub.stores.objects.sql import SqlStore, SQLStoreConfig
+from digitalhub.utils.exceptions import StoreError
+from digitalhub.utils.uri_utils import map_uri_scheme
+
+if typing.TYPE_CHECKING:
+    from digitalhub.stores.objects.base import Store
+
+
+REGISTRY_STORES = {
+    "local": LocalStore,
+    "s3": S3Store,
+    "remote": RemoteStore,
+    "sql": SqlStore,
+}
+
+
+class StoreBuilder:
+    """
+    Store builder class.
+    """
+
+    def __init__(self) -> None:
+        self._instances: dict[str, Store] = {}
+        self._default: Store | None = None
+        self._def_scheme = "s3"
+
+    def build(self, store_cfg: StoreParameters) -> None:
+        """
+        Build a store instance and register it.
+        It overrides any existing instance.
+
+        Parameters
+        ----------
+        store_cfg : StoreParameters
+            Store configuration.
+
+        Returns
+        -------
+        None
+        """
+        scheme = map_uri_scheme(store_cfg.type)
+        self._instances[scheme] = self.build_store(store_cfg)
+
+    def get(self, uri: str) -> Store:
+        """
+        Get a store instance by URI.
+
+        Parameters
+        ----------
+        uri : str
+            URI to parse.
+
+        Returns
+        -------
+        Store
+            The store instance.
+        """
+        scheme = map_uri_scheme(uri)
+        if scheme not in self._instances:
+            store_cfg = get_env_store_config(scheme)
+            self._instances[scheme] = self.build_store(store_cfg)
+        return self._instances[scheme]
+
+    def default(self) -> Store:
+        """
+        Get the default store instance.
+
+        Returns
+        -------
+        Store
+            The default store instance.
+
+        Raises
+        ------
+        StoreError
+            If no default store is set.
+        """
+        if self._default is None:
+            store_cfg = get_env_store_config(self._def_scheme)
+            self._default = self.build_store(store_cfg)
+        return self._default
+
+    def build_store(self, cfg: StoreParameters) -> Store:
+        """
+        Build a store instance.
+
+        Parameters
+        ----------
+        cfg : StoreParameters
+            Store configuration.
+
+        Returns
+        -------
+        Store
+            The store instance.
+
+        Raises
+        ------
+        NotImplementedError
+            If the store type is not implemented.
+        """
+        try:
+            obj = REGISTRY_STORES[cfg.type](cfg.name, cfg.type, cfg.config)
+            if cfg.is_default and self._default is not None:
+                raise StoreError("Only one default store!")
+            return obj
+        except KeyError as e:
+            raise NotImplementedError from e
+
+    @staticmethod
+    def _check_config(config: StoreParameters | dict) -> StoreParameters:
+        """
+        Check the store configuration validity.
+
+        Parameters
+        ----------
+        config : StoreParameters | dict
+            The store configuration.
+
+        Returns
+        -------
+        StoreParameters
+            The store configuration.
+
+        Raises
+        ------
+        TypeError
+            If the config parameter is not a StoreParameters instance or a well-formed dictionary.
+        """
+        if not isinstance(config, StoreParameters):
+            try:
+                return StoreParameters(**config)
+            except TypeError as e:
+                raise StoreError("Invalid store configuration type.") from e
+            except ValidationError as e:
+                raise StoreError("Malformed store configuration parameters.") from e
+        return config
+
+
+def get_env_store_config(scheme: str) -> StoreParameters:
+    """
+    Get a store configuration from the environment.
+
+    Parameters
+    ----------
+    scheme : str
+        URI scheme.
+
+    Returns
+    -------
+    StoreParameters
+        The store configuration based on the scheme.
+
+    Raises
+    ------
+    ValueError
+        If the scheme is not supported.
+    """
+    if scheme == "s3":
+        return StoreParameters(
+            name="s3",
+            type="s3",
+            config=S3StoreConfig(
+                endpoint_url=os.getenv("S3_ENDPOINT_URL"),  # type: ignore
+                aws_access_key_id=os.getenv("AWS_ACCESS_KEY_ID"),  # type: ignore
+                aws_secret_access_key=os.getenv("AWS_SECRET_ACCESS_KEY"),  # type: ignore
+                bucket_name=os.getenv("S3_BUCKET_NAME"),  # type: ignore
+            ),
+        )
+    if scheme == "sql":
+        return StoreParameters(
+            name="sql",
+            type="sql",
+            config=SQLStoreConfig(
+                host=os.getenv("POSTGRES_HOST"),  # type: ignore
+                port=os.getenv("POSTGRES_PORT"),  # type: ignore
+                user=os.getenv("POSTGRES_USER"),  # type: ignore
+                password=os.getenv("POSTGRES_PASSWORD"),  # type: ignore
+                database=os.getenv("POSTGRES_DATABASE"),  # type: ignore
+                pg_schema=os.getenv("POSTGRES_SCHEMA"),  # type: ignore
+            ),
+        )
+    if scheme == "remote":
+        return StoreParameters(
+            name="remote",
+            type="remote",
+            config=RemoteStoreConfig(),
+        )
+    if scheme == "local":
+        return StoreParameters(
+            name="local",
+            type="local",
+            config=LocalStoreConfig(
+                path="tempsdk",
+            ),
+        )
+    raise ValueError(f"Unsupported scheme {scheme}")
+
+
+def set_store(store_cfg: StoreParameters) -> None:
+    """
+    Set a new store instance with the given configuration.
+
+    Parameters
+    ----------
+    store_cfg : StoreParameters
+        Store configuration.
+
+    Returns
+    -------
+    None
+    """
+    store_builder.build(store_cfg)
+
+
+def get_store(uri: str) -> Store:
+    """
+    Get store instance by uri.
+
+    Parameters
+    ---------
+    uri : str
+        URI to parse.
+
+    Returns
+    -------
+    Store
+        Store instance.
+    """
+    return store_builder.get(uri)
+
+
+def get_default_store() -> Store:
+    """
+    Get the default store instance. The default store is the one that
+    can persist artifacts and dataitems.
+
+    Returns
+    -------
+    Store
+        Default store instance.
+    """
+    return store_builder.default()
+
+
+store_builder = StoreBuilder()