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

statslibx/descriptive.py

@@ -2,6 +2,13 @@ import numpy as np
 import pandas as pd
 from typing import Optional, Union, Literal, List
 from datetime import datetime
+import flet as ft
+import os
+import matplotlib.pyplot as plt
+import seaborn as sns
+import io
+import base64
+import plotly.express as px
 
 class DescriptiveStats:
     """
@@ -20,6 +27,10 @@ class DescriptiveStats:
         backend : str
             'pandas' o 'polars' para procesamiento
         """
+
+        if isinstance(data, str) and os.path.exists(data):
+                data = DescriptiveStats.from_file(data).data
+
         if isinstance(data, np.ndarray):
             if data.ndim == 1:
                 data = pd.DataFrame({'var': data})
@@ -29,6 +40,40 @@ class DescriptiveStats:
         self.data = data
         self.backend = backend
         self._numeric_cols = data.select_dtypes(include=[np.number]).columns.tolist()
+    
+    @staticmethod
+    def from_file(path: str):
+        """
+        Carga automática de archivos y devuelve instancia de Intelligence.
+        Soporta CSV, Excel, TXT, JSON, Parquet, Feather, TSV.
+        """
+        if not os.path.exists(path):
+            raise FileNotFoundError(f"Archivo no encontrado: {path}")
+
+        ext = os.path.splitext(path)[1].lower()
+
+        if ext == ".csv":
+            df = pd.read_csv(path)
+
+        elif ext in [".xlsx", ".xls"]:
+            df = pd.read_excel(path)
+
+        elif ext in [".txt", ".tsv"]:
+            df = pd.read_table(path)
+
+        elif ext == ".json":
+            df = pd.read_json(path)
+
+        elif ext == ".parquet":
+            df = pd.read_parquet(path)
+
+        elif ext == ".feather":
+            df = pd.read_feather(path)
+
+        else:
+            raise ValueError(f"Formato no soportado: {ext}")
+
+        return DescriptiveStats(df)
         
     # ============= MÉTODOS UNIVARIADOS =============
     
@@ -174,137 +219,58 @@ class DescriptiveStats:
     # ============= REGRESIÓN LINEAL =============
     
     def linear_regression(self, 
-                         y: str,
-                         X: Union[str, List[str]],
-                         engine: Literal['statsmodels', 'scikit-learn'] = 'statsmodels',
-                         fit_intercept: bool = True,
-                         show_plot: bool = False,
-                         plot_backend: str = 'seaborn',
-                         handle_missing: Literal['drop', 'error', 'warn'] = 'drop') -> 'LinearRegressionResult':
+                        X: Union[str, List[str]], 
+                        y: str,
+                        engine: Literal['statsmodels', 'scikit-learn'] = 'statsmodels',
+                        fit_intercept: bool = True,
+                        show_plot: bool = False,
+                        plot_backend: str = 'seaborn',
+                        handle_missing: Literal['drop', 'error', 'warn'] = 'drop') -> tuple:
         """
-        Regresión lineal simple o múltiple
-        
-        Parameters:
-        -----------
-        y : str
-            Variable dependiente
-        X : str o list
-            Variable(s) independiente(s)
-        engine : str
-            'statsmodels' o 'scikit-learn'
-        fit_intercept : bool
-            Si incluir intercepto
-        show_plot : bool
-            Mostrar gráficos diagnósticos
-        plot_backend : str
-            Backend para visualización
-        
-        Returns:
-        --------
-        LinearRegressionResult
-            Objeto con resultados y método summary()
+        Regresión lineal simple o múltiple con opción de mostrar gráfico.
+        Siempre devuelve un tuple: (LinearRegressionResult, figura o None)
         """
         if isinstance(X, str):
             X = [X]
-        
-        # Verificar que las columnas existen
-        missing_columns = []
-        if y not in self.data.columns:
-            missing_columns.append(y)
-        for x_col in X:
-            if x_col not in self.data.columns:
-                missing_columns.append(x_col)
-        
+
+        # Verificar columnas
+        missing_columns = [col for col in [y] + X if col not in self.data.columns]
         if missing_columns:
             raise ValueError(f"Columnas no encontradas: {missing_columns}")
-        
-        # Crear DataFrame con solo las columnas necesarias
+
+        # Preparar datos
         regression_data = self.data[[y] + X].copy()
-        
-        # Manejar valores infinitos
         numeric_cols = regression_data.select_dtypes(include=[np.number]).columns
         for col in numeric_cols:
-            if regression_data[col].dtype in [np.float64, np.float32, np.float16]:
-                inf_mask = np.isinf(regression_data[col])
-                if inf_mask.any():
-                    print(f"Advertencia: Columna '{col}' tiene {inf_mask.sum()} valores infinitos. Serán convertidos a NaN.")
-                    regression_data[col] = regression_data[col].replace([np.inf, -np.inf], np.nan)
-        
-        # Manejar valores faltantes
-        missing_before = regression_data.isnull().sum()
-        total_missing = missing_before.sum()
-        
-        if total_missing > 0:
-            missing_info = "\n".join([f"  - {col}: {missing_before[col]} missing" 
-                                    for col in missing_before[missing_before > 0].index])
-            
+            regression_data[col] = regression_data[col].replace([np.inf, -np.inf], np.nan)
+
+        # Manejo de valores faltantes
+        if regression_data.isnull().any().any():
             if handle_missing == 'error':
-                raise ValueError(f"Datos contienen valores faltantes:\n{missing_info}")
-            
-            elif handle_missing == 'warn':
-                print(f"Advertencia: Datos contienen {total_missing} valores faltantes:\n{missing_info}")
-                print("Eliminando filas con valores faltantes...")
-                regression_data_clean = regression_data.dropna()
-            
-            elif handle_missing == 'drop':
-                regression_data_clean = regression_data.dropna()
-                
-            else:
-                raise ValueError(f"Método de manejo de missing values no reconocido: {handle_missing}")
-            
-            # Informar sobre la limpieza
-            rows_before = len(regression_data)
-            rows_after = len(regression_data_clean)
-            rows_removed = rows_before - rows_after
-            
-            if rows_removed > 0:
-                print(f"Limpieza de datos: {rows_removed} filas eliminadas ({rows_after} filas restantes)")
-                
-                if rows_after < len(X) + 1:  # +1 para el intercepto
-                    raise ValueError(
-                        f"Muy pocas filas después de limpieza: {rows_after}. "
-                        f"Se necesitan al menos {len(X) + 1} filas para regresión."
-                    )
-        else:
-            regression_data_clean = regression_data
-        
-        # Extraer datos limpios
-        X_data = regression_data_clean[X].values
-        y_data = regression_data_clean[y].values
-        
-        # Validar que los datos son numéricos
-        if not np.issubdtype(X_data.dtype, np.number):
-            raise ValueError("Las variables independientes deben ser numéricas")
-        if not np.issubdtype(y_data.dtype, np.number):
-            raise ValueError("La variable dependiente debe ser numérica")
-        
-        # Validar que no hay más missing values
-        if np.isnan(X_data).any() or np.isnan(y_data).any():
-            raise ValueError("Todavía hay valores NaN después de la limpieza")
-        
-        # Validar que no hay valores infinitos
-        if np.isinf(X_data).any() or np.isinf(y_data).any():
-            raise ValueError("Todavía hay valores infinitos después de la limpieza")
-        
-        # Crear y ajustar el modelo
-        result = LinearRegressionResult(
-            X_data, y_data, X, y, 
-            engine=engine, 
-            fit_intercept=fit_intercept
-        )
+                raise ValueError("Datos contienen valores faltantes")
+            regression_data = regression_data.dropna()
+
+        X_data = regression_data[X].values
+        y_data = regression_data[y].values
+
+        # Ajustar modelo
+        result = LinearRegressionResult(X_data, y_data, X, y, engine=engine, fit_intercept=fit_intercept)
         result.fit()
         result.show_plot = show_plot
         result.plot_backend = plot_backend
-        
-        # Agregar información de limpieza al resultado
-        result.data_info = {
-            'original_rows': len(self.data),
-            'clean_rows': len(regression_data_clean),
-            'rows_removed': len(self.data) - len(regression_data_clean),
-            'missing_handled': total_missing > 0
-        }
-        
-        return result
+
+        figura = None
+        # Graficar si es regresión simple
+        if show_plot and len(X) == 1 and plot_backend.lower() == 'seaborn':
+            import matplotlib.pyplot as plt
+            g = sns.lmplot(x=X[0], y=y, data=regression_data, ci=None)
+            g.figure.suptitle(f"Regresión lineal: {y} ~ {X[0]}", y=1.02)
+            plt.tight_layout()
+            figura = g.figure
+
+        return result, figura
+
+
     
     def help(self):
         """
@@ -366,6 +332,15 @@ class DescriptiveStats:
     
     Incluye: conteo, media, mediana, moda, desv. est., varianza,
             mínimo, Q1, Q3, máximo, IQR, asimetría, curtosis
+  • .summary().to_dataframe(format)
+    Format:
+        - Wide
+        - Long
+        - Compact
+
+  • .summary().to_categorical_summary() 
+  • .summary().to_styled_df() 
+
 
 ┌────────────────────────────────────────────────────────────────────────────┐
 │ 4. 📈 REGRESIÓN LINEAL                                                     │
@@ -560,14 +535,151 @@ class DescriptiveSummary:
         output.append("=" * 100)
         return "\n".join(output)
     
+    def to_dataframe(self, format='wide'):
+        """
+        Convierte los resultados a DataFrame.
+        
+        Parameters:
+        -----------
+        format : str, default 'wide'
+            - 'wide': Variables en columnas, estadísticas en filas
+            - 'long': Formato largo (variable, estadística, valor)
+            - 'compact': Variables en filas, estadísticas en columnas
+        """
+        if format == 'wide':
+            return self._to_wide_df()
+        elif format == 'long':
+            return self._to_long_df()
+        elif format == 'compact':
+            return self._to_compact_df()
+        else:
+            raise ValueError("format debe ser 'wide', 'long' o 'compact'")
+    
+    def _to_wide_df(self):
+        """
+        Formato ancho: Variables en columnas, estadísticas en filas.
+        
+        Ejemplo:
+                        Variable1  Variable2  Variable3
+        count              150.0      150.0      150.0
+        mean                 5.8        3.1        3.8
+        median               5.8        3.0        4.0
+        ...
+        """
+        df = pd.DataFrame(self.results)
+        
+        # Ordenar índice por categorías
+        order = [
+            'count', 'mean', 'median', 'mode',  # Tendencia central
+            'std', 'variance', 'iqr',            # Dispersión
+            'min', 'q1', 'q3', 'max',            # Cuartiles
+            'skewness', 'kurtosis'               # Forma
+        ]
+        
+        # Reordenar filas según el orden definido
+        df = df.reindex([stat for stat in order if stat in df.index])
+        
+        return df
+    
+    def _to_compact_df(self):
+        """
+        Formato compacto: Variables en filas, estadísticas en columnas.
+        
+        Ejemplo:
+                  count   mean  median   mode   std  variance  ...
+        Var1      150.0   5.8     5.8    5.0   0.8      0.68  ...
+        Var2      150.0   3.1     3.0    3.0   0.4      0.19  ...
+        Var3      150.0   3.8     4.0    1.0   1.8      3.11  ...
+        """
+        df_data = []
+        
+        for var_name, stats in self.results.items():
+            row = {'Variable': var_name}
+            row.update(stats)
+            df_data.append(row)
+        
+        df = pd.DataFrame(df_data)
+        df = df.set_index('Variable')
+        
+        # Ordenar columnas por categorías
+        order = [
+            'count', 'mean', 'median', 'mode',
+            'std', 'variance', 'iqr',
+            'min', 'q1', 'q3', 'max',
+            'skewness', 'kurtosis'
+        ]
+        
+        df = df[[col for col in order if col in df.columns]]
+        
+        return df
+    
+    def _to_long_df(self):
+        """
+        Formato largo: Una fila por cada combinación variable-estadística.
+        
+        Ejemplo:
+             Variable  Estadistica    Valor
+        0       Var1        count   150.00
+        1       Var1         mean     5.84
+        2       Var1       median     5.80
+        ...
+        """
+        data = []
+        
+        for var_name, stats in self.results.items():
+            for stat_name, value in stats.items():
+                data.append({
+                    'Variable': var_name,
+                    'Estadistica': stat_name,
+                    'Valor': value
+                })
+        
+        return pd.DataFrame(data)
+    
+    def to_styled_df(self):
+        """
+        Devuelve un DataFrame con formato wide y estilo aplicado.
+        Útil para notebooks de Jupyter.
+        """
+        df = self._to_wide_df()
+        
+        styled = df.style.format("{:.4f}") \
+                    .background_gradient(cmap='YlOrRd', axis=1) \
+                    .set_caption(f"Estadística Descriptiva - {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
+        
+        return styled
+    
+    def to_categorical_summary(self):
+        """
+        Crea un resumen organizado por categorías de estadísticas.
+        
+        Returns:
+        --------
+        dict of DataFrames
+        """
+        df_wide = self._to_wide_df()
+        
+        return {
+            'Tendencia Central': df_wide.loc[['count', 'mean', 'median', 'mode']],
+            'Dispersión': df_wide.loc[['std', 'variance', 'iqr']],
+            'Cuartiles': df_wide.loc[['min', 'q1', 'q3', 'max']],
+            'Forma': df_wide.loc[['skewness', 'kurtosis']]
+        }
+    
 
 import numpy as np
 from datetime import datetime
 
 
+import numpy as np
+import pandas as pd
+from datetime import datetime
+import matplotlib.pyplot as plt
+import seaborn as sns
+
 class LinearRegressionResult:
     """Clase para resultados de regresión lineal"""
-    
+
     def __init__(self, X, y, X_names, y_name, engine='statsmodels', fit_intercept=True):
         self.X = X
         self.y = y
@@ -579,7 +691,7 @@ class LinearRegressionResult:
         self.results = None
         self.show_plot = False
         self.plot_backend = 'seaborn'
-        
+
         # Atributos que se llenarán después del fit
         self.coef_ = None
         self.intercept_ = None
@@ -594,7 +706,7 @@ class LinearRegressionResult:
         self.std_errors = None
         self.t_values = None
         self.p_values = None
-        
+
     def fit(self):
         """Ajustar el modelo"""
         if self.engine == 'statsmodels':
@@ -604,7 +716,7 @@ class LinearRegressionResult:
                 X = sm.add_constant(X)
             self.model = sm.OLS(self.y, X)
             self.results = self.model.fit()
-            
+
             # Extraer atributos
             if self.fit_intercept:
                 self.intercept_ = self.results.params[0]
@@ -618,7 +730,7 @@ class LinearRegressionResult:
                 self.std_errors = self.results.bse
                 self.t_values = self.results.tvalues
                 self.p_values = self.results.pvalues
-            
+
             self.r_squared = self.results.rsquared
             self.adj_r_squared = self.results.rsquared_adj
             self.f_statistic = self.results.fvalue
@@ -627,24 +739,24 @@ class LinearRegressionResult:
             self.bic = self.results.bic
             self.residuals = self.results.resid
             self.predictions = self.results.fittedvalues
-            
+
         else:  # scikit-learn
             from sklearn.linear_model import LinearRegression
             self.model = LinearRegression(fit_intercept=self.fit_intercept)
             self.model.fit(self.X, self.y)
-            
+
             self.coef_ = self.model.coef_
             self.intercept_ = self.model.intercept_
-            self.r_squared = self.model.score(self.X, self.y)
             self.predictions = self.model.predict(self.X)
             self.residuals = self.y - self.predictions
-            
-            # Calcular métricas adicionales manualmente
+            self.r_squared = self.model.score(self.X, self.y)
+
+            # Calcular R^2 ajustado
             n, k = self.X.shape
             self.adj_r_squared = 1 - (1 - self.r_squared) * (n - 1) / (n - k - 1)
-            
+
         return self
-    
+
     def predict(self, X_new):
         """Hacer predicciones con nuevos datos"""
         if self.engine == 'statsmodels':
@@ -654,16 +766,12 @@ class LinearRegressionResult:
             return self.results.predict(X_new)
         else:
             return self.model.predict(X_new)
-    
+
     def summary(self):
         """Mostrar resumen estilo OLS"""
         return self.__repr__()
-    
+
     def __repr__(self):
-        return self._format_output()
-    
-    def _format_output(self):
-        """Formato estilo OLS de statsmodels"""
         output = []
         output.append("=" * 100)
         output.append("RESULTADOS DE REGRESIÓN LINEAL".center(100))
@@ -673,7 +781,7 @@ class LinearRegressionResult:
         output.append(f"Motor: {self.engine}")
         output.append(f"Fecha: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
         output.append("-" * 100)
-        
+
         # Información del modelo
         output.append("\nINFORMACIÓN DEL MODELO:")
         output.append("-" * 100)
@@ -681,24 +789,22 @@ class LinearRegressionResult:
         output.append("-" * 100)
         output.append(f"{'R-cuadrado':<50} {self.r_squared:>20.6f}")
         output.append(f"{'R-cuadrado Ajustado':<50} {self.adj_r_squared:>20.6f}")
-        
+
         if self.f_statistic is not None:
             output.append(f"{'Estadístico F':<50} {self.f_statistic:>20.6f}")
             output.append(f"{'Prob (F-estadístico)':<50} {self.f_pvalue:>20.6e}")
-        
+
         if self.aic is not None:
             output.append(f"{'AIC':<50} {self.aic:>20.6f}")
             output.append(f"{'BIC':<50} {self.bic:>20.6f}")
-        
+
         # Coeficientes
         output.append("\nCOEFICIENTES:")
         output.append("-" * 100)
-        
         if self.std_errors is not None:
             output.append(f"{'Variable':<20} {'Coef.':>15} {'Std Err':>15} {'t':>15} {'P>|t|':>15}")
             output.append("-" * 100)
             output.append(f"{'const':<20} {self.intercept_:>15.6f} {'-':>15} {'-':>15} {'-':>15}")
-            
             for i, name in enumerate(self.X_names):
                 output.append(
                     f"{name:<20} {self.coef_[i]:>15.6f} {self.std_errors[i]:>15.6f} "
@@ -708,10 +814,9 @@ class LinearRegressionResult:
             output.append(f"{'Variable':<20} {'Coeficiente':>20}")
             output.append("-" * 100)
             output.append(f"{'const':<20} {self.intercept_:>20.6f}")
-            
             for i, name in enumerate(self.X_names):
                 output.append(f"{name:<20} {self.coef_[i]:>20.6f}")
-        
+
         # Análisis de residuos
         output.append("\nANÁLISIS DE RESIDUOS:")
         output.append("-" * 100)
@@ -721,10 +826,31 @@ class LinearRegressionResult:
         output.append(f"{'Desv. Std. de Residuos':<50} {np.std(self.residuals):>20.6f}")
         output.append(f"{'Mínimo Residuo':<50} {np.min(self.residuals):>20.6f}")
         output.append(f"{'Máximo Residuo':<50} {np.max(self.residuals):>20.6f}")
-        
         output.append("=" * 100)
-        
+
         if self.show_plot:
+            self.plot()
             output.append("\n[Gráficos diagnósticos generados]")
-        
-        return "\n".join(output)
+
+        return "\n".join(output)
+
+    def plot(self):
+        """Generar gráficos de regresión y residuales"""
+        if len(self.X_names) == 1:
+            # Scatter + línea de regresión
+            df_plot = pd.DataFrame({
+                self.X_names[0]: self.X.flatten(),
+                self.y_name: self.y,
+                'Predicciones': self.predictions
+            })
+            sns.lmplot(x=self.X_names[0], y=self.y_name, data=df_plot, ci=None)
+            plt.title(f"Regresión lineal: {self.y_name} ~ {self.X_names[0]}")
+            plt.show()
+        else:
+            # Para regresión múltiple, solo gráfico residuos vs predicciones
+            plt.scatter(self.predictions, self.residuals)
+            plt.axhline(0, color='red', linestyle='--')
+            plt.xlabel("Predicciones")
+            plt.ylabel("Residuos")
+            plt.title("Residuos vs Predicciones")
+            plt.show()