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

digitalhub/factory/factory.py

@@ -0,0 +1,268 @@
+from __future__ import annotations
+
+import typing
+
+from digitalhub.utils.exceptions import BuilderError
+
+if typing.TYPE_CHECKING:
+    from digitalhub.entities._base.entity.builder import EntityBuilder
+    from digitalhub.entities._base.entity.entity import Entity
+    from digitalhub.entities._base.entity.metadata import Metadata
+    from digitalhub.entities._base.entity.spec import Spec
+    from digitalhub.entities._base.entity.status import Status
+    from digitalhub.entities._base.runtime_entity.builder import RuntimeEntityBuilder
+    from digitalhub.runtimes._base import Runtime
+    from digitalhub.runtimes.builder import RuntimeBuilder
+
+
+class Factory:
+    """
+    Factory class for building entities and runtimes.
+    """
+
+    def __init__(self):
+        self._entity_builders: dict[str, EntityBuilder | RuntimeEntityBuilder] = {}
+        self._runtime_builders: dict[str, RuntimeBuilder] = {}
+
+    def add_entity_builder(self, name: str, builder: EntityBuilder | RuntimeEntityBuilder) -> None:
+        """
+        Add a builder to the factory.
+
+        Parameters
+        ----------
+        name : str
+            Builder name.
+        builder : EntityBuilder
+            Builder object.
+
+        Returns
+        -------
+        None
+        """
+        if name in self._entity_builders:
+            raise BuilderError(f"Builder {name} already exists.")
+        self._entity_builders[name] = builder()
+
+    def add_runtime_builder(self, name: str, builder: RuntimeBuilder) -> None:
+        """
+        Add a builder to the factory.
+
+        Parameters
+        ----------
+        name : str
+            Builder name.
+        builder : RuntimeBuilder
+            Builder object.
+
+        Returns
+        -------
+        None
+        """
+        if name in self._runtime_builders:
+            raise BuilderError(f"Builder {name} already exists.")
+        self._runtime_builders[name] = builder()
+
+    def build_entity_from_params(self, kind_to_build_from: str, **kwargs) -> Entity:
+        """
+        Build an entity from parameters.
+
+        Parameters
+        ----------
+        kind_to_build_from : str
+            Entity type.
+        **kwargs
+            Entity parameters.
+
+        Returns
+        -------
+        Entity
+            Entity object.
+        """
+        return self._entity_builders[kind_to_build_from].build(**kwargs)
+
+    def build_entity_from_dict(self, kind_to_build_from: str, obj: dict) -> Entity:
+        """
+        Build an entity from a dictionary.
+
+        Parameters
+        ----------
+        kind_to_build_from : str
+            Entity type.
+        dict_data : dict
+            Dictionary with entity data.
+
+        Returns
+        -------
+        Entity
+            Entity object.
+        """
+        return self._entity_builders[kind_to_build_from].from_dict(obj)
+
+    def build_spec(self, kind_to_build_from: str, **kwargs) -> Spec:
+        """
+        Build an entity spec.
+
+        Parameters
+        ----------
+        kind_to_build_from : str
+            Entity type.
+
+        Returns
+        -------
+        Spec
+            Spec object.
+        """
+        return self._entity_builders[kind_to_build_from].build_spec(**kwargs)
+
+    def build_metadata(self, kind_to_build_from: str, **kwargs) -> Metadata:
+        """
+        Build an entity metadata.
+
+        Parameters
+        ----------
+        kind_to_build_from : str
+            Entity type.
+
+        Returns
+        -------
+        Metadata
+            Metadata object.
+        """
+        return self._entity_builders[kind_to_build_from].build_metadata(**kwargs)
+
+    def build_status(self, kind_to_build_from: str, **kwargs) -> Status:
+        """
+        Build an entity status.
+
+        Parameters
+        ----------
+        kind_to_build_from : str
+            Entity type.
+
+        Returns
+        -------
+        Status
+            Status object.
+        """
+        return self._entity_builders[kind_to_build_from].build_status(**kwargs)
+
+    def build_runtime(self, kind_to_build_from: str, project: str) -> Runtime:
+        """
+        Build a runtime.
+
+        Parameters
+        ----------
+        kind_to_build_from : str
+            Runtime type.
+        project : str
+            Project name.
+
+        Returns
+        -------
+        Runtime
+            Runtime object.
+        """
+        return self._runtime_builders[kind_to_build_from].build(project=project)
+
+    def get_entity_type_from_kind(self, kind: str) -> str:
+        """
+        Get entity type from builder.
+
+        Parameters
+        ----------
+        kind : str
+            Entity type.
+
+        Returns
+        -------
+        str
+            Entity type.
+        """
+        return self._entity_builders[kind].get_entity_type()
+
+    def get_executable_kind(self, kind: str) -> str:
+        """
+        Get executable kind.
+
+        Parameters
+        ----------
+        kind : str
+            Kind.
+
+        Returns
+        -------
+        str
+            Executable kind.
+        """
+        return self._entity_builders[kind].get_executable_kind()
+
+    def get_action_from_task_kind(self, kind: str, task_kind: str) -> str:
+        """
+        Get action from task.
+
+        Parameters
+        ----------
+        kind : str
+            Kind.
+        task_kind : str
+            Task kind.
+
+        Returns
+        -------
+        str
+            Action.
+        """
+        return self._entity_builders[kind].get_action_from_task_kind(task_kind)
+
+    def get_task_kind_from_action(self, kind: str, action: str) -> list[str]:
+        """
+        Get task kinds from action.
+
+        Parameters
+        ----------
+        kind : str
+            Kind.
+        action : str
+            Action.
+
+        Returns
+        -------
+        list[str]
+            Task kinds.
+        """
+        return self._entity_builders[kind].get_task_kind_from_action(action)
+
+    def get_run_kind(self, kind: str) -> str:
+        """
+        Get run kind.
+
+        Parameters
+        ----------
+        kind : str
+            Kind.
+
+        Returns
+        -------
+        str
+            Run kind.
+        """
+        return self._entity_builders[kind].get_run_kind()
+
+    def get_all_kinds(self, kind: str) -> list[str]:
+        """
+        Get all kinds.
+
+        Parameters
+        ----------
+        kind : str
+            Kind.
+
+        Returns
+        -------
+        list[str]
+            All kinds.
+        """
+        return self._entity_builders[kind].get_all_kinds()
+
+
+factory = Factory()

digitalhub/factory/utils.py

@@ -0,0 +1,90 @@
+from __future__ import annotations
+
+import importlib
+import importlib.metadata
+import pkgutil
+import re
+from types import ModuleType
+
+from digitalhub.factory.factory import factory
+
+
+def import_module(package: str) -> ModuleType:
+    """
+    Import modules from package name.
+
+    Parameters
+    ----------
+    package : str
+        Package name.
+
+    Returns
+    -------
+    ModuleType
+        Module.
+    """
+    try:
+        return importlib.import_module(package)
+    except ModuleNotFoundError:
+        raise ModuleNotFoundError(f"Package {package} not found.")
+    except Exception as e:
+        raise e
+
+
+def list_runtimes() -> list[str]:
+    """
+    List installed runtimes for digitalhub.
+
+    Returns
+    -------
+    list
+        List of installed runtimes names.
+    """
+    pattern = r"digitalhub_runtime_.*"
+    runtimes = []
+    try:
+        for _, name, _ in pkgutil.iter_modules():
+            if re.match(pattern, name):
+                runtimes.append(name)
+        return runtimes
+    except Exception:
+        raise RuntimeError("Error listing installed runtimes.")
+
+
+def register_runtimes_entities() -> None:
+    """
+    Register runtimes and related entities into registry.
+
+    Returns
+    -------
+    None
+    """
+    for package in list_runtimes():
+        module = import_module(package)
+        entity_builders = getattr(module, "entity_builders")
+        for entity_builder_tuple in entity_builders:
+            kind, builder = entity_builder_tuple
+            factory.add_entity_builder(kind, builder)
+
+        runtime_builders = getattr(module, "runtime_builders")
+        for runtime_builder_tuple in runtime_builders:
+            kind, builder = runtime_builder_tuple
+            factory.add_runtime_builder(kind, builder)
+
+
+def register_entities() -> None:
+    """
+    Register layer and related entities into registry.
+
+    Returns
+    -------
+    None
+    """
+    try:
+        module = import_module("digitalhub.entities.builders")
+        entities_builders_list = getattr(module, "entity_builders")
+        for entity_builder_tuple in entities_builders_list:
+            kind, builder = entity_builder_tuple
+            factory.add_entity_builder(kind, builder)
+    except Exception:
+        pass

digitalhub/readers/_base/builder.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+import typing
+from abc import abstractmethod
+
+from digitalhub.utils.exceptions import BuilderError
+
+if typing.TYPE_CHECKING:
+    from digitalhub.readers._base.reader import DataframeReader
+
+
+class ReaderBuilder:
+    ENGINE = None
+    DATAFRAME_CLASS = None
+
+    def __init__(self):
+        if self.ENGINE is None:
+            raise BuilderError("ENGINE must be set.")
+        if self.DATAFRAME_CLASS is None:
+            raise BuilderError("DATAFRAME_CLASS must be set.")
+
+    @abstractmethod
+    def build(self, **kwargs) -> DataframeReader:
+        """
+        Build reader object.
+        """

digitalhub/readers/_base/reader.py

@@ -0,0 +1,70 @@
+from __future__ import annotations
+
+from abc import ABCMeta, abstractmethod
+from typing import Any
+
+
+class DataframeReader(metaclass=ABCMeta):
+    """
+    Dataframe reader abstract class.
+    """
+
+    ##############################
+    # Read methods
+    ##############################
+
+    @staticmethod
+    @abstractmethod
+    def read_df(path: str | list[str], extension: str, **kwargs) -> Any:
+        """
+        Read DataFrame from path.
+        """
+
+    ##############################
+    # Write methods
+    ##############################
+
+    @abstractmethod
+    def write_df(self, df: Any, dst: Any, extension: str | None = None, **kwargs) -> None:
+        """
+        Method to write a dataframe to a file.
+        """
+
+    @staticmethod
+    @abstractmethod
+    def write_csv(df: Any, *args, **kwargs) -> str:
+        """
+        Write DataFrame as csv.
+        """
+
+    @staticmethod
+    @abstractmethod
+    def write_parquet(df: Any, *args, **kwargs) -> str:
+        """
+        Write DataFrame as parquet.
+        """
+
+    @staticmethod
+    @abstractmethod
+    def write_table(df: Any, *args, **kwargs) -> str:
+        """
+        Write DataFrame as table.
+        """
+
+    ##############################
+    # Utils
+    ##############################
+
+    @staticmethod
+    @abstractmethod
+    def get_schema(df: Any) -> Any:
+        """
+        Get schema.
+        """
+
+    @staticmethod
+    @abstractmethod
+    def get_preview(df: Any) -> Any:
+        """
+        Get preview.
+        """

digitalhub/readers/api.py

@@ -0,0 +1,80 @@
+from __future__ import annotations
+
+import typing
+from typing import Any
+
+from digitalhub.readers.factory import factory
+
+if typing.TYPE_CHECKING:
+    from digitalhub.readers._base.reader import DataframeReader
+
+
+def get_reader_by_engine(engine: str | None = None) -> DataframeReader:
+    """
+    Get Dataframe reader.
+
+    Parameters
+    ----------
+    engine : str
+        Dataframe engine (pandas, polars, etc.).
+
+    Returns
+    -------
+    DataframeReader
+        Reader object.
+    """
+    if engine is None:
+        engine = factory.get_default()
+    try:
+        return factory.build(engine=engine)
+    except KeyError:
+        engines = factory.list_supported_engines()
+        msg = f"Unsupported dataframe engine: '{engine}'. Supported engines: {engines}"
+        raise ValueError(msg)
+
+
+def get_reader_by_object(obj: Any) -> DataframeReader:
+    """
+    Get Dataframe reader by object.
+
+    Parameters
+    ----------
+    obj : Any
+        Object to get reader from.
+
+    Returns
+    -------
+    DataframeReader
+        Reader object.
+    """
+    try:
+        obj_name = f"{obj.__class__.__module__}.{obj.__class__.__name__}"
+        return factory.build(dataframe=obj_name)
+    except KeyError:
+        types = factory.list_supported_dataframes()
+        msg = f"Unsupported dataframe type: '{obj}'. Supported types: {types}"
+        raise ValueError(msg)
+
+
+def get_supported_engines() -> list[str]:
+    """
+    Get supported engines.
+
+    Returns
+    -------
+    list
+        List of supported engines.
+    """
+    return factory.list_supported_engines()
+
+
+def get_supported_dataframes() -> list[str]:
+    """
+    Get supported dataframes.
+
+    Returns
+    -------
+    list
+        List of supported dataframes.
+    """
+    return factory.list_supported_dataframes()

digitalhub/readers/factory.py

@@ -0,0 +1,133 @@
+from __future__ import annotations
+
+import typing
+
+if typing.TYPE_CHECKING:
+    from digitalhub.readers._base.builder import ReaderBuilder
+    from digitalhub.readers._base.reader import DataframeReader
+
+
+class ReaderFactory:
+    """
+    Reader factory class.
+    """
+
+    def __init__(self) -> None:
+        self._engine_builders: dict[str, ReaderBuilder] = None
+        self._dataframe_builders: dict[str, ReaderBuilder] = None
+        self._default: str = None
+
+    def add_builder(self, engine: str, dataframe: str, builder: ReaderBuilder) -> None:
+        """
+        Add a builder to the factory.
+
+        Parameters
+        ----------
+        name : str
+            Reader name.
+        builder : DataframeReader
+            Builder object.
+
+        Returns
+        -------
+        None
+        """
+        if self._engine_builders is None:
+            self._engine_builders = {}
+        if engine in self._engine_builders:
+            raise ValueError(f"Engine {engine} already exists.")
+        self._engine_builders[engine] = builder
+
+        if self._dataframe_builders is None:
+            self._dataframe_builders = {}
+        if dataframe in self._dataframe_builders:
+            raise ValueError(f"Dataframe {dataframe} already exists.")
+        self._dataframe_builders[dataframe] = builder
+
+    def build(self, engine: str | None = None, dataframe: str | None = None, **kwargs) -> DataframeReader:
+        """
+        Build reader object.
+
+        Parameters
+        ----------
+        engine : str | None
+            Engine name.
+        dataframe : str | None
+            Dataframe name.
+        **kwargs : dict
+            Keyword arguments.
+
+        Returns
+        -------
+        DataframeReader
+            Reader object.
+        """
+        if (engine is None) == (dataframe is None):
+            raise ValueError("Either engine or dataframe must be provided.")
+        if engine is not None:
+            return self._engine_builders[engine].build(**kwargs)
+        return self._dataframe_builders[dataframe].build(**kwargs)
+
+    def list_supported_engines(self) -> list[str]:
+        """
+        List supported engines.
+
+        Returns
+        -------
+        list[str]
+            List of supported engines.
+        """
+        return list(self._engine_builders.keys())
+
+    def list_supported_dataframes(self) -> list[str]:
+        """
+        List supported dataframes.
+
+        Returns
+        -------
+        list[str]
+            List of supported dataframes.
+        """
+        return list(self._dataframe_builders.keys())
+
+    def set_default(self, engine: str) -> None:
+        """
+        Set default engine.
+
+        Parameters
+        ----------
+        engine : str
+            Engine name.
+
+        Returns
+        -------
+        None
+        """
+        if engine not in self._engine_builders:
+            raise ValueError(f"Engine {engine} not found.")
+        self._default = engine
+
+    def get_default(self) -> str:
+        """
+        Get default engine.
+
+        Returns
+        -------
+        str
+            Default engine.
+        """
+        if self._default is None:
+            raise ValueError("No default engine set.")
+        return self._default
+
+
+factory = ReaderFactory()
+
+try:
+    from digitalhub.readers.pandas.builder import ReaderBuilderPandas
+
+    factory.add_builder(ReaderBuilderPandas.ENGINE, ReaderBuilderPandas.DATAFRAME_CLASS, ReaderBuilderPandas())
+    factory.set_default(ReaderBuilderPandas.ENGINE)
+
+except ImportError:
+    pass

digitalhub/readers/pandas/builder.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+from digitalhub.readers._base.builder import ReaderBuilder
+from digitalhub.readers.pandas.reader import DataframeReaderPandas
+
+
+class ReaderBuilderPandas(ReaderBuilder):
+    """
+    Pandas reader builder.
+    """
+
+    ENGINE = "pandas"
+    DATAFRAME_CLASS = "pandas.core.frame.DataFrame"
+
+    def build(self, **kwargs) -> DataframeReaderPandas:
+        """
+        Build reader object.
+
+        Parameters
+        ----------
+        **kwargs : dict
+            Keyword arguments.
+
+        Returns
+        -------
+        DataframeReaderPandas
+            Pandas reader object.
+        """
+        return DataframeReaderPandas(**kwargs)