aiverify-moonshot 0.4.1__py3-none-any.whl → 0.4.3__py3-none-any.whl

moonshot/src/connectors_endpoints/connector_endpoint.py

@@ -8,33 +8,39 @@ from moonshot.src.connectors_endpoints.connector_endpoint_arguments import (
     ConnectorEndpointArguments,
 )
 from moonshot.src.storage.storage import Storage
+from moonshot.src.utils.log import configure_logger
+
+# Create a logger for this module
+logger = configure_logger(__name__)
 
 
 class ConnectorEndpoint:
     @staticmethod
     def create(ep_args: ConnectorEndpointArguments) -> str:
         """
-        Creates a new connector endpoint.
+        Creates a new connector endpoint and stores its details as a JSON object.
+
+        This method accepts a ConnectorEndpointArguments object, generates a unique slugified ID from the endpoint's
+        name, and stores the endpoint's details in a JSON file within a specified directory.
 
-        This method takes a ConnectorEndpointArguments object as input, generates a unique slugified ID based on the
-        endpoint's name, and then creates a new endpoint with the provided details. The endpoint information is stored
-        as a JSON object in the directory specified by `EnvVariables.CONNECTORS_ENDPOINTS`. If the operation is
-        successful, the unique ID of the new endpoint is returned. If any error arises during the process, an exception
-        is raised and the error message is logged.
+        The directory path is determined by the `EnvVariables.CONNECTORS_ENDPOINTS` environment variable.
+        Upon successful creation, the method returns the unique ID of the endpoint.
+        If an error occurs during the creation process, the method raises an exception and logs the error message.
 
         Args:
-            ep_args (ConnectorEndpointArguments): An object containing the details of the endpoint to be created.
+            ep_args (ConnectorEndpointArguments): The details of the endpoint to be created,
+            encapsulated in a ConnectorEndpointArguments object.
 
         Returns:
-            str: The unique ID of the newly created endpoint.
+            str: The unique ID of the newly created endpoint, derived from slugifying the endpoint's name.
 
         Raises:
-            Exception: If there's an error during the endpoint creation process.
+            Exception: If an error occurs during the creation process, including issues with storing the endpoint's
+            details.
         """
         try:
             ep_id = slugify(ep_args.name, lowercase=True)
             ep_info = {
-                "id": ep_id,
                 "name": ep_args.name,
                 "connector_type": ep_args.connector_type,
                 "uri": ep_args.uri,
@@ -51,59 +57,63 @@ class ConnectorEndpoint:
             return ep_id
 
         except Exception as e:
-            print(f"Failed to create endpoint: {str(e)}")
+            logger.error(f"Failed to create endpoint: {str(e)}")
             raise e
 
     @staticmethod
     @validate_call
     def read(ep_id: str) -> ConnectorEndpointArguments:
         """
-        Fetches the details of a given endpoint.
+        Retrieves the details of a specified endpoint by its ID.
 
-        This method takes an endpoint ID as input, finds the corresponding JSON file in the directory
-        specified by `EnvironmentVars.CONNECTORS_ENDPOINTS`, and returns a ConnectorEndpointArguments object
-        that contains the endpoint's details. If any error arises during the process, an exception is raised and the
-        error message is logged.
+        This method searches for the endpoint's corresponding JSON file within the directory defined by the
+        `EnvVariables.CONNECTORS_ENDPOINTS` environment variable. It then constructs and returns a
+        ConnectorEndpointArguments object populated with the endpoint's details. If the endpoint ID is not found or
+        any other error occurs, an exception is raised with an appropriate error message.
 
         Args:
-            ep_id (str): The unique ID of the endpoint to be fetched.
+            ep_id (str): The unique identifier of the endpoint whose details are to be retrieved.
 
         Returns:
-            ConnectorEndpointArguments: An object encapsulating the details of the fetched endpoint.
+            ConnectorEndpointArguments: An instance filled with the endpoint's details.
 
         Raises:
-            Exception: If there's an error during the file reading process or any other operation within the method.
+            RuntimeError: If the endpoint ID is empty or the specified endpoint does not exist.
+            Exception: For any issues encountered during the file reading or data parsing process.
         """
         try:
-            if ep_id:
-                return ConnectorEndpointArguments(
-                    **ConnectorEndpoint._read_endpoint(ep_id)
-                )
-            else:
-                raise RuntimeError("Connector Endpoint ID is empty")
+            if not ep_id:
+                raise RuntimeError("Connector Endpoint ID is empty.")
+
+            endpoint_details = ConnectorEndpoint._read_endpoint(ep_id)
+            if not endpoint_details:
+                raise RuntimeError(f"Endpoint with ID '{ep_id}' does not exist.")
+
+            return ConnectorEndpointArguments(**endpoint_details)
 
         except Exception as e:
-            print(f"Failed to read endpoint: {str(e)}")
+            logger.error(f"Failed to read endpoint: {str(e)}")
             raise e
 
     @staticmethod
     def _read_endpoint(ep_id: str) -> dict:
         """
-        Reads the endpoint information from a JSON file and adds the creation datetime.
+        Retrieves the endpoint's information from a JSON file, including its creation datetime.
 
-        This method accepts an endpoint ID as an argument, locates the corresponding JSON file in the directory
-        defined by `EnvironmentVars.CONNECTORS_ENDPOINTS`, and returns a dictionary that encapsulates the endpoint's
-        details along with its creation datetime. If any error occurs during the process, it is handled by the calling
-        method.
+        This internal method is designed to fetch the details of a specific endpoint by its ID. It searches for the
+        corresponding JSON file within the directory specified by `EnvVariables.CONNECTORS_ENDPOINTS`. The method
+        returns a dictionary containing the endpoint's information, enriched with the creation datetime. Errors
+        encountered during this process are managed by the method that invokes this one.
 
         Args:
-            ep_id (str): The unique identifier of the endpoint to be retrieved.
+            ep_id (str): The unique identifier of the endpoint whose information is being retrieved.
 
         Returns:
-            dict: A dictionary containing the details of the retrieved endpoint along with its creation datetime.
+            dict: A dictionary with the endpoint's information, including its creation datetime.
         """
-        connector_endpoint_info = Storage.read_object(
-            EnvVariables.CONNECTORS_ENDPOINTS.name, ep_id, "json"
+        connector_endpoint_info = {"id": ep_id}
+        connector_endpoint_info.update(
+            Storage.read_object(EnvVariables.CONNECTORS_ENDPOINTS.name, ep_id, "json")
         )
         creation_datetime = Storage.get_creation_datetime(
             EnvVariables.CONNECTORS_ENDPOINTS.name, ep_id, "json"
@@ -116,35 +126,41 @@ class ConnectorEndpoint:
     @staticmethod
     def update(ep_args: ConnectorEndpointArguments) -> bool:
         """
-        Updates the endpoint information based on the provided arguments.
+        Updates the endpoint information in the storage based on the provided ConnectorEndpointArguments object.
+
+        This method serializes the provided ConnectorEndpointArguments object into a dictionary, excluding the 'id' and
+        'created_date' keys. It then persists the updated information to the corresponding JSON file within the
+        directory defined by `EnvVariables.CONNECTORS_ENDPOINTS`.
 
-        This method takes a ConnectorEndpointArguments object, converts it to a dictionary, and removes the
-        'created_date' key if it exists. It then writes the updated information to the corresponding JSON file
-        in the directory specified by `EnvVariables.CONNECTORS_ENDPOINTS`.
+        This operation ensures that the endpoint's mutable attributes are updated according to the provided arguments.
 
         Args:
-            ep_args (ConnectorEndpointArguments): An object containing the updated details of the endpoint.
+            ep_args (ConnectorEndpointArguments): The object encapsulating the updated attributes of the endpoint.
 
         Returns:
-            bool: True if the update operation was successful.
+            bool: Indicates whether the update operation was successful. Returns True if the update was successfully
+            persisted to the storage; otherwise, an exception is raised.
 
         Raises:
-            Exception: If there's an error during the update process.
+            Exception: Signifies a failure in the update process, potentially due to issues with data serialization or
+            storage access.
         """
         try:
-            # Convert the endpoint arguments to a dictionary
-            # Remove created_date if it exists
+            # Serialize the ConnectorEndpointArguments object to a dictionary and remove derived properties
             ep_info = ep_args.to_dict()
-            ep_info.pop("created_date", None)
+            ep_info.pop("id", None)  # The 'id' is derived and should not be written
+            ep_info.pop(
+                "created_date", None
+            )  # The 'created_date' is derived and should not be written
 
-            # Write the updated endpoint information to the file
+            # Write the updated endpoint information to the storage
             Storage.create_object(
                 EnvVariables.CONNECTORS_ENDPOINTS.name, ep_args.id, ep_info, "json"
             )
             return True
 
         except Exception as e:
-            print(f"Failed to update endpoint: {str(e)}")
+            logger.error(f"Failed to update endpoint: {str(e)}")
             raise e
 
     @staticmethod
@@ -171,7 +187,7 @@ class ConnectorEndpoint:
             return True
 
         except Exception as e:
-            print(f"Failed to delete endpoint: {str(e)}")
+            logger.error(f"Failed to delete endpoint: {str(e)}")
             raise e
 
     @staticmethod
@@ -207,5 +223,5 @@ class ConnectorEndpoint:
             return retn_eps_ids, retn_eps
 
         except Exception as e:
-            print(f"Failed to get available endpoints: {str(e)}")
+            logger.error(f"Failed to get available endpoints: {str(e)}")
             raise e

moonshot/src/cookbooks/cookbook.py

@@ -8,6 +8,10 @@ from slugify import slugify
 from moonshot.src.configs.env_variables import EnvVariables
 from moonshot.src.cookbooks.cookbook_arguments import CookbookArguments
 from moonshot.src.storage.storage import Storage
+from moonshot.src.utils.log import configure_logger
+
+# Create a logger for this module
+logger = configure_logger(__name__)
 
 
 class Cookbook:
@@ -31,8 +35,7 @@ class Cookbook:
         Returns:
             Cookbook: An instance of the Cookbook class populated with the loaded cookbook information.
         """
-        cb_info = Storage.read_object(EnvVariables.COOKBOOKS.name, cb_id, "json")
-        return cls(CookbookArguments(**cb_info))
+        return cls(Cookbook.read(cb_id))
 
     @staticmethod
     def create(cb_args: CookbookArguments) -> str:
@@ -58,6 +61,11 @@ class Cookbook:
         """
         try:
             cb_id = slugify(cb_args.name, lowercase=True)
+            cb_info = {
+                "name": cb_args.name,
+                "description": cb_args.description,
+                "recipes": cb_args.recipes,
+            }
 
             # check if the cookbook exists
             if Storage.is_object_exists(EnvVariables.COOKBOOKS.name, cb_id, "json"):
@@ -70,55 +78,70 @@ class Cookbook:
                 ):
                     raise RuntimeError(f"{recipe} recipe does not exist.")
 
-            cb_info = {
-                "id": cb_id,
-                "name": cb_args.name,
-                "description": cb_args.description,
-                "recipes": cb_args.recipes,
-            }
-
             # Write as json output
             Storage.create_object(EnvVariables.COOKBOOKS.name, cb_id, cb_info, "json")
             return cb_id
 
         except Exception as e:
-            print(f"Failed to create cookbook: {str(e)}")
+            logger.error(f"Failed to create cookbook: {str(e)}")
             raise e
 
     @staticmethod
     @validate_call
     def read(cb_id: str) -> CookbookArguments:
         """
-        Retrieves the details of a specified cookbook.
+        Fetches and returns the details of a specified cookbook by its ID.
+
+        This method takes a cookbook ID, searches for its corresponding JSON file in the directory set by
+        `EnvironmentVars.COOKBOOKS`, and constructs a CookbookArguments object with the cookbook's details.
 
-        This method accepts a cookbook ID as an argument, locates the corresponding JSON file in the directory
-        defined by `EnvironmentVars.COOKBOOKS`, and returns a CookbookArguments object that encapsulates the cookbook's
-        details. If any error occurs during the process, an exception is raised and the error message is logged.
+        If the process encounters any issues, such as the file not existing or being inaccessible, it logs the error
+        and raises an exception.
 
         Args:
-            cb_id (str): The unique identifier of the cookbook to be retrieved.
+            cb_id (str): The unique identifier of the cookbook to fetch.
 
         Returns:
-            CookbookArguments: An object encapsulating the details of the retrieved cookbook.
+            CookbookArguments: An instance filled with the cookbook's details.
 
         Raises:
-            Exception: If there's an error during the file reading process or any other operation within the method.
+            RuntimeError: If the cookbook ID is empty or the specified cookbook does not exist.
+            Exception: For any issues encountered during the file reading or data parsing process.
         """
         try:
             if not cb_id:
-                raise RuntimeError("Cookbook ID is empty")
+                raise RuntimeError("Cookbook ID is empty.")
 
-            obj_results = Storage.read_object(
-                EnvVariables.COOKBOOKS.name, cb_id, "json"
-            )
-            if obj_results:
-                return CookbookArguments(**obj_results)
-            else:
-                raise RuntimeError(f"Unable to get results for {cb_id}.")
+            cookbook_details = Cookbook._read_cookbook(cb_id)
+            if not cookbook_details:
+                raise RuntimeError(f"Cookbook with ID '{cb_id}' does not exist.")
+
+            return CookbookArguments(**cookbook_details)
 
         except Exception as e:
-            print(f"Failed to read cookbook: {str(e)}")
-            raise e
+            logger.error(f"Failed to read cookbook: {str(e)}")
+            raise
+
+    @staticmethod
+    def _read_cookbook(cb_id: str) -> dict:
+        """
+        Retrieves the cookbook's information from a JSON file.
+
+        This internal method is designed to fetch the details of a specific cookbook by its ID. It searches for the
+        corresponding JSON file within the directory specified by `EnvVariables.COOKBOOKS`. The method returns a
+        dictionary containing the cookbook's information.
+
+        Args:
+            cb_id (str): The unique identifier of the cookbook whose information is being retrieved.
+
+        Returns:
+            dict: A dictionary with the cookbook's information.
+        """
+        cookbook_info = {"id": cb_id}
+        cookbook_info.update(
+            Storage.read_object(EnvVariables.COOKBOOKS.name, cb_id, "json")
+        )
+        return cookbook_info
 
     @staticmethod
     def update(cb_args: CookbookArguments) -> bool:
@@ -145,17 +168,18 @@ class Cookbook:
                 ):
                     raise RuntimeError(f"{recipe} recipe does not exist.")
 
-            # Convert the cookbook arguments to a dictionary
+            # Serialize the CookbookArguments object to a dictionary and remove derived properties
             cb_info = cb_args.to_dict()
+            cb_info.pop("id", None)  # The 'id' is derived and should not be written
 
-            # Write the updated cookbook information to the file
+            # Write the updated cookbook information to the storage
             Storage.create_object(
                 EnvVariables.COOKBOOKS.name, cb_args.id, cb_info, "json"
             )
             return True
 
         except Exception as e:
-            print(f"Failed to update cookbook: {str(e)}")
+            logger.error(f"Failed to update cookbook: {str(e)}")
             raise e
 
     @staticmethod
@@ -181,7 +205,7 @@ class Cookbook:
             return True
 
         except Exception as e:
-            print(f"Failed to delete cookbook: {str(e)}")
+            logger.error(f"Failed to delete cookbook: {str(e)}")
             raise e
 
     @staticmethod
@@ -210,16 +234,12 @@ class Cookbook:
                 if "__" in cb:
                     continue
 
-                cb_info = CookbookArguments(
-                    **Storage.read_object(
-                        EnvVariables.COOKBOOKS.name, Path(cb).stem, "json"
-                    )
-                )
+                cb_info = CookbookArguments(**Cookbook._read_cookbook(Path(cb).stem))
                 retn_cbs.append(cb_info)
                 retn_cbs_ids.append(cb_info.id)
 
             return retn_cbs_ids, retn_cbs
 
         except Exception as e:
-            print(f"Failed to get available cookbooks: {str(e)}")
+            logger.error(f"Failed to get available cookbooks: {str(e)}")
             raise e

moonshot/src/datasets/dataset.py

@@ -2,17 +2,137 @@ from __future__ import annotations
 
 from pathlib import Path
 
+import pandas as pd
+from datasets import load_dataset
 from pydantic import validate_call
+from slugify import slugify
 
 from moonshot.src.configs.env_variables import EnvVariables
 from moonshot.src.datasets.dataset_arguments import DatasetArguments
 from moonshot.src.storage.storage import Storage
+from moonshot.src.utils.log import configure_logger
+
+# Create a logger for this module
+logger = configure_logger(__name__)
 
 
 class Dataset:
     cache_name = "cache"
     cache_extension = "json"
 
+    @staticmethod
+    @validate_call
+    def create(ds_args: DatasetArguments, method: str, **kwargs) -> str:
+        """
+        Creates a new dataset based on the provided arguments and method.
+
+        This method generates a unique dataset ID using the dataset name,
+        checks if a dataset with the same ID already exists, and then
+        creates the dataset using the specified method (either 'csv' or
+        'hf'). The dataset information is then stored as a JSON object.
+
+        Args:
+            ds_args (DatasetArguments): The arguments containing dataset
+                details such as name, description, reference, and license.
+            method (str): The method to create the dataset. It can be either
+                'csv' or 'hf'.
+            **kwargs: Additional keyword arguments required for the specified
+                method.
+                - For 'csv' method: 'csv_file_path' (str): The file path to
+                    the CSV file.
+                - For 'hf' method: 'dataset_name' (str): The name of the
+                    Hugging Face dataset.
+                    'dataset_config' (str): The configuration of the Hugging
+                    Face dataset.
+                    'split' (str): The split of the dataset to load.
+                    'input_col' (list[str]): The list of input columns.
+                    'target_col' (str): The target column.
+
+        Returns:
+            str: The unique ID of the created dataset.
+
+        Raises:
+            RuntimeError: If a dataset with the same ID already exists.
+            Exception: If any other error occurs during the dataset creation
+                process.
+        """
+        try:
+            ds_id = slugify(ds_args.name, lowercase=True)
+
+            # Check if the dataset exists
+            if Storage.is_object_exists(EnvVariables.DATASETS.name, ds_id, "json"):
+                raise RuntimeError(f"Dataset with ID '{ds_id}' already exists.")
+
+            examples = [{}]
+            if method == "csv":
+                examples = Dataset._convert_csv(kwargs["csv_file_path"])
+            elif method == "hf":
+                examples = Dataset._download_hf(kwargs)
+
+            ds_info = {
+                "id": ds_id,
+                "name": ds_args.name,
+                "description": ds_args.description,
+                "reference": ds_args.reference,
+                "license": ds_args.license,
+                "examples": examples,
+            }
+
+            # Write as JSON output
+            file_path = Storage.create_object(
+                EnvVariables.DATASETS.name, ds_id, ds_info, "json"
+            )
+            return file_path
+
+        except Exception as e:
+            logger.error(f"Failed to create dataset: {str(e)}")
+            raise e
+
+    @staticmethod
+    def _convert_csv(csv_file: str) -> list[dict]:
+        """
+        Converts a CSV file to a list of dictionaries.
+
+        This method reads a CSV file and converts its contents into a list of dictionaries,
+        where each dictionary represents a row in the CSV file.
+
+        Args:
+            csv_file (str): The file path to the CSV file.
+
+        Returns:
+            list[dict]: A list of dictionaries representing the CSV data.
+        """
+        df = pd.read_csv(csv_file)
+        data = df.to_dict("records")
+        return data
+
+    @staticmethod
+    def _download_hf(hf_args) -> list[dict]:
+        """
+        Downloads a dataset from Hugging Face and converts it to a list of dictionaries.
+
+        This method loads a dataset from Hugging Face based on the provided arguments and converts
+        its contents into a list of dictionaries, where each dictionary contains 'input' and 'target' keys.
+
+        Args:
+            hf_args (dict): A dictionary containing the following keys:
+                - 'dataset_name' (str): The name of the Hugging Face dataset.
+                - 'dataset_config' (str): The configuration of the Hugging Face dataset.
+                - 'split' (str): The split of the dataset to load.
+                - 'input_col' (list[str]): The list of input columns.
+                - 'target_col' (str): The target column.
+
+        Returns:
+            list[dict]: A list of dictionaries representing the dataset.
+        """
+        dataset = load_dataset(hf_args["dataset_name"], hf_args["dataset_config"])
+        data = []
+        for example in dataset[hf_args["split"]]:
+            input_data = " ".join([str(example[col]) for col in hf_args["input_col"]])
+            target_data = str(example[hf_args["target_col"]])
+            data.append({"input": input_data, "target": target_data})
+        return data
+
     @staticmethod
     @validate_call
     def read(ds_id: str) -> DatasetArguments:
@@ -40,7 +160,7 @@ class Dataset:
                 raise RuntimeError("Dataset ID is empty")
 
         except Exception as e:
-            print(f"Failed to read dataset: {str(e)}")
+            logger.error(f"Failed to read dataset: {str(e)}")
             raise e
 
     @staticmethod
@@ -111,7 +231,7 @@ class Dataset:
             return True
 
         except Exception as e:
-            print(f"Failed to delete dataset: {str(e)}")
+            logger.error(f"Failed to delete dataset: {str(e)}")
             raise e
 
     @staticmethod
@@ -137,7 +257,7 @@ class Dataset:
             )
             return cache_info if cache_info else {}
         except Exception as e:
-            print(f"Failed to retrieve cache information: {str(e)}")
+            logger.error(f"Failed to retrieve cache information: {str(e)}")
             return {}
 
     @staticmethod
@@ -156,7 +276,7 @@ class Dataset:
                 obj_extension=Dataset.cache_extension,
             )
         except Exception as e:
-            print(f"Failed to write cache information: {str(e)}")
+            logger.error(f"Failed to write cache information: {str(e)}")
             raise e
 
     @staticmethod
@@ -215,7 +335,7 @@ class Dataset:
             return retn_datasets_ids, retn_datasets
 
         except Exception as e:
-            print(f"Failed to get available datasets: {str(e)}")
+            logger.error(f"Failed to get available datasets: {str(e)}")
             raise e
 
     @staticmethod

moonshot/src/metrics/metric.py

@@ -8,6 +8,10 @@ from moonshot.src.configs.env_variables import EnvVariables
 from moonshot.src.metrics.metric_interface import MetricInterface
 from moonshot.src.storage.storage import Storage
 from moonshot.src.utils.import_modules import get_instance
+from moonshot.src.utils.log import configure_logger
+
+# Create a logger for this module
+logger = configure_logger(__name__)
 
 
 class Metric:
@@ -64,7 +68,7 @@ class Metric:
             return True
 
         except Exception as e:
-            print(f"Failed to delete metric: {str(e)}")
+            logger.error(f"Failed to delete metric: {str(e)}")
             raise e
 
     @staticmethod
@@ -90,7 +94,7 @@ class Metric:
             )
             return cache_info if cache_info else {}
         except Exception:
-            print(
+            logger.error(
                 f"No previous cache information because {Metric.cache_name} is not found."
             )
             return {}
@@ -111,7 +115,7 @@ class Metric:
                 obj_extension=Metric.cache_extension,
             )
         except Exception as e:
-            print(f"Failed to write cache information: {str(e)}")
+            logger.error(f"Failed to write cache information: {str(e)}")
             raise e
 
     @staticmethod
@@ -154,7 +158,7 @@ class Metric:
             return retn_mets_ids, retn_mets
 
         except Exception as e:
-            print(f"Failed to get available metrics: {str(e)}")
+            logger.error(f"Failed to get available metrics: {str(e)}")
             raise e
 
     @staticmethod

moonshot/src/metrics/metric_interface.py

@@ -3,8 +3,12 @@ from typing import Any
 
 from moonshot.src.configs.env_variables import EnvVariables
 from moonshot.src.storage.storage import Storage
+from moonshot.src.utils.log import configure_logger
 from moonshot.src.utils.timeit import timeit
 
+# Create a logger for this module
+logger = configure_logger(__name__)
+
 
 class MetricInterface:
     config_name = "metrics_config"
@@ -75,8 +79,10 @@ class MetricInterface:
             return obj_results.get(met_id, {})
 
         except Exception as e:
-            print(f"[MetricInterface] Failed to read metrics configuration: {str(e)}")
-            print("Attempting to create empty metrics configuration...")
+            logger.warning(
+                f"[MetricInterface] Failed to read metrics configuration: {str(e)}"
+            )
+            logger.info("Attempting to create empty metrics configuration...")
             try:
                 Storage.create_object(
                     obj_type=EnvVariables.METRICS.name,

moonshot/src/prompt_templates/prompt_template.py

@@ -4,6 +4,10 @@ from jinja2 import Template
 
 from moonshot.src.configs.env_variables import EnvVariables
 from moonshot.src.storage.storage import Storage
+from moonshot.src.utils.log import configure_logger
+
+# Create a logger for this module
+logger = configure_logger(__name__)
 
 
 class PromptTemplate:
@@ -79,7 +83,7 @@ class PromptTemplate:
             return True
 
         except Exception as e:
-            print(f"Failed to delete prompt template: {str(e)}")
+            logger.error(f"Failed to delete prompt template: {str(e)}")
             raise e
 
     @staticmethod