zenml-nightly 0.64.0.dev20240811__py3-none-any.whl → 0.66.0.dev20240910__py3-none-any.whl

zenml/integrations/numpy/materializers/numpy_materializer.py

@@ -0,0 +1,246 @@
+#  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 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.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 self.artifact_store.exists(numpy_file):
+            with self.artifact_store.open(numpy_file, "rb") as f:
+                return np.load(f, allow_pickle=True)
+        elif self.artifact_store.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 self.artifact_store.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 self.artifact_store.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 self.artifact_store.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 self.artifact_store.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

zenml/integrations/pandas/__init__.py

@@ -0,0 +1,32 @@
+#  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.
+"""Initialization of the Pandas integration."""
+
+from zenml.integrations.constants import PANDAS
+from zenml.integrations.integration import Integration
+
+
+class PandasIntegration(Integration):
+    """Definition of Pandas integration for ZenML."""
+
+    NAME = PANDAS
+    REQUIREMENTS = ["pandas>=2.0.0"]
+
+    @classmethod
+    def activate(cls) -> None:
+        """Activates the integration."""
+        from zenml.integrations.pandas import materializers  # noqa
+
+
+PandasIntegration.check_installation()

zenml/integrations/pandas/materializers/__init__.py

@@ -0,0 +1,18 @@
+#  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.
+"""Initialization of the Pandas materializer."""
+
+from zenml.integrations.pandas.materializers.pandas_materializer import (  # noqa
+    PandasMaterializer,
+)

zenml/integrations/pandas/materializers/pandas_materializer.py

@@ -0,0 +1,192 @@
+#  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.
+"""Materializer for Pandas."""
+
+import os
+from typing import Any, ClassVar, Dict, Optional, Tuple, Type, Union
+
+import pandas as pd
+
+from zenml.artifact_stores.base_artifact_store import BaseArtifactStore
+from zenml.enums import ArtifactType, VisualizationType
+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,
+    )
+    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)
+        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 self.artifact_store.exists(self.parquet_path):
+            if self.pyarrow_exists:
+                with self.artifact_store.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 self.artifact_store.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 self.artifact_store.open(self.parquet_path, mode="wb") as f:
+                df.to_parquet(f, compression=COMPRESSION_TYPE)
+        else:
+            with self.artifact_store.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 self.artifact_store.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/integrations/prodigy/annotators/prodigy_annotator.py

@@ -221,7 +221,7 @@ class ProdigyAnnotator(BaseAnnotator, AuthenticationMixin):
     def get_dataset(self, **kwargs: Any) -> Any:
         """Gets the dataset metadata for the given name.
 
-        If you would like the labelled data, use `get_labeled_data` instead.
+        If you would like the labeled data, use `get_labeled_data` instead.
 
         Args:
             **kwargs: Additional keyword arguments to pass to the Prodigy client.

zenml/integrations/seldon/__init__.py

@@ -16,9 +16,8 @@
 The Seldon Core integration allows you to use the Seldon Core model serving
 platform to implement continuous model deployment.
 """
-from typing import List, Type
+from typing import List, Type, Optional
 
-from zenml.enums import StackComponentType
 from zenml.integrations.constants import SELDON
 from zenml.integrations.integration import Integration
 from zenml.stack import Flavor
@@ -33,7 +32,8 @@ class SeldonIntegration(Integration):
     REQUIREMENTS = [
         "kubernetes==18.20.0",
     ]
-    REQUIREMENTS_IGNORED_ON_UNINSTALL = ["kubernetes"]
+
+    REQUIREMENTS_IGNORED_ON_UNINSTALL = ["kubernetes", "numpy"]
 
     @classmethod
     def activate(cls) -> None:
@@ -52,5 +52,20 @@ class SeldonIntegration(Integration):
 
         return [SeldonModelDeployerFlavor]
 
+    @classmethod
+    def get_requirements(cls, target_os: Optional[str] = None) -> List[str]:
+        """Method to get the requirements for the integration.
+
+        Args:
+            target_os: The target operating system to get the requirements for.
+
+        Returns:
+            A list of requirements.
+        """
+        from zenml.integrations.numpy import NumpyIntegration
+
+        return cls.REQUIREMENTS + \
+            NumpyIntegration.get_requirements(target_os=target_os)
+
 
 SeldonIntegration.check_installation()

zenml/integrations/sklearn/__init__.py

@@ -21,7 +21,7 @@ class SklearnIntegration(Integration):
     """Definition of sklearn integration for ZenML."""
 
     NAME = SKLEARN
-    REQUIREMENTS = ["scikit-learn"]
+    REQUIREMENTS = ["scikit-learn", "scikit-image"]
 
     @classmethod
     def activate(cls) -> None:

zenml/integrations/skypilot_azure/__init__.py

@@ -31,7 +31,7 @@ class SkypilotAzureIntegration(Integration):
     """Definition of Skypilot (Azure) Integration for ZenML."""
 
     NAME = SKYPILOT_AZURE
-    REQUIREMENTS = ["skypilot-nightly[azure]==1.0.0.dev20240716"]
+    REQUIREMENTS = ["skypilot[azure]>=0.6.1"]
     APT_PACKAGES = ["openssh-client", "rsync"]
 
     @classmethod

zenml/integrations/tensorboard/__init__.py

@@ -34,7 +34,7 @@ class TensorBoardIntegration(Integration):
         Returns:
             A list of requirements.
         """
-        requirements = ["tensorboard>=2.12,<=2.15"]
+        requirements = ["tensorboard>=2.12,<2.15"]
         return requirements
 
     @classmethod

zenml/integrations/tensorflow/__init__.py

@@ -62,11 +62,11 @@ class TensorflowIntegration(Integration):
         target_os = target_os or platform.system()
         if target_os == "Darwin" and platform.machine() == "arm64":
             requirements = [
-                "tensorflow-macos>=2.12,<=2.15",
+                "tensorflow-macos>=2.12,<2.15",
             ]
         else:
             requirements = [
-                "tensorflow>=2.12,<=2.15",
+                "tensorflow>=2.12,<2.15",
                 "tensorflow_io>=0.24.0",
             ]
         if sys.version_info.minor == 8:

zenml/integrations/tensorflow/materializers/tf_dataset_materializer.py

@@ -48,7 +48,7 @@ class TensorflowDatasetMaterializer(BaseMaterializer):
         temp_dir = tempfile.mkdtemp()
         io_utils.copy_dir(self.uri, temp_dir)
         path = os.path.join(temp_dir, DEFAULT_FILENAME)
-        dataset = tf.data.experimental.load(path)
+        dataset = tf.data.Dataset.load(path)
         # Don't delete the temporary directory here as the dataset is lazily
         # loaded and needs to read it when the object gets used
         return dataset
@@ -62,7 +62,7 @@ class TensorflowDatasetMaterializer(BaseMaterializer):
         temp_dir = tempfile.TemporaryDirectory()
         path = os.path.join(temp_dir.name, DEFAULT_FILENAME)
         try:
-            tf.data.experimental.save(
+            tf.data.Dataset.save(
                 dataset, path, compression=None, shard_func=None
             )
             io_utils.copy_dir(temp_dir.name, self.uri)

zenml/integrations/whylogs/__init__.py

@@ -13,9 +13,8 @@
 #  permissions and limitations under the License.
 """Initialization of the whylogs integration."""
 
-from typing import List, Type
+from typing import List, Type, Optional
 
-from zenml.enums import StackComponentType
 from zenml.integrations.constants import WHYLOGS
 from zenml.integrations.integration import Integration
 from zenml.stack import Flavor
@@ -29,6 +28,8 @@ class WhylogsIntegration(Integration):
     NAME = WHYLOGS
     REQUIREMENTS = ["whylogs[viz]~=1.0.5", "whylogs[whylabs]~=1.0.5"]
 
+    REQUIREMENTS_IGNORED_ON_UNINSTALL = ["pandas"]
+
     @classmethod
     def activate(cls) -> None:
         """Activates the integration."""
@@ -48,5 +49,20 @@ class WhylogsIntegration(Integration):
 
         return [WhylogsDataValidatorFlavor]
 
+    @classmethod
+    def get_requirements(cls, target_os: Optional[str] = None) -> List[str]:
+        """Method to get the requirements for the integration.
+
+        Args:
+            target_os: The target operating system to get the requirements for.
+
+        Returns:
+            A list of requirements.
+        """
+        from zenml.integrations.pandas import PandasIntegration
+
+        return cls.REQUIREMENTS + \
+            PandasIntegration.get_requirements(target_os=target_os)
+
 
 WhylogsIntegration.check_installation()

zenml/logging/step_logging.py

@@ -13,6 +13,7 @@
 #  permissions and limitations under the License.
 """ZenML logging handler."""
 
+import datetime
 import os
 import re
 import sys
@@ -312,16 +313,22 @@ class StepLogsStorage:
                             "w",
                         ) as file:
                             for message in self.buffer:
+                                timestamp = datetime.datetime.now(
+                                    datetime.timezone.utc
+                                ).strftime("%Y-%m-%d %H:%M:%S")
                                 file.write(
-                                    remove_ansi_escape_codes(message) + "\n"
+                                    f"[{timestamp} UTC] {remove_ansi_escape_codes(message)}\n"
                                 )
                     else:
                         with self.artifact_store.open(
                             self.logs_uri, "a"
                         ) as file:
                             for message in self.buffer:
+                                timestamp = datetime.datetime.now(
+                                    datetime.timezone.utc
+                                ).strftime("%Y-%m-%d %H:%M:%S")
                                 file.write(
-                                    remove_ansi_escape_codes(message) + "\n"
+                                    f"[{timestamp} UTC] {remove_ansi_escape_codes(message)}\n"
                                 )
 
             except (OSError, IOError) as e: