aiverify-moonshot 0.4.0__py3-none-any.whl

moonshot/src/cookbooks/cookbook.py

@@ -0,0 +1,225 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from pydantic import validate_call
+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
+
+
+class Cookbook:
+    def __init__(self, cb_args: CookbookArguments) -> None:
+        self.id = cb_args.id
+        self.name = cb_args.name
+        self.description = cb_args.description
+        self.recipes = cb_args.recipes
+
+    @classmethod
+    def load(cls, cb_id: str) -> Cookbook:
+        """
+        This method loads a cookbook from a JSON file.
+
+        It uses the cookbook ID to construct the file path for the JSON file in the designated cookbook directory.
+        The method then reads the JSON file and returns the cookbook information as a Cookbook instance.
+
+        Args:
+            cb_id (str): The unique identifier of the 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))
+
+    @staticmethod
+    def create(cb_args: CookbookArguments) -> str:
+        """
+        This method is responsible for creating a new cookbook and storing its details in a JSON file.
+
+        The function accepts `cb_args` parameter which contains the necessary details for creating a new cookbook.
+        It generates a unique ID for the cookbook by slugifying the cookbook name. After that, it constructs a
+        dictionary with the cookbook's details and writes this information to a JSON file. The JSON file is named after
+        the cookbook ID and is stored in the directory specified by `EnvironmentVars.COOKBOOKS`.
+
+        If the operation encounters any error, an exception is raised and the error message is printed.
+
+        Args:
+            cb_args (CookbookArguments): An object that holds the necessary details for creating a new cookbook.
+
+        Returns:
+            str: The unique ID of the newly created cookbook.
+
+        Raises:
+            RuntimeError: If any of the recipes specified in the cookbook does not exist.
+            Exception: If there is an error during the file writing process or any other operation within the method.
+        """
+        try:
+            cb_id = slugify(cb_args.name, lowercase=True)
+
+            # check if the cookbook exists
+            if Storage.is_object_exists(EnvVariables.COOKBOOKS.name, cb_id, "json"):
+                raise RuntimeError(f"Cookbook with ID '{cb_id}' already exists.")
+
+            # check if recipes in list exist before creating cookbook
+            for recipe in cb_args.recipes:
+                if not Storage.is_object_exists(
+                    EnvVariables.RECIPES.name, recipe, "json"
+                ):
+                    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)}")
+            raise e
+
+    @staticmethod
+    @validate_call
+    def read(cb_id: str) -> CookbookArguments:
+        """
+        Retrieves the details of a specified cookbook.
+
+        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.
+
+        Args:
+            cb_id (str): The unique identifier of the cookbook to be retrieved.
+
+        Returns:
+            CookbookArguments: An object encapsulating the details of the retrieved cookbook.
+
+        Raises:
+            Exception: If there's an error during the file reading process or any other operation within the method.
+        """
+        try:
+            if not cb_id:
+                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}.")
+
+        except Exception as e:
+            print(f"Failed to read cookbook: {str(e)}")
+            raise e
+
+    @staticmethod
+    def update(cb_args: CookbookArguments) -> bool:
+        """
+        Updates the details of an existing cookbook.
+
+        This method accepts a CookbookArguments object, converts it to a dictionary, and writes the updated
+        information to the corresponding JSON file in the directory defined by `EnvVariables.COOKBOOKS`.
+
+        Args:
+            cb_args (CookbookArguments): An object containing the updated details of the cookbook.
+
+        Returns:
+            bool: True if the update was successful.
+
+        Raises:
+            Exception: If there's an error during the update process.
+        """
+        try:
+            # check if recipes in list exist before creating cookbook
+            for recipe in cb_args.recipes:
+                if not Storage.is_object_exists(
+                    EnvVariables.RECIPES.name, recipe, "json"
+                ):
+                    raise RuntimeError(f"{recipe} recipe does not exist.")
+
+            # Convert the cookbook arguments to a dictionary
+            cb_info = cb_args.to_dict()
+
+            # Write the updated cookbook information to the file
+            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)}")
+            raise e
+
+    @staticmethod
+    @validate_call
+    def delete(cb_id: str) -> bool:
+        """
+        Deletes a cookbook identified by its ID.
+
+        This method removes the cookbook's JSON file from the storage, using the `Storage.delete_object` method.
+        The `EnvVariables.COOKBOOKS` environment variable specifies the directory where the cookbook files are stored.
+
+        Args:
+            cb_id (str): The unique identifier of the cookbook to be deleted.
+
+        Returns:
+            bool: True if the deletion was successful.
+
+        Raises:
+            Exception: If there's an error during the deletion process.
+        """
+        try:
+            Storage.delete_object(EnvVariables.COOKBOOKS.name, cb_id, "json")
+            return True
+
+        except Exception as e:
+            print(f"Failed to delete cookbook: {str(e)}")
+            raise e
+
+    @staticmethod
+    def get_available_items() -> tuple[list[str], list[CookbookArguments]]:
+        """
+        Retrieves and returns all available cookbooks.
+
+        This method scans the directory specified by `EnvironmentVars.COOKBOOKS` and identifies all stored cookbook
+        files. It excludes any files that contain "__" in their names. For each valid cookbook file, the method reads
+        the file content and constructs a CookbookArguments object encapsulating the cookbook's details.
+        Both the CookbookArguments object and the cookbook ID are then appended to their respective lists.
+
+        Returns:
+            tuple[list[str], list[CookbookArguments]]: A tuple where the first element is a list of cookbook IDs and
+            the second element is a list of CookbookArguments objects representing the details of each cookbook.
+
+        Raises:
+            Exception: If an error occurs during the file reading process or any other operation within the method.
+        """
+        try:
+            retn_cbs = []
+            retn_cbs_ids = []
+
+            cbs = Storage.get_objects(EnvVariables.COOKBOOKS.name, "json")
+            for cb in cbs:
+                if "__" in cb:
+                    continue
+
+                cb_info = CookbookArguments(
+                    **Storage.read_object(
+                        EnvVariables.COOKBOOKS.name, Path(cb).stem, "json"
+                    )
+                )
+                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)}")
+            raise e

moonshot/src/cookbooks/cookbook_arguments.py

@@ -0,0 +1,34 @@
+from pydantic import BaseModel, Field
+
+
+class CookbookArguments(BaseModel):
+    id: str  # id (str): The unique identifier for the Cookbook.
+
+    name: str = Field(min_length=1)  # name (str): The name of the Cookbook.
+
+    description: str  # description (str): A brief description of the Cookbook.
+
+    recipes: list[str] = Field(
+        min_length=1
+    )  # recipes (list): A list of recipes included in the Cookbook.
+
+    def to_dict(self) -> dict:
+        """
+        Converts the CookbookArguments instance into a dictionary.
+
+        This method takes all the attributes of the CookbookArguments instance and constructs a dictionary
+        with attribute names as keys and their corresponding values. This includes the id, name, description,
+        and recipes.
+
+        This dictionary can be used for serialization purposes, such as storing the cookbook information in a JSON file
+        or sending it over a network.
+
+        Returns:
+            dict: A dictionary representation of the CookbookArguments instance.
+        """
+        return {
+            "id": self.id,
+            "name": self.name,
+            "description": self.description,
+            "recipes": self.recipes,
+        }

moonshot/src/datasets/dataset.py

@@ -0,0 +1,255 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from pydantic import validate_call
+
+from moonshot.src.configs.env_variables import EnvVariables
+from moonshot.src.datasets.dataset_arguments import DatasetArguments
+from moonshot.src.storage.storage import Storage
+
+
+class Dataset:
+    cache_name = "cache"
+    cache_extension = "json"
+
+    @staticmethod
+    @validate_call
+    def read(ds_id: str) -> DatasetArguments:
+        """
+        Fetches the details of a given dataset.
+
+        This method takes a dataset ID as input, finds the corresponding JSON file in the directory
+        specified by `EnvVariables.DATASETS`, and returns a DatasetArguments object
+        that contains the dataset's details. If any error arises during the process, an exception is raised and the
+        error message is logged.
+
+        Args:
+            ds_id (str): The unique ID of the dataset to be fetched.
+
+        Returns:
+            DatasetArguments: An object encapsulating the details of the fetched dataset.
+
+        Raises:
+            Exception: If there's an error during the file reading process or any other operation within the method.
+        """
+        try:
+            if ds_id:
+                return DatasetArguments(**Dataset._read_dataset(ds_id))
+            else:
+                raise RuntimeError("Dataset ID is empty")
+
+        except Exception as e:
+            print(f"Failed to read dataset: {str(e)}")
+            raise e
+
+    @staticmethod
+    def _read_dataset(ds_id: str) -> dict:
+        """
+        Retrieves dataset information from storage and augments it with metadata.
+
+        This method takes a dataset ID, locates the corresponding JSON file within the directory
+        specified by `EnvVariables.DATASETS`, and constructs a dictionary that includes the dataset's
+        core details, as well as metadata such as the creation datetime and the count of dataset prompts.
+
+        Args:
+            ds_id (str): The unique identifier of the dataset to be retrieved.
+
+        Returns:
+            dict: A dictionary with the dataset's core information, enriched with metadata like the creation datetime
+                  and the total number of prompts contained within the dataset.
+        """
+        # Read the basic dataset information
+        dataset_info = Storage.read_object_with_iterator(
+            obj_type=EnvVariables.DATASETS.name,
+            obj_id=ds_id,
+            obj_extension="json",
+            json_keys=["name", "description", "license", "reference"],
+            iterator_keys=["examples.item"],
+        )
+
+        # Add additional parameters - [id, num_of_dataset_prompts, creation_date]
+        # Append the dataset ID to the dataset_info
+        dataset_info["id"] = ds_id
+
+        # Use Storage.count_objects to get the number of examples in a memory-efficient way
+        dataset_info["num_of_dataset_prompts"] = Storage.count_objects(
+            EnvVariables.DATASETS.name, ds_id, "json", "examples.item"
+        )
+
+        # Assign the creation date to the dataset_info
+        creation_datetime = Storage.get_creation_datetime(
+            EnvVariables.DATASETS.name, ds_id, "json"
+        )
+        dataset_info["created_date"] = creation_datetime.replace(
+            microsecond=0
+        ).isoformat(" ")
+
+        return dataset_info
+
+    @staticmethod
+    @validate_call
+    def delete(ds_id: str) -> bool:
+        """
+        Deletes a dataset from storage.
+
+        This method attempts to delete the dataset with the given ID from the storage. If the deletion is successful,
+        it returns True. If an exception occurs during the deletion process, it prints an error message and re-raises
+        the exception.
+
+        Args:
+            ds_id (str): The unique identifier of the dataset to be deleted.
+
+        Returns:
+            bool: True if the dataset was successfully deleted.
+
+        Raises:
+            Exception: If an error occurs during the deletion process.
+        """
+        try:
+            Storage.delete_object(EnvVariables.DATASETS.name, ds_id, "json")
+            return True
+
+        except Exception as e:
+            print(f"Failed to delete dataset: {str(e)}")
+            raise e
+
+    @staticmethod
+    def get_cache_information() -> dict:
+        """
+        Retrieves cache information from the storage.
+
+        This method attempts to read the cache information from the storage and return it as a dictionary.
+        If the cache information does not exist or an error occurs, it returns an empty dictionary.
+
+        Returns:
+            dict: A dictionary containing the cache information or an empty dictionary if an error occurs
+            or if the cache information does not exist.
+
+        Raises:
+            Exception: If there's an error during the retrieval process, it is logged and an
+            empty dictionary is returned.
+        """
+        try:
+            # Retrieve cache information from the storage and return it as a dictionary
+            cache_info = Storage.read_object(
+                EnvVariables.DATASETS.name, Dataset.cache_name, Dataset.cache_extension
+            )
+            return cache_info if cache_info else {}
+        except Exception as e:
+            print(f"Failed to retrieve cache information: {str(e)}")
+            return {}
+
+    @staticmethod
+    def write_cache_information(cache_info: dict) -> None:
+        """
+        Writes the updated cache information to the storage.
+
+        Args:
+            cache_info (dict): The cache information to be written.
+        """
+        try:
+            Storage.create_object(
+                obj_type=EnvVariables.DATASETS.name,
+                obj_id=Dataset.cache_name,
+                obj_info=cache_info,
+                obj_extension=Dataset.cache_extension,
+            )
+        except Exception as e:
+            print(f"Failed to write cache information: {str(e)}")
+            raise e
+
+    @staticmethod
+    def get_available_items(
+        datasets: list[str] = [],
+    ) -> tuple[list[str], list[DatasetArguments]]:
+        """
+        Retrieves a list of available dataset IDs and their corresponding DatasetArguments objects.
+
+        This method filters out any non-dataset files and the cache file from the list of datasets. It then
+        retrieves or updates the dataset information from the cache for each dataset. If the cache is updated
+        during this process, it writes the updated cache information back to the storage.
+
+        Args:
+            datasets (list[str], optional): A list of dataset file names. If not provided, it will retrieve
+                the list of all dataset files from the storage. Defaults to an empty list.
+
+        Returns:
+            tuple[list[str], list[DatasetArguments]]: A tuple containing two lists:
+                - The first list contains the IDs of the available datasets.
+                - The second list contains the corresponding DatasetArguments objects for those IDs.
+        """
+        try:
+            retn_datasets = []
+            retn_datasets_ids = []
+            ds_cache_info = Dataset.get_cache_information()
+            cache_needs_update = False  # Initialize a flag to track cache updates
+
+            if datasets:
+                datasets_objects = datasets
+            else:
+                datasets_objects = Storage.get_objects(
+                    EnvVariables.DATASETS.name, "json"
+                )
+
+            for ds in datasets_objects:
+                if (
+                    "__" in ds
+                    or f"{Dataset.cache_name}.{Dataset.cache_extension}" in ds
+                ):
+                    continue
+
+                ds_name = Path(ds).stem
+                ds_info, cache_updated = Dataset._get_or_update_dataset_info(
+                    ds_name, ds_cache_info
+                )
+                if cache_updated:
+                    cache_needs_update = True  # Set the flag if any cache was updated
+
+                retn_datasets.append(ds_info)
+                retn_datasets_ids.append(ds_info.id)
+
+            if cache_needs_update:  # Check the flag after the loop
+                Dataset.write_cache_information(ds_cache_info)
+
+            return retn_datasets_ids, retn_datasets
+
+        except Exception as e:
+            print(f"Failed to get available datasets: {str(e)}")
+            raise e
+
+    @staticmethod
+    def _get_or_update_dataset_info(
+        ds_name: str, ds_cache_info: dict
+    ) -> tuple[DatasetArguments, bool]:
+        """
+        Retrieves or updates the dataset information from the cache.
+
+        This method checks if the dataset information is already available in the cache and if the file hash matches
+        the one stored in the cache. If it does, the information is retrieved from the cache. If not, the dataset
+        information is read from the storage, the cache is updated with the new information and the new file hash,
+        and a flag is set to indicate that the cache has been updated.
+
+        Args:
+            ds_name (str): The name of the dataset.
+            ds_cache_info (dict): A dictionary containing the cached dataset information.
+
+        Returns:
+            tuple[DatasetArguments, bool]: A tuple containing the DatasetArguments object with the dataset information
+                                           and a boolean indicating whether the cache was updated or not.
+        """
+        file_hash = Storage.get_file_hash(EnvVariables.DATASETS.name, ds_name, "json")
+        cache_updated = False
+
+        if ds_name in ds_cache_info and file_hash == ds_cache_info[ds_name]["hash"]:
+            ds_metadata = ds_cache_info[ds_name].copy()
+            ds_metadata.pop("hash", None)
+            ds_info = DatasetArguments(**ds_metadata)
+        else:
+            ds_info = DatasetArguments(**Dataset._read_dataset(ds_name))
+            ds_info.examples = None
+            ds_cache_info[ds_name] = ds_info.copy().to_dict()
+            ds_cache_info[ds_name]["hash"] = file_hash
+            cache_updated = True
+
+        return ds_info, cache_updated

moonshot/src/datasets/dataset_arguments.py

@@ -0,0 +1,50 @@
+from pydantic import BaseModel
+from pyparsing import Iterator
+
+
+class DatasetArguments(BaseModel):
+    class Config:
+        arbitrary_types_allowed = True
+
+    # id (str): Unique identifier for the dataset
+    id: str
+
+    # name (str): Name of the dataset
+    name: str
+
+    # description (str): Description of the dataset's contents and purpose
+    description: str
+
+    # examples (Iterator[dict] | None): Generator of examples from the dataset, where each example is a dictionary.
+    examples: Iterator[dict] | None
+
+    # num_of_dataset_prompts (int): The number of dataset prompts, automatically calculated
+    num_of_dataset_prompts: int = 0
+
+    # created_date (str): The creation date and time of the dataset in ISO format without 'T'. Automatically generated.
+    created_date: str = ""
+
+    # reference (str): An optional string to store a reference link or identifier for the dataset
+    reference: str = ""
+
+    # license (str): License information for the dataset. Defaults to an empty string if not provided.
+    license: str = ""
+
+    def to_dict(self) -> dict:
+        """
+        Converts the DatasetArguments object to a dictionary.
+
+        Returns:
+            dict: A dictionary representation of the DatasetArguments object, including the id, name, description,
+                  examples, number of dataset prompts, created date, reference, and license.
+        """
+        return {
+            "id": self.id,
+            "name": self.name,
+            "description": self.description,
+            "examples": self.examples,
+            "num_of_dataset_prompts": self.num_of_dataset_prompts,
+            "created_date": self.created_date,
+            "reference": self.reference,
+            "license": self.license,
+        }