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

ml_tools/ML_optimization/_single_dragon.py

@@ -0,0 +1,203 @@
+from typing import Literal, Union, Optional
+from pathlib import Path
+
+from ..optimization_tools import create_optimization_bounds
+from ..ML_inference import DragonInferenceHandler
+from ..schema import FeatureSchema
+
+from .._core import get_logger
+from ..keys._keys import MLTaskKeys
+
+from ._single_manual import FitnessEvaluator, create_pytorch_problem, run_optimization
+
+
+_LOGGER = get_logger("DragonOptimizer")
+
+
+__all__ = [
+    "DragonOptimizer",
+]
+
+
+class DragonOptimizer:
+    """
+    A wrapper class for setting up and running EvoTorch optimization tasks for regression models.
+
+    This class combines the functionality of `FitnessEvaluator`, `create_pytorch_problem`, and
+    `run_optimization` into a single, streamlined workflow. 
+    
+    SNES and CEM algorithms do not accept bounds, the given bounds will be used as an initial starting point.
+
+    Example:
+        >>> # 1. Define bounds for continuous features
+        >>> cont_bounds = {'feature_A': (0, 100), 'feature_B': (-10, 10)}
+        >>>
+        >>> # 2. Initialize the optimizer
+        >>> optimizer = DragonOptimizer(
+        ...     inference_handler=my_handler,
+        ...     schema=schema,
+        ...     target_name="my_target",
+        ...     continuous_bounds_map=cont_bounds,
+        ...     task="max",
+        ...     algorithm="Genetic",
+        ... )
+        >>> # 3. Run the optimization
+        >>> best_result = optimizer.run(
+        ...     num_generations=100,
+        ...     save_dir="/path/to/results",
+        ...     save_format="csv"
+        ... )
+    """
+    def __init__(self,
+                 inference_handler: DragonInferenceHandler,
+                 schema: FeatureSchema,
+                 target_name: str,
+                 continuous_bounds_map: dict[str, tuple[float, float]],
+                 task: Literal["min", "max"],
+                 algorithm: Literal["SNES", "CEM", "Genetic"] = "Genetic",
+                 population_size: int = 200,
+                 discretize_start_at_zero: bool = True,
+                 **searcher_kwargs):
+        """
+        Initializes the optimizer by creating the EvoTorch problem and searcher.
+
+        Args:
+            inference_handler (DragonInferenceHandler): 
+                An initialized inference handler containing the model.
+            schema (FeatureSchema): 
+                The definitive schema object from data_exploration.
+            target_name (str): 
+                target name to optimize.
+            continuous_bounds_map (Dict[str, Tuple[float, float]]):
+                A dictionary mapping the *name* of each **continuous** feature
+                to its (min_bound, max_bound) tuple.
+            task (str): The optimization goal, either "min" or "max".
+            
+            algorithm (str): The search algorithm to use ("SNES", "CEM", "Genetic").
+            population_size (int): Population size for CEM and GeneticAlgorithm.
+            discretize_start_at_zero (bool): 
+                True if the discrete encoding starts at 0 (e.g., [0, 1, 2]).
+                False if it starts at 1 (e.g., [1, 2, 3]).
+            **searcher_kwargs: Additional keyword arguments for the selected 
+                               search algorithm's constructor.
+        """
+        # --- Store schema ---
+        self.schema = schema
+        # --- Store inference handler ---
+        self.inference_handler = inference_handler
+        
+        # Ensure only Regression tasks are used
+        allowed_tasks = [MLTaskKeys.REGRESSION, MLTaskKeys.MULTITARGET_REGRESSION]
+        if self.inference_handler.task not in allowed_tasks:
+            _LOGGER.error(f"DragonOptimizer only supports {allowed_tasks}. Got '{self.inference_handler.task}'.")
+            raise ValueError(f"Invalid Task: {self.inference_handler.task}")
+        
+        # --- store target name ---
+        self.target_name = target_name
+        
+        # --- flag to control single vs multi-target ---
+        self.is_multi_target = False
+        
+        # --- 1. Create bounds from schema ---
+        # This is the robust way to get bounds
+        bounds = create_optimization_bounds(
+            schema=schema,
+            continuous_bounds_map=continuous_bounds_map,
+            start_at_zero=discretize_start_at_zero
+        )
+        
+        # Resolve target index if multi-target
+        target_index = None
+        
+        if self.inference_handler.target_ids is None:
+            # This should be caught by ML_inference logic
+            _LOGGER.error("The provided inference handler does not have 'target_ids' defined.")
+            raise ValueError()
+
+        if target_name not in self.inference_handler.target_ids:
+            _LOGGER.error(f"Target name '{target_name}' not found in the inference handler's 'target_ids': {self.inference_handler.target_ids}")
+            raise ValueError()
+
+        if len(self.inference_handler.target_ids) == 1:
+            # Single target regression
+            target_index = None
+            _LOGGER.info(f"Optimization locked to single-target model '{target_name}'.")
+        else:
+            # Multi-target regression (optimizing one specific column)
+            target_index = self.inference_handler.target_ids.index(target_name)
+            self.is_multi_target = True
+            _LOGGER.info(f"Optimization locked to target '{target_name}' (Index {target_index}) in a multi-target model.")
+        
+        # --- 2. Make a fitness function ---
+        self.evaluator = FitnessEvaluator(
+            inference_handler=inference_handler,
+            # Get categorical info from the schema
+            categorical_index_map=schema.categorical_index_map,
+            discretize_start_at_zero=discretize_start_at_zero,
+            target_index=target_index
+        )
+        
+        # --- 3. Create the problem and searcher factory ---
+        self.problem, self.searcher_factory = create_pytorch_problem(
+            evaluator=self.evaluator,
+            bounds=bounds,
+            task=task,
+            algorithm=algorithm,
+            population_size=population_size,
+            **searcher_kwargs
+        )
+        
+        # --- 4. Store other info needed by run() ---
+        self.discretize_start_at_zero = discretize_start_at_zero
+
+    def run(self,
+            num_generations: int,
+            save_dir: Union[str, Path],
+            save_format: Literal['csv', 'sqlite', 'both'],
+            repetitions: int = 1,
+            verbose: bool = True) -> Optional[dict]:
+        """
+        Runs the evolutionary optimization process using the pre-configured settings.
+
+        The `feature_names` are automatically pulled from the `FeatureSchema`
+        provided during initialization.
+
+        Args:
+            num_generations (int): The total number of generations for each repetition.
+            save_dir (str | Path): The directory where result files will be saved.
+            save_format (Literal['csv', 'sqlite', 'both']): The format for saving results.
+            repetitions (int): The number of independent times to run the optimization.
+            verbose (bool): If True, enables detailed logging.
+
+        Returns:
+            Optional[dict]: A dictionary with the best result if repetitions is 1, 
+                            otherwise None.
+        """
+        # Pass inference handler and target names for multi-target only
+        if self.is_multi_target:
+            target_names_to_pass = self.inference_handler.target_ids
+            inference_handler_to_pass = self.inference_handler
+        else:
+            target_names_to_pass = None
+            inference_handler_to_pass = None
+        
+        # Call the existing run function, passing info from the schema
+        return run_optimization(
+            problem=self.problem,
+            searcher_factory=self.searcher_factory,
+            num_generations=num_generations,
+            target_name=self.target_name,
+            save_dir=save_dir,
+            save_format=save_format,
+            # Get the definitive feature names (as a list) from the schema
+            feature_names=list(self.schema.feature_names),
+            # Get categorical info from the schema
+            categorical_map=self.schema.categorical_index_map,
+            categorical_mappings=self.schema.categorical_mappings,
+            repetitions=repetitions,
+            verbose=verbose,
+            discretize_start_at_zero=self.discretize_start_at_zero,
+            all_target_names=target_names_to_pass,
+            inference_handler=inference_handler_to_pass
+        )
+        

ml_tools/{_core/_ML_optimization.py → ML_optimization/_single_manual.py}

@@ -1,222 +1,39 @@
-import pandas # logger
+import pandas as pd
 import torch
-import numpy    #handling torch to numpy
+import numpy
 import evotorch
 from evotorch.algorithms import SNES, CEM, GeneticAlgorithm
 from evotorch.logging import PandasLogger
 from evotorch.operators import SimulatedBinaryCrossOver, GaussianMutation
-from typing import Literal, Union, Tuple, List, Optional, Any, Callable, Dict
+from typing import Literal, Union, Optional, Any, Callable
 from pathlib import Path
 from tqdm.auto import trange
 from contextlib import nullcontext
 from functools import partial
 
-from ._SQL import DragonSQL
-from ._optimization_tools import _save_result, create_optimization_bounds
-from ._utilities import save_dataframe_filename
-from ._math_utilities import discretize_categorical_values
-from ._ML_inference import DragonInferenceHandler
-from ._path_manager import make_fullpath, sanitize_filename
-from ._logger import get_logger
-from ._script_info import _script_info
-from ._keys import PyTorchInferenceKeys, MLTaskKeys
-from ._schema import FeatureSchema
+from ..SQL import DragonSQL
+from ..utilities import save_dataframe_filename
+from ..ML_inference import DragonInferenceHandler
 
+from ..math_utilities import discretize_categorical_values
+from ..path_manager import make_fullpath, sanitize_filename
+from .._core import get_logger
+from ..keys._keys import PyTorchInferenceKeys
 
-_LOGGER = get_logger("Optimizer")
+
+_LOGGER = get_logger("Optimization")
 
 
 __all__ = [
-    "DragonOptimizer",
     "FitnessEvaluator",
     "create_pytorch_problem",
-    "run_optimization"
+    "run_optimization",
+    "_save_result",
+    "_handle_pandas_log",
+    "_run_single_optimization_rep"
 ]
 
 
-class DragonOptimizer:
-    """
-    A wrapper class for setting up and running EvoTorch optimization tasks for regression models.
-
-    This class combines the functionality of `FitnessEvaluator`, `create_pytorch_problem`, and
-    `run_optimization` into a single, streamlined workflow. 
-    
-    SNES and CEM algorithms do not accept bounds, the given bounds will be used as an initial starting point.
-
-    Example:
-        >>> # 1. Define bounds for continuous features
-        >>> cont_bounds = {'feature_A': (0, 100), 'feature_B': (-10, 10)}
-        >>>
-        >>> # 2. Initialize the optimizer
-        >>> optimizer = DragonOptimizer(
-        ...     inference_handler=my_handler,
-        ...     schema=schema,
-        ...     target_name="my_target",
-        ...     continuous_bounds_map=cont_bounds,
-        ...     task="max",
-        ...     algorithm="Genetic",
-        ... )
-        >>> # 3. Run the optimization
-        >>> best_result = optimizer.run(
-        ...     num_generations=100,
-        ...     save_dir="/path/to/results",
-        ...     save_format="csv"
-        ... )
-    """
-    def __init__(self,
-                 inference_handler: DragonInferenceHandler,
-                 schema: FeatureSchema,
-                 target_name: str,
-                 continuous_bounds_map: Dict[str, Tuple[float, float]],
-                 task: Literal["min", "max"],
-                 algorithm: Literal["SNES", "CEM", "Genetic"] = "Genetic",
-                 population_size: int = 200,
-                 discretize_start_at_zero: bool = True,
-                 **searcher_kwargs):
-        """
-        Initializes the optimizer by creating the EvoTorch problem and searcher.
-
-        Args:
-            inference_handler (DragonInferenceHandler): 
-                An initialized inference handler containing the model.
-            schema (FeatureSchema): 
-                The definitive schema object from data_exploration.
-            target_name (str): 
-                target name to optimize.
-            continuous_bounds_map (Dict[str, Tuple[float, float]]):
-                A dictionary mapping the *name* of each **continuous** feature
-                to its (min_bound, max_bound) tuple.
-            task (str): The optimization goal, either "min" or "max".
-            
-            algorithm (str): The search algorithm to use ("SNES", "CEM", "Genetic").
-            population_size (int): Population size for CEM and GeneticAlgorithm.
-            discretize_start_at_zero (bool): 
-                True if the discrete encoding starts at 0 (e.g., [0, 1, 2]).
-                False if it starts at 1 (e.g., [1, 2, 3]).
-            **searcher_kwargs: Additional keyword arguments for the selected 
-                               search algorithm's constructor.
-        """
-        # --- Store schema ---
-        self.schema = schema
-        # --- Store inference handler ---
-        self.inference_handler = inference_handler
-        
-        # Ensure only Regression tasks are used
-        allowed_tasks = [MLTaskKeys.REGRESSION, MLTaskKeys.MULTITARGET_REGRESSION]
-        if self.inference_handler.task not in allowed_tasks:
-            _LOGGER.error(f"DragonOptimizer only supports {allowed_tasks}. Got '{self.inference_handler.task}'.")
-            raise ValueError(f"Invalid Task: {self.inference_handler.task}")
-        
-        # --- store target name ---
-        self.target_name = target_name
-        
-        # --- flag to control single vs multi-target ---
-        self.is_multi_target = False
-        
-        # --- 1. Create bounds from schema ---
-        # This is the robust way to get bounds
-        bounds = create_optimization_bounds(
-            schema=schema,
-            continuous_bounds_map=continuous_bounds_map,
-            start_at_zero=discretize_start_at_zero
-        )
-        
-        # Resolve target index if multi-target
-        target_index = None
-        
-        if self.inference_handler.target_ids is None:
-            # This should be caught by ML_inference logic
-            _LOGGER.error("The provided inference handler does not have 'target_ids' defined.")
-            raise ValueError()
-
-        if target_name not in self.inference_handler.target_ids:
-            _LOGGER.error(f"Target name '{target_name}' not found in the inference handler's 'target_ids': {self.inference_handler.target_ids}")
-            raise ValueError()
-
-        if len(self.inference_handler.target_ids) == 1:
-            # Single target regression
-            target_index = None
-            _LOGGER.info(f"Optimization locked to single-target model '{target_name}'.")
-        else:
-            # Multi-target regression (optimizing one specific column)
-            target_index = self.inference_handler.target_ids.index(target_name)
-            self.is_multi_target = True
-            _LOGGER.info(f"Optimization locked to target '{target_name}' (Index {target_index}) in a multi-target model.")
-        
-        # --- 2. Make a fitness function ---
-        self.evaluator = FitnessEvaluator(
-            inference_handler=inference_handler,
-            # Get categorical info from the schema
-            categorical_index_map=schema.categorical_index_map,
-            discretize_start_at_zero=discretize_start_at_zero,
-            target_index=target_index
-        )
-        
-        # --- 3. Create the problem and searcher factory ---
-        self.problem, self.searcher_factory = create_pytorch_problem(
-            evaluator=self.evaluator,
-            bounds=bounds,
-            task=task,
-            algorithm=algorithm,
-            population_size=population_size,
-            **searcher_kwargs
-        )
-        
-        # --- 4. Store other info needed by run() ---
-        self.discretize_start_at_zero = discretize_start_at_zero
-
-    def run(self,
-            num_generations: int,
-            save_dir: Union[str, Path],
-            save_format: Literal['csv', 'sqlite', 'both'],
-            repetitions: int = 1,
-            verbose: bool = True) -> Optional[dict]:
-        """
-        Runs the evolutionary optimization process using the pre-configured settings.
-
-        The `feature_names` are automatically pulled from the `FeatureSchema`
-        provided during initialization.
-
-        Args:
-            num_generations (int): The total number of generations for each repetition.
-            save_dir (str | Path): The directory where result files will be saved.
-            save_format (Literal['csv', 'sqlite', 'both']): The format for saving results.
-            repetitions (int): The number of independent times to run the optimization.
-            verbose (bool): If True, enables detailed logging.
-
-        Returns:
-            Optional[dict]: A dictionary with the best result if repetitions is 1, 
-                            otherwise None.
-        """
-        # Pass inference handler and target names for multi-target only
-        if self.is_multi_target:
-            target_names_to_pass = self.inference_handler.target_ids
-            inference_handler_to_pass = self.inference_handler
-        else:
-            target_names_to_pass = None
-            inference_handler_to_pass = None
-        
-        # Call the existing run function, passing info from the schema
-        return run_optimization(
-            problem=self.problem,
-            searcher_factory=self.searcher_factory,
-            num_generations=num_generations,
-            target_name=self.target_name,
-            save_dir=save_dir,
-            save_format=save_format,
-            # Get the definitive feature names (as a list) from the schema
-            feature_names=list(self.schema.feature_names),
-            # Get categorical info from the schema
-            categorical_map=self.schema.categorical_index_map,
-            categorical_mappings=self.schema.categorical_mappings,
-            repetitions=repetitions,
-            verbose=verbose,
-            discretize_start_at_zero=self.discretize_start_at_zero,
-            all_target_names=target_names_to_pass,
-            inference_handler=inference_handler_to_pass
-        )
-        
-        
 class FitnessEvaluator:
     """
     A callable class that wraps the PyTorch model inference handler and performs
@@ -227,7 +44,7 @@ class FitnessEvaluator:
     """
     def __init__(self,
                  inference_handler: DragonInferenceHandler,
-                 categorical_index_map: Optional[Dict[int, int]] = None,
+                 categorical_index_map: Optional[dict[int, int]] = None,
                  target_index: Optional[int] = None,
                  discretize_start_at_zero: bool = True):
         """
@@ -287,12 +104,12 @@ class FitnessEvaluator:
 
 def create_pytorch_problem(
     evaluator: FitnessEvaluator,
-    bounds: Tuple[List[float], List[float]],
+    bounds: tuple[list[float], list[float]],
     task: Literal["min", "max"],
     algorithm: Literal["SNES", "CEM", "Genetic"] = "Genetic",
     population_size: int = 200,
     **searcher_kwargs
-) -> Tuple[evotorch.Problem, Callable[[], Any]]:
+) -> tuple[evotorch.Problem, Callable[[], Any]]:
     """
     Creates and configures an EvoTorch Problem and a Searcher factory class for a PyTorch model.
     
@@ -389,13 +206,13 @@ def run_optimization(
     target_name: str,
     save_dir: Union[str, Path],
     save_format: Literal['csv', 'sqlite', 'both'],
-    feature_names: Optional[List[str]],
+    feature_names: Optional[list[str]],
     repetitions: int = 1,
     verbose: bool = True,
-    categorical_map: Optional[Dict[int, int]] = None,
-    categorical_mappings: Optional[Dict[str, Dict[str, int]]] = None,
+    categorical_map: Optional[dict[int, int]] = None,
+    categorical_mappings: Optional[dict[str, dict[str, int]]] = None,
     discretize_start_at_zero: bool = True,
-    all_target_names: Optional[List[str]] = None,
+    all_target_names: Optional[list[str]] = None,
     inference_handler: Optional[DragonInferenceHandler] = None
 ) -> Optional[dict]:
     """
@@ -563,14 +380,14 @@ def run_optimization(
 def _run_single_optimization_rep(
     searcher_factory: Callable[[],Any],
     num_generations: int,
-    feature_names: List[str],
+    feature_names: list[str],
     target_name: str,
-    categorical_map: Optional[Dict[int, int]],
+    categorical_map: Optional[dict[int, int]],
     discretize_start_at_zero: bool,
     attach_logger: bool,
-    all_target_names: List[str],
+    all_target_names: list[str],
     inference_handler: Optional[DragonInferenceHandler]
-) -> Tuple[dict, Optional[PandasLogger]]:
+) -> tuple[dict, Optional[PandasLogger]]:
     """
     Internal helper to run one full optimization repetition.
     
@@ -639,10 +456,55 @@ def _run_single_optimization_rep(
     return result_dict, pandas_logger
 
 
+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 _handle_pandas_log(logger: PandasLogger, save_path: Path, target_name: str):
     log_dataframe = logger.to_dataframe()
     save_dataframe_filename(df=log_dataframe, save_dir=save_path / "EvolutionLogs", filename=target_name)
 
-
-def info():
-    _script_info(__all__)

ml_tools/{_core → ML_scaler}/_ML_scaler.py

@@ -1,12 +1,11 @@
 import torch
 from torch.utils.data import Dataset, DataLoader
 from pathlib import Path
-from typing import Union, List, Optional
+from typing import Union, Optional
 
-from ._logger import get_logger
-from ._script_info import _script_info
-from ._path_manager import make_fullpath
-from ._keys import ScalerKeys
+from .._core import get_logger
+from ..path_manager import make_fullpath
+from ..keys._keys import ScalerKeys
 
 
 _LOGGER = get_logger("DragonScaler")
@@ -25,7 +24,7 @@ class DragonScaler:
     def __init__(self,
                  mean: Optional[torch.Tensor] = None,
                  std: Optional[torch.Tensor] = None,
-                 continuous_feature_indices: Optional[List[int]] = None):
+                 continuous_feature_indices: Optional[list[int]] = None):
         """
         Initializes the scaler.
         """
@@ -34,7 +33,7 @@ class DragonScaler:
         self.continuous_feature_indices = continuous_feature_indices
 
     @classmethod
-    def fit(cls, dataset: Dataset, continuous_feature_indices: List[int], batch_size: int = 64) -> 'DragonScaler':
+    def fit(cls, dataset: Dataset, continuous_feature_indices: list[int], batch_size: int = 64) -> 'DragonScaler':
         """
         Fits the scaler using a PyTorch Dataset (Method A) using Batched Welford's Algorithm.
         """
@@ -72,7 +71,7 @@ class DragonScaler:
             else:
                 # Batched Welford's Update
                 # Combine existing global stats (A) with new batch stats (B)
-                delta = mean_batch - mean_global
+                delta = mean_batch - mean_global # type: ignore
                 new_n_total = n_total + n_batch
                 
                 # Update M2 (Sum of Squares)
@@ -93,7 +92,7 @@ class DragonScaler:
         # Unbiased estimator (divide by n-1)
         if n_total < 2:
             _LOGGER.warning(f"Only one sample found. Standard deviation set to 1.")
-            std = torch.ones_like(mean_global)
+            std = torch.ones_like(mean_global) # type: ignore
         else:
             variance = m2_global / (n_total - 1)
             std = torch.sqrt(torch.clamp(variance, min=1e-8))
@@ -218,5 +217,3 @@ class DragonScaler:
             return f"DragonScaler(fitted for {num_features} columns)"
         return "DragonScaler(not fitted)"
 
-def info():
-    _script_info(__all__)

ml_tools/ML_scaler/__init__.py

@@ -0,0 +1,10 @@
+from ._ML_scaler import (
+    DragonScaler
+)
+
+from ._imprimir import info
+
+
+__all__ = [
+    "DragonScaler"
+]

ml_tools/ML_scaler/_imprimir.py

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

ml_tools/ML_trainer/__init__.py

@@ -0,0 +1,20 @@
+from ._dragon_trainer import (
+    DragonTrainer
+)
+
+from ._dragon_sequence_trainer import (
+    DragonSequenceTrainer
+)
+
+from ._dragon_detection_trainer import (
+    DragonDetectionTrainer
+)
+
+from ._imprimir import info
+
+
+__all__ = [
+    "DragonTrainer",
+    "DragonSequenceTrainer",
+    "DragonDetectionTrainer",
+]