dragon-ml-toolbox 19.14.0__py3-none-any.whl → 20.0.0__py3-none-any.whl

ml_tools/{_core/_ML_vision_transformers.py → ML_vision_transformers/_core_transforms.py}

@@ -1,14 +1,13 @@
-from typing import Union, Dict, Type, Callable, Optional, Any, List, Literal, Tuple
+from typing import Union, Type, Callable, Any
 from PIL import ImageOps, Image
 from torchvision import transforms
 from pathlib import Path
 import json
 import random
 
-from ._logger import get_logger
-from ._script_info import _script_info
-from ._keys import VisionTransformRecipeKeys
-from ._path_manager import make_fullpath
+from .._core import get_logger
+from ..keys._keys import VisionTransformRecipeKeys
+from ..path_manager import make_fullpath
 
 
 _LOGGER = get_logger("Transformers")
@@ -20,7 +19,8 @@ __all__ = [
     "LetterboxResize",
     "HistogramEqualization",
     "RandomHistogramEqualization",
-    "create_offline_augmentations"
+    "_save_recipe",
+    "_load_recipe_and_build_transform",
 ]
 
 # --- Custom Vision Transform Class ---
@@ -82,7 +82,7 @@ class LetterboxResize:
     """
     def __init__(
         self, 
-        target_size: Union[int, Tuple[int, int]], 
+        target_size: Union[int, tuple[int, int]], 
         pad_color: Union[str, int] = "black"
     ) -> None:
         
@@ -189,7 +189,7 @@ class RandomHistogramEqualization:
 
 #############################################################
 #NOTE: Add custom transforms.
-TRANSFORM_REGISTRY: Dict[str, Type[Callable]] = {
+TRANSFORM_REGISTRY: dict[str, Type[Callable]] = {
     "ResizeAspectFill": ResizeAspectFill, 
     "LetterboxResize": LetterboxResize,
     "HistogramEqualization": HistogramEqualization,
@@ -198,153 +198,12 @@ TRANSFORM_REGISTRY: Dict[str, Type[Callable]] = {
 #############################################################
 
 
-def create_offline_augmentations(
-    input_directory: Union[str, Path],
-    output_directory: Union[str, Path],
-    results_per_image: int,
-    recipe: Optional[Dict[str, Any]] = None,
-    save_format: Literal["WEBP", "JPEG", "PNG", "BMP", "TIF"] = "WEBP",
-    save_quality: int = 80
-) -> None:
-    """
-    Reads all valid images from an input directory, applies augmentations,
-    and saves the new images to an output directory (offline augmentation).
-
-    Skips subdirectories in the input path.
-
-    Args:
-        input_directory (Union[str, Path]): Path to the directory of source images.
-        output_directory (Union[str, Path]): Path to save the augmented images.
-        results_per_image (int): The number of augmented versions to create
-                                 for each source image.
-        recipe (Optional[Dict[str, Any]]): A transform recipe dictionary. If None,
-                                           a default set of strong, random
-                                           augmentations will be used.
-        save_format (str): The format to save images (e.g., "WEBP", "JPEG", "PNG").
-                           Defaults to "WEBP" for good compression.
-        save_quality (int): The quality for lossy formats (1-100). Defaults to 80.
-    """
-    VALID_IMG_EXTENSIONS = ('.jpg', '.jpeg', '.png', '.bmp', '.webp', '.tif', '.tiff')
-    
-    # --- 1. Validate Paths ---
-    in_path = make_fullpath(input_directory, enforce="directory")
-    out_path = make_fullpath(output_directory, make=True, enforce="directory")
-    
-    _LOGGER.info(f"Starting offline augmentation:\n\tInput: {in_path}\n\tOutput: {out_path}")
-
-    # --- 2. Find Images ---
-    image_files = [
-        f for f in in_path.iterdir()
-        if f.is_file() and f.suffix.lower() in VALID_IMG_EXTENSIONS
-    ]
-    
-    if not image_files:
-        _LOGGER.warning(f"No valid image files found in {in_path}.")
-        return
-
-    _LOGGER.info(f"Found {len(image_files)} images to process.")
-
-    # --- 3. Define Transform Pipeline ---
-    transform_pipeline: transforms.Compose
-    
-    if recipe:
-        _LOGGER.info("Building transformations from provided recipe.")
-        try:
-            transform_pipeline = _build_transform_from_recipe(recipe)
-        except Exception as e:
-            _LOGGER.error(f"Failed to build transform from recipe: {e}")
-            return
-    else:
-        _LOGGER.info("No recipe provided. Using default random augmentation pipeline.")
-        # Default "random" pipeline
-        transform_pipeline = transforms.Compose([
-            transforms.RandomResizedCrop(256, scale=(0.4, 1.0)),
-            transforms.RandomHorizontalFlip(p=0.5),
-            transforms.RandomRotation(degrees=90),
-            transforms.ColorJitter(brightness=0.3, contrast=0.3, saturation=0.3, hue=0.15),
-            transforms.RandomPerspective(distortion_scale=0.2, p=0.4),
-            transforms.RandomAffine(degrees=0, translate=(0.1, 0.1)),
-            transforms.RandomApply([
-                transforms.GaussianBlur(kernel_size=3)
-            ], p=0.3)
-        ])
-
-    # --- 4. Process Images ---
-    total_saved = 0
-    format_upper = save_format.upper()
-    
-    for img_path in image_files:
-        _LOGGER.debug(f"Processing {img_path.name}...")
-        try:
-            original_image = Image.open(img_path).convert("RGB")
-            
-            for i in range(results_per_image):
-                new_stem = f"{img_path.stem}_aug_{i+1:03d}"
-                output_path = out_path / f"{new_stem}.{format_upper.lower()}"
-                
-                # Apply transform
-                transformed_image = transform_pipeline(original_image)
-                
-                # Save
-                transformed_image.save(
-                    output_path, 
-                    format=format_upper, 
-                    quality=save_quality,
-                    optimize=True # Add optimize flag
-                )
-                total_saved += 1
-                
-        except Exception as e:
-            _LOGGER.warning(f"Failed to process or save augmentations for {img_path.name}: {e}")
-
-    _LOGGER.info(f"Offline augmentation complete. Saved {total_saved} new images.")
-
-
-def _build_transform_from_recipe(recipe: Dict[str, Any]) -> transforms.Compose:
-    """Internal helper to build a transform pipeline from a recipe dict."""
-    pipeline_steps: List[Callable] = []
-    
-    if VisionTransformRecipeKeys.PIPELINE not in recipe:
-        _LOGGER.error("Recipe dict is invalid: missing 'pipeline' key.")
-        raise ValueError("Invalid recipe format.")
-
-    for step in recipe[VisionTransformRecipeKeys.PIPELINE]:
-        t_name = step.get(VisionTransformRecipeKeys.NAME)
-        t_kwargs = step.get(VisionTransformRecipeKeys.KWARGS, {})
-        
-        if not t_name:
-            _LOGGER.error(f"Invalid transform step, missing 'name': {step}")
-            continue
-        
-        transform_class: Any = None
-
-        # 1. Check standard torchvision transforms
-        if hasattr(transforms, t_name):
-            transform_class = getattr(transforms, t_name)
-        # 2. Check custom transforms
-        elif t_name in TRANSFORM_REGISTRY:
-            transform_class = TRANSFORM_REGISTRY[t_name]
-        # 3. Not found
-        else:
-            _LOGGER.error(f"Unknown transform '{t_name}' in recipe. Not found in torchvision.transforms or TRANSFORM_REGISTRY.")
-            raise ValueError(f"Unknown transform name: {t_name}")
-            
-        # Instantiate the transform
-        try:
-            pipeline_steps.append(transform_class(**t_kwargs))
-        except Exception as e:
-            _LOGGER.error(f"Failed to instantiate transform '{t_name}' with kwargs {t_kwargs}: {e}")
-            raise
-            
-    return transforms.Compose(pipeline_steps)
-
-
-def _save_recipe(recipe: Dict[str, Any], filepath: Path) -> None:
+def _save_recipe(recipe: dict[str, Any], filepath: Path) -> None:
     """
     Saves a transform recipe dictionary to a JSON file.
 
     Args:
-        recipe (Dict[str, Any]): The recipe dictionary to save.
+        recipe (dict[str, Any]): The recipe dictionary to save.
         filepath (str): The path to the output .json file.
     """
     final_filepath = filepath.with_suffix(".json")
@@ -383,7 +242,7 @@ def _load_recipe_and_build_transform(filepath: Union[str,Path]) -> transforms.Co
         _LOGGER.error(f"Failed to load recipe from '{final_filepath}': {e}")
         raise
         
-    pipeline_steps: List[Callable] = []
+    pipeline_steps: list[Callable] = []
     
     if VisionTransformRecipeKeys.PIPELINE not in recipe:
         _LOGGER.error("Recipe file is invalid: missing 'pipeline' key.")
@@ -416,6 +275,3 @@ def _load_recipe_and_build_transform(filepath: Union[str,Path]) -> transforms.Co
     _LOGGER.info(f"Successfully loaded and built transform pipeline from '{final_filepath.name}'.")
     return transforms.Compose(pipeline_steps)
 
-
-def info():
-    _script_info(__all__)

ml_tools/ML_vision_transformers/_imprimir.py

@@ -0,0 +1,14 @@
+from .._core import _imprimir_disponibles
+
+_GRUPOS = [
+    # Custom Transforms
+    "ResizeAspectFill",
+    "LetterboxResize",
+    "HistogramEqualization",
+    "RandomHistogramEqualization",
+    # Offline Augmentation
+    "create_offline_augmentations",
+]
+
+def info():
+    _imprimir_disponibles(_GRUPOS)

ml_tools/ML_vision_transformers/_offline_augmentation.py

@@ -0,0 +1,159 @@
+from typing import Union, Callable, Optional, Any, Literal
+from PIL import Image
+from torchvision import transforms
+from pathlib import Path
+
+from .._core import get_logger
+from ..keys._keys import VisionTransformRecipeKeys
+from ..path_manager import make_fullpath
+
+from ._core_transforms import TRANSFORM_REGISTRY
+
+
+_LOGGER = get_logger("Offline Augmentation")
+
+
+__all__ = [
+    "create_offline_augmentations"
+]
+
+def create_offline_augmentations(
+    input_directory: Union[str, Path],
+    output_directory: Union[str, Path],
+    results_per_image: int,
+    recipe: Optional[dict[str, Any]] = None,
+    save_format: Literal["WEBP", "JPEG", "PNG", "BMP", "TIF"] = "WEBP",
+    save_quality: int = 80
+) -> None:
+    """
+    Reads all valid images from an input directory, applies augmentations,
+    and saves the new images to an output directory (offline augmentation).
+
+    Skips subdirectories in the input path.
+
+    Args:
+        input_directory (Union[str, Path]): Path to the directory of source images.
+        output_directory (Union[str, Path]): Path to save the augmented images.
+        results_per_image (int): The number of augmented versions to create
+                                 for each source image.
+        recipe (Optional[Dict[str, Any]]): A transform recipe dictionary. If None,
+                                           a default set of strong, random
+                                           augmentations will be used.
+        save_format (str): The format to save images (e.g., "WEBP", "JPEG", "PNG").
+                           Defaults to "WEBP" for good compression.
+        save_quality (int): The quality for lossy formats (1-100). Defaults to 80.
+    """
+    VALID_IMG_EXTENSIONS = ('.jpg', '.jpeg', '.png', '.bmp', '.webp', '.tif', '.tiff')
+    
+    # --- 1. Validate Paths ---
+    in_path = make_fullpath(input_directory, enforce="directory")
+    out_path = make_fullpath(output_directory, make=True, enforce="directory")
+    
+    _LOGGER.info(f"Starting offline augmentation:\n\tInput: {in_path}\n\tOutput: {out_path}")
+
+    # --- 2. Find Images ---
+    image_files = [
+        f for f in in_path.iterdir()
+        if f.is_file() and f.suffix.lower() in VALID_IMG_EXTENSIONS
+    ]
+    
+    if not image_files:
+        _LOGGER.warning(f"No valid image files found in {in_path}.")
+        return
+
+    _LOGGER.info(f"Found {len(image_files)} images to process.")
+
+    # --- 3. Define Transform Pipeline ---
+    transform_pipeline: transforms.Compose
+    
+    if recipe:
+        _LOGGER.info("Building transformations from provided recipe.")
+        try:
+            transform_pipeline = _build_transform_from_recipe(recipe)
+        except Exception as e:
+            _LOGGER.error(f"Failed to build transform from recipe: {e}")
+            return
+    else:
+        _LOGGER.info("No recipe provided. Using default random augmentation pipeline.")
+        # Default "random" pipeline
+        transform_pipeline = transforms.Compose([
+            transforms.RandomResizedCrop(256, scale=(0.4, 1.0)),
+            transforms.RandomHorizontalFlip(p=0.5),
+            transforms.RandomRotation(degrees=90),
+            transforms.ColorJitter(brightness=0.3, contrast=0.3, saturation=0.3, hue=0.15),
+            transforms.RandomPerspective(distortion_scale=0.2, p=0.4),
+            transforms.RandomAffine(degrees=0, translate=(0.1, 0.1)),
+            transforms.RandomApply([
+                transforms.GaussianBlur(kernel_size=3)
+            ], p=0.3)
+        ])
+
+    # --- 4. Process Images ---
+    total_saved = 0
+    format_upper = save_format.upper()
+    
+    for img_path in image_files:
+        _LOGGER.debug(f"Processing {img_path.name}...")
+        try:
+            original_image = Image.open(img_path).convert("RGB")
+            
+            for i in range(results_per_image):
+                new_stem = f"{img_path.stem}_aug_{i+1:03d}"
+                output_path = out_path / f"{new_stem}.{format_upper.lower()}"
+                
+                # Apply transform
+                transformed_image = transform_pipeline(original_image)
+                
+                # Save
+                transformed_image.save(
+                    output_path, 
+                    format=format_upper, 
+                    quality=save_quality,
+                    optimize=True # Add optimize flag
+                )
+                total_saved += 1
+                
+        except Exception as e:
+            _LOGGER.warning(f"Failed to process or save augmentations for {img_path.name}: {e}")
+
+    _LOGGER.info(f"Offline augmentation complete. Saved {total_saved} new images.")
+
+
+def _build_transform_from_recipe(recipe: dict[str, Any]) -> transforms.Compose:
+    """Internal helper to build a transform pipeline from a recipe dict."""
+    pipeline_steps: list[Callable] = []
+    
+    if VisionTransformRecipeKeys.PIPELINE not in recipe:
+        _LOGGER.error("Recipe dict is invalid: missing 'pipeline' key.")
+        raise ValueError("Invalid recipe format.")
+
+    for step in recipe[VisionTransformRecipeKeys.PIPELINE]:
+        t_name = step.get(VisionTransformRecipeKeys.NAME)
+        t_kwargs = step.get(VisionTransformRecipeKeys.KWARGS, {})
+        
+        if not t_name:
+            _LOGGER.error(f"Invalid transform step, missing 'name': {step}")
+            continue
+        
+        transform_class: Any = None
+
+        # 1. Check standard torchvision transforms
+        if hasattr(transforms, t_name):
+            transform_class = getattr(transforms, t_name)
+        # 2. Check custom transforms
+        elif t_name in TRANSFORM_REGISTRY:
+            transform_class = TRANSFORM_REGISTRY[t_name]
+        # 3. Not found
+        else:
+            _LOGGER.error(f"Unknown transform '{t_name}' in recipe. Not found in torchvision.transforms or TRANSFORM_REGISTRY.")
+            raise ValueError(f"Unknown transform name: {t_name}")
+            
+        # Instantiate the transform
+        try:
+            pipeline_steps.append(transform_class(**t_kwargs))
+        except Exception as e:
+            _LOGGER.error(f"Failed to instantiate transform '{t_name}' with kwargs {t_kwargs}: {e}")
+            raise
+            
+    return transforms.Compose(pipeline_steps)
+

ml_tools/{_core/_PSO_optimization.py → PSO_optimization/_PSO.py}

@@ -1,21 +1,21 @@
 import numpy as np
+import pandas as pd
 from pathlib import Path
 import xgboost as xgb
 import lightgbm as lgb
-from typing import Literal, Union, Tuple, Dict, Optional
+from typing import Literal, Union, Optional
 from copy import deepcopy
 import torch
 from tqdm import trange
 from contextlib import nullcontext
 
-from ._serde import deserialize_object
-from ._math_utilities import threshold_binary_values, threshold_binary_values_batch
-from ._path_manager import sanitize_filename, make_fullpath, list_files_by_extension
-from ._logger import get_logger
-from ._keys import EnsembleKeys
-from ._script_info import _script_info
-from ._SQL import DragonSQL
-from ._optimization_tools import _save_result
+from ..serde import deserialize_object
+from ..SQL import DragonSQL
+
+from ..math_utilities import threshold_binary_values, threshold_binary_values_batch
+from ..keys._keys import EnsembleKeys
+from ..path_manager import sanitize_filename, make_fullpath, list_files_by_extension
+from .._core import get_logger
 
 
 _LOGGER = get_logger("PSO")
@@ -247,7 +247,7 @@ def run_pso(lower_boundaries: list[float],
             swarm_size: int=200, 
             max_iterations: int=3000,
             random_state: int=101,
-            post_hoc_analysis: Optional[int]=20) -> Optional[Tuple[Dict[str, float], Dict[str, float]]]:
+            post_hoc_analysis: Optional[int]=20) -> Optional[tuple[dict[str, float], dict[str, float]]]:
     """
     Executes Particle Swarm Optimization (PSO) to optimize a given objective function and saves the results as a CSV file.
 
@@ -384,6 +384,54 @@ def run_pso(lower_boundaries: list[float],
             return None
 
 
+def _save_result(
+        result_dict: dict,
+        save_format: Literal['csv', 'sqlite', 'both'],
+        csv_path: Path,
+        db_manager: Optional[DragonSQL] = None,
+        db_table_name: Optional[str] = None,
+        categorical_mappings: Optional[dict[str, dict[str, int]]] = None
+    ):
+    """
+    Private helper to handle saving a single result to CSV, SQLite, or both.
+    
+    If `categorical_mappings` is provided, it will reverse-map integer values
+    to their string representations before saving.
+    """
+    # --- Reverse Mapping Logic ---
+    # Create a copy to hold the values to be saved
+    save_dict = result_dict.copy()
+    
+    if categorical_mappings:
+        for feature_name, mapping in categorical_mappings.items():
+            if feature_name in save_dict:
+                # Create a reverse map {0: 'Category_A', 1: 'Category_B'}
+                reverse_map = {idx: name for name, idx in mapping.items()}
+                
+                # Get the integer value from the results (e.g., 0)
+                int_value = save_dict[feature_name]
+                
+                # Find the corresponding string (e.g., 'Category_A')
+                # Use .get() for safety, defaulting to the original value if not found
+                string_value = reverse_map.get(int_value, int_value)
+                
+                # Update the dictionary that will be saved
+                save_dict[feature_name] = string_value
+    
+    # Save to CSV
+    if save_format in ['csv', 'both']:
+        df_row = pd.DataFrame([save_dict])
+        file_exists = csv_path.exists()
+        df_row.to_csv(csv_path, mode='a', index=False, header=not file_exists)
+
+    # Save to SQLite
+    if save_format in ['sqlite', 'both']:
+        if db_manager and db_table_name:
+            db_manager.insert_row(db_table_name, save_dict)
+        else:
+            _LOGGER.warning("SQLite saving requested but db_manager or table_name not provided.")
+
+
 def _pso(func: ObjectiveFunction,
          lb: np.ndarray,
          ub: np.ndarray,
@@ -536,8 +584,3 @@ def _pso(func: ObjectiveFunction,
     else:
         return best_position, best_score
 
-
-
-
-def info():
-    _script_info(__all__)

ml_tools/{PSO_optimization.py → PSO_optimization/__init__.py}

@@ -1,10 +1,12 @@
-from ._core._PSO_optimization import (
+from ._PSO import (
     ObjectiveFunction,
     multiple_objective_functions_from_dir,
-    run_pso,
-    info
+    run_pso
 )
 
+from ._imprimir import info
+
+
 __all__ = [
     "ObjectiveFunction",
     "multiple_objective_functions_from_dir",

ml_tools/PSO_optimization/_imprimir.py

@@ -0,0 +1,10 @@
+from .._core import _imprimir_disponibles
+
+_GRUPOS = [
+    "ObjectiveFunction",
+    "multiple_objective_functions_from_dir",
+    "run_pso"
+]
+
+def info():
+    _imprimir_disponibles(_GRUPOS)

ml_tools/SQL/__init__.py

@@ -0,0 +1,7 @@
+from ._dragon_SQL import DragonSQL
+
+from ._imprimir import info
+
+__all__ = [
+    "DragonSQL",
+]

ml_tools/{_core/_SQL.py → SQL/_dragon_SQL.py}

@@ -1,11 +1,10 @@
 import sqlite3
 import pandas as pd
 from pathlib import Path
-from typing import Union, Dict, Any, Optional, List, Literal
+from typing import Union, Any, Optional, Literal
 
-from ._logger import get_logger
-from ._script_info import _script_info
-from ._path_manager import make_fullpath, sanitize_filename
+from .._core import get_logger
+from ..path_manager import make_fullpath, sanitize_filename
 
 
 _LOGGER = get_logger("DragonSQL")
@@ -80,7 +79,7 @@ class DragonSQL:
             self.conn.close()
             _LOGGER.info(f"Database connection closed: {self.db_path.name}")
 
-    def create_table(self, table_name: str, schema: Dict[str, str], if_not_exists: bool = True):
+    def create_table(self, table_name: str, schema: dict[str, str], if_not_exists: bool = True):
         """
         Creates a new table in the database based on a provided schema.
 
@@ -109,7 +108,7 @@ class DragonSQL:
         _LOGGER.info(f"➡️ Executing: {query}")
         self.cursor.execute(query)
 
-    def insert_row(self, table_name: str, data: Dict[str, Any]):
+    def insert_row(self, table_name: str, data: dict[str, Any]):
         """
         Inserts a single row of data into the specified table.
 
@@ -175,7 +174,7 @@ class DragonSQL:
         
         self.cursor.execute(query, params if params else ())
 
-    def insert_many(self, table_name: str, data: List[Dict[str, Any]]):
+    def insert_many(self, table_name: str, data: list[dict[str, Any]]):
         """
         Inserts multiple rows into the specified table in a single, efficient transaction.
 
@@ -239,7 +238,7 @@ class DragonSQL:
         )
         _LOGGER.info(f"➡️ Wrote {len(df)} rows from DataFrame to table '{table_name}' using mode '{if_exists}'.")
         
-    def list_tables(self) -> List[str]:
+    def list_tables(self) -> list[str]:
         """Returns a list of all table names in the database."""
         if not self.cursor:
             _LOGGER.error("Database connection is not open.")
@@ -300,6 +299,3 @@ class DragonSQL:
         else:
             _LOGGER.error("Cannot commit: Database connection is not open.")
 
-
-def info():
-    _script_info(__all__)

ml_tools/SQL/_imprimir.py

@@ -0,0 +1,8 @@
+from .._core import _imprimir_disponibles
+
+_GRUPOS = [
+    "DragonSQL",
+]
+
+def info():
+    _imprimir_disponibles(_GRUPOS)

ml_tools/{_core → VIF}/_VIF_factor.py

@@ -7,10 +7,10 @@ from statsmodels.tools.tools import add_constant
 import warnings
 from pathlib import Path
 
-from ._utilities import yield_dataframes_from_dir, save_dataframe_filename
-from ._path_manager import sanitize_filename, make_fullpath
-from ._logger import get_logger
-from ._script_info import _script_info
+from ..utilities import yield_dataframes_from_dir, save_dataframe_filename
+
+from ..path_manager import sanitize_filename, make_fullpath
+from .._core import get_logger
 
 
 _LOGGER = get_logger("VIF")
@@ -31,7 +31,7 @@ def compute_vif(
     save_dir: Optional[Union[str,Path]] = None,
     filename: Optional[str] = None,
     fontsize: int = 14,
-    show_plot: bool = True
+    show_plot: bool = False
 ) -> pd.DataFrame:
     """
     Computes Variance Inflation Factors (VIF) for numeric columns in a DataFrame. Optionally, generates a bar plot of VIF values.
@@ -234,6 +234,3 @@ def compute_vif_multi(input_directory: Union[str, Path],
             if len(dropped_cols) > 0:
                 save_dataframe_filename(df=result_df, save_dir=output_dataset_path, filename=new_filename)
 
-
-def info():
-    _script_info(__all__)

ml_tools/{VIF_factor.py → VIF/__init__.py}

@@ -1,10 +1,12 @@
-from ._core._VIF_factor import (
+from ._VIF_factor import (
     compute_vif,
     drop_vif_based,
     compute_vif_multi,
-    info
 )
 
+from ._imprimir import info
+
+
 __all__ = [
     "compute_vif",
     "drop_vif_based",

ml_tools/VIF/_imprimir.py

@@ -0,0 +1,10 @@
+from .._core import _imprimir_disponibles
+
+_GRUPOS = [
+    "compute_vif",
+    "drop_vif_based",
+    "compute_vif_multi"
+]
+
+def info():
+    _imprimir_disponibles(_GRUPOS)

ml_tools/_core/__init__.py

@@ -1 +1,7 @@
-__all__ = []
+from ._script_info import _imprimir_disponibles
+from ._logger import get_logger
+
+__all__ = [
+    "_imprimir_disponibles",
+    "get_logger"
+]