dragon-ml-toolbox 3.12.6__py3-none-any.whl → 4.1.0__py3-none-any.whl

ml_tools/path_manager.py

@@ -1,12 +1,18 @@
 from pprint import pprint
-from typing import Optional, List, Dict, Callable, Union
+from typing import Optional, List, Dict, Union, Literal
 from pathlib import Path
-from .utilities import _script_info
-from .logger import _LOGGER
+import re
+from ._script_info import _script_info
+from ._logger import _LOGGER
+import sys
 
 
 __all__ = [
-    "PathManager"
+    "PathManager",
+    "make_fullpath",
+    "sanitize_filename",
+    "list_csv_paths",
+    "list_files_by_extension",
 ]
 
 
@@ -14,7 +20,7 @@ class PathManager:
     """
     Manages and stores a project's file paths, acting as a centralized
     "path database". It supports both development mode and applications
-    bundled with Briefcase.
+    bundled with Pyinstaller.
     
     Supports python dictionary syntax.
     """
@@ -23,23 +29,14 @@ class PathManager:
         anchor_file: str,
         base_directories: Optional[List[str]] = None
     ):
-        """
-        The initializer determines the project's root directory and can pre-register
-        a list of base directories relative to that root.
-
-        Args:
-            anchor_file (str): The absolute path to a file whose parent directory will be considered the package root and name. Typically, `__file__`.
-            base_directories (Optional[List[str]]): A list of directory names located at the same level as the anchor file to be registered immediately.
-        """
         resolved_anchor_path = Path(anchor_file).resolve()
         self._package_name = resolved_anchor_path.parent.name
-        self._is_bundled, self._resource_path_func = self._check_bundle_status()
+        self._is_bundled, bundle_root = self._get_bundle_root()
         self._paths: Dict[str, Path] = {}
 
         if self._is_bundled:
-            # In a bundle, resource_path gives the absolute path to the 'app_packages' dir
-            # when given the package name.
-            package_root = self._resource_path_func(self._package_name) # type: ignore
+            # In a PyInstaller bundle, the package is inside the temp _MEIPASS dir
+            package_root = Path(bundle_root) / self._package_name # type: ignore
         else:
             # In dev mode, the package root is the directory containing the anchor file.
             package_root = resolved_anchor_path.parent
@@ -50,21 +47,21 @@ class PathManager:
         # Register all the base directories
         if base_directories:
             for dir_name in base_directories:
-                # In dev mode, this is simple. In a bundle, we must resolve
-                # each path from the package root.
-                if self._is_bundled:
-                     self._paths[dir_name] = self._resource_path_func(self._package_name, dir_name) # type: ignore
-                else:
-                     self._paths[dir_name] = package_root / dir_name
+                # This logic works for both dev mode and bundled mode
+                self._paths[dir_name] = package_root / dir_name
                      
-    # A helper function to find the briefcase-injected resource function
-    def _check_bundle_status(self) -> tuple[bool, Optional[Callable]]:
-        """Checks if the app is running in a Briefcase bundle."""
-        try:
-            # This function is injected by Briefcase into the global scope
-            from briefcase.platforms.base import resource_path # type: ignore
-            return True, resource_path
-        except (ImportError, NameError):
+    def _get_bundle_root(self) -> tuple[bool, Optional[str]]:
+        """
+        Checks if the app is running in a PyInstaller bundle and returns the root path.
+        
+        Returns:
+            A tuple (is_bundled, bundle_root_path). `bundle_root_path` is the
+            path to the temporary directory `_MEIPASS` if bundled, otherwise None.
+        """
+        if getattr(sys, 'frozen', False) and hasattr(sys, '_MEIPASS'):
+            # This is the standard way to check for a PyInstaller bundle
+            return True, sys._MEIPASS # type: ignore
+        else:
             return False, None
 
     def get(self, key: str) -> Path:
@@ -208,5 +205,171 @@ class PathManager:
         return self._paths.items()
 
 
+def make_fullpath(
+        input_path: Union[str, Path],
+        make: bool = False,
+        verbose: bool = False,
+        enforce: Optional[Literal["directory", "file"]] = None
+    ) -> Path:
+    """
+    Resolves a string or Path into an absolute Path, optionally creating it.
+
+    - If the path exists, it is returned.
+    - If the path does not exist and `make=True`, it will:
+        - Create the file if the path has a suffix
+        - Create the directory if it has no suffix
+    - If `make=False` and the path does not exist, an error is raised.
+    - If `enforce`, raises an error if the resolved path is not what was enforced.
+    - Optionally prints whether the resolved path is a file or directory.
+
+    Parameters:
+        input_path (str | Path): 
+            Path to resolve.
+        make (bool): 
+            If True, attempt to create file or directory.
+        verbose (bool): 
+            Print classification after resolution.
+        enforce ("directory" | "file" | None):
+            Raises an error if the resolved path is not what was enforced.
+
+    Returns:
+        Path: Resolved absolute path.
+
+    Raises:
+        ValueError: If the path doesn't exist and can't be created.
+        TypeError: If the final path does not match the `enforce` parameter.
+        
+    ## 🗒️ Note:
+    
+    Directories with dots will be treated as files.
+    
+    Files without extension will be treated as directories.
+    """
+    path = Path(input_path).expanduser()
+
+    is_file = path.suffix != ""
+
+    try:
+        resolved = path.resolve(strict=True)
+    except FileNotFoundError:
+        if not make:
+            raise ValueError(f"❌ Path does not exist: '{path}'")
+
+        try:
+            if is_file:
+                # Create parent directories first
+                path.parent.mkdir(parents=True, exist_ok=True)
+                path.touch(exist_ok=False)
+            else:
+                path.mkdir(parents=True, exist_ok=True)
+            resolved = path.resolve(strict=True)
+        except Exception as e:
+            raise ValueError(f"❌ Failed to create {'file' if is_file else 'directory'} '{path}': {e}")
+    
+    if enforce == "file" and not resolved.is_file():
+        raise TypeError(f"❌ Path was enforced as a file, but it is not: '{resolved}'")
+    
+    if enforce == "directory" and not resolved.is_dir():
+        raise TypeError(f"❌ Path was enforced as a directory, but it is not: '{resolved}'")
+
+    if verbose:
+        if resolved.is_file():
+            print("📄 Path is a File")
+        elif resolved.is_dir():
+            print("📁 Path is a Directory")
+        else:
+            print("❓ Path exists but is neither file nor directory")
+
+    return resolved
+
+
+def sanitize_filename(filename: str) -> str:
+    """
+    Sanitizes the name by:
+    - Stripping leading/trailing whitespace.
+    - Replacing all internal whitespace characters with underscores.
+    - Removing or replacing characters invalid in filenames.
+
+    Args:
+        filename (str): Base filename.
+
+    Returns:
+        str: A sanitized string suitable to use as a filename.
+    """
+    # Strip leading/trailing whitespace
+    sanitized = filename.strip()
+    
+    # Replace all whitespace sequences (space, tab, etc.) with underscores
+    sanitized = re.sub(r'\s+', '_', sanitized)
+
+    # Conservative filter to keep filenames safe across platforms
+    sanitized = re.sub(r'[^\w\-.]', '', sanitized)
+    
+    # Check for empty string after sanitization
+    if not sanitized:
+        raise ValueError("The sanitized filename is empty. The original input may have contained only invalid characters.")
+
+    return sanitized
+
+
+def list_csv_paths(directory: Union[str,Path], verbose: bool=True) -> dict[str, Path]:
+    """
+    Lists all `.csv` files in the specified directory and returns a mapping: filenames (without extensions) to their absolute paths.
+
+    Parameters:
+        directory (str | Path): Path to the directory containing `.csv` files.
+
+    Returns:
+        (dict[str, Path]): Dictionary mapping {filename: filepath}.
+    """
+    dir_path = make_fullpath(directory)
+
+    csv_paths = list(dir_path.glob("*.csv"))
+    if not csv_paths:
+        raise IOError(f"❌ No CSV files found in directory: {dir_path.name}")
+    
+    # make a dictionary of paths and names
+    name_path_dict = {p.stem: p for p in csv_paths}
+    
+    if verbose:
+        _LOGGER.info("🗂️ CSV files found:")
+        for name in name_path_dict.keys():
+            print(f"\t{name}")
+
+    return name_path_dict
+
+
+def list_files_by_extension(directory: Union[str,Path], extension: str, verbose: bool=True) -> dict[str, Path]:
+    """
+    Lists all files with the specified extension in the given directory and returns a mapping: 
+    filenames (without extensions) to their absolute paths.
+
+    Parameters:
+        directory (str | Path): Path to the directory to search in.
+        extension (str): File extension to search for (e.g., 'json', 'txt').
+
+    Returns:
+        (dict[str, Path]): Dictionary mapping {filename: filepath}.
+    """
+    dir_path = make_fullpath(directory)
+    
+    # Normalize the extension (remove leading dot if present)
+    normalized_ext = extension.lstrip(".").lower()
+    pattern = f"*.{normalized_ext}"
+    
+    matched_paths = list(dir_path.glob(pattern))
+    if not matched_paths:
+        raise IOError(f"❌ No '.{normalized_ext}' files found in directory: {dir_path}")
+
+    name_path_dict = {p.stem: p for p in matched_paths}
+    
+    if verbose:
+        _LOGGER.info(f"\n📂 '{normalized_ext.upper()}' files found:")
+        for name in name_path_dict:
+            print(f"\t{name}")
+    
+    return name_path_dict
+
+
 def info():
     _script_info(__all__)

ml_tools/utilities.py

@@ -3,23 +3,20 @@ import numpy as np
 import pandas as pd
 import polars as pl
 from pathlib import Path
-import re
 from typing import Literal, Union, Sequence, Optional, Any, Iterator, Tuple
 import joblib
 from joblib.externals.loky.process_executor import TerminatedWorkerError
+from .path_manager import sanitize_filename, make_fullpath, list_csv_paths
+from ._script_info import _script_info
 
 
 # Keep track of available tools
 __all__ = [
-    "make_fullpath",
-    "list_csv_paths",
-    "list_files_by_extension",
     "load_dataframe",
     "yield_dataframes_from_dir",
     "merge_dataframes",
     "save_dataframe",
     "normalize_mixed_list",
-    "sanitize_filename",
     "threshold_binary_values",
     "threshold_binary_values_batch",
     "serialize_object",
@@ -29,143 +26,6 @@ __all__ = [
 ]
 
 
-def make_fullpath(
-        input_path: Union[str, Path],
-        make: bool = False,
-        verbose: bool = False,
-        enforce: Optional[Literal["directory", "file"]] = None
-    ) -> Path:
-    """
-    Resolves a string or Path into an absolute Path, optionally creating it.
-
-    - If the path exists, it is returned.
-    - If the path does not exist and `make=True`, it will:
-        - Create the file if the path has a suffix
-        - Create the directory if it has no suffix
-    - If `make=False` and the path does not exist, an error is raised.
-    - If `enforce`, raises an error if the resolved path is not what was enforced.
-    - Optionally prints whether the resolved path is a file or directory.
-
-    Parameters:
-        input_path (str | Path): 
-            Path to resolve.
-        make (bool): 
-            If True, attempt to create file or directory.
-        verbose (bool): 
-            Print classification after resolution.
-        enforce ("directory" | "file" | None):
-            Raises an error if the resolved path is not what was enforced.
-
-    Returns:
-        Path: Resolved absolute path.
-
-    Raises:
-        ValueError: If the path doesn't exist and can't be created.
-        TypeError: If the final path does not match the `enforce` parameter.
-        
-    ## 🗒️ Note:
-    
-    Directories with dots will be treated as files.
-    
-    Files without extension will be treated as directories.
-    """
-    path = Path(input_path).expanduser()
-
-    is_file = path.suffix != ""
-
-    try:
-        resolved = path.resolve(strict=True)
-    except FileNotFoundError:
-        if not make:
-            raise ValueError(f"❌ Path does not exist: '{path}'")
-
-        try:
-            if is_file:
-                # Create parent directories first
-                path.parent.mkdir(parents=True, exist_ok=True)
-                path.touch(exist_ok=False)
-            else:
-                path.mkdir(parents=True, exist_ok=True)
-            resolved = path.resolve(strict=True)
-        except Exception as e:
-            raise ValueError(f"❌ Failed to create {'file' if is_file else 'directory'} '{path}': {e}")
-    
-    if enforce == "file" and not resolved.is_file():
-        raise TypeError(f"❌ Path was enforced as a file, but it is not: '{resolved}'")
-    
-    if enforce == "directory" and not resolved.is_dir():
-        raise TypeError(f"❌ Path was enforced as a directory, but it is not: '{resolved}'")
-
-    if verbose:
-        if resolved.is_file():
-            print("📄 Path is a File")
-        elif resolved.is_dir():
-            print("📁 Path is a Directory")
-        else:
-            print("❓ Path exists but is neither file nor directory")
-
-    return resolved
-
-
-def list_csv_paths(directory: Union[str,Path], verbose: bool=True) -> dict[str, Path]:
-    """
-    Lists all `.csv` files in the specified directory and returns a mapping: filenames (without extensions) to their absolute paths.
-
-    Parameters:
-        directory (str | Path): Path to the directory containing `.csv` files.
-
-    Returns:
-        (dict[str, Path]): Dictionary mapping {filename: filepath}.
-    """
-    dir_path = make_fullpath(directory)
-
-    csv_paths = list(dir_path.glob("*.csv"))
-    if not csv_paths:
-        raise IOError(f"❌ No CSV files found in directory: {dir_path.name}")
-    
-    # make a dictionary of paths and names
-    name_path_dict = {p.stem: p for p in csv_paths}
-    
-    if verbose:
-        print("\n🗂️ CSV files found:")
-        for name in name_path_dict.keys():
-            print(f"\t{name}")
-
-    return name_path_dict
-
-
-def list_files_by_extension(directory: Union[str,Path], extension: str, verbose: bool=True) -> dict[str, Path]:
-    """
-    Lists all files with the specified extension in the given directory and returns a mapping: 
-    filenames (without extensions) to their absolute paths.
-
-    Parameters:
-        directory (str | Path): Path to the directory to search in.
-        extension (str): File extension to search for (e.g., 'json', 'txt').
-
-    Returns:
-        (dict[str, Path]): Dictionary mapping {filename: filepath}.
-    """
-    dir_path = make_fullpath(directory)
-    
-    # Normalize the extension (remove leading dot if present)
-    normalized_ext = extension.lstrip(".").lower()
-    pattern = f"*.{normalized_ext}"
-    
-    matched_paths = list(dir_path.glob(pattern))
-    if not matched_paths:
-        raise IOError(f"❌ No '.{normalized_ext}' files found in directory: {dir_path}")
-
-    name_path_dict = {p.stem: p for p in matched_paths}
-    
-    if verbose:
-        print(f"\n📂 '{normalized_ext.upper()}' files found:")
-        for name in name_path_dict:
-            print(f"\t{name}")
-    
-    return name_path_dict
-
-
 def load_dataframe(
     df_path: Union[str, Path], 
     kind: Literal["pandas", "polars"] = "pandas",
@@ -412,35 +272,6 @@ def normalize_mixed_list(data: list, threshold: int = 2) -> list[float]:
     return [x / total for x in adjusted]
 
 
-def sanitize_filename(filename: str) -> str:
-    """
-    Sanitizes the name by:
-    - Stripping leading/trailing whitespace.
-    - Replacing all internal whitespace characters with underscores.
-    - Removing or replacing characters invalid in filenames.
-
-    Args:
-        filename (str): Base filename.
-
-    Returns:
-        str: A sanitized string suitable to use as a filename.
-    """
-    # Strip leading/trailing whitespace
-    sanitized = filename.strip()
-    
-    # Replace all whitespace sequences (space, tab, etc.) with underscores
-    sanitized = re.sub(r'\s+', '_', sanitized)
-
-    # Conservative filter to keep filenames safe across platforms
-    sanitized = re.sub(r'[^\w\-.]', '', sanitized)
-    
-    # Check for empty string after sanitization
-    if not sanitized:
-        raise ValueError("The sanitized filename is empty. The original input may have contained only invalid characters.")
-
-    return sanitized
-
-
 def threshold_binary_values(
     input_array: Union[Sequence[float], np.ndarray, pd.Series, pl.Series],
     binary_values: Optional[int] = None
@@ -675,14 +506,5 @@ def train_dataset_orchestrator(list_of_dirs: list[Union[str,Path]],
     print(f"\n✅ {total_saved} single-target datasets were created.")
 
 
-def _script_info(all_data: list[str]):
-    """
-    List available names.
-    """
-    print("Available functions and objects:")
-    for i, name in enumerate(all_data, start=1):
-            print(f"{i} - {name}")
-
-
 def info():
     _script_info(__all__)

dragon_ml_toolbox-3.12.6.dist-info/METADATA

@@ -1,137 +0,0 @@
-Metadata-Version: 2.4
-Name: dragon-ml-toolbox
-Version: 3.12.6
-Summary: A collection of tools for data science and machine learning projects.
-Author-email: Karl Loza <luigiloza@gmail.com>
-License-Expression: MIT
-Project-URL: Homepage, https://github.com/DrAg0n-BoRn/ML_tools
-Project-URL: Changelog, https://github.com/DrAg0n-BoRn/ML_tools/blob/master/CHANGELOG.md
-Classifier: Programming Language :: Python :: 3
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.10
-Description-Content-Type: text/markdown
-License-File: LICENSE
-License-File: LICENSE-THIRD-PARTY.md
-Requires-Dist: numpy<2.0
-Requires-Dist: scikit-learn
-Requires-Dist: openpyxl
-Requires-Dist: miceforest>=6.0.0
-Requires-Dist: plotnine>=0.12
-Requires-Dist: matplotlib
-Requires-Dist: seaborn
-Requires-Dist: pandas
-Requires-Dist: polars
-Requires-Dist: imbalanced-learn
-Requires-Dist: statsmodels
-Requires-Dist: ipython
-Requires-Dist: ipykernel
-Requires-Dist: notebook
-Requires-Dist: jupyterlab
-Requires-Dist: ipywidgets
-Requires-Dist: joblib
-Requires-Dist: xgboost
-Requires-Dist: lightgbm<=4.5.0
-Requires-Dist: shap
-Requires-Dist: tqdm>=4.0
-Requires-Dist: Pillow
-Provides-Extra: pytorch
-Requires-Dist: torch; extra == "pytorch"
-Requires-Dist: torchvision; extra == "pytorch"
-Provides-Extra: gui
-Requires-Dist: FreeSimpleGUI>=5.2; extra == "gui"
-Dynamic: license-file
-
-# dragon-ml-toolbox
-
-A collection of Python utilities for data science and machine learning, structured as a modular package for easy reuse and installation.
-
-## Features
-
-- Modular scripts for data exploration, logging, machine learning, and more.
-- Designed for seamless integration as a Git submodule or installable Python package.
-
-## Installation
-
-**Python 3.10+ recommended.**
-
-### Via PyPI
-
-Install the latest stable release from PyPI:
-
-```bash
-pip install dragon-ml-toolbox
-```
-
-### Via GitHub (Editable)
-
-Clone the repository and install in editable mode with optional dependencies:
-
-```bash
-git clone https://github.com/DrAg0n-BoRn/ML_tools.git
-cd ML_tools
-pip install -e .
-```
-
-### Via conda-forge
-
-Install from the conda-forge channel:
-
-```bash
-conda install -c conda-forge dragon-ml-toolbox
-```
-**Note:** This version is outdated or broken due to dependency incompatibilities. Use PyPi instead.
-
-## Optional dependencies
-
-### FreeSimpleGUI
-
-Wrapper library used to build powerful GUIs. Requires the tkinter backend.
-
-```bash
-pip install dragon-ml-toolbox[gui]
-```
-
-### PyTorch
-
-Different builds available depending on the **platform** and **hardware acceleration** (e.g., CUDA for NVIDIA GPUs on Linux/Windows, or MPS for Apple Silicon on macOS).
-
-Install the default CPU-only version with
-
-```bash
-pip install dragon-ml-toolbox[pytorch]
-```
-
-To make use of GPU acceleration use the official PyTorch installation instructions:
-
-[PyTorch Instructions](https://pytorch.org/get-started/locally/)
-
-## Usage
-
-After installation, import modules like this:
-
-```python
-from ml_tools.utilities import sanitize_filename
-from ml_tools.logger import custom_logger
-```
-
-## Available modules
-
-```bash
-data_exploration
-datasetmaster
-ensemble_learning
-ETL_engineering
-GUI_tools
-handle_excel
-logger
-MICE_imputation
-ML_callbacks
-ML_evaluation
-ML_trainer
-ML_tutorial
-path_manager
-PSO_optimization
-RNN_forecast
-utilities
-VIF_factor
-```

dragon_ml_toolbox-3.12.6.dist-info/RECORD

@@ -1,26 +0,0 @@
-dragon_ml_toolbox-3.12.6.dist-info/licenses/LICENSE,sha256=2uUFNy7D0TLgHim1K5s3DIJ4q_KvxEXVilnU20cWliY,1066
-dragon_ml_toolbox-3.12.6.dist-info/licenses/LICENSE-THIRD-PARTY.md,sha256=lY4_rJPnLnMu7YBQaY-_iz1JRDcLdQzNCyeLAF1glJY,1837
-ml_tools/ETL_engineering.py,sha256=yeZsW_7zRvEcuMZbM4E2GV1dxwBoWIeJAcFFk2AK0fY,39502
-ml_tools/GUI_tools.py,sha256=dkB2nxY1RxR_PDw6h2virWc9KR0E_C7elzVZ36uFJVM,45406
-ml_tools/MICE_imputation.py,sha256=7CDsIQxx5Jb_DwPAmWmz3FXcn85sUyH7g9UcZ1_E07s,11412
-ml_tools/ML_callbacks.py,sha256=g_9nSzoA22UJOQZCPKeDz-Ayh0ECFZLzRd6rZ8SokrE,13080
-ml_tools/ML_evaluation.py,sha256=oiDV6HItQloUUKCUpltV-2pogubWLBieGpc-VUwosAQ,10106
-ml_tools/ML_trainer.py,sha256=gGXAu65v_5yYCqKqmHpSLJ3yY0M_Scr_nJ6qHBHSK1k,14487
-ml_tools/ML_tutorial.py,sha256=m5mZPULhO4mOpfp32fM_mUNVduv-S2hoKNbsZObNI4k,12233
-ml_tools/PSO_optimization.py,sha256=1wRM-goZSwCji5LQVDP1VjF0LyGN5-QWBvofbwfjQRQ,24780
-ml_tools/RNN_forecast.py,sha256=IZLcPs3by0Chei7ill_Grjxs7BBUnzau0Oavi3dWiyE,1886
-ml_tools/VIF_factor.py,sha256=gD3sZ9HBdTHlf4gbvUvx6kKczO_JFxMZKTXw1h0KVCg,10365
-ml_tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ml_tools/_pytorch_models.py,sha256=bpWZsrSwCvHJQkR6UfoPpElsMv9AvmiNErNHC8NYB_I,10132
-ml_tools/data_exploration.py,sha256=ZpjK_lN5mDhjf9iQpvyYNA2SF7M5q4D5m09saln7YFI,25241
-ml_tools/datasetmaster.py,sha256=S3PKHNQZ9cyAOck8xQltVLZhaD1gFLfgHFL-aRjz4JU,30077
-ml_tools/ensemble_learning.py,sha256=D-9IbOKtCvyAB-LbPu3sdSRtdp0RZIcQEZcyMnarHmQ,45758
-ml_tools/handle_excel.py,sha256=2Q_MBArss4emPQ8p-Uj9x_e7wGg3OoYM2AU_HG59UCY,12978
-ml_tools/keys.py,sha256=3YVbcYARSjE3vKr_6PavJSf7vXvlos7szu3qva4T3Ts,781
-ml_tools/logger.py,sha256=UkbiU9ihBhw9VKyn3rZzisdClWV94EBV6B09_D0iUU0,6026
-ml_tools/path_manager.py,sha256=1LD9JFzqVyJQl2kTA7tK930_IV3qxfiV4cMIBzItytY,8309
-ml_tools/utilities.py,sha256=Vh4ZdI03g8EpgQL7KDwnAw2vtBlHtx6KxCuAATxLvT4,24208
-dragon_ml_toolbox-3.12.6.dist-info/METADATA,sha256=qhni3r9Wsp7cx0WORT1m-xd3P_iqM7wdq08WIdC0g2U,3274
-dragon_ml_toolbox-3.12.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-dragon_ml_toolbox-3.12.6.dist-info/top_level.txt,sha256=wm-oxax3ciyez6VoO4zsFd-gSok2VipYXnbg3TH9PtU,9
-dragon_ml_toolbox-3.12.6.dist-info/RECORD,,