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

digitalhub/entities/model/entity/_base.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+import typing
+
+from digitalhub.entities._base.entity.material import MaterialEntity
+from digitalhub.entities.entity_types import EntityTypes
+
+if typing.TYPE_CHECKING:
+    from digitalhub.entities._base.metadata import Metadata
+    from digitalhub.entities.model.spec import ModelSpec
+    from digitalhub.entities.model.status import ModelStatus
+
+
+class Model(MaterialEntity):
+    """
+    A class representing a model.
+    """
+
+    ENTITY_TYPE = EntityTypes.MODEL.value
+
+    def __init__(
+        self,
+        project: str,
+        name: str,
+        uuid: str,
+        kind: str,
+        metadata: Metadata,
+        spec: ModelSpec,
+        status: ModelStatus,
+        user: str | None = None,
+    ) -> None:
+        super().__init__(project, name, uuid, kind, metadata, spec, status, user)
+        self.spec: ModelSpec
+        self.status: ModelStatus

digitalhub/entities/model/entity/huggingface.py

@@ -0,0 +1,9 @@
+from __future__ import annotations
+
+from digitalhub.entities.model.entity._base import Model
+
+
+class ModelHuggingface(Model):
+    """
+    Huggingface model.
+    """

digitalhub/entities/model/entity/mlflow.py

@@ -0,0 +1,90 @@
+from __future__ import annotations
+
+from urllib.parse import urlparse
+
+import mlflow
+
+from digitalhub.entities.model.entity._base import Model
+from digitalhub.entities.model.models import Dataset, Signature
+
+
+class ModelMlflow(Model):
+    """
+    Mlflow model.
+    """
+
+
+def from_mlflow_run(run_id: str) -> dict:
+    """
+    Extract from mlflow run spec for Digitalhub Model.
+
+    Parameters
+    ----------
+    run_id : str
+        The id of the mlflow run.
+
+    Returns
+    -------
+    dict
+        The extracted spec.
+    """
+
+    # Get MLFlow run
+    client = mlflow.MlflowClient()
+    run = client.get_run(run_id)
+
+    # Extract spec
+    data = run.data
+    parameters = data.params
+    metrics = data.metrics
+    source_path = urlparse(run.info.artifact_uri).path
+    model_uri = f"runs:/{run_id}/model"
+    model = mlflow.pyfunc.load_model(model_uri=model_uri)
+    model_config = model.model_config
+    flavor = None
+    for f in model.metadata.flavors:
+        if f != "python_function":
+            flavor = f
+            break
+
+    # Extract signature
+    mlflow_signature = model.metadata.signature
+    signature = Signature(
+        inputs=mlflow_signature.inputs.to_json() if mlflow_signature.inputs else None,
+        outputs=mlflow_signature.outputs.to_json() if mlflow_signature.outputs else None,
+        params=mlflow_signature.params.to_json() if mlflow_signature.params else None,
+    ).dict()
+
+    # Extract datasets
+    datasets = []
+    if run.inputs and run.inputs.dataset_inputs:
+        datasets = [
+            Dataset(
+                name=d.dataset.name,
+                digest=d.dataset.digest,
+                profile=d.dataset.profile,
+                schema=d.dataset.schema,
+                source=d.dataset.source,
+                source_type=d.dataset.source_type,
+            ).dict()
+            for d in run.inputs.dataset_inputs
+        ]
+
+    # Create model params
+    model_params = {}
+
+    # source path
+    model_params["source"] = source_path
+
+    # common properties
+    model_params["framework"] = flavor
+    model_params["parameters"] = parameters
+    model_params["metrics"] = metrics
+
+    # specific to MLFlow
+    model_params["flavor"] = flavor
+    model_params["model_config"] = model_config
+    model_params["input_datasets"] = datasets
+    model_params["signature"] = signature
+
+    return model_params

digitalhub/entities/model/entity/model.py

@@ -0,0 +1,9 @@
+from __future__ import annotations
+
+from digitalhub.entities.model.entity._base import Model
+
+
+class ModelModel(Model):
+    """
+    Model model.
+    """

digitalhub/entities/model/entity/sklearn.py

@@ -0,0 +1,9 @@
+from __future__ import annotations
+
+from digitalhub.entities.model.entity._base import Model
+
+
+class ModelSklearn(Model):
+    """
+    SKLearn model.
+    """

digitalhub/entities/model/models.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+from pydantic import BaseModel, Field
+
+
+class Signature(BaseModel):
+    """
+    MLFlow model signature.
+    """
+
+    inputs: str = None
+    outputs: str = None
+    params: str = None
+
+
+class Dataset(BaseModel):
+    """
+    MLFlow model dataset.
+    """
+
+    name: str = None
+    digest: str = None
+    profile: str = None
+    schema_: str = Field(default=None, alias="schema")
+    source: str = None
+    source_type: str = None

digitalhub/entities/model/spec.py

@@ -0,0 +1,146 @@
+from __future__ import annotations
+
+from digitalhub.entities._base.spec.material import MaterialParams, MaterialSpec
+from digitalhub.entities.model.models import Dataset, Signature
+
+
+class ModelSpec(MaterialSpec):
+    """
+    Model specifications.
+    """
+
+    def __init__(
+        self,
+        path: str,
+        framework: str | None = None,
+        algorithm: str | None = None,
+        base_model: str | None = None,
+        parameters: dict | None = None,
+        metrics: dict | None = None,
+    ) -> None:
+        self.path = path
+        self.framework = framework
+        self.algorithm = algorithm
+        self.base_model = base_model
+        self.parameters = parameters
+        self.metrics = metrics
+
+
+class ModelParams(MaterialParams):
+    """
+    Model parameters.
+    """
+
+    path: str
+    """Path to the model."""
+
+    framework: str = None
+    """Model framework (e.g. 'pytorch')."""
+
+    algorithm: str = None
+    """Model algorithm (e.g. 'resnet')."""
+
+    base_model: str = None
+    """Base model."""
+
+    parameters: dict = None
+    """Model parameters."""
+
+    metrics: dict = None
+    """Model metrics."""
+
+
+class ModelSpecModel(ModelSpec):
+    """
+    Model specifications.
+    """
+
+
+class ModelParamsModel(ModelParams):
+    """
+    Model parameters.
+    """
+
+
+class ModelSpecMlflow(ModelSpec):
+    """
+    Mlflow model specifications.
+    """
+
+    def __init__(
+        self,
+        path: str,
+        framework: str | None = None,
+        algorithm: str | None = None,
+        base_model: str | None = None,
+        parameters: dict | None = None,
+        metrics: dict | None = None,
+        flavor: str | None = None,
+        model_config: dict | None = None,
+        input_datasets: list[Dataset] | None = None,
+        signature: Signature = None,
+    ) -> None:
+        super().__init__(path, framework, algorithm, base_model, parameters, metrics)
+        self.flavor = flavor
+        self.model_config = model_config
+        self.input_datasets = input_datasets
+        self.signature = signature
+
+
+class ModelParamsMlflow(ModelParams):
+    """
+    Mlflow model parameters.
+    """
+
+    flavor: str = None
+    """Mlflow model flavor."""
+    model_config: dict = None
+    """Mlflow model config."""
+    input_datasets: list[Dataset] = None
+    """Mlflow input datasets."""
+    signature: Signature = None
+    """Mlflow model signature."""
+
+
+class ModelSpecSklearn(ModelSpec):
+    """
+    SKLearn model specifications.
+    """
+
+
+class ModelParamsSklearn(ModelParams):
+    """
+    SKLearn model parameters.
+    """
+
+
+class ModelSpecHuggingface(ModelSpec):
+    """
+    Huggingface model specifications.
+    """
+
+    def __init__(
+        self,
+        path: str,
+        framework: str | None = None,
+        algorithm: str | None = None,
+        base_model: str | None = None,
+        parameters: dict | None = None,
+        metrics: dict | None = None,
+        model_id: str | None = None,
+        model_revision: str = None,
+    ) -> None:
+        super().__init__(path, framework, algorithm, base_model, parameters, metrics)
+        self.model_id = model_id
+        self.model_revision = model_revision
+
+
+class ModelParamsHuggingface(ModelParams):
+    """
+    Huggingface model parameters.
+    """
+
+    model_id: str = None
+    """Huggingface model id. Optional. If not specified, the model is loaded from the model path"""
+    model_revision: str = None
+    """Huggingface model revision. Optional."""

digitalhub/entities/model/status.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+from digitalhub.entities._base.status.material import MaterialStatus
+
+
+class ModelStatus(MaterialStatus):
+    """
+    Status class for model entities.
+    """
+
+
+class ModelStatusModel(ModelStatus):
+    """
+    Status class for model entities.
+    """
+
+
+class ModelStatusMlflow(ModelStatus):
+    """
+    Status class for model entities.
+    """
+
+
+class ModelStatusSklearn(ModelStatus):
+    """
+    Status class for model entities.
+    """
+
+
+class ModelStatusHuggingface(ModelStatus):
+    """
+    Status class for model entities.
+    """

digitalhub/entities/project/builder.py

@@ -0,0 +1,82 @@
+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.project.entity import Project
+
+
+def project_from_parameters(
+    name: str,
+    kind: str,
+    description: str | None = None,
+    labels: list[str] | None = None,
+    local: bool = False,
+    context: str | None = None,
+    **kwargs,
+) -> Project:
+    """
+    Create a new object.
+
+    Parameters
+    ----------
+    name : str
+        Object name.
+    kind : str
+        Kind the object.
+    description : str
+        Description of the object (human readable).
+    labels : list[str]
+        List of labels.
+    local : bool
+        If True, use local backend, if False use DHCore backend. Default to False.
+    context : str
+        The context local folder of the project.
+    **kwargs : dict
+        Spec keyword arguments.
+
+    Returns
+    -------
+    Project
+        Object instance.
+    """
+    name = build_name(name)
+    spec = build_spec(
+        kind,
+        context=context,
+        **kwargs,
+    )
+    metadata = build_metadata(
+        kind,
+        project=name,
+        name=name,
+        description=description,
+        labels=labels,
+    )
+    status = build_status(kind)
+    return Project(
+        name=name,
+        kind=kind,
+        metadata=metadata,
+        spec=spec,
+        status=status,
+        local=local,
+    )
+
+
+def project_from_dict(obj: dict) -> Project:
+    """
+    Create a new object from dictionary.
+
+    Parameters
+    ----------
+    obj : dict
+        Dictionary to create object from.
+
+    Returns
+    -------
+    Project
+        Object instance.
+    """
+    return Project.from_dict(obj)