raman-data 0.0.1__py3-none-any.whl

raman_data/__init__.py

@@ -0,0 +1,43 @@
+"""
+A unified API for loading and accessing Raman spectroscopy datasets.
+"""
+
+__all__ = [
+    "TASK_TYPE",
+    "raman_data"
+]
+
+from typing import List, Optional, Union
+
+from .types import RamanDataset
+from . import datasets
+from .types import TASK_TYPE
+
+
+
+
+def raman_data(
+    dataset_name: Optional[str] = None,
+    cache_dir: Optional[str] = None,
+    task_type: Optional[TASK_TYPE] = None
+) -> Union[RamanDataset, List[str]]:
+    """
+    Main function to interact with Raman datasets.
+
+    - If 'name' is provided, it loads the specified dataset.
+    - If 'name' is None, it lists available datasets, optionally filtered by 'task_type'.
+
+    Args:
+        dataset_name: The name of the dataset to load. If None, lists datasets.
+        cache_dir: The directory to use for caching the data.
+        task_type: Filters the dataset list by task type ('classification' or 'regression').
+
+    Returns:
+        - A RamanDataset object if 'name' is specified.
+        - A list of dataset names if 'name' is None.
+    """
+    if dataset_name is None:
+        return datasets.list_datasets(task_type=task_type)
+    else:
+        return datasets.load_dataset(dataset_name=dataset_name,
+                                     cache_dir=cache_dir)

raman_data/datasets.py

@@ -0,0 +1,83 @@
+"""
+Internal functions for loading and listing datasets.
+"""
+
+from typing import List, Optional
+from .types import RamanDataset
+
+from raman_data.loaders.KagLoader import KagLoader
+from raman_data.loaders.HugLoader import HugLoader
+from raman_data.loaders.ZenLoader import ZenLoader
+from raman_data.loaders.ZipLoader import ZipLoader
+from raman_data.types import TASK_TYPE
+
+__LOADERS = [
+    KagLoader,
+    HugLoader,
+    ZenLoader,
+    #ZipLoader
+]
+
+def list_datasets(
+    task_type: Optional[TASK_TYPE] = None
+) -> List[str]:
+    """
+    Lists the available Raman spectroscopy datasets.
+
+    Args:
+        task_type: If specified, filters the datasets by task type.
+                   Can be 'TASK_TYPE.Classification' or 'TASK_TYPE.Regression'.
+
+    Returns:
+        A list of available dataset names.
+    """
+
+    datasets = {}
+
+    for loader in __LOADERS:
+        for name, dataset_info in loader.DATASETS.items():
+            datasets.update({name: dataset_info})
+
+    if task_type:
+        return [name for name, dataset_info in datasets.items() if dataset_info.task_type == task_type]
+    
+    return list(datasets.keys())
+
+
+def load_dataset(
+    dataset_name: str,
+    cache_dir: Optional[str] = None
+) -> RamanDataset | None:
+    """
+    (Down-)Loads a specific Raman spectroscopy dataset.
+
+    When called for the first time, it will download the data from its original source
+    and store it in the cache directory. Subsequent calls will load the data from the cache.
+
+    Args:
+        dataset_name: The name of the dataset to load.
+        cache_dir: The directory to use for caching the data. If None, a default
+                   directory will be used.
+
+    Returns:
+        RamanDataset|None: A RamanDataset object containing
+                           the data, target, spectra and metadata or
+                           None if load process fails.
+
+    Raises:
+        ValueError: If the dataset name is not found.
+    """
+    if dataset_name not in list_datasets():
+        raise ValueError(f"Dataset '{dataset_name}' not found. "
+                         f"Available datasets: {list_datasets()}")
+
+    get_dataset = None
+    
+    for loader in __LOADERS:
+        if not (dataset_name in loader.DATASETS):
+            continue
+        
+        get_dataset = loader.load_dataset
+        break
+
+    return get_dataset(dataset_name, cache_dir)

raman_data/exceptions.py

@@ -0,0 +1,31 @@
+from typing import Optional
+
+class ChecksumError(Exception):
+    def __init__(
+        self, 
+        expected_checksum: Optional[str] = None,
+        actual_checksum: Optional[str] = None
+    ) -> None:
+        
+        super().__init__()
+        self.expected_checksum = expected_checksum
+        self.actual_checksum = actual_checksum
+        
+    def __str__(self) -> str:
+        return f"Expected: {self.expected_checksum} but got {self.actual_checksum}"
+    
+
+class CorruptedZipFileError(Exception):
+    def __init__(
+        self, 
+        zip_file_path: Optional[str] = None,
+        zip_file_name: Optional[str] = None
+    ) -> None:
+        
+        super().__init__()
+        self.zip_file_path = zip_file_path
+        self.zip_file_name = zip_file_name
+        
+    def __str__(self) -> str:
+         return f"The file {self.zip_file_name} at {self.zip_file_path} seams to be corrupted or in a other way not usable!"
+    

raman_data/loaders/HugLoader.py

@@ -0,0 +1,170 @@
+from typing import Optional, Tuple
+
+import datasets
+import pandas as pd
+import numpy as np
+
+from raman_data.types import DatasetInfo, RamanDataset, CACHE_DIR, TASK_TYPE
+from raman_data.loaders.ILoader import ILoader
+from raman_data.loaders.LoaderTools import LoaderTools
+
+
+class HugLoader(ILoader):
+    """
+    A static class specified in providing datasets hosted on HuggingFace.
+    """
+
+    @staticmethod
+    def __load_substarteMix(
+        df: pd.DataFrame
+    ) -> Tuple[np.ndarray, np.ndarray, np.ndarray] | None:
+
+        end_data_index = len(df.columns.values) - 8
+
+        raman_shifts = df.loc[:, :"3384.7"].to_numpy().T
+        spectra = np.array(df.columns.values[:end_data_index])
+        concentrations = df.loc[:, "Glucose":].to_numpy()
+
+        return raman_shifts, spectra, concentrations
+
+
+    @staticmethod
+    def __load_EcoliFermentation(
+        df: pd.DataFrame
+    ) -> Tuple[np.ndarray, np.ndarray, np.ndarray] | None:
+
+        end_data_index = len(df.columns.values) - 2
+
+        raman_shifts = df.loc[:, :"3384.7"].to_numpy().T
+        spectra = np.array(df.columns.values[:end_data_index])
+        concentrations = df.loc[:, :"Glucose"].to_numpy()
+
+        return raman_shifts, spectra, concentrations
+
+
+    @staticmethod
+    def __load_FuleSpectra(
+        df: pd.DataFrame
+    )-> Tuple[np.ndarray, np.ndarray, np.ndarray] | None:
+
+        end_data_index = len(df.columns.values) - 12
+
+        raman_shifts = df.loc[:, :"3801.0"].to_numpy().T
+        spectra = np.array(df.columns.values[:end_data_index])
+        concentrations = df.loc[:, "Research Octane Number":].to_numpy()
+
+        return raman_shifts, spectra, concentrations
+
+
+    DATASETS = {
+        "chlange/SubstrateMixRaman": DatasetInfo(
+            task_type=TASK_TYPE.Regression,
+            id=None,
+            loader=__load_substarteMix,
+            metadata={
+                "full_name" : "chlange/SubstrateMixRaman",
+                "source" : "https://huggingface.co/datasets/chlange/SubstrateMixRaman",
+                "paper" : "https://dx.doi.org/10.2139/ssrn.5239248",
+                "description" : "This dataset, designed for biotechnological applications, provides a valuable resource for calibrating models used in high-throughput bioprocess development, particularly for bacterial fermentations. It features Raman spectra of samples containing varying, statistically independent concentrations of eight key metabolites, along with mineral salt medium and antifoam."
+            }
+        ),
+        "chlange/RamanSpectraEcoliFermentation": DatasetInfo(
+            task_type=TASK_TYPE.Classification,
+            id=None,
+            loader=__load_EcoliFermentation,
+            metadata={
+                "full_name" : "chlange/RamanSpectraEcoliFermentation",
+                "source" : "https://huggingface.co/datasets/chlange/RamanSpectraEcoliFermentation",
+                "paper" : "https://doi.org/10.1002/bit.70006",
+                "description" : "Dataset Card for Raman Spectra from High-Throughput Bioprocess Fermentations of E. Coli. Raman spectra were obtained during an E. coli fermentation process consisting of a batch and a glucose-limited feeding phase, each lasting about four hours. Samples were automatically collected hourly, centrifuged to separate cells from the supernatant, and the latter was used for both metabolite analysis and Raman measurements. Two Raman spectra of ten seconds each were recorded per sample, with cell removal improving metabolite signal quality. More details can be found in the paper https://doi.org/10.1002/bit.70006"
+            }
+        ),
+        "chlange/FuelRamanSpectraBenchtop": DatasetInfo(
+            task_type=TASK_TYPE.Regression,
+            id=None,
+            loader=__load_FuleSpectra,
+            metadata={
+                "full_name" : "chlange/FuelRamanSpectraBenchtop",
+                "source" : "https://huggingface.co/datasets/chlange/FuelRamanSpectraBenchtop",
+                "paper" : "http://dx.doi.org/10.1021/acs.energyfuels.9b02944",
+                "description" : "This dataset contains Raman spectra for the analysis and prediction of key parameters in commercial fuel samples (gasoline). It includes spectra of 179 fuel samples from various refineries."
+            }
+        )
+    }
+
+
+    @staticmethod
+    def download_dataset(
+        dataset_name: str,
+        cache_path: Optional[str] = None
+    ) -> str | None:
+        if not LoaderTools.is_dataset_available(dataset_name, HugLoader.DATASETS):
+            print(f"[!] Cannot download {dataset_name} dataset with HuggingFace loader")
+            return
+
+        if not (cache_path is None):
+            LoaderTools.set_cache_root(cache_path, CACHE_DIR.HuggingFace)
+        cache_path = LoaderTools.get_cache_root(CACHE_DIR.HuggingFace)
+
+        print(f"Downloading HuggingFace dataset: {dataset_name}")
+        
+        datasets.load_dataset(
+            path=dataset_name,
+            cache_dir=cache_path
+        )
+
+        cache_path = cache_path if cache_path else "~/.cache/huggingface"
+        print(f"Dataset downloaded into {cache_path}")
+
+        return cache_path
+
+
+    @staticmethod
+    def load_dataset(
+        dataset_name: str,
+        cache_path: Optional[str] = None
+    ) -> RamanDataset | None:
+        if not LoaderTools.is_dataset_available(dataset_name, HugLoader.DATASETS):
+            print(f"[!] Cannot load {dataset_name} dataset with HuggingFace loader")
+            return
+
+        if not (cache_path is None):
+            LoaderTools.set_cache_root(cache_path, CACHE_DIR.HuggingFace)
+        cache_path = LoaderTools.get_cache_root(CACHE_DIR.HuggingFace)
+
+        print(
+            f"Loading HuggingFace dataset from " \
+            f"{cache_path if cache_path else 'default folder (~/.cache/huggingface)'}"
+        )
+
+        dataDict = datasets.load_dataset(path=dataset_name, cache_dir=cache_path)
+
+        df = pd.concat(
+            [
+                pd.DataFrame(dataDict["train"]),
+                pd.DataFrame(dataDict["test"]),
+                pd.DataFrame(dataDict["validation"]),
+            ],
+            ignore_index=True,
+        )
+    
+        data = HugLoader.DATASETS[dataset_name].loader(df)
+
+        if data is not None:
+            raman_shifts, spectra, concentrations = data
+            return RamanDataset(
+                data=raman_shifts,
+                target=concentrations,
+                spectra=spectra,
+                metadata=HugLoader.DATASETS[dataset_name].metadata
+            )
+        
+        return data
+
+
+    @staticmethod
+    def list_datasets() -> None:
+        """
+        Prints formatted list of datasets provided by this loader.
+        """
+        LoaderTools.list_datasets(HugLoader)

raman_data/loaders/ILoader.py

@@ -0,0 +1,86 @@
+from abc import ABCMeta, abstractmethod
+from typing import Optional
+
+from raman_data.types import RamanDataset
+
+class ILoader(metaclass=ABCMeta):
+    """
+    The general interface of all loaders.
+    """
+    @classmethod
+    def __subclasshook__(cls, subclass):
+        """
+        Checks whether a subclass has needed properties.
+
+        Args:
+            subclass (class): A class to check inheritance of.
+
+        Returns:
+            bool: True, if the subclass has required properties.
+                  False otherwise.
+        """
+        if not (hasattr(subclass, 'download_dataset') and
+            callable(subclass.download_dataset) and
+            hasattr(subclass, 'load_dataset') and
+            callable(subclass.load_dataset)):
+            return False
+        
+        try:
+            subclass.download_dataset('')
+            subclass.load_dataset('', '')
+        except NotImplementedError:
+            return False
+        
+        return True
+
+
+    @abstractmethod
+    def download_dataset(
+        dataset_name: str,
+        cache_path: Optional[str] = None
+    ) -> str | None:
+        """
+        Downloads certain dataset into a predefined cache folder.
+
+        Args:
+            dataset_name (str): The name of a dataset to download.
+            cache_path (str, optional): The path to save the dataset to.
+                                        If None, uses the lastly saved path.
+
+        Raises:
+            NotImplementedError: If not implemented raises the error by default.
+
+        Returns:
+            str|None: The path the dataset is downloaded to.
+                      If the dataset isn't on the list of a loader,
+                      returns None.
+        """
+        raise NotImplementedError
+
+
+    @abstractmethod
+    def load_dataset(
+        dataset_name: str,
+        cache_path: Optional[str] = None
+    ) -> RamanDataset | None:
+        """
+        Loads certain dataset from cache folder.
+        If the dataset isn't in the cache folder, downloads it into that folder.
+
+        Args:
+            dataset_name (str): The name of a dataset.
+            cache_path (str, optional): The path to the dataset's folder.
+                                        If None, uses the lastly saved path.
+                                        If "default", sets the default path ('~/.cache').
+
+        Raises:
+            NotImplementedError: If not implemented raises the error by default.
+
+        Returns:
+            RamanDataset|None: A RamanDataset object containing
+                                the data, target, spectra and metadata.
+                                If the dataset isn't on the list of a loader
+                                or load fails, returns None.
+        """
+        raise NotImplementedError
+

raman_data/loaders/KagLoader.py

@@ -0,0 +1,274 @@
+from typing import Optional, Tuple
+
+from kagglehub import dataset_load, dataset_download
+from kagglehub import KaggleDatasetAdapter
+import numpy as np
+import pandas as pd
+
+from raman_data.types import DatasetInfo, RamanDataset, CACHE_DIR, TASK_TYPE
+from raman_data.loaders.ILoader import ILoader
+from raman_data.loaders.LoaderTools import LoaderTools
+
+
+class KagLoader(ILoader):
+    """
+    A static class specified in providing datasets hosted on Kaggle.
+    """
+    @staticmethod
+    def __load_diabetes(
+        id: str
+    ) -> Tuple[np.ndarray, np.ndarray, np.ndarray] | None:
+        file_handle = "codina/raman-spectroscopy-of-diabetes"
+
+        df = dataset_load(
+            adapter=KaggleDatasetAdapter.PANDAS,
+            handle=file_handle,
+            path=f"{id}.csv"
+        )
+
+        if id == "AGEs":
+            raman_shifts = df.loc[1:, "Var802":].to_numpy().T
+            spectra = df.loc[0, "Var802":].to_numpy()
+            concentration = df.loc[1:, "AGEsID"].to_numpy()
+        else:
+            raman_shifts = df.loc[1:, "Var2":].to_numpy().T
+            spectra = df.loc[0, "Var2":].to_numpy()
+            concentration = df.loc[1:, "has_DM2"].to_numpy()
+
+        return raman_shifts, spectra, concentration
+
+
+    @staticmethod
+    def __load_sergioalejandrod(
+        id: str
+    ) -> Tuple[np.ndarray, np.ndarray, np.ndarray] | None:
+        file_handle = "sergioalejandrod/raman-spectroscopy"
+        header = ["Gly, 40 mM", "Leu, 40 mM", "Phe, 40 mM", "Trp, 40 mM"]
+
+        df = dataset_load(
+            adapter=KaggleDatasetAdapter.PANDAS,
+            handle=file_handle,
+            path="AminoAcids_40mM.xlsx",
+            pandas_kwargs={"sheet_name": f"Sheet{id}"}
+        )
+
+        raman_shifts = df.loc[1:, 4.5:].to_numpy()
+        spectra = df.loc[1:, header[(int(id) - 1)]].to_numpy()
+        concentration = np.array(df.columns.values[2:], dtype=float)
+
+        return raman_shifts, spectra, concentration
+
+
+    @staticmethod
+    def __load_andriitrelin():
+        raise NotImplementedError
+
+
+    @staticmethod
+    def __load_cancer_cells(
+        id: str
+    )-> Tuple[np.ndarray, np.ndarray, np.ndarray] | None:
+        raise NotImplementedError
+
+        file_handle = "mathiascharconnet/cancer-cells-sers-spectra"
+        lable_list = ["A", "A-S", "G", "G-S", "HPM", "HPM-S", "HF", "HF-S", "ZAM", "ZAM-S", "DMEM", "DMEM-S"]
+        file_list = {"(COOH)2.csv":None, 
+                     "COOH.csv":None, 
+                     "NH2.csv":None}
+
+        for lable in lable_list:
+            for file in file_list.keys():
+
+                df = dataset_load(
+                    adapter=KaggleDatasetAdapter.PANDAS,
+                    handle=file_handle,
+                    path=f"{lable}/{file}"
+                )
+
+                if file_list[file] is None:
+                    file_list[file] = df
+                else:
+                    file_list[file] = pd.concat([file_list[file], df])
+ 
+        spectra = np.linspace(100, 4278, 2090)
+
+
+    DATASETS = {
+        "codina/diabetes/AGEs": DatasetInfo(
+            task_type=TASK_TYPE.Classification,
+            id="AGEs",
+            loader=__load_diabetes,
+            metadata={
+                "full_name" : "codina/raman-spectroscopy-of-diabetes",
+                "source" : "https://www.kaggle.com/datasets/codina/raman-spectroscopy-of-diabetes",
+                "paper" : "https://doi.org/10.1364/BOE.9.004998",
+                "description" : "This is the dataset of our work where the application of portable Raman spectroscopy coupled with several supervised machine-learning techniques, is used to discern between diabetic patients (DM2) and healthy controls (Ctrl), with a high degree of accuracy."
+            }
+        ),
+        "codina/diabetes/earLobe": DatasetInfo(
+            task_type=TASK_TYPE.Classification,
+            id="earLobe",
+            loader=__load_diabetes,
+            metadata={
+                "full_name" : "codina/raman-spectroscopy-of-diabetes",
+                "source" : "https://www.kaggle.com/datasets/codina/raman-spectroscopy-of-diabetes",
+                "paper" : "https://doi.org/10.1364/BOE.9.004998",
+                "description" : "This is the dataset of our work where the application of portable Raman spectroscopy coupled with several supervised machine-learning techniques, is used to discern between diabetic patients (DM2) and healthy controls (Ctrl), with a high degree of accuracy."
+            }
+        ),
+        "codina/diabetes/innerArm": DatasetInfo(
+            task_type=TASK_TYPE.Classification,
+            id="innerArm",
+            loader=__load_diabetes,
+            metadata={
+                "full_name" : "codina/raman-spectroscopy-of-diabetes",
+                "source" : "https://www.kaggle.com/datasets/codina/raman-spectroscopy-of-diabetes",
+                "paper" : "https://doi.org/10.1364/BOE.9.004998",
+                "description" : "This is the dataset of our work where the application of portable Raman spectroscopy coupled with several supervised machine-learning techniques, is used to discern between diabetic patients (DM2) and healthy controls (Ctrl), with a high degree of accuracy."
+            }
+        ),
+        "codina/diabetes/thumbNail": DatasetInfo(
+            task_type=TASK_TYPE.Classification,
+            id="thumbNail",
+            loader=__load_diabetes,
+            metadata={
+                "full_name" : "codina/raman-spectroscopy-of-diabetes",
+                "source" : "https://www.kaggle.com/datasets/codina/raman-spectroscopy-of-diabetes",
+                "paper" : "https://doi.org/10.1364/BOE.9.004998",
+                "description" : "This is the dataset of our work where the application of portable Raman spectroscopy coupled with several supervised machine-learning techniques, is used to discern between diabetic patients (DM2) and healthy controls (Ctrl), with a high degree of accuracy."
+            }
+        ),
+        "codina/diabetes/vein": DatasetInfo(
+            task_type=TASK_TYPE.Classification,
+            id="vein",
+            loader=__load_diabetes,
+            metadata={
+                "full_name" : "codina/raman-spectroscopy-of-diabetes",
+                "source" : "https://www.kaggle.com/datasets/codina/raman-spectroscopy-of-diabetes",
+                "paper" : "https://doi.org/10.1364/BOE.9.004998",
+                "description" : "This is the dataset of our work where the application of portable Raman spectroscopy coupled with several supervised machine-learning techniques, is used to discern between diabetic patients (DM2) and healthy controls (Ctrl), with a high degree of accuracy."
+            }
+        ),
+        "sergioalejandrod/AminoAcids/glycine": DatasetInfo(
+            task_type=TASK_TYPE.Classification,
+            id="1",
+            loader=__load_sergioalejandrod,
+            metadata={
+                "full_name" : "sergioalejandrod/raman-spectroscopy",
+                "source" : "https://www.kaggle.com/datasets/sergioalejandrod/raman-spectroscopy",
+                "paper" : "https://doi.org/10.1021/acs.analchem.0c03015",
+                "description" : "This data set was produced by Hirotsugu Hiramatsu as part of his experiment revolving around the enhancement of Raman signal utilizing a vertical flow method."
+            }
+        ),
+        "sergioalejandrod/AminoAcids/leucine": DatasetInfo(
+            task_type=TASK_TYPE.Classification,
+            id="2",
+            loader=__load_sergioalejandrod,
+            metadata={
+                "full_name" : "sergioalejandrod/raman-spectroscopy",
+                "source" : "https://www.kaggle.com/datasets/sergioalejandrod/raman-spectroscopy",
+                "paper" : "https://doi.org/10.1021/acs.analchem.0c03015",
+                "description" : "This data set was produced by Hirotsugu Hiramatsu as part of his experiment revolving around the enhancement of Raman signal utilizing a vertical flow method."
+            }
+        ),
+        "sergioalejandrod/AminoAcids/phenylalanine": DatasetInfo(
+            task_type=TASK_TYPE.Classification,
+            id="3",
+            loader=__load_sergioalejandrod,
+            metadata={
+                "full_name" : "sergioalejandrod/raman-spectroscopy",
+                "source" : "https://www.kaggle.com/datasets/sergioalejandrod/raman-spectroscopy",
+                "paper" : "https://doi.org/10.1021/acs.analchem.0c03015",
+                "description" : "This data set was produced by Hirotsugu Hiramatsu as part of his experiment revolving around the enhancement of Raman signal utilizing a vertical flow method."
+            }
+        ),
+        "sergioalejandrod/AminoAcids/tryptophan": DatasetInfo(
+            task_type=TASK_TYPE.Classification,
+            id="4",
+            loader=__load_sergioalejandrod,
+            metadata={
+                "full_name" : "sergioalejandrod/raman-spectroscopy",
+                "source" : "https://www.kaggle.com/datasets/sergioalejandrod/raman-spectroscopy",
+                "paper" : "https://doi.org/10.1021/acs.analchem.0c03015",
+                "description" : "This data set was produced by Hirotsugu Hiramatsu as part of his experiment revolving around the enhancement of Raman signal utilizing a vertical flow method."
+            }
+        ),
+        # "andriitrelin/cells-raman-spectra": DatasetInfo(
+        #     task_type=TASK_TYPE.Classification,
+        #     id=None,
+        #     loader=__load_andriitrelin
+        # ),
+        #"mathiascharconnet/cancer-cells-sers-spectra" : DatasetInfo(
+        #    task_type=TASK_TYPE.Classification,
+        #    id=None,
+        #    loader=__load_cancer_cells,
+        #    metadata={
+        #        "full_name" : "mathiascharconnet/cancer-cells-sers-spectra",
+        #        "source" : "https://www.kaggle.com/code/mathiascharconnet/cancer-cells-sers-spectra/input",
+        #        "paper" : "https://doi.org/10.1016/j.snb.2020.127660",
+        #        "description" : "This dataset was collected in the University of Chemistry and Technology, Prague during work on cancer detection. It contains Raman spectra of the culture medium, corresponding to several kinds of cancer and normal cells. Dataset consists of 12 folders with 3 CSV files in each. Folders are named after specific samples (tabulated below). Each CSV in folder contains spectra of medium, collected on the gold nanourchins functionalized with corresponding moiety. Please refer to the original publication for details."
+        #    }
+        #)
+    }
+
+
+    @staticmethod
+    def download_dataset(
+        dataset_name: str,
+        cache_path: Optional[str] = None,
+    ) -> str | None:
+        if not LoaderTools.is_dataset_available(dataset_name, KagLoader.DATASETS):
+            print(f"[!] Cannot download {dataset_name} dataset with Kaggle loader")
+            return
+
+        if not (cache_path is None):
+            LoaderTools.set_cache_root(cache_path, CACHE_DIR.Kaggle)
+        cache_path = LoaderTools.get_cache_root(CACHE_DIR.HuggingFace)
+
+        print(f"Downloading Kaggle dataset: {dataset_name}")
+        
+        path = dataset_download(handle=dataset_name, path=cache_path)
+        print(f"Dataset downloaded into {path}")
+
+        return path
+
+
+    @staticmethod
+    def load_dataset(
+        dataset_name: str,
+        cache_path: Optional[str] = None
+    ) -> RamanDataset | None:
+        if not LoaderTools.is_dataset_available(dataset_name, KagLoader.DATASETS):
+            print(f"[!] Cannot load {dataset_name} dataset with Kaggle loader")
+            return
+
+        if not (cache_path is None):
+            LoaderTools.set_cache_root(cache_path, CACHE_DIR.Kaggle)
+        cache_path = LoaderTools.get_cache_root(CACHE_DIR.HuggingFace)
+
+        print(
+            f"Loading Kaggle dataset from "
+            f"{cache_path if cache_path else 'default folder (~/.cache/kagglehub)'}"
+        )
+
+        dataset_id = KagLoader.DATASETS[dataset_name].id
+
+        data = KagLoader.DATASETS[dataset_name].loader(dataset_id)
+
+        if data is not None:
+            raman_shifts, spectra, concentrations = data
+            return RamanDataset(
+                data=raman_shifts,
+                target=concentrations,
+                spectra=spectra,
+                metadata=KagLoader.DATASETS[dataset_name].metadata
+            )
+        
+        return data
+
+    @staticmethod
+    def list_datasets() -> None:
+        """
+        Prints formatted list of datasets provided by this loader.
+        """
+        LoaderTools.list_datasets(KagLoader)