dragon-ml-toolbox 11.1.1__py3-none-any.whl → 12.0.0__py3-none-any.whl

ml_tools/utilities.py

@@ -1,15 +1,12 @@
-import math
 import numpy as np
 import pandas as pd
 import polars as pl
 from pathlib import Path
-from typing import Literal, Union, Sequence, Optional, Any, Iterator, Tuple, overload, TypeVar, get_origin, Type
-import joblib
-from joblib.externals.loky.process_executor import TerminatedWorkerError
-from .path_manager import sanitize_filename, make_fullpath, list_csv_paths, list_files_by_extension, list_subdirectories
+from typing import Literal, Union, Optional, Any, Iterator, Tuple, overload
+
+from .path_manager import sanitize_filename, make_fullpath, list_csv_paths
 from ._script_info import _script_info
 from ._logger import _LOGGER
-from .keys import DatasetKeys, PytorchModelArchitectureKeys, PytorchArtifactPathKeys, SHAPKeys
 
 
 # Keep track of available tools
@@ -18,16 +15,10 @@ __all__ = [
     "yield_dataframes_from_dir",
     "merge_dataframes",
     "save_dataframe",
-    "normalize_mixed_list",
-    "threshold_binary_values",
-    "threshold_binary_values_batch",
-    "serialize_object",
-    "deserialize_object",
+    "save_dataframe_path",
     "distribute_dataset_by_target",
     "train_dataset_orchestrator",
-    "train_dataset_yielder",
-    "find_model_artifacts",
-    "select_features_by_shap"
+    "train_dataset_yielder"
 ]
 
 
@@ -132,6 +123,7 @@ def load_dataframe(
     
     return df, df_name # type: ignore
 
+
 def yield_dataframes_from_dir(datasets_dir: Union[str,Path], verbose: bool=True):
     """
     Iterates over all CSV files in a given directory, loading each into a Pandas DataFrame.
@@ -236,7 +228,7 @@ def save_dataframe(df: Union[pd.DataFrame, pl.DataFrame], save_dir: Union[str,Pa
         return
     
     # Create the directory if it doesn't exist
-    save_path = make_fullpath(save_dir, make=True)
+    save_path = make_fullpath(save_dir, make=True, enforce="directory")
     
     # Clean the filename
     filename = sanitize_filename(filename)
@@ -258,250 +250,24 @@ def save_dataframe(df: Union[pd.DataFrame, pl.DataFrame], save_dir: Union[str,Pa
     _LOGGER.info(f"Saved dataset: '{filename}' with shape: {df.shape}")
 
 
-def normalize_mixed_list(data: list, threshold: int = 2) -> list[float]:
+def save_dataframe_path(df: Union[pd.DataFrame, pl.DataFrame], full_path: Path):
     """
-    Normalize a mixed list of numeric values and strings casted to floats so that the sum of the values equals 1.0,
-    applying heuristic adjustments to correct for potential data entry scale mismatches.
-
-    Parameters:
-        data (list): 
-            A list of values that may include strings, floats, integers, or None.
-            None values are treated as 0.0.
-        
-        threshold (int, optional): 
-            The number of log10 orders of magnitude below the median scale 
-            at which a value is considered suspect and is scaled upward accordingly. 
-            Default is 2.
+    Saves a DataFrame to a specified full path.
 
-    Returns:
-        List[float]: A list of normalized float values summing to 1.0. 
-    
-    Notes:
-        - Zeros and None values remain zero.
-        - Input strings are automatically cast to floats if possible.
+    This function is a convenience wrapper for `save_dataframe()`. It takes a
+    single `pathlib.Path` object pointing to a `.csv` file.
 
-    Example:
-        >>> normalize_mixed_list([1, "0.01", 4, None])
-        [0.2, 0.2, 0.6, 0.0]
-    """
-    # Step 1: Convert all values to float, treat None as 0.0
-    float_list = [float(x) if x is not None else 0.0 for x in data]
-    
-    # Raise for negative values
-    if any(x < 0 for x in float_list):
-        _LOGGER.error("Negative values are not allowed in the input list.")
-        raise ValueError()
-    
-    # Step 2: Compute log10 of non-zero values
-    nonzero = [x for x in float_list if x > 0]
-    if not nonzero:
-        return [0.0 for _ in float_list]
-    
-    log_scales = [math.log10(x) for x in nonzero]
-    log_median = np.median(log_scales)
-    
-    # Step 3: Adjust values that are much smaller than median
-    adjusted = []
-    for x in float_list:
-        if x == 0.0:
-            adjusted.append(0.0)
-        else:
-            log_x = math.log10(x)
-            if log_median - log_x > threshold:
-                scale_diff = round(log_median - log_x)
-                adjusted.append(x * (10 ** scale_diff))
-            else:
-                adjusted.append(x)
-    
-    # Step 4: Normalize to sum to 1.0
-    total = sum(adjusted)
-    if total == 0:
-        return [0.0 for _ in adjusted]
-    
-    return [x / total for x in adjusted]
-
-
-def threshold_binary_values(
-    input_array: Union[Sequence[float], np.ndarray, pd.Series, pl.Series],
-    binary_values: Optional[int] = None
-) -> Union[np.ndarray, pd.Series, pl.Series, list[float], tuple[float]]:
-    """
-    Thresholds binary features in a 1D input. The number of binary features are counted starting from the end.
-    
-    Binary elements are converted to 0 or 1 using a 0.5 threshold.
-
-    Parameters:
-        input_array: 1D sequence, NumPy array, pandas Series, or polars Series.
-        binary_values (Optional[int]) :
-            - If `None`, all values are treated as binary.
-            - If `int`, only this many last `binary_values` are thresholded.
-
-    Returns:
-        Any:
-        Same type as input
+    Args:
+        df (Union[pd.DataFrame, pl.DataFrame]): The pandas or polars DataFrame to save.
+        full_path (Path): The complete file path, including the filename and `.csv` extension, where the DataFrame will be saved.
     """
-    original_type = type(input_array)
-
-    if isinstance(input_array, pl.Series):
-        array = input_array.to_numpy()
-    elif isinstance(input_array, (pd.Series, np.ndarray)):
-        array = np.asarray(input_array)
-    elif isinstance(input_array, (list, tuple)):
-        array = np.array(input_array)
-    else:
-        _LOGGER.error("Unsupported input type")
-        raise TypeError()
-
-    array = array.flatten()
-    total = array.shape[0]
-
-    bin_count = total if binary_values is None else binary_values
-    if not (0 <= bin_count <= total):
-        _LOGGER.error("'binary_values' must be between 0 and the total number of elements")
+    if not isinstance(full_path, Path) or not full_path.suffix.endswith(".csv"):
+        _LOGGER.error('A path object pointing to a .csv file must be provided.')
         raise ValueError()
-
-    if bin_count == 0:
-        result = array
-    else:
-        cont_part = array[:-bin_count] if bin_count < total else np.array([])
-        bin_part = (array[-bin_count:] > 0.5).astype(int)
-        result = np.concatenate([cont_part, bin_part])
-
-    if original_type is pd.Series:
-        return pd.Series(result, index=input_array.index if hasattr(input_array, 'index') else None) # type: ignore
-    elif original_type is pl.Series:
-        return pl.Series(input_array.name if hasattr(input_array, 'name') else "binary", result) # type: ignore
-    elif original_type is list:
-        return result.tolist()
-    elif original_type is tuple:
-        return tuple(result)
-    else:
-        return result
-    
-    
-def threshold_binary_values_batch(
-    input_array: np.ndarray,
-    binary_values: int
-) -> np.ndarray:
-    """
-    Threshold the last `binary_values` columns of a 2D NumPy array to binary {0,1} using 0.5 cutoff.
-
-    Parameters
-    ----------
-    input_array : np.ndarray
-        2D array with shape (batch_size, n_features).
-    binary_values : int
-        Number of binary features located at the END of each row.
-
-    Returns
-    -------
-    np.ndarray
-        Thresholded array, same shape as input.
-    """
-    if input_array.ndim != 2:
-        _LOGGER.error(f"Expected 2D array, got {input_array.ndim}D array.")
-        raise AssertionError()
-    
-    batch_size, total_features = input_array.shape
-    
-    if not (0 <= binary_values <= total_features):
-        _LOGGER.error("'binary_values' out of valid range.")
-        raise AssertionError()
-
-    if binary_values == 0:
-        return input_array.copy()
-
-    cont_part = input_array[:, :-binary_values] if binary_values < total_features else np.empty((batch_size, 0))
-    bin_part = input_array[:, -binary_values:] > 0.5
-    bin_part = bin_part.astype(np.int32)
-
-    return np.hstack([cont_part, bin_part])
-
-
-def serialize_object(obj: Any, save_dir: Union[str,Path], filename: str, verbose: bool=True, raise_on_error: bool=False) -> None:
-    """
-    Serializes a Python object using joblib; suitable for Python built-ins, numpy, and pandas.
-
-    Parameters:
-        obj (Any) : The Python object to serialize.
-        save_dir (str | Path) : Directory path where the serialized object will be saved.
-        filename (str) : Name for the output file, extension will be appended if needed.
-    """
-    try:
-        save_path = make_fullpath(save_dir, make=True)
-        sanitized_name = sanitize_filename(filename)
-        if not sanitized_name.endswith('.joblib'):
-            sanitized_name = sanitized_name + ".joblib"
-        full_path = save_path / sanitized_name
-        joblib.dump(obj, full_path)
-    except (IOError, OSError, TypeError, TerminatedWorkerError) as e:
-        _LOGGER.error(f"Failed to serialize object of type '{type(obj)}'.")
-        if raise_on_error:
-            raise e
-        return None
-    else:
-        if verbose:
-            _LOGGER.info(f"Object of type '{type(obj)}' saved to '{full_path}'")
-        return None
-
-# Define a TypeVar to link the expected type to the return type of deserialization
-T = TypeVar('T')
-    
-def deserialize_object(
-    filepath: Union[str, Path],
-    expected_type: Optional[Type[T]] = None,
-    verbose: bool = True,
-    raise_on_error: bool = True
-    ) -> Optional[T]:
-    """
-    Loads a serialized object from a .joblib file.
-
-    Parameters:
-        filepath (str | Path): Full path to the serialized .joblib file.
-        expected_type (Type[T] | None): The expected type of the object.
-            If provided, the function raises a TypeError if the loaded object
-            is not an instance of this type. It correctly handles generics
-            like `list[str]` by checking the base type (e.g., `list`).
-            Defaults to None, which skips the type check.
-        verbose (bool): If True, logs success messages.
-        raise_on_error (bool): If True, raises exceptions on errors. If False, returns None instead.
-
-    Returns:
-        (Any | None): The deserialized Python object, which will match the
-            `expected_type` if provided. Returns None if an error
-            occurs and `raise_on_error` is False.
-    """
-    true_filepath = make_fullpath(filepath)
-    
-    try:
-        obj = joblib.load(true_filepath)
-    except (IOError, OSError, EOFError, TypeError, ValueError) as e:
-        _LOGGER.error(f"Failed to deserialize object from '{true_filepath}'.")
-        if raise_on_error:
-            raise e
-        return None
-    else:
-        # --- Type Validation Step ---
-        if expected_type:
-            # get_origin handles generics (e.g., list[str] -> list)
-            # If it's not a generic, get_origin returns None, so we use the type itself.
-            type_to_check = get_origin(expected_type) or expected_type
-            
-            # Can't do an isinstance check on 'Any', skip it.
-            if type_to_check is not Any and not isinstance(obj, type_to_check):
-                error_msg = (
-                    f"Type mismatch: Expected an instance of '{expected_type}', "
-                    f"but found '{type(obj)}' in '{true_filepath}'."
-                )
-                _LOGGER.error(error_msg)
-                if raise_on_error:
-                    raise TypeError()
-                return None
-        
-        if verbose:
-            _LOGGER.info(f"Loaded object of type '{type(obj)}' from '{true_filepath}'.")
         
-        return obj
+    save_dataframe(df=df, 
+                   save_dir=full_path.parent,
+                   filename=full_path.name)
 
 
 def distribute_dataset_by_target(
@@ -616,205 +382,5 @@ def train_dataset_yielder(
         yield (df_features, df_target, feature_names, target_col)
 
 
-def find_model_artifacts(target_directory: Union[str,Path], load_scaler: bool, verbose: bool=False) -> list[dict[str,Any]]:
-    """
-    Scans subdirectories to find paths to model weights, target names, feature names, and model architecture. Optionally an scaler path if `load_scaler` is True.
-
-    This function operates on a specific directory structure. It expects the
-    `target_directory` to contain one or more subdirectories, where each
-    subdirectory represents a single trained model result.
-
-    The expected directory structure for each model is as follows:
-    ```
-        target_directory
-        ├── model_1
-        │   ├── *.pth
-        │   ├── scaler_*.pth          (Required if `load_scaler` is True)
-        │   ├── feature_names.txt
-        │   ├── target_names.txt
-        │   └── architecture.json
-        └── model_2/
-            └── ...
-    ```
-
-    Args:
-        target_directory (str | Path): The path to the root directory that contains model subdirectories.
-        load_scaler (bool): If True, the function requires and searches for a scaler file (`.pth`) in each model subdirectory.
-        verbose (bool): If True, enables detailed logging during the file paths search process.
-
-    Returns:
-        (list[dict[str, Path]]): A list of dictionaries, where each dictionary
-            corresponds to a model found in a subdirectory. The dictionary
-            maps standardized keys to the absolute paths of the model's
-            artifacts (weights, architecture, features, targets, and scaler).
-            The scaler path will be `None` if `load_scaler` is False.
-    """
-    # validate directory
-    root_path = make_fullpath(target_directory, enforce="directory")
-    
-    # store results
-    all_artifacts: list[dict] = list()
-    
-    # find model directories
-    result_dirs_dict = list_subdirectories(root_dir=root_path, verbose=verbose)
-    for dir_name, dir_path in result_dirs_dict.items():
-        # find files
-        model_pth_dict = list_files_by_extension(directory=dir_path, extension="pth", verbose=verbose)
-        
-        # restriction
-        if load_scaler:
-            if len(model_pth_dict) != 2:
-                _LOGGER.error(f"Directory {dir_path} should contain exactly 2 '.pth' files: scaler and weights.")
-                raise IOError()
-        else:
-            if len(model_pth_dict) != 1:
-                _LOGGER.error(f"Directory {dir_path} should contain exactly 1 '.pth' file: weights.")
-                raise IOError()
-        
-        ##### Scaler and Weights #####
-        scaler_path = None
-        weights_path = None
-        
-        # load weights and scaler if present
-        for pth_filename, pth_path in model_pth_dict.items():
-            if load_scaler and pth_filename.lower().startswith(DatasetKeys.SCALER_PREFIX):
-                scaler_path = pth_path
-            else:
-                weights_path = pth_path
-        
-        # validation
-        if not weights_path:
-            _LOGGER.error(f"Error parsing the model weights path from '{dir_name}'")
-            raise IOError()
-        
-        if load_scaler and not scaler_path:
-            _LOGGER.error(f"Error parsing the scaler path from '{dir_name}'")
-            raise IOError()
-        
-        ##### Target and Feature names #####
-        target_names_path = None
-        feature_names_path = None
-        
-        # load feature and target names
-        model_txt_dict = list_files_by_extension(directory=dir_path, extension="txt", verbose=verbose)
-        
-        for txt_filename, txt_path in model_txt_dict.items():
-            if txt_filename == DatasetKeys.FEATURE_NAMES:
-                feature_names_path = txt_path
-            elif txt_filename == DatasetKeys.TARGET_NAMES:
-                target_names_path = txt_path
-        
-        # validation
-        if not target_names_path or not feature_names_path:
-            _LOGGER.error(f"Error parsing features path or targets path from '{dir_name}'")
-            raise IOError()
-        
-        ##### load model architecture path #####
-        architecture_path = None
-        
-        model_json_dict = list_files_by_extension(directory=dir_path, extension="json", verbose=verbose)
-        
-        for json_filename, json_path in model_json_dict.items():
-            if json_filename == PytorchModelArchitectureKeys.SAVENAME:
-                architecture_path = json_path
-        
-        # validation
-        if not architecture_path:
-            _LOGGER.error(f"Error parsing the model architecture path from '{dir_name}'")
-            raise IOError()
-        
-        ##### Paths dictionary #####
-        parsing_dict = {
-            PytorchArtifactPathKeys.WEIGHTS_PATH: weights_path,
-            PytorchArtifactPathKeys.ARCHITECTURE_PATH: architecture_path,
-            PytorchArtifactPathKeys.FEATURES_PATH: feature_names_path,
-            PytorchArtifactPathKeys.TARGETS_PATH: target_names_path,
-            PytorchArtifactPathKeys.SCALER_PATH: scaler_path
-        }
-        
-        all_artifacts.append(parsing_dict)
-    
-    return all_artifacts
-
-
-def select_features_by_shap(
-    root_directory: Union[str, Path],
-    shap_threshold: float = 1.0,
-    verbose: bool = True) -> list[str]:
-    """
-    Scans subdirectories to find SHAP summary CSVs, then extracts feature
-    names whose mean absolute SHAP value meets a specified threshold.
-
-    This function is useful for automated feature selection based on feature
-    importance scores aggregated from multiple models.
-
-    Args:
-        root_directory (Union[str, Path]):
-            The path to the root directory that contains model subdirectories.
-        shap_threshold (float):
-            The minimum mean absolute SHAP value for a feature to be included
-            in the final list.
-
-    Returns:
-        list[str]:
-            A single, sorted list of unique feature names that meet the
-            threshold criteria across all found files.
-    """
-    if verbose:
-        _LOGGER.info(f"Starting feature selection with SHAP threshold >= {shap_threshold}")
-    root_path = make_fullpath(root_directory, enforce="directory")
-
-    # --- Step 2: Directory and File Discovery ---
-    subdirectories = list_subdirectories(root_dir=root_path, verbose=False)
-    
-    shap_filename = SHAPKeys.SAVENAME + ".csv"
-
-    valid_csv_paths = []
-    for dir_name, dir_path in subdirectories.items():
-        expected_path = dir_path / shap_filename
-        if expected_path.is_file():
-            valid_csv_paths.append(expected_path)
-        else:
-            _LOGGER.warning(f"No '{shap_filename}' found in subdirectory '{dir_name}'.")
-    
-    if not valid_csv_paths:
-        _LOGGER.error(f"Process halted: No '{shap_filename}' files were found in any subdirectory.")
-        return []
-
-    if verbose:
-        _LOGGER.info(f"Found {len(valid_csv_paths)} SHAP summary files to process.")
-
-    # --- Step 3: Data Processing and Feature Extraction ---
-    master_feature_set = set()
-    for csv_path in valid_csv_paths:
-        try:
-            df, _ = load_dataframe(csv_path, kind="pandas", verbose=False)
-            
-            # Validate required columns
-            required_cols = {SHAPKeys.FEATURE_COLUMN, SHAPKeys.SHAP_VALUE_COLUMN}
-            if not required_cols.issubset(df.columns):
-                _LOGGER.warning(f"Skipping '{csv_path}': missing required columns.")
-                continue
-
-            # Filter by threshold and extract features
-            filtered_df = df[df[SHAPKeys.SHAP_VALUE_COLUMN] >= shap_threshold]
-            features = filtered_df[SHAPKeys.FEATURE_COLUMN].tolist()
-            master_feature_set.update(features)
-
-        except (ValueError, pd.errors.EmptyDataError):
-            _LOGGER.warning(f"Skipping '{csv_path}' because it is empty or malformed.")
-            continue
-        except Exception as e:
-            _LOGGER.error(f"An unexpected error occurred while processing '{csv_path}': {e}")
-            continue
-
-    # --- Step 4: Finalize and Return ---
-    final_features = sorted(list(master_feature_set))
-    if verbose:
-        _LOGGER.info(f"Selected {len(final_features)} unique features across all files.")
-    
-    return final_features
-
-
 def info():
     _script_info(__all__)

dragon_ml_toolbox-11.1.1.dist-info/RECORD

@@ -1,37 +0,0 @@
-dragon_ml_toolbox-11.1.1.dist-info/licenses/LICENSE,sha256=L35WDmmLZNTlJvxF6Vy7Uy4SYNi6rCfWUqlTHpoRMoU,1081
-dragon_ml_toolbox-11.1.1.dist-info/licenses/LICENSE-THIRD-PARTY.md,sha256=iy2r_R7wjzsCbz_Q_jMsp_jfZ6oP8XW9QhwzRBH0mGY,1904
-ml_tools/ETL_cleaning.py,sha256=-JrYkT8AvkZFK-Agzhp6uVxaZXzFw49t0txjf6Z1Apw,20365
-ml_tools/ETL_engineering.py,sha256=9dmNd2e3fUldwhIggogGKPlxTb02rtb463Kq5QHnqJo,54551
-ml_tools/GUI_tools.py,sha256=kEQWg-bog3pB5tI22gMGKWaCGHnz9TB2Lvvfhf5F2CI,45412
-ml_tools/MICE_imputation.py,sha256=kVSythWfxJFR4-2mtcYCWQaQ1Oz5yyx_SJu5gjnS7H8,11670
-ml_tools/ML_callbacks.py,sha256=JPvEw_cW5tYNJ2rMSgnNrKLuni_UrmuhDFaOw-u2SvA,13926
-ml_tools/ML_datasetmaster.py,sha256=vqKZhCXsvN5yeRJdOKqMPh5OhY1xe6xlNjM3WoH5lys,30821
-ml_tools/ML_evaluation.py,sha256=6FB6S-aDDpFzQdrp3flBVECzEsHhMbQknYVGhHooEFs,16207
-ml_tools/ML_evaluation_multi.py,sha256=2jTSNFCu8cz5C05EusnrDyffs59M2Fq3UXSHxo2TR1A,12515
-ml_tools/ML_inference.py,sha256=SGDPiPxs_OYDKKRZziFMyaWcC8A37c70W9t-dMP5niI,23066
-ml_tools/ML_models.py,sha256=JMFOuw4jtX5RtUFpkQWS8-dzDW0AwqYjbl67XRCVubA,27996
-ml_tools/ML_optimization.py,sha256=mMVLR3Atu2yeS-zzPCnKBO6CwRgJavCXUJT3zvniUjo,18097
-ml_tools/ML_scaler.py,sha256=h2ymq5u953Lx60Qb38Y0mAWj85x9PbnP0xYNQ3pd8-w,7535
-ml_tools/ML_trainer.py,sha256=_g48w5Ak-wQr5fGHdJqlcpnzv3gWyL1ghkOhy9VOZbo,23930
-ml_tools/PSO_optimization.py,sha256=q0VYpssQGbPum7xdnkDXlJQKhZMYZo8acHpKhajPK3c,22954
-ml_tools/RNN_forecast.py,sha256=8rNZr-eWOBXMiDQV22e_tQTPM5LM2IFggEAa1FaoXaI,1965
-ml_tools/SQL.py,sha256=rPeKywvwJ5oHYVUQUovO3OUkXQTxBT9Dvwb6E2ntphY,11233
-ml_tools/VIF_factor.py,sha256=MkMh_RIdsN2XUPzKNGRiEcmB17R_MmvGV4ezpL5zD2E,10403
-ml_tools/__init__.py,sha256=q0y9faQ6e17XCQ7eUiCZ1FJ4Bg5EQqLjZ9f_l5REUUY,41
-ml_tools/_logger.py,sha256=wcImAiXEZKPNcwM30qBh3t7HvoPURonJY0nrgMGF0sM,4719
-ml_tools/_script_info.py,sha256=21r83LV3RubsNZ_RTEUON6RbDf7Mh4_udweNcvdF_Fk,212
-ml_tools/constants.py,sha256=3br5Rk9cL2IUo638eJuMOGdbGQaWssaUecYEvSeRBLM,3322
-ml_tools/custom_logger.py,sha256=ry43hk54K6xKo8jRAgq1sFxUpOA9T0LIJ7sw0so2BW0,5880
-ml_tools/data_exploration.py,sha256=-aTi5jmv4AepPgi2k_85qEJsSLx5zPOtTbhorqzUvGQ,38542
-ml_tools/ensemble_evaluation.py,sha256=FGHSe8LBI8_w8LjNeJWOcYQ1UK_mc6fVah8gmSvNVGg,26853
-ml_tools/ensemble_inference.py,sha256=Hun_ipIZaaLrHxSo63J6NKS_O1fMWi_6HkuSHs4RywI,9349
-ml_tools/ensemble_learning.py,sha256=3s0kH4i_naj0IVl_T4knst-Hwg4TScWjEdsXX5KAi7I,21929
-ml_tools/handle_excel.py,sha256=He4UT15sCGhaG-JKfs7uYVAubxWjrqgJ6U7OhMR2fuE,14005
-ml_tools/keys.py,sha256=FDpbS3Jb0pjrVvvp2_8nZi919mbob_-xwuy5OOtKM_A,1848
-ml_tools/optimization_tools.py,sha256=P3I6lIpvZ8Xf2kX5FvvBKBmrK2pB6idBpkTzfUJxTeE,5073
-ml_tools/path_manager.py,sha256=ke0MYOhYheRPX599GUbrvRsYHn2JKUmMDldS5LP6LQA,18431
-ml_tools/utilities.py,sha256=uheMUjQJ1zI69gASsE-mCq4KlRPVGgrgqson02rGNYM,30755
-dragon_ml_toolbox-11.1.1.dist-info/METADATA,sha256=Vl_AVzC58IA6OESD3NQTPADls7o_eN5dl-s2qKdWBZI,6657
-dragon_ml_toolbox-11.1.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-dragon_ml_toolbox-11.1.1.dist-info/top_level.txt,sha256=wm-oxax3ciyez6VoO4zsFd-gSok2VipYXnbg3TH9PtU,9
-dragon_ml_toolbox-11.1.1.dist-info/RECORD,,