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

ml_tools/{_core/_ETL_engineering.py → ETL_engineering/_transforms.py}

@@ -1,22 +1,16 @@
 import polars as pl
 import re
-from pathlib import Path
-from typing import Literal, Union, Optional, Any, Callable, List, Dict, Tuple
+from typing import Literal, Union, Optional
 
-from ._utilities import load_dataframe, save_dataframe_filename
-from ._path_manager import make_fullpath
-from ._script_info import _script_info
-from ._logger import get_logger
 from ..constants import CHEMICAL_ELEMENT_SYMBOLS
-from ._keys import MagicWords
 
+from .._core import get_logger
 
-_LOGGER = get_logger("ETL Engineering")
+
+_LOGGER = get_logger("ETL Transforms")
 
 
 __all__ = [
-    "DragonTransformRecipe",
-    "DragonProcessor",
     "BinaryTransformer",
     "MultiBinaryDummifier",
     "AutoDummifier",
@@ -34,250 +28,6 @@ __all__ = [
     "MolecularFormulaTransformer"
 ]
 
-############ TRANSFORM MAIN ####################
-
-class DragonTransformRecipe:
-    """
-    A builder class for creating a data transformation recipe.
-
-    This class provides a structured way to define a series of transformation
-    steps, with validation performed at the time of addition. It is designed
-    to be passed to a `DragonProcessor`.
-    
-    Use the method `add()` to add recipes.
-    """
-    def __init__(self):
-        self._steps: List[Dict[str, Any]] = []
-
-    def add(
-        self,
-        input_col_name: str,
-        transform: Union[str, Callable],
-        output_col_names: Optional[Union[str, List[str]]] = None
-    ) -> "DragonTransformRecipe":
-        """
-        Adds a new transformation step to the recipe.
-
-        Args:
-            input_col_name: The name of the column from the source DataFrame.
-            output_col_names: The desired name(s) for the output column(s).
-                        - A string for a 1-to-1 mapping.
-                        - A list of strings for a 1-to-many mapping.
-                        - A string prefix for 1-to-many mapping.
-                        - If None, the input name is used for 1-to-1 transforms,
-                          or the transformer's default names are used for 1-to-many.
-            transform: The transformation to apply: 
-                - Use "rename" for simple column renaming
-                - If callable, must accept a `pl.Series` as the only parameter and return either a `pl.Series` or `pl.DataFrame`.
-
-        Returns:
-            The instance of the recipe itself to allow for method chaining.
-        """
-        # --- Validation ---
-        if not isinstance(input_col_name, str) or not input_col_name:
-            _LOGGER.error("'input_col' must be a non-empty string.")
-            raise TypeError()
-            
-        if transform == MagicWords.RENAME:
-            if not isinstance(output_col_names, str):
-                _LOGGER.error("For a RENAME operation, 'output_col' must be a string.")
-                raise TypeError()
-        elif not isinstance(transform, Callable):
-            _LOGGER.error(f"'transform' must be a callable function or the string '{MagicWords.RENAME}'.")
-            raise TypeError()
-        
-        # --- Add Step ---
-        step = {
-            "input_col": input_col_name,
-            "output_col": output_col_names,
-            "transform": transform,
-        }
-        self._steps.append(step)
-        return self  # Allow chaining: recipe.add(...).add(...)
-
-    def __iter__(self):
-        """Allows the class to be iterated over, like a list."""
-        return iter(self._steps)
-
-    def __len__(self):
-        """Allows the len() function to be used on an instance."""
-        return len(self._steps)
-
-
-class DragonProcessor:
-    """
-    Transforms a Polars DataFrame based on a provided `DragonTransformRecipe` object.
-    
-    Use the methods `transform()` or `load_transform_save()`.
-    """
-    def __init__(self, recipe: DragonTransformRecipe):
-        """
-        Initializes the DragonProcessor with a transformation recipe.
-
-        Args:
-            recipe: An instance of the `DragonTransformRecipe` class that has
-                    been populated with transformation steps.
-        """
-        if not isinstance(recipe, DragonTransformRecipe):
-            _LOGGER.error("The recipe must be an instance of DragonTransformRecipe.")
-            raise TypeError()
-        if len(recipe) == 0:
-            _LOGGER.error("The recipe cannot be empty.")
-            raise ValueError()
-        self._recipe = recipe
-
-    def transform(self, df: pl.DataFrame) -> pl.DataFrame:
-        """
-        Applies the transformation recipe to the input DataFrame.
-        """
-        processed_columns = []
-        # Recipe object is iterable
-        for step in self._recipe:
-            input_col_name = step["input_col"]
-            output_col_spec = step["output_col"]
-            transform_action = step["transform"]
-
-            if input_col_name not in df.columns:
-                _LOGGER.error(f"Input column '{input_col_name}' not found in DataFrame.")
-                raise ValueError()
-
-            input_series = df.get_column(input_col_name)
-
-            if transform_action == MagicWords.RENAME:
-                processed_columns.append(input_series.alias(output_col_spec))
-                continue
-
-            if isinstance(transform_action, Callable):
-                result = transform_action(input_series)
-
-                if isinstance(result, pl.Series):
-                    # Default to input name if spec is None
-                    output_name = output_col_spec if output_col_spec is not None else input_col_name
-                    
-                    if not isinstance(output_name, str):
-                        _LOGGER.error(f"Function for '{input_col_name}' returned a Series but 'output_col' must be a string or None.")
-                        raise TypeError()
-                    processed_columns.append(result.alias(output_name))
-                
-                elif isinstance(result, pl.DataFrame):
-                    # 1. Handle None in output names
-                    if output_col_spec is None:
-                        # Use the column names generated by the transformer directly
-                        processed_columns.extend(result.get_columns())
-                    
-                    # 2. Handle list-based renaming
-                    elif isinstance(output_col_spec, list):
-                        if len(result.columns) != len(output_col_spec):
-                            _LOGGER.error(f"Mismatch in '{input_col_name}': function produced {len(result.columns)} columns, but recipe specifies {len(output_col_spec)} output names.")
-                            raise ValueError()
-                        
-                        renamed_df = result.rename(dict(zip(result.columns, output_col_spec)))
-                        processed_columns.extend(renamed_df.get_columns())
-                    
-                    # 3. Global logic for adding a single prefix to all columns.
-                    elif isinstance(output_col_spec, str):
-                        prefix = output_col_spec
-                        new_names = {}
-                        
-                        for col in result.columns:
-                            # Case 1: Transformer's output column name contains the input name.
-                            # Action: Replace the input name with the desired prefix.
-                            # Example: input='color', output='color_red', prefix='spec' -> 'spec_red'
-                            # if input_col_name in col:
-                            if col.startswith(input_col_name):
-                                new_names[col] = col.replace(input_col_name, prefix, 1)
-                            
-                            # Case 2: Transformer's output is an independent name.
-                            # Action: Prepend the prefix to the output name.
-                            # Example: input='ratio', output='A_B', prefix='spec' -> 'spec_A_B'
-                            else:
-                                new_names[col] = f"{prefix}_{col}"
-                                
-                        renamed_df = result.rename(new_names)
-                        processed_columns.extend(renamed_df.get_columns())    
-                    
-                    
-                    else:
-                        _LOGGER.error(f"Function for '{input_col_name}' returned a DataFrame, so 'output_col' must be a list of names, a string prefix, or None.")
-                        raise TypeError()
-                
-                else:
-                    _LOGGER.error(f"Function for '{input_col_name}' returned an unexpected type: {type(result)}.")
-                    raise TypeError()
-            
-            else: # This case is unlikely due to builder validation.
-                _LOGGER.error(f"Invalid 'transform' action for '{input_col_name}': {transform_action}")
-                raise TypeError()
-
-        if not processed_columns:
-            _LOGGER.error("The transformation resulted in an empty DataFrame.")
-            return pl.DataFrame()
-        
-        _LOGGER.info(f"Processed dataframe with {len(processed_columns)} columns.")
-
-        return pl.DataFrame(processed_columns)
-    
-    def load_transform_save(self, input_path: Union[str,Path], output_path: Union[str,Path]):
-        """
-        Convenience wrapper for the transform method that includes automatic dataframe loading and saving.
-        """
-        # Validate paths
-        in_path = make_fullpath(input_path, enforce="file")
-        out_path = make_fullpath(output_path, make=True, enforce="file")
-        
-        # load df
-        df, _ = load_dataframe(df_path=in_path, kind="polars", all_strings=True)
-        
-        # Process
-        df_processed = self.transform(df)
-        
-        # save processed df
-        save_dataframe_filename(df=df_processed, save_dir=out_path.parent, filename=out_path.name)
-        
-    def __str__(self) -> str:
-        """
-        Provides a detailed, human-readable string representation of the
-        entire processing pipeline.
-        """
-        header = "DragonProcessor Pipeline"
-        divider = "-" * len(header)
-        num_steps = len(self._recipe)
-        
-        lines = [
-            header,
-            divider,
-            f"Number of steps: {num_steps}\n"
-        ]
-
-        if num_steps == 0:
-            lines.append("No transformation steps defined.")
-            return "\n".join(lines)
-
-        for i, step in enumerate(self._recipe, 1):
-            transform_action = step["transform"]
-            
-            # Get a clean name for the transformation action
-            if transform_action == MagicWords.RENAME: # "rename"
-                transform_name = "Rename"
-            else:
-                # This works for both functions and class instances
-                transform_name = type(transform_action).__name__
-
-            lines.append(f"[{i}] Input: '{step['input_col']}'")
-            lines.append(f"    - Transform: {transform_name}")
-            lines.append(f"    - Output(s): {step['output_col']}")
-            if i < num_steps:
-                lines.append("") # Add a blank line between steps
-
-        return "\n".join(lines)
-
-    def inspect(self) -> None:
-        """
-        Prints the detailed string representation of the pipeline to the console.
-        """
-        print(self)
-
-############ TRANSFORMERS ####################
 
 class BinaryTransformer:
     """
@@ -285,8 +35,8 @@ class BinaryTransformer:
     """
     def __init__(
         self,
-        true_keywords: Optional[List[str]] = None,
-        false_keywords: Optional[List[str]] = None,
+        true_keywords: Optional[list[str]] = None,
+        false_keywords: Optional[list[str]] = None,
         case_insensitive: bool = True,
         use_regex: bool = False
     ):
@@ -407,7 +157,7 @@ class MultiBinaryDummifier:
     text column based on a list of keywords or regex patterns.
     """
     def __init__(self, 
-                 keywords: List[str], 
+                 keywords: list[str], 
                  case_insensitive: bool = True,
                  use_regex: bool = False):
         """ 
@@ -499,8 +249,8 @@ class KeywordDummifier:
     """
     def __init__(
         self, 
-        group_names: List[str], 
-        group_keywords: List[List[str]], 
+        group_names: list[str], 
+        group_keywords: list[list[str]], 
         case_insensitive: bool = True,
         use_regex: bool = False
     ):
@@ -1099,7 +849,7 @@ class CategoryMapper:
     """
     def __init__(
         self,
-        mapping: Dict[str, Union[int, float]],
+        mapping: dict[str, Union[int, float]],
         unseen_value: Optional[Union[int, float]] = None,
     ):
         if not isinstance(mapping, dict):
@@ -1160,7 +910,7 @@ class RegexMapper:
     """
     def __init__(
         self,
-        mapping: Dict[str, Union[int, float]],
+        mapping: dict[str, Union[int, float]],
         unseen_value: Optional[Union[int, float]] = None,
         case_insensitive: bool = True,
     ):
@@ -1173,7 +923,7 @@ class RegexMapper:
         
         # --- Process and validate patterns ---
         # Process patterns here to be more efficient, avoiding reprocessing on every __call__.
-        self.processed_mapping: List[Tuple[str, Union[int, float]]] = []
+        self.processed_mapping: list[tuple[str, Union[int, float]]] = []
         for pattern, value in mapping.items():
             final_pattern = f"(?i){pattern}" if case_insensitive else pattern
 
@@ -1224,7 +974,7 @@ class ValueBinner:
     """
     def __init__(
         self,
-        breaks: List[Union[int, float]],
+        breaks: list[Union[int, float]],
         left_closed: bool = False,
     ):
         """  
@@ -1294,7 +1044,7 @@ class DateFeatureExtractor:
 
     def __init__(
         self,
-        features: List[str],
+        features: list[str],
         format: Optional[str] = None,
     ):
         """
@@ -1422,6 +1172,3 @@ class MolecularFormulaTransformer:
 
         return base_df.select(select_expressions)
 
-
-def info():
-    _script_info(__all__)

ml_tools/{_core → GUI_tools}/_GUI_tools.py

@@ -3,14 +3,13 @@ from pathlib import Path
 import traceback
 import FreeSimpleGUI as sg
 from functools import wraps
-from typing import Any, Dict, Tuple, List, Literal, Union, Optional, Callable
+from typing import Any, Literal, Union, Optional, Callable
 import numpy as np
 import json
 
-from ._script_info import _script_info
-from ._path_manager import make_fullpath
-from ._logger import get_logger
-from ._keys import _OneHotOtherPlaceholder, SchemaKeys
+from ..path_manager import make_fullpath
+from .._core import get_logger
+from ..keys._keys import _OneHotOtherPlaceholder, SchemaKeys
 
 
 _LOGGER = get_logger("GUI Tools")
@@ -19,9 +18,9 @@ _LOGGER = get_logger("GUI Tools")
 __all__ = [
     "DragonGUIConfig", 
     "DragonGUIFactory",
-    "catch_exceptions", 
     "DragonFeatureMaster",
-    "DragonGUIHandler" 
+    "DragonGUIHandler",
+    "catch_exceptions",
 ]
 
 # --- Configuration Management ---
@@ -197,7 +196,7 @@ class DragonGUIFactory:
         }
         return sg.Button(text.title(), key=key, **style_args)
 
-    def make_frame(self, title: str, layout: List[List[Union[sg.Element, sg.Column]]], center_layout: bool = False, **kwargs) -> sg.Frame:
+    def make_frame(self, title: str, layout: list[list[Union[sg.Element, sg.Column]]], center_layout: bool = False, **kwargs) -> sg.Frame:
         """
         Creates a styled frame around a given layout.
 
@@ -226,12 +225,12 @@ class DragonGUIFactory:
     # --- General-Purpose Layout Generators ---
     def generate_continuous_layout(
         self,
-        data_dict: Dict[str, Union[Tuple[Union[int,float,None], Union[int,float,None]],List[Union[int,float,None]]]],
+        data_dict: dict[str, Union[tuple[Union[int,float,None], Union[int,float,None]],list[Union[int,float,None]]]],
         is_target: bool = False,
         layout_mode: Literal["grid", "row"] = 'grid',
         number_columns: int = 5,
         center_layout: bool = True
-    ) -> List[List[sg.Column]]:
+    ) -> list[list[sg.Column]]:
         """
         Generates a layout for continuous features or targets.
 
@@ -292,11 +291,11 @@ class DragonGUIFactory:
 
     def generate_combo_layout(
         self,
-        data_dict: Dict[str, Union[List[Any],Tuple[Any,...]]],
+        data_dict: dict[str, Union[list[Any],tuple[Any,...]]],
         layout_mode: Literal["grid", "row"] = 'grid',
         number_columns: int = 5,
         center_layout: bool = True
-    ) -> List[List[sg.Column]]:
+    ) -> list[list[sg.Column]]:
         """
         Generates a layout for categorical or binary features using Combo boxes.
 
@@ -334,11 +333,11 @@ class DragonGUIFactory:
     
     def generate_multiselect_layout(
         self,
-        data_dict: Dict[str, Union[List[Any], Tuple[Any, ...]]],
+        data_dict: dict[str, Union[list[Any], tuple[Any, ...]]],
         layout_mode: Literal["grid", "row"] = 'grid',
         number_columns: int = 5,
         center_layout: bool = True
-    ) -> List[List[sg.Column]]:
+    ) -> list[list[sg.Column]]:
         """
         Generates a layout for features using Listbox elements for multiple selections.
 
@@ -386,7 +385,7 @@ class DragonGUIFactory:
         return self._build_grid_layout(all_feature_layouts, number_columns, bg_color, center_layout) # type: ignore
 
     # --- Window Creation ---
-    def create_window(self, title: str, layout: List[List[sg.Element]], **kwargs) -> sg.Window:
+    def create_window(self, title: str, layout: list[list[sg.Element]], **kwargs) -> sg.Window:
         """
         Creates and finalizes the main application window.
 
@@ -413,7 +412,7 @@ class DragonGUIFactory:
         
         return window
     
-    def _build_grid_layout(self, all_feature_layouts: List[sg.Column], num_columns: int, bg_color: str, center_layout: bool = True) -> List[List[sg.Column]]:
+    def _build_grid_layout(self, all_feature_layouts: list[sg.Column], num_columns: int, bg_color: str, center_layout: bool = True) -> list[list[sg.Column]]:
         """
         Private helper to distribute feature layouts vertically into a grid of columns.
         """
@@ -485,12 +484,12 @@ class DragonFeatureMaster:
     for each feature type.
     """
     def __init__(self,
-                 targets: Dict[str, str],
-                 continuous_features: Optional[Dict[str, Tuple[str, float, float]]] = None,
-                 binary_features: Optional[Dict[str, str]] = None,
-                 multi_binary_features: Optional[Dict[str, Dict[str, str]]] = None,
-                 one_hot_features: Optional[Dict[str, Dict[str, str]]] = None,
-                 categorical_features: Optional[List[Tuple[str, str, Dict[str, int]]]] = None,
+                 targets: dict[str, str],
+                 continuous_features: Optional[dict[str, tuple[str, float, float]]] = None,
+                 binary_features: Optional[dict[str, str]] = None,
+                 multi_binary_features: Optional[dict[str, dict[str, str]]] = None,
+                 one_hot_features: Optional[dict[str, dict[str, str]]] = None,
+                 categorical_features: Optional[list[tuple[str, str, dict[str, int]]]] = None,
                  add_one_hot_other_placeholder: bool = True) -> None:
         """
         Initializes the DragonFeatureMaster instance by processing feature and target definitions.
@@ -690,26 +689,26 @@ class DragonFeatureMaster:
             add_one_hot_other_placeholder=False
         )
         
-    def _handle_targets(self, targets: Dict[str, str]):
+    def _handle_targets(self, targets: dict[str, str]):
         # Make dictionary GUI name: range values
         gui_values: dict[str, tuple[None,None]] = {gui_key: (None, None) for gui_key in targets.keys()}
         # Map GUI name to Model name (same as input)
         return gui_values
         
-    def _handle_continuous_features(self, continuous_features: Dict[str, Tuple[str, float, float]]):
+    def _handle_continuous_features(self, continuous_features: dict[str, tuple[str, float, float]]):
         # Make dictionary GUI name: range values
         gui_values: dict[str, tuple[float,float]] = {gui_key: (tuple_values[1], tuple_values[2]) for gui_key, tuple_values in continuous_features.items()}
         # Map GUI name to Model name
         gui_to_model: dict[str,str] = {gui_key: tuple_values[0] for gui_key, tuple_values in continuous_features.items()}
         return gui_values, gui_to_model
     
-    def _handle_binary_features(self, binary_features: Dict[str, str]):
+    def _handle_binary_features(self, binary_features: dict[str, str]):
         # Make dictionary GUI name: range values
         gui_values: dict[str, tuple[Literal["False"],Literal["True"]]] = {gui_key: ("False", "True") for gui_key in binary_features.keys()}
         # Map GUI name to Model name (same as input)
         return gui_values
     
-    def _handle_multi_binary_features(self, multi_binary_features: Dict[str, Dict[str, str]]):
+    def _handle_multi_binary_features(self, multi_binary_features: dict[str, dict[str, str]]):
         # Make dictionary GUI name: range values
         gui_values: dict[str, tuple[str,...]] = {
             gui_key: tuple(nested_dict.keys()) 
@@ -717,13 +716,13 @@ class DragonFeatureMaster:
         # Map GUI name to Model name and preserve internal mapping (same as input)
         return gui_values
 
-    def _handle_one_hot_features(self, one_hot_features: Dict[str, Dict[str,str]]):
+    def _handle_one_hot_features(self, one_hot_features: dict[str, dict[str,str]]):
         # Make dictionary GUI name: range values
         gui_values: dict[str, tuple[str,...]] = {gui_key: tuple(nested_dict.keys()) for gui_key, nested_dict in one_hot_features.items()}
         # Map GUI name to Model name and preserve internal mapping (same as input)
         return gui_values
         
-    def _handle_categorical_features(self, categorical_features: List[Tuple[str, str, Dict[str, int]]]):
+    def _handle_categorical_features(self, categorical_features: list[tuple[str, str, dict[str, int]]]):
         # Make dictionary GUI name: range values
         gui_values: dict[str, tuple[str,...]] = {gui_key: tuple(gui_options.keys()) for gui_key, _, gui_options in categorical_features}
         # Map GUI name to Model name and preserve internal mapping
@@ -939,7 +938,7 @@ class DragonGUIHandler:
         # Feature master instance
         self.master = feature_handler
 
-    def _process_continuous(self, gui_feature: str, chosen_value: Any) -> Tuple[str,float]:
+    def _process_continuous(self, gui_feature: str, chosen_value: Any) -> tuple[str,float]:
         """
         Maps GUI name to model expected name and casts the value to float.
         """
@@ -955,7 +954,7 @@ class DragonGUIHandler:
         else:
             return model_name, float_value
         
-    def _process_binary(self, gui_feature: str, chosen_value: str) -> Tuple[str,int]:
+    def _process_binary(self, gui_feature: str, chosen_value: str) -> tuple[str,int]:
         """
         Maps GUI name to model expected name and casts the value to binary (0,1).
         """
@@ -996,7 +995,7 @@ class DragonGUIHandler:
 
             return results
         
-    def _process_one_hot(self, gui_feature: str, chosen_value: str) -> Dict[str,int]:
+    def _process_one_hot(self, gui_feature: str, chosen_value: str) -> dict[str,int]:
         """
         Maps GUI names to model expected names and casts values to one-hot encoding.
         """
@@ -1019,7 +1018,7 @@ class DragonGUIHandler:
             
             return results
         
-    def _process_categorical(self, gui_feature: str, chosen_value: str) -> Tuple[str,int]:
+    def _process_categorical(self, gui_feature: str, chosen_value: str) -> tuple[str,int]:
         """
         Maps GUI name to model expected name and casts the value to a categorical number.
         """
@@ -1034,7 +1033,7 @@ class DragonGUIHandler:
             result = categorical_mapping[chosen_value]
             return model_name, result
         
-    def update_target_fields(self, window: sg.Window, inference_results: Dict[str, Any]):
+    def update_target_fields(self, window: sg.Window, inference_results: dict[str, Any]):
         """
         Updates the GUI's target fields with inference results.
 
@@ -1051,8 +1050,8 @@ class DragonGUIHandler:
             display_value = f"{result:.2f}" if isinstance(result, (int, float)) else result
             window[gui_key].update(display_value) # type: ignore
             
-    def _call_subprocess(self, window_values: Dict[str,Any], master_feature: Dict[str,str], processor: Callable) -> Dict[str, Union[float,int]]:
-        processed_features_subset: Dict[str, Union[float,int]] = dict()
+    def _call_subprocess(self, window_values: dict[str,Any], master_feature: dict[str,str], processor: Callable) -> dict[str, Union[float,int]]:
+        processed_features_subset: dict[str, Union[float,int]] = dict()
         
         for gui_name in master_feature.keys():
             chosen_value = window_values.get(gui_name)
@@ -1071,12 +1070,12 @@ class DragonGUIHandler:
         
         return processed_features_subset
 
-    def process_features(self,  window_values: Dict[str, Any]) -> np.ndarray:
+    def process_features(self,  window_values: dict[str, Any]) -> np.ndarray:
         """
         Translates GUI values to a model-expected input array, returning a 1D numpy array.
         """
         # Stage 1: Process GUI inputs into a dictionary
-        processed_features: Dict[str, Union[float,int]] = {}
+        processed_features: dict[str, Union[float,int]] = {}
         
         if self.master.has_continuous:
             processed_subset = self._call_subprocess(window_values=window_values,
@@ -1109,7 +1108,7 @@ class DragonGUIHandler:
             processed_features.update(processed_subset)
 
         # Stage 2: Assemble the final vector using the model's required order
-        final_vector: List[float] = list()
+        final_vector: list[float] = list()
         
         try:
             for feature_name in self.model_expected_features:
@@ -1119,5 +1118,3 @@ class DragonGUIHandler:
         
         return np.array(final_vector, dtype=np.float32)
 
-def info():
-    _script_info(__all__)

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

@@ -1,16 +1,18 @@
-from ._core._GUI_tools import (
+from ._GUI_tools import (
     DragonGUIConfig,
     DragonGUIFactory,
-    catch_exceptions,
     DragonFeatureMaster,
     DragonGUIHandler,
-    info
+    catch_exceptions,
 )
 
+from ._imprimir import info
+
+
 __all__ = [
     "DragonGUIConfig", 
     "DragonGUIFactory",
-    "catch_exceptions", 
     "DragonFeatureMaster",
-    "DragonGUIHandler" 
+    "DragonGUIHandler",
+    "catch_exceptions", 
 ]

ml_tools/GUI_tools/_imprimir.py

@@ -0,0 +1,12 @@
+from .._core import _imprimir_disponibles
+
+_GRUPOS = [
+    "DragonGUIConfig", 
+    "DragonGUIFactory",
+    "DragonFeatureMaster",
+    "DragonGUIHandler",
+    "catch_exceptions"
+]
+
+def info():
+    _imprimir_disponibles(_GRUPOS)