statslibx 0.1.5__py3-none-any.whl → 0.1.6__py3-none-any.whl

statslibx/utils.py

@@ -61,9 +61,9 @@ class UtilsStats:
         plt.rcParams['figure.figsize'] = [figsize[0], figsize[1]]
     
     def set_save_fig_options(self, save_fig: Optional[bool] = False, 
-                           fig_format: str = 'png', 
-                           fig_dpi: int = 300,
-                           figures_dir: str = 'figures'):
+                            fig_format: str = 'png', 
+                            fig_dpi: int = 300,
+                            figures_dir: str = 'figures'):
         """Configurar opciones para guardar figuras"""
         self._save_fig = save_fig
         self._fig_format = fig_format
@@ -163,7 +163,7 @@ class UtilsStats:
             raise Exception(f"Error al cargar el archivo {path}: {str(e)}")
 
     def _resolve_data(self, data: Union[pd.DataFrame, pd.Series, np.ndarray, list, str, Path],
-                     column: Optional[str] = None) -> Tuple[Union[pd.DataFrame, pd.Series, np.ndarray], str]:
+                        column: Optional[str] = None) -> Tuple[Union[pd.DataFrame, pd.Series, np.ndarray], str]:
         """
         Resuelve el input de datos: si es una ruta, carga el archivo; si no, usa los datos directamente
         
@@ -219,9 +219,9 @@ class UtilsStats:
         return f"{num:.{decimals}f}"
 
     def check_normality(self, 
-                       data: Union[pd.Series, np.ndarray, pd.DataFrame, str, Path], 
-                       column: Optional[str] = None,
-                       alpha: float = 0.05) -> dict:
+                        data: Union[pd.Series, np.ndarray, pd.DataFrame, str, Path], 
+                        column: Optional[str] = None,
+                        alpha: float = 0.05) -> dict:
         """
         Verifica si los datos siguen distribución normal usando Shapiro-Wilk
         
@@ -265,10 +265,10 @@ class UtilsStats:
         }
 
     def calculate_confidence_intervals(self, 
-                                     data: Union[pd.Series, np.ndarray, pd.DataFrame, str, Path],
-                                     column: Optional[str] = None,
-                                     confidence_level: float = 0.95,
-                                     method: str = 'parametric') -> dict:
+                                        data: Union[pd.Series, np.ndarray, pd.DataFrame, str, Path],
+                                        column: Optional[str] = None,
+                                        confidence_level: float = 0.95,
+                                        method: str = 'parametric') -> dict:
         """
         Calcula intervalos de confianza para la media
         
@@ -338,10 +338,10 @@ class UtilsStats:
         }
 
     def detect_outliers(self, 
-                       data: Union[pd.Series, np.ndarray, pd.DataFrame, str, Path],
-                       column: Optional[str] = None,
-                       method: Literal['iqr', 'zscore', 'isolation_forest'] = 'iqr',
-                       **kwargs) -> np.ndarray:
+                        data: Union[pd.Series, np.ndarray, pd.DataFrame, str, Path],
+                        column: Optional[str] = None,
+                        method: Literal['iqr', 'zscore', 'isolation_forest'] = 'iqr',
+                        **kwargs) -> np.ndarray:
         """
         Detecta outliers usando diferentes métodos
         
@@ -399,7 +399,7 @@ class UtilsStats:
         return outliers
 
     def calculate_effect_size(self, group1: np.ndarray, group2: np.ndarray, 
-                             method: Literal['cohen', 'hedges'] = 'cohen') -> dict:
+                                method: Literal['cohen', 'hedges'] = 'cohen') -> dict:
         """
         Calcula el tamaño del efecto entre dos grupos
         """
@@ -530,15 +530,15 @@ class UtilsStats:
         return fig
 
     def plot_distribution(self, 
-                         data: Union[pd.DataFrame, pd.Series, np.ndarray, str, Path],
-                         column: Optional[str] = None,
-                         plot_type: Literal['hist', 'kde', 'box', 'violin', 'all'] = 'hist',
-                         backend: Optional[Literal['matplotlib', 'seaborn', 'plotly']] = "seaborn",
-                         bins: int = 30,
-                         figsize: Optional[Tuple[int, int]] = None,
-                         save_fig: Optional[bool] = None,
-                         filename: Optional[str] = None,
-                         **kwargs):
+                            data: Union[pd.DataFrame, pd.Series, np.ndarray, str, Path],
+                            column: Optional[str] = None,
+                            plot_type: Literal['hist', 'kde', 'box', 'violin', 'all'] = 'hist',
+                            backend: Optional[Literal['matplotlib', 'seaborn', 'plotly']] = "seaborn",
+                            bins: int = 30,
+                            figsize: Optional[Tuple[int, int]] = None,
+                            save_fig: Optional[bool] = None,
+                            filename: Optional[str] = None,
+                            **kwargs):
         """
         Graficar distribución de una variable
         
@@ -653,13 +653,13 @@ class UtilsStats:
         return fig
 
     def plot_correlation_matrix(self, 
-                               data: Union[pd.DataFrame, str, Path],
-                               method: str = 'pearson',
-                               backend: Optional[Literal['seaborn', 'plotly']] = None,
-                               figsize: Optional[Tuple[int, int]] = None,
-                               save_fig: Optional[bool] = None,
-                               filename: Optional[str] = None,
-                               **kwargs):
+                                data: Union[pd.DataFrame, str, Path],
+                                method: str = 'pearson',
+                                backend: Optional[Literal['seaborn', 'plotly']] = None,
+                                figsize: Optional[Tuple[int, int]] = None,
+                                save_fig: Optional[bool] = None,
+                                filename: Optional[str] = None,
+                                **kwargs):
         """
         Visualizar matriz de correlación
         
@@ -691,8 +691,8 @@ class UtilsStats:
             mask = np.triu(np.ones_like(corr_matrix, dtype=bool))
             
             sns.heatmap(corr_matrix, mask=mask, annot=True, fmt='.2f', 
-                       cmap='coolwarm', center=0, ax=ax,
-                       square=True, linewidths=0.5, **kwargs)
+                        cmap='coolwarm', center=0, ax=ax,
+                        square=True, linewidths=0.5, **kwargs)
             ax.set_title(f'Matriz de Correlación ({method})', fontsize=14, pad=20)
             plt.tight_layout()
             
@@ -735,13 +735,13 @@ class UtilsStats:
         return fig
 
     def plot_scatter_matrix(self, 
-                           data: Union[pd.DataFrame, str, Path],
-                           columns: Optional[List[str]] = None,
-                           backend: Optional[Literal['seaborn', 'plotly', 'pandas']] = None,
-                           figsize: Optional[Tuple[int, int]] = None,
-                           save_fig: Optional[bool] = None,
-                           filename: Optional[str] = None,
-                           **kwargs):
+                            data: Union[pd.DataFrame, str, Path],
+                            columns: Optional[List[str]] = None,
+                            backend: Optional[Literal['seaborn', 'plotly', 'pandas']] = None,
+                            figsize: Optional[Tuple[int, int]] = None,
+                            save_fig: Optional[bool] = None,
+                            filename: Optional[str] = None,
+                            **kwargs):
         """
         Matriz de gráficos de dispersión (pairplot)
         
@@ -796,15 +796,15 @@ class UtilsStats:
     # ============= GRÁFICOS CON INTERVALOS DE CONFIANZA =============
 
     def plot_distribution_with_ci(self,
-                               data: Union[pd.DataFrame, pd.Series, np.ndarray, str, Path],
-                               column: Optional[str] = None,
-                               confidence_level: float = 0.95,
-                               ci_method: str = 'parametric',
-                               bins: int = 30,
-                               figsize: Optional[Tuple[int, int]] = None,
-                               save_fig: Optional[bool] = None,
-                               filename: Optional[str] = None,
-                               **kwargs) -> plt.Figure:
+                                data: Union[pd.DataFrame, pd.Series, np.ndarray, str, Path],
+                                column: Optional[str] = None,
+                                confidence_level: float = 0.95,
+                                ci_method: str = 'parametric',
+                                bins: int = 30,
+                                figsize: Optional[Tuple[int, int]] = None,
+                                save_fig: Optional[bool] = None,
+                                filename: Optional[str] = None,
+                                **kwargs) -> plt.Figure:
         """
         Distribución con intervalos de confianza
         
@@ -911,12 +911,12 @@ class UtilsStats:
 
 
     def plot_multiple_distributions_with_ci(self, 
-                                           data_dict: dict,
-                                           confidence_level: float = 0.95,
-                                           figsize: Optional[Tuple[int, int]] = None,
-                                           save_fig: Optional[bool] = None,
-                                           filename: Optional[str] = None,
-                                           **kwargs) -> plt.Figure:
+                                            data_dict: dict,
+                                            confidence_level: float = 0.95,
+                                            figsize: Optional[Tuple[int, int]] = None,
+                                            save_fig: Optional[bool] = None,
+                                            filename: Optional[str] = None,
+                                            **kwargs) -> plt.Figure:
         """
         Grafica múltiples distribuciones con sus intervalos de confianza
         """
@@ -960,7 +960,7 @@ class UtilsStats:
             
             ax2.axvline(ci_result['mean'], color='red', linestyle='-', linewidth=3)
             ax2.axvspan(ci_result['ci_lower'], ci_result['ci_upper'], 
-                       alpha=0.3, color='orange')
+                        alpha=0.3, color='orange')
             ax2.axvline(ci_result['ci_lower'], color='orange', linestyle='--', linewidth=2)
             ax2.axvline(ci_result['ci_upper'], color='orange', linestyle='--', linewidth=2)
             
@@ -980,8 +980,8 @@ class UtilsStats:
     # ============= MÉTODOS UTILITARIOS ADICIONALES =============
 
     def get_descriptive_stats(self, 
-                             data: Union[pd.DataFrame, pd.Series, np.ndarray, str, Path],
-                             column: Optional[str] = None) -> dict:
+                                data: Union[pd.DataFrame, pd.Series, np.ndarray, str, Path],
+                                column: Optional[str] = None) -> dict:
         """
         Obtiene estadísticas descriptivas completas
         
@@ -1016,4 +1016,371 @@ class UtilsStats:
             'skewness': stats.skew(data_clean),
             'kurtosis': stats.kurtosis(data_clean),
             'range': np.max(data_clean) - np.min(data_clean)
-        }
+        }
+
+    def help(self):
+        """
+        Muestra ayuda completa de la clase DescriptiveStats
+        """
+        help_text = """
+╔════════════════════════════════════════════════════════════════════════════╗
+║                    📊 CLASE UtilsStats - AYUDA COMPLETA                    ║
+╚════════════════════════════════════════════════════════════════════════════╝
+
+📝 DESCRIPCIÓN:
+   Clase para análisis estadístico descriptivo univariado y multivariado.
+   Proporciona herramientas para análisis exploratorio de datos, medidas de
+   tendencia central, dispersión, forma de distribución y regresión lineal.
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+📋 MÉTODOS PRINCIPALES:
+
+┌────────────────────────────────────────────────────────────────────────────┐
+│ 1. 📊 ANÁLISIS ESTADÍSTICO                                                 │
+└────────────────────────────────────────────────────────────────────────────┘
+
+  • .check_normality(data, alpha=0.05)
+    Verifica normalidad usando test Shapiro-Wilk
+    Retorna: dict con estadístico, p-value e interpretación
+
+  • .calculate_confidence_intervals(data, confidence_level=0.95, 
+                                   method='parametric')
+    Calcula intervalos de confianza para la media
+    Métodos: 'parametric' o 'bootstrap'
+
+  • .detect_outliers(data, method='iqr', **kwargs)
+    Detecta valores atípicos
+    Métodos: 'iqr', 'zscore', 'isolation_forest'
+
+  • .calculate_effect_size(group1, group2, method='cohen')
+    Calcula tamaño del efecto entre grupos
+    Métodos: 'cohen' (Cohen's d) o 'hedges' (Hedges' g)
+
+  • .get_descriptive_stats(data, column=None)
+    Estadísticas descriptivas completas en un dict
+
+┌────────────────────────────────────────────────────────────────────────────┐
+│ 2. 🎨 VISUALIZACIÓN DE DISTRIBUCIONES                                      │
+└────────────────────────────────────────────────────────────────────────────┘
+
+  • .plot_distribution(data, column=None, plot_type='hist', 
+                      backend='seaborn', bins=30, figsize=None, 
+                      save_fig=None, filename=None)
+    
+    Grafica distribución de una variable
+    
+    plot_type: 'hist', 'kde', 'box', 'violin', 'all'
+    backend: 'matplotlib', 'seaborn', 'plotly'
+
+  • .plot_distribution_with_ci(data, column=None, confidence_level=0.95,
+                               ci_method='parametric', bins=30, figsize=None,
+                               save_fig=None, filename=None)
+    
+    Distribución con intervalos de confianza visualizados
+
+  • .plot_multiple_distributions_with_ci(data_dict, confidence_level=0.95)
+    
+    Compara múltiples distribuciones con sus IC
+
+┌────────────────────────────────────────────────────────────────────────────┐
+│ 3. 🎨 VISUALIZACIÓN MULTIVARIADA                                           │
+└────────────────────────────────────────────────────────────────────────────┘
+
+  • .plot_correlation_matrix(data, method='pearson', backend='seaborn',
+                            figsize=None, save_fig=None)
+    
+    Matriz de correlación con heatmap
+    Métodos: 'pearson', 'spearman', 'kendall'
+
+  • .plot_scatter_matrix(data, columns=None, backend='seaborn',
+                        figsize=None, save_fig=None)
+    
+    Matriz de gráficos de dispersión (pairplot)
+    Backends: 'seaborn', 'plotly', 'pandas'
+
+┌────────────────────────────────────────────────────────────────────────────┐
+│ 4. ⚙️  CONFIGURACIÓN                                                       │
+└────────────────────────────────────────────────────────────────────────────┘
+
+  • .set_plot_backend(backend)
+    Establece backend por defecto: 'matplotlib', 'seaborn', 'plotly'
+
+  • .set_default_figsize(figsize)
+    Establece tamaño de figura por defecto: (ancho, alto)
+
+  • .set_save_fig_options(save_fig=False, fig_format='png', 
+                         fig_dpi=300, figures_dir='figures')
+    
+    Configura guardado automático de figuras
+
+┌────────────────────────────────────────────────────────────────────────────┐
+│ 5. 🛠️  UTILIDADES                                                          │
+└────────────────────────────────────────────────────────────────────────────┘
+
+  • .validate_dataframe(data)
+    Valida y convierte datos a DataFrame
+
+  • .format_number(num, decimals=6, scientific=False)
+    Formatea números con precisión específica
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+💡 EJEMPLOS DE USO:
+
+  ┌─ Ejemplo 1: Configuración Inicial ──────────────────────────────────────┐
+  │ from utils import UtilsStats                                            │
+  │ import pandas as pd                                                      │
+  │ import numpy as np                                                       │
+  │                                                                          │
+  │ # Inicializar                                                            │
+  │ utils = UtilsStats()                                                    │
+  │                                                                          │
+  │ # Configurar visualización                                               │
+  │ utils.set_plot_backend('seaborn')                                       │
+  │ utils.set_default_figsize((12, 6))                                      │
+  │                                                                          │
+  │ # Configurar guardado automático                                         │
+  │ utils.set_save_fig_options(                                             │
+  │     save_fig=True,                                                      │
+  │     fig_format='png',                                                   │
+  │     fig_dpi=300,                                                        │
+  │     figures_dir='mis_graficos'                                          │
+  │ )                                                                        │
+  └──────────────────────────────────────────────────────────────────────────┘
+
+  ┌─ Ejemplo 2: Análisis de Normalidad ─────────────────────────────────────┐
+  │ # Generar datos                                                          │
+  │ datos_normales = np.random.normal(0, 1, 1000)                           │
+  │ datos_no_normales = np.random.exponential(2, 1000)                      │
+  │                                                                          │
+  │ # Test de normalidad                                                     │
+  │ resultado1 = utils.check_normality(datos_normales)                      │
+  │ print(f"Normales: {resultado1['interpretation']}")                      │
+  │ print(f"p-value: {resultado1['shapiro_pvalue']:.4f}")                   │
+  │                                                                          │
+  │ resultado2 = utils.check_normality(datos_no_normales)                   │
+  │ print(f"No normales: {resultado2['interpretation']}")                   │
+  └──────────────────────────────────────────────────────────────────────────┘
+
+  ┌─ Ejemplo 3: Intervalos de Confianza ────────────────────────────────────┐
+  │ # Método paramétrico                                                     │
+  │ ci_param = utils.calculate_confidence_intervals(                        │
+  │     datos_normales,                                                     │
+  │     confidence_level=0.95,                                              │
+  │     method='parametric'                                                 │
+  │ )                                                                        │
+  │                                                                          │
+  │ print(f"Media: {ci_param['mean']:.3f}")                                 │
+  │ print(f"IC 95%: [{ci_param['ci_lower']:.3f}, "                          │
+  │       f"{ci_param['ci_upper']:.3f}]")                                   │
+  │                                                                          │
+  │ # Método bootstrap (para datos no normales)                              │
+  │ ci_boot = utils.calculate_confidence_intervals(                         │
+  │     datos_no_normales,                                                  │
+  │     confidence_level=0.95,                                              │
+  │     method='bootstrap'                                                  │
+  │ )                                                                        │
+  └──────────────────────────────────────────────────────────────────────────┘
+
+  ┌─ Ejemplo 4: Detección de Outliers ──────────────────────────────────────┐
+  │ # Método IQR (rango intercuartílico)                                     │
+  │ datos = np.random.normal(100, 15, 1000)                                 │
+  │ datos = np.append(datos, [200, 210, -50])  # Agregar outliers           │
+  │                                                                          │
+  │ outliers_iqr = utils.detect_outliers(datos, method='iqr')               │
+  │ print(f"Outliers IQR: {outliers_iqr.sum()}")                            │
+  │                                                                          │
+  │ # Método Z-score                                                         │
+  │ outliers_z = utils.detect_outliers(                                     │
+  │     datos,                                                              │
+  │     method='zscore',                                                    │
+  │     threshold=3                                                         │
+  │ )                                                                        │
+  │ print(f"Outliers Z-score: {outliers_z.sum()}")                          │
+  │                                                                          │
+  │ # Isolation Forest (machine learning)                                    │
+  │ outliers_if = utils.detect_outliers(                                    │
+  │     datos,                                                              │
+  │     method='isolation_forest',                                          │
+  │     contamination=0.05                                                  │
+  │ )                                                                        │
+  └──────────────────────────────────────────────────────────────────────────┘
+
+  ┌─ Ejemplo 5: Tamaño del Efecto ──────────────────────────────────────────┐
+  │ # Comparar dos grupos                                                    │
+  │ grupo_control = np.random.normal(100, 15, 100)                          │
+  │ grupo_tratamiento = np.random.normal(110, 15, 100)                      │
+  │                                                                          │
+  │ efecto = utils.calculate_effect_size(                                   │
+  │     grupo_control,                                                      │
+  │     grupo_tratamiento,                                                  │
+  │     method='cohen'                                                      │
+  │ )                                                                        │
+  │                                                                          │
+  │ print(f"Cohen's d: {efecto['effect_size']:.3f}")                        │
+  │ print(f"Interpretación: {efecto['interpretation']}")                    │
+  │ print(f"Diferencia de medias: {efecto['mean_diff']:.2f}")               │
+  └──────────────────────────────────────────────────────────────────────────┘
+
+  ┌─ Ejemplo 6: Gráficos de Distribución ───────────────────────────────────┐
+  │ df = pd.DataFrame({                                                      │
+  │     'edad': np.random.normal(35, 10, 500),                              │
+  │     'salario': np.random.lognormal(10.5, 0.5, 500)                      │
+  │ })                                                                       │
+  │                                                                          │
+  │ # Histograma simple                                                      │
+  │ fig1 = utils.plot_distribution(                                         │
+  │     df,                                                                 │
+  │     column='edad',                                                      │
+  │     plot_type='hist',                                                   │
+  │     bins=30                                                             │
+  │ )                                                                        │
+  │                                                                          │
+  │ # Panel completo (histograma, box, violin, Q-Q)                          │
+  │ fig2 = utils.plot_distribution(                                         │
+  │     df,                                                                 │
+  │     column='salario',                                                   │
+  │     plot_type='all',                                                    │
+  │     backend='seaborn'                                                   │
+  │ )                                                                        │
+  │                                                                          │
+  │ # Con Plotly (interactivo)                                               │
+  │ fig3 = utils.plot_distribution(                                         │
+  │     df,                                                                 │
+  │     column='edad',                                                      │
+  │     plot_type='violin',                                                 │
+  │     backend='plotly'                                                    │
+  │ )                                                                        │
+  └──────────────────────────────────────────────────────────────────────────┘
+
+  ┌─ Ejemplo 7: Distribución con Intervalos de Confianza ───────────────────┐
+  │ # Visualizar distribución con IC                                         │
+  │ fig = utils.plot_distribution_with_ci(                                  │
+  │     df,                                                                 │
+  │     column='edad',                                                      │
+  │     confidence_level=0.95,                                              │
+  │     ci_method='parametric',                                             │
+  │     bins=30,                                                            │
+  │     save_fig=True,                                                      │
+  │     filename='edad_con_ic'                                              │
+  │ )                                                                        │
+  │                                                                          │
+  │ # Comparar múltiples distribuciones                                      │
+  │ data_dict = {                                                            │
+  │     'Grupo A': df['edad'][:200],                                        │
+  │     'Grupo B': df['edad'][200:400],                                     │
+  │     'Grupo C': df['edad'][400:]                                         │
+  │ }                                                                        │
+  │                                                                          │
+  │ fig = utils.plot_multiple_distributions_with_ci(                        │
+  │     data_dict,                                                          │
+  │     confidence_level=0.95                                               │
+  │ )                                                                        │
+  └──────────────────────────────────────────────────────────────────────────┘
+
+  ┌─ Ejemplo 8: Matriz de Correlación ──────────────────────────────────────┐
+  │ # Crear datos correlacionados                                            │
+  │ df = pd.DataFrame({                                                      │
+  │     'A': np.random.normal(0, 1, 100),                                   │
+  │     'B': np.random.normal(0, 1, 100),                                   │
+  │     'C': np.random.normal(0, 1, 100)                                    │
+  │ })                                                                       │
+  │ df['D'] = df['A'] * 0.8 + np.random.normal(0, 0.2, 100)                │
+  │                                                                          │
+  │ # Matriz de correlación con seaborn                                      │
+  │ fig = utils.plot_correlation_matrix(                                    │
+  │     df,                                                                 │
+  │     method='pearson',                                                   │
+  │     backend='seaborn',                                                  │
+  │     figsize=(10, 8)                                                     │
+  │ )                                                                        │
+  │                                                                          │
+  │ # Con Plotly (interactiva)                                               │
+  │ fig = utils.plot_correlation_matrix(                                    │
+  │     df,                                                                 │
+  │     method='spearman',                                                  │
+  │     backend='plotly'                                                    │
+  │ )                                                                        │
+  └──────────────────────────────────────────────────────────────────────────┘
+
+  ┌─ Ejemplo 9: Matriz de Dispersión ───────────────────────────────────────┐
+  │ # Pairplot completo                                                      │
+  │ fig = utils.plot_scatter_matrix(                                        │
+  │     df,                                                                 │
+  │     columns=['A', 'B', 'C', 'D'],                                       │
+  │     backend='seaborn'                                                   │
+  │ )                                                                        │
+  │                                                                          │
+  │ # Con Plotly                                                             │
+  │ fig = utils.plot_scatter_matrix(                                        │
+  │     df,                                                                 │
+  │     backend='plotly'                                                    │
+  │ )                                                                        │
+  └──────────────────────────────────────────────────────────────────────────┘
+
+  ┌─ Ejemplo 10: Estadísticas Descriptivas Completas ───────────────────────┐
+  │ # Obtener todas las estadísticas                                         │
+  │ stats = utils.get_descriptive_stats(df, column='edad')                  │
+  │                                                                          │
+  │ print(f"Media: {stats['mean']:.2f}")                                    │
+  │ print(f"Mediana: {stats['median']:.2f}")                                │
+  │ print(f"Desv. Est.: {stats['std']:.2f}")                                │
+  │ print(f"IQR: {stats['iqr']:.2f}")                                       │
+  │ print(f"Asimetría: {stats['skewness']:.3f}")                            │
+  │ print(f"Curtosis: {stats['kurtosis']:.3f}")                             │
+  └──────────────────────────────────────────────────────────────────────────┘
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+🎯 CARACTERÍSTICAS CLAVE:
+
+  ✓ Múltiples backends de visualización (matplotlib, seaborn, plotly)
+  ✓ Guardado automático de figuras en alta resolución
+  ✓ Análisis estadísticos robustos
+  ✓ Detección de outliers con 3 métodos
+  ✓ Intervalos de confianza paramétricos y bootstrap
+  ✓ Visualizaciones profesionales listas para publicación
+  ✓ Manejo automático de valores faltantes
+  ✓ Integración perfecta con pandas y numpy
+  ✓ Gráficos interactivos con Plotly
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+📊 BACKENDS DE VISUALIZACIÓN:
+
+  🔹 Matplotlib:
+     • Rápido y ligero
+     • Ideal para gráficos simples
+     • Mejor para exportar a archivos
+
+  🔹 Seaborn:
+     • Gráficos estadísticos elegantes
+     • Temas predefinidos atractivos
+     • Mejor para análisis exploratorio
+
+  🔹 Plotly:
+     • Gráficos interactivos
+     • Zoom, pan, hover tooltips
+     • Ideal para presentaciones y dashboards
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+💡 CONSEJOS Y MEJORES PRÁCTICAS:
+
+  1. Siempre verificar normalidad antes de usar métodos paramétricos
+  2. Usar bootstrap para IC cuando los datos no son normales
+  3. Detectar outliers antes de calcular estadísticas
+  4. Guardar figuras en alta resolución (300 DPI) para publicaciones
+  5. Usar Plotly para presentaciones interactivas
+  6. Usar seaborn para análisis exploratorio rápido
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+📚 DOCUMENTACIÓN ADICIONAL:
+   Para más información sobre métodos específicos, use:
+   help(UtilsStats.nombre_metodo)
+
+╚════════════════════════════════════════════════════════════════════════════╝
+    """
+        print(help_text)

{statslibx-0.1.5.dist-info → statslibx-0.1.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: statslibx
-Version: 0.1.5
+Version: 0.1.6
 Summary: Librería de estadística descriptiva e inferencial para Python
 Home-page: https://github.com/Immanuel3008/StatsLibX
 Author: Emmanuel Ascendra Perez

{statslibx-0.1.5.dist-info → statslibx-0.1.6.dist-info}/RECORD

@@ -1,14 +1,14 @@
-statslibx/__init__.py,sha256=KVRs6x_NAlnosyfyPpWHA-8ZpGqekwL7sbGcbvuP0rg,1173
-statslibx/descriptive.py,sha256=3bZswmyB2NxVjSPrj7l4P0cko77sKeN7zMT8gx5x5I4,38051
-statslibx/inferential.py,sha256=gpd9ek5cKo3kUCcKFTwq9tVHTmRYFoBvlcNf2EGRRCM,49310
-statslibx/utils.py,sha256=nmOLyRVlI35A-S0AcBgePtR_ezeYkFxG9--fqY920_A,40545
+statslibx/__init__.py,sha256=gA9uNJ7Th8mJunugVps8UWgBNJtMeo_mHqU-QSkEXQE,1173
+statslibx/descriptive.py,sha256=Hjti-Cs-7-SzrTb0k4s92c4nasLthVwhYU75GS56LAc,40124
+statslibx/inferential.py,sha256=0lpVAp2SiKDgWkH3z3JoVFAjMaXW2VboxtA2vwPwq04,49947
+statslibx/utils.py,sha256=qDqF_XgvEJbdQURA2v0gF0sw0nNQR4-MFXDvVTl_00s,68480
 statslibx/datasets/__init__.py,sha256=wQ4p8hXIhJqV-msWzTvvnbv-l7jyWz5Rn3JZyMSYJ44,452
 statslibx/datasets/course_completion.csv,sha256=jaqyxAh4YCsYuH5OFsjvGV7KUyM_7vQt6LgnqnNAFsI,22422135
 statslibx/datasets/iris.csv,sha256=xSdC5QMVqZ-Vajg_rt91dVUmdfZAnvD5pHB23QhHmTA,3858
 statslibx/datasets/penguins.csv,sha256=4HY2vYr3QmAJnqL4Z44uq7813vV5lAzHb2cGHuFsBsE,13478
 statslibx/datasets/sp500_companies.csv,sha256=WKS72YOGnAbyLR6kD95fOpIYZt5oXGjPryyFVqLRF_k,803820
 statslibx/datasets/titanic.csv,sha256=5seOS8ybyBMBCCWhgKZrsbu06m_OWyKtD9l0YXOImXU,29474
-statslibx-0.1.5.dist-info/METADATA,sha256=osEyU9pI4kjUMqjiCKUOkTpEGKiACgVaWp9b7mt3c6s,2943
-statslibx-0.1.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-statslibx-0.1.5.dist-info/top_level.txt,sha256=eeYZXyFm0hIjuI0ba3wF6XW938Mv9tv7Nk9qgjYfCtU,10
-statslibx-0.1.5.dist-info/RECORD,,
+statslibx-0.1.6.dist-info/METADATA,sha256=7djbcDCGKwPIIjMnF3hjrsjpgeJFUYxEO9zrVTayUj0,2943
+statslibx-0.1.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+statslibx-0.1.6.dist-info/top_level.txt,sha256=eeYZXyFm0hIjuI0ba3wF6XW938Mv9tv7Nk9qgjYfCtU,10
+statslibx-0.1.6.dist-info/RECORD,,