zenml-nightly 0.55.0.dev20240124__py3-none-any.whl → 0.72.0.dev20250116__py3-none-any.whl

zenml/materializers/numpy_materializer.py

@@ -1,4 +1,4 @@
-#  Copyright (c) ZenML GmbH 2021. All Rights Reserved.
+#  Copyright (c) ZenML GmbH 2024. All Rights Reserved.
 #
 #  Licensed under the Apache License, Version 2.0 (the "License");
 #  you may not use this file except in compliance with the License.
@@ -11,235 +11,25 @@
 #  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
 #  or implied. See the License for the specific language governing
 #  permissions and limitations under the License.
-"""Implementation of the ZenML NumPy materializer."""
-
-import os
-from collections import Counter
-from typing import TYPE_CHECKING, Any, ClassVar, Dict, Tuple, Type
-
-import numpy as np
-
-from zenml.enums import ArtifactType, VisualizationType
-from zenml.io import fileio
-from zenml.logger import get_logger
-from zenml.materializers.base_materializer import BaseMaterializer
-from zenml.metadata.metadata_types import DType, MetadataType
-
-if TYPE_CHECKING:
-    from numpy.typing import NDArray
-
-logger = get_logger(__name__)
-
-
-NUMPY_FILENAME = "data.npy"
-
-DATA_FILENAME = "data.parquet"
-SHAPE_FILENAME = "shape.json"
-DATA_VAR = "data_var"
-
-
-class NumpyMaterializer(BaseMaterializer):
-    """Materializer to read data to and from pandas."""
-
-    ASSOCIATED_TYPES: ClassVar[Tuple[Type[Any], ...]] = (np.ndarray,)
-    ASSOCIATED_ARTIFACT_TYPE: ClassVar[ArtifactType] = ArtifactType.DATA
-
-    def load(self, data_type: Type[Any]) -> "Any":
-        """Reads a numpy array from a `.npy` file.
-
-        Args:
-            data_type: The type of the data to read.
-
-
-        Raises:
-            ImportError: If pyarrow is not installed.
-
-        Returns:
-            The numpy array.
-        """
-        numpy_file = os.path.join(self.uri, NUMPY_FILENAME)
-
-        if fileio.exists(numpy_file):
-            with fileio.open(numpy_file, "rb") as f:
-                return np.load(f, allow_pickle=True)
-        elif fileio.exists(os.path.join(self.uri, DATA_FILENAME)):
-            logger.warning(
-                "A legacy artifact was found. "
-                "This artifact was created with an older version of "
-                "ZenML. You can still use it, but it will be "
-                "converted to the new format on the next materialization."
-            )
-            try:
-                # Import old materializer dependencies
-                import pyarrow as pa  # type: ignore
-                import pyarrow.parquet as pq  # type: ignore
-
-                from zenml.utils import yaml_utils
-
-                # Read numpy array from parquet file
-                shape_dict = yaml_utils.read_json(
-                    os.path.join(self.uri, SHAPE_FILENAME)
-                )
-                shape_tuple = tuple(shape_dict.values())
-                with fileio.open(
-                    os.path.join(self.uri, DATA_FILENAME), "rb"
-                ) as f:
-                    input_stream = pa.input_stream(f)
-                    data = pq.read_table(input_stream)
-                vals = getattr(data.to_pandas(), DATA_VAR).values
-                return np.reshape(vals, shape_tuple)
-            except ImportError:
-                raise ImportError(
-                    "You have an old version of a `NumpyMaterializer` ",
-                    "data artifact stored in the artifact store ",
-                    "as a `.parquet` file, which requires `pyarrow` for reading. ",
-                    "You can install `pyarrow` by running `pip install pyarrow`.",
-                )
-
-    def save(self, arr: "NDArray[Any]") -> None:
-        """Writes a np.ndarray to the artifact store as a `.npy` file.
-
-        Args:
-            arr: The numpy array to write.
-        """
-        with fileio.open(os.path.join(self.uri, NUMPY_FILENAME), "wb") as f:
-            np.save(f, arr)
-
-    def save_visualizations(
-        self, arr: "NDArray[Any]"
-    ) -> Dict[str, VisualizationType]:
-        """Saves visualizations for a numpy array.
-
-        If the array is 1D, a histogram is saved. If the array is 2D or 3D with
-        3 or 4 channels, an image is saved.
-
-        Args:
-            arr: The numpy array to visualize.
-
-        Returns:
-            A dictionary of visualization URIs and their types.
-        """
-        if not np.issubdtype(arr.dtype, np.number):
-            return {}
-
-        try:
-            # Save histogram for 1D arrays
-            if len(arr.shape) == 1:
-                histogram_path = os.path.join(self.uri, "histogram.png")
-                histogram_path = histogram_path.replace("\\", "/")
-                self._save_histogram(histogram_path, arr)
-                return {histogram_path: VisualizationType.IMAGE}
-
-            # Save as image for 3D arrays with 3 or 4 channels
-            if len(arr.shape) == 3 and arr.shape[2] in [3, 4]:
-                image_path = os.path.join(self.uri, "image.png")
-                image_path = image_path.replace("\\", "/")
-                self._save_image(image_path, arr)
-                return {image_path: VisualizationType.IMAGE}
-
-        except ImportError:
-            logger.info(
-                "Skipping visualization of numpy array because matplotlib "
-                "is not installed. To install matplotlib, run "
-                "`pip install matplotlib`."
-            )
-
-        return {}
-
-    def _save_histogram(self, output_path: str, arr: "NDArray[Any]") -> None:
-        """Saves a histogram of a numpy array.
-
-        Args:
-            output_path: The path to save the histogram to.
-            arr: The numpy array of which to save the histogram.
-        """
-        import matplotlib.pyplot as plt
-
-        plt.hist(arr)
-        with fileio.open(output_path, "wb") as f:
-            plt.savefig(f)
-        plt.close()
-
-    def _save_image(self, output_path: str, arr: "NDArray[Any]") -> None:
-        """Saves a numpy array as an image.
-
-        Args:
-            output_path: The path to save the image to.
-            arr: The numpy array to save.
-        """
-        from matplotlib.image import imsave
-
-        with fileio.open(output_path, "wb") as f:
-            imsave(f, arr)
-
-    def extract_metadata(
-        self, arr: "NDArray[Any]"
-    ) -> Dict[str, "MetadataType"]:
-        """Extract metadata from the given numpy array.
-
-        Args:
-            arr: The numpy array to extract metadata from.
-
-        Returns:
-            The extracted metadata as a dictionary.
-        """
-        if np.issubdtype(arr.dtype, np.number):
-            return self._extract_numeric_metadata(arr)
-        elif np.issubdtype(arr.dtype, np.unicode_) or np.issubdtype(
-            arr.dtype, np.object_
-        ):
-            return self._extract_text_metadata(arr)
-        else:
-            return {}
-
-    def _extract_numeric_metadata(
-        self, arr: "NDArray[Any]"
-    ) -> Dict[str, "MetadataType"]:
-        """Extracts numeric metadata from a numpy array.
-
-        Args:
-            arr: The numpy array to extract metadata from.
-
-        Returns:
-            A dictionary of metadata.
-        """
-        min_val = np.min(arr).item()
-        max_val = np.max(arr).item()
-
-        numpy_metadata: Dict[str, "MetadataType"] = {
-            "shape": tuple(arr.shape),
-            "dtype": DType(arr.dtype.type),
-            "mean": np.mean(arr).item(),
-            "std": np.std(arr).item(),
-            "min": min_val,
-            "max": max_val,
-        }
-        return numpy_metadata
-
-    def _extract_text_metadata(
-        self, arr: "NDArray[Any]"
-    ) -> Dict[str, "MetadataType"]:
-        """Extracts text metadata from a numpy array.
-
-        Args:
-            arr: The numpy array to extract metadata from.
-
-        Returns:
-            A dictionary of metadata.
-        """
-        text = " ".join(arr)
-        words = text.split()
-        word_counts = Counter(words)
-        unique_words = len(word_counts)
-        total_words = len(words)
-        most_common_word, most_common_count = word_counts.most_common(1)[0]
-
-        text_metadata: Dict[str, "MetadataType"] = {
-            "shape": tuple(arr.shape),
-            "dtype": DType(arr.dtype.type),
-            "unique_words": unique_words,
-            "total_words": total_words,
-            "most_common_word": most_common_word,
-            "most_common_count": most_common_count,
-        }
-        return text_metadata
+"""Placeholder for importing the Numpy Materializer from its former path."""
+
+# With the code below, we keep a reference to the NumpyMaterializer in its
+# original spot. So, if someone has an artifact version that was created with
+# the NumpyMaterializer, (assuming that they have it installed), they will still
+# be able to use the artifact version. However, if this file is to be removed,
+# you have to write a DB migration script to change the materializer source
+# of the old artifact version entries.
+
+try:
+    from zenml.integrations.numpy.materializers.numpy_materializer import (  # noqa
+        NumpyMaterializer,
+    )
+except (ImportError, ModuleNotFoundError) as e:
+    raise ImportError(
+        "The ZenML built-in Numpy materializer has been moved to an "
+        "integration. Before you use it, make sure you that the `numpy` "
+        "integration is installed with `zenml integration install numpy`, "
+        "and if you need to import the materializer explicitly, please use: "
+        "'from zenml.integrations.numpy.materializers import "
+        f"NumpyMaterializer': {e}"
+    )

zenml/materializers/pandas_materializer.py

@@ -1,4 +1,4 @@
-#  Copyright (c) ZenML GmbH 2021. All Rights Reserved.
+#  Copyright (c) ZenML GmbH 2024. All Rights Reserved.
 #
 #  Licensed under the Apache License, Version 2.0 (the "License");
 #  you may not use this file except in compliance with the License.
@@ -11,177 +11,25 @@
 #  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
 #  or implied. See the License for the specific language governing
 #  permissions and limitations under the License.
-"""Materializer for Pandas."""
-
-import os
-from typing import Any, ClassVar, Dict, Tuple, Type, Union
-
-import pandas as pd
-
-from zenml.enums import ArtifactType, VisualizationType
-from zenml.io import fileio
-from zenml.logger import get_logger
-from zenml.materializers.base_materializer import BaseMaterializer
-from zenml.metadata.metadata_types import DType, MetadataType
-
-logger = get_logger(__name__)
-
-PARQUET_FILENAME = "df.parquet.gzip"
-COMPRESSION_TYPE = "gzip"
-
-CSV_FILENAME = "df.csv"
-
-
-class PandasMaterializer(BaseMaterializer):
-    """Materializer to read data to and from pandas."""
-
-    ASSOCIATED_TYPES: ClassVar[Tuple[Type[Any], ...]] = (
-        pd.DataFrame,
-        pd.Series,
+"""Placeholder for importing the Pandas Materializer from its former path."""
+
+# With the code below, we keep a reference to the PandasMaterializer in its
+# original spot. So, if someone has an artifact version that was created with
+# the NumpyMaterializer, (assuming that they have it installed), they will still
+# be able to use the artifact version. However, if this file is to be removed,
+# you have to write a DB migration script to change the materializer source
+# of the old artifact version entries.
+
+try:
+    from zenml.integrations.pandas.materializers.pandas_materializer import (  # noqa
+        PandasMaterializer,
+    )
+except (ImportError, ModuleNotFoundError) as e:
+    raise ImportError(
+        "The ZenML built-in Pandas materializer has been moved to an "
+        "integration. Before you use it, make sure you that the `pandas` "
+        "integration is installed with `zenml integration install pandas`, "
+        "and if you need to import the materializer explicitly, please use: "
+        "'from zenml.integrations.pandas.materializers import "
+        f"PandasMaterializer': {e}"
     )
-    ASSOCIATED_ARTIFACT_TYPE: ClassVar[ArtifactType] = ArtifactType.DATA
-
-    def __init__(self, uri: str):
-        """Define `self.data_path`.
-
-        Args:
-            uri: The URI where the artifact data is stored.
-        """
-        super().__init__(uri)
-        try:
-            import pyarrow  # type: ignore # noqa
-
-            self.pyarrow_exists = True
-        except ImportError:
-            self.pyarrow_exists = False
-            logger.warning(
-                "By default, the `PandasMaterializer` stores data as a "
-                "`.csv` file. If you want to store data more efficiently, "
-                "you can install `pyarrow` by running "
-                "'`pip install pyarrow`'. This will allow `PandasMaterializer` "
-                "to automatically store the data as a `.parquet` file instead."
-            )
-        finally:
-            self.parquet_path = os.path.join(self.uri, PARQUET_FILENAME)
-            self.csv_path = os.path.join(self.uri, CSV_FILENAME)
-
-    def load(self, data_type: Type[Any]) -> Union[pd.DataFrame, pd.Series]:
-        """Reads `pd.DataFrame` or `pd.Series` from a `.parquet` or `.csv` file.
-
-        Args:
-            data_type: The type of the data to read.
-
-        Raises:
-            ImportError: If pyarrow or fastparquet is not installed.
-
-        Returns:
-            The pandas dataframe or series.
-        """
-        if fileio.exists(self.parquet_path):
-            if self.pyarrow_exists:
-                with fileio.open(self.parquet_path, mode="rb") as f:
-                    df = pd.read_parquet(f)
-            else:
-                raise ImportError(
-                    "You have an old version of a `PandasMaterializer` "
-                    "data artifact stored in the artifact store "
-                    "as a `.parquet` file, which requires `pyarrow` "
-                    "for reading, You can install `pyarrow` by running "
-                    "'`pip install pyarrow fastparquet`'."
-                )
-        else:
-            with fileio.open(self.csv_path, mode="rb") as f:
-                df = pd.read_csv(f, index_col=0, parse_dates=True)
-
-        # validate the type of the data.
-        def is_dataframe_or_series(
-            df: Union[pd.DataFrame, pd.Series],
-        ) -> Union[pd.DataFrame, pd.Series]:
-            """Checks if the data is a `pd.DataFrame` or `pd.Series`.
-
-            Args:
-                df: The data to check.
-
-            Returns:
-                The data if it is a `pd.DataFrame` or `pd.Series`.
-            """
-            if issubclass(data_type, pd.Series):
-                # Taking the first column if its a series as the assumption
-                # is that there will only be one
-                assert len(df.columns) == 1
-                df = df[df.columns[0]]
-                return df
-            else:
-                return df
-
-        return is_dataframe_or_series(df)
-
-    def save(self, df: Union[pd.DataFrame, pd.Series]) -> None:
-        """Writes a pandas dataframe or series to the specified filename.
-
-        Args:
-            df: The pandas dataframe or series to write.
-        """
-        if isinstance(df, pd.Series):
-            df = df.to_frame(name="series")
-
-        if self.pyarrow_exists:
-            with fileio.open(self.parquet_path, mode="wb") as f:
-                df.to_parquet(f, compression=COMPRESSION_TYPE)
-        else:
-            with fileio.open(self.csv_path, mode="wb") as f:
-                df.to_csv(f, index=True)
-
-    def save_visualizations(
-        self, df: Union[pd.DataFrame, pd.Series]
-    ) -> Dict[str, VisualizationType]:
-        """Save visualizations of the given pandas dataframe or series.
-
-        Args:
-            df: The pandas dataframe or series to visualize.
-
-        Returns:
-            A dictionary of visualization URIs and their types.
-        """
-        describe_uri = os.path.join(self.uri, "describe.csv")
-        describe_uri = describe_uri.replace("\\", "/")
-        with fileio.open(describe_uri, mode="wb") as f:
-            df.describe().to_csv(f)
-        return {describe_uri: VisualizationType.CSV}
-
-    def extract_metadata(
-        self, df: Union[pd.DataFrame, pd.Series]
-    ) -> Dict[str, "MetadataType"]:
-        """Extract metadata from the given pandas dataframe or series.
-
-        Args:
-            df: The pandas dataframe or series to extract metadata from.
-
-        Returns:
-            The extracted metadata as a dictionary.
-        """
-        pandas_metadata: Dict[str, "MetadataType"] = {"shape": df.shape}
-
-        if isinstance(df, pd.Series):
-            pandas_metadata["dtype"] = DType(df.dtype.type)
-            pandas_metadata["mean"] = float(df.mean().item())
-            pandas_metadata["std"] = float(df.std().item())
-            pandas_metadata["min"] = float(df.min().item())
-            pandas_metadata["max"] = float(df.max().item())
-
-        else:
-            pandas_metadata["dtype"] = {
-                str(key): DType(value.type) for key, value in df.dtypes.items()
-            }
-            for stat_name, stat in {
-                "mean": df.mean,
-                "std": df.std,
-                "min": df.min,
-                "max": df.max,
-            }.items():
-                pandas_metadata[stat_name] = {
-                    str(key): float(value)
-                    for key, value in stat(numeric_only=True).to_dict().items()
-                }
-
-        return pandas_metadata

zenml/materializers/pydantic_materializer.py

@@ -45,7 +45,7 @@ class PydanticMaterializer(BaseMaterializer):
         """
         data_path = os.path.join(self.uri, DEFAULT_FILENAME)
         contents = yaml_utils.read_json(data_path)
-        return data_type.parse_raw(contents)
+        return data_type.model_validate_json(contents)
 
     def save(self, data: BaseModel) -> None:
         """Serialize a BaseModel to JSON.
@@ -54,7 +54,7 @@ class PydanticMaterializer(BaseMaterializer):
             data: The data to store.
         """
         data_path = os.path.join(self.uri, DEFAULT_FILENAME)
-        yaml_utils.write_json(data_path, data.json())
+        yaml_utils.write_json(data_path, data.model_dump_json())
 
     def extract_metadata(self, data: BaseModel) -> Dict[str, "MetadataType"]:
         """Extract metadata from the given BaseModel object.

zenml/materializers/service_materializer.py

@@ -14,13 +14,13 @@
 """Implementation of a materializer to read and write ZenML service instances."""
 
 import os
+import uuid
 from typing import TYPE_CHECKING, Any, ClassVar, Dict, Tuple, Type
 
+from zenml.client import Client
 from zenml.enums import ArtifactType
-from zenml.io import fileio
 from zenml.materializers.base_materializer import BaseMaterializer
-from zenml.services.service import BaseService
-from zenml.services.service_registry import ServiceRegistry
+from zenml.services.service import BaseDeploymentService, BaseService
 
 if TYPE_CHECKING:
     from zenml.metadata.metadata_types import MetadataType
@@ -47,9 +47,11 @@ class ServiceMaterializer(BaseMaterializer):
             A ZenML service instance.
         """
         filepath = os.path.join(self.uri, SERVICE_CONFIG_FILENAME)
-        with fileio.open(filepath, "r") as f:
-            service = ServiceRegistry().load_service_from_json(f.read())
-        return service
+        with self.artifact_store.open(filepath, "r") as f:
+            service_id = f.read().strip()
+
+        service = Client().get_service(name_id_or_prefix=uuid.UUID(service_id))
+        return BaseDeploymentService.from_model(service)
 
     def save(self, service: BaseService) -> None:
         """Writes a ZenML service.
@@ -61,8 +63,8 @@ class ServiceMaterializer(BaseMaterializer):
             service: A ZenML service instance.
         """
         filepath = os.path.join(self.uri, SERVICE_CONFIG_FILENAME)
-        with fileio.open(filepath, "w") as f:
-            f.write(service.json(indent=4))
+        with self.artifact_store.open(filepath, "w") as f:
+            f.write(str(service.uuid))
 
     def extract_metadata(
         self, service: BaseService
@@ -77,6 +79,6 @@ class ServiceMaterializer(BaseMaterializer):
         """
         from zenml.metadata.metadata_types import Uri
 
-        if service.endpoint and service.endpoint.status.uri:
-            return {"uri": Uri(service.endpoint.status.uri)}
+        if prediction_url := service.get_prediction_url() or None:
+            return {"uri": Uri(prediction_url)}
         return {}

zenml/materializers/structured_string_materializer.py

@@ -17,25 +17,25 @@ import os
 from typing import Dict, Type, Union
 
 from zenml.enums import ArtifactType, VisualizationType
-from zenml.io import fileio
 from zenml.logger import get_logger
 from zenml.materializers.base_materializer import BaseMaterializer
-from zenml.types import CSVString, HTMLString, MarkdownString
+from zenml.types import CSVString, HTMLString, JSONString, MarkdownString
 
 logger = get_logger(__name__)
 
 
-STRUCTURED_STRINGS = Union[CSVString, HTMLString, MarkdownString]
+STRUCTURED_STRINGS = Union[CSVString, HTMLString, MarkdownString, JSONString]
 
 HTML_FILENAME = "output.html"
 MARKDOWN_FILENAME = "output.md"
 CSV_FILENAME = "output.csv"
+JSON_FILENAME = "output.json"
 
 
 class StructuredStringMaterializer(BaseMaterializer):
     """Materializer for HTML or Markdown strings."""
 
-    ASSOCIATED_TYPES = (CSVString, HTMLString, MarkdownString)
+    ASSOCIATED_TYPES = (CSVString, HTMLString, MarkdownString, JSONString)
     ASSOCIATED_ARTIFACT_TYPE = ArtifactType.DATA_ANALYSIS
 
     def load(self, data_type: Type[STRUCTURED_STRINGS]) -> STRUCTURED_STRINGS:
@@ -47,7 +47,7 @@ class StructuredStringMaterializer(BaseMaterializer):
         Returns:
             The loaded data.
         """
-        with fileio.open(self._get_filepath(data_type), "r") as f:
+        with self.artifact_store.open(self._get_filepath(data_type), "r") as f:
             return data_type(f.read())
 
     def save(self, data: STRUCTURED_STRINGS) -> None:
@@ -56,7 +56,9 @@ class StructuredStringMaterializer(BaseMaterializer):
         Args:
             data: The data to save as an HTML or Markdown file.
         """
-        with fileio.open(self._get_filepath(type(data)), "w") as f:
+        with self.artifact_store.open(
+            self._get_filepath(type(data)), "w"
+        ) as f:
             f.write(data)
 
     def save_visualizations(
@@ -93,6 +95,8 @@ class StructuredStringMaterializer(BaseMaterializer):
             filename = HTML_FILENAME
         elif issubclass(data_type, MarkdownString):
             filename = MARKDOWN_FILENAME
+        elif issubclass(data_type, JSONString):
+            filename = JSON_FILENAME
         else:
             raise ValueError(
                 f"Data type {data_type} is not supported by this materializer."
@@ -119,6 +123,8 @@ class StructuredStringMaterializer(BaseMaterializer):
             return VisualizationType.HTML
         elif issubclass(data_type, MarkdownString):
             return VisualizationType.MARKDOWN
+        elif issubclass(data_type, JSONString):
+            return VisualizationType.JSON
         else:
             raise ValueError(
                 f"Data type {data_type} is not supported by this materializer."

zenml/materializers/uuid_materializer.py

@@ -0,0 +1,79 @@
+#  Copyright (c) ZenML GmbH 2024. All Rights Reserved.
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at:
+#
+#       https://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
+#  or implied. See the License for the specific language governing
+#  permissions and limitations under the License.
+"""Implementation of ZenML's UUID materializer."""
+
+import os
+import uuid
+from typing import Any, ClassVar, Dict, Optional, Tuple, Type
+
+from zenml.artifact_stores.base_artifact_store import BaseArtifactStore
+from zenml.enums import ArtifactType
+from zenml.materializers.base_materializer import BaseMaterializer
+from zenml.metadata.metadata_types import MetadataType
+
+DEFAULT_FILENAME = "uuid.txt"
+
+
+class UUIDMaterializer(BaseMaterializer):
+    """Materializer to handle UUID objects."""
+
+    ASSOCIATED_TYPES: ClassVar[Tuple[Type[Any], ...]] = (uuid.UUID,)
+    ASSOCIATED_ARTIFACT_TYPE: ClassVar[ArtifactType] = ArtifactType.DATA
+
+    def __init__(
+        self, uri: str, artifact_store: Optional[BaseArtifactStore] = None
+    ):
+        """Define `self.data_path`.
+
+        Args:
+            uri: The URI where the artifact data is stored.
+            artifact_store: The artifact store where the artifact data is stored.
+        """
+        super().__init__(uri, artifact_store)
+        self.data_path = os.path.join(self.uri, DEFAULT_FILENAME)
+
+    def load(self, _: Type[uuid.UUID]) -> uuid.UUID:
+        """Read UUID from artifact store.
+
+        Args:
+            _: The type of the data to be loaded.
+
+        Returns:
+            The loaded UUID.
+        """
+        with self.artifact_store.open(self.data_path, "r") as f:
+            uuid_str = f.read().strip()
+        return uuid.UUID(uuid_str)
+
+    def save(self, data: uuid.UUID) -> None:
+        """Write UUID to artifact store.
+
+        Args:
+            data: The UUID to be saved.
+        """
+        with self.artifact_store.open(self.data_path, "w") as f:
+            f.write(str(data))
+
+    def extract_metadata(self, data: uuid.UUID) -> Dict[str, MetadataType]:
+        """Extract metadata from the UUID.
+
+        Args:
+            data: The UUID to extract metadata from.
+
+        Returns:
+            A dictionary of metadata extracted from the UUID.
+        """
+        return {
+            "string_representation": str(data),
+        }