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

statslibx/utils.py

@@ -6,6 +6,7 @@ import warnings
 import os
 from scipy import stats
 import seaborn as sns
+from pathlib import Path
 
 
 class UtilsStats:
@@ -13,11 +14,15 @@ class UtilsStats:
     Clase utilitaria para operaciones estadísticas comunes y visualización
     
     Esta clase proporciona métodos para validación de datos, análisis estadísticos
-    básicos y visualización de resultados.
+    básicos y visualización de resultados. Ahora con soporte para leer archivos directamente.
     
     Examples:
     ---------
     >>> utils = UtilsStats()
+    >>> # Desde archivo
+    >>> data = utils.load_data("datos.csv")
+    >>> utils.check_normality(data, column='edad')
+    >>> # Desde array
     >>> data = np.random.normal(0, 1, 100)
     >>> utils.check_normality(data)
     >>> utils.plot_distribution(data)
@@ -47,34 +52,26 @@ class UtilsStats:
         plt.rcParams['lines.linewidth'] = 2
     
     def set_plot_backend(self, backend: Literal['matplotlib', 'seaborn', 'plotly']):
-        """
-        Establecer el backend de visualización por defecto
-        """
+        """Establecer el backend de visualización por defecto"""
         self._plot_backend = backend
     
     def set_default_figsize(self, figsize: Tuple[int, int]):
-        """
-        Establecer el tamaño de figura por defecto
-        """
+        """Establecer el tamaño de figura por defecto"""
         self._default_figsize = figsize
         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'):
-        """
-        Configurar opciones para guardar figuras
-        """
+                            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
         self._fig_dpi = fig_dpi
         self._figures_dir = figures_dir
     
     def _save_figure(self, fig, filename: str, **kwargs):
-        """
-        Guardar figura si save_fig está activado
-        """
+        """Guardar figura si save_fig está activado"""
         if self._save_fig:
             try:
                 os.makedirs(self._figures_dir, exist_ok=True)
@@ -93,10 +90,114 @@ class UtilsStats:
             except Exception as e:
                 print(f"✗ Error guardando figura: {e}")
 
-    # ============= MÉTODOS DE ANÁLISIS ESTADÍSTICO =============
+    # ============= NUEVO: MÉTODOS DE CARGA DE DATOS =============
+
+    def load_data(self, path: Union[str, Path], **kwargs) -> pd.DataFrame:
+        """
+        Carga datos desde archivo en múltiples formatos
+        
+        Parameters:
+        -----------
+        path : str o Path
+            Ruta al archivo de datos
+        **kwargs : dict
+            Argumentos adicionales para la función de lectura de pandas
+            
+        Returns:
+        --------
+        pd.DataFrame
+            DataFrame con los datos cargados
+            
+        Supported formats:
+        ------------------
+        - CSV (.csv)
+        - Excel (.xlsx, .xls)
+        - Text/TSV (.txt, .tsv)
+        - JSON (.json)
+        - Parquet (.parquet)
+        - Feather (.feather)
+        
+        Examples:
+        ---------
+        >>> utils = UtilsStats()
+        >>> df = utils.load_data("datos.csv")
+        >>> df = utils.load_data("datos.xlsx", sheet_name="Hoja1")
+        >>> df = utils.load_data("datos.json")
+        """
+        path = Path(path)
+        
+        if not path.exists():
+            raise FileNotFoundError(f"El archivo no existe: {path}")
+        
+        ext = path.suffix.lower()
+        
+        try:
+            if ext == ".csv":
+                df = pd.read_csv(path, **kwargs)
+                
+            elif ext in [".xlsx", ".xls"]:
+                df = pd.read_excel(path, **kwargs)
+                
+            elif ext in [".txt", ".tsv"]:
+                df = pd.read_table(path, **kwargs)
+                
+            elif ext == ".json":
+                df = pd.read_json(path, **kwargs)
+                
+            elif ext == ".parquet":
+                df = pd.read_parquet(path, **kwargs)
+                
+            elif ext == ".feather":
+                df = pd.read_feather(path, **kwargs)
+                
+            else:
+                raise ValueError(f"Formato de archivo no soportado: {ext}")
+            
+            print(f"✓ Datos cargados exitosamente desde: {path}")
+            print(f"  Shape: {df.shape}")
+            print(f"  Columnas: {list(df.columns)}")
+            
+            return df
+            
+        except Exception as e:
+            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]:
+        """
+        Resuelve el input de datos: si es una ruta, carga el archivo; si no, usa los datos directamente
+        
+        Returns:
+        --------
+        Tuple[data, data_source]
+            - data: Los datos procesados
+            - data_source: String indicando la fuente ('file' o 'memory')
+        """
+        # Si es string o Path, intentar cargar como archivo
+        if isinstance(data, (str, Path)):
+            path = Path(data)
+            if path.exists():
+                df = self.load_data(path)
+                if column is not None and column in df.columns:
+                    return df[column], 'file'
+                return df, 'file'
+            else:
+                raise FileNotFoundError(f"El archivo no existe: {path}")
+        
+        # Si ya son datos en memoria, devolverlos tal cual
+        return data, 'memory'
+
+    # ============= MÉTODOS DE ANÁLISIS ESTADÍSTICO (ACTUALIZADOS) =============
 
-    def validate_dataframe(self, data: Union[pd.DataFrame, np.ndarray, list]) -> pd.DataFrame:
-        """Valida y convierte datos a DataFrame"""
+    def validate_dataframe(self, data: Union[pd.DataFrame, np.ndarray, list, str, Path]) -> pd.DataFrame:
+        """
+        Valida y convierte datos a DataFrame
+        
+        Ahora acepta también rutas de archivos
+        """
+        # Intentar resolver si es un archivo
+        data, source = self._resolve_data(data)
+        
         if isinstance(data, pd.DataFrame):
             return data
         elif isinstance(data, np.ndarray):
@@ -117,8 +218,36 @@ class UtilsStats:
             return f"{num:.{decimals}e}"
         return f"{num:.{decimals}f}"
 
-    def check_normality(self, data: Union[pd.Series, np.ndarray], alpha: float = 0.05) -> dict:
-        """Verifica si los datos siguen distribución normal usando Shapiro-Wilk"""
+    def check_normality(self, 
+                        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
+        
+        Parameters:
+        -----------
+        data : Series, ndarray, DataFrame, str o Path
+            Datos a analizar o ruta al archivo
+        column : str, optional
+            Columna a analizar (si data es DataFrame o archivo)
+        alpha : float
+            Nivel de significancia
+            
+        Examples:
+        ---------
+        >>> utils.check_normality("datos.csv", column="edad")
+        >>> utils.check_normality(np.random.normal(0, 1, 100))
+        """
+        # Resolver datos
+        data, source = self._resolve_data(data, column)
+        
+        # Extraer array
+        if isinstance(data, pd.DataFrame):
+            if column is None:
+                raise ValueError("Debe especificar 'column' cuando data es DataFrame")
+            data = data[column]
+        
         if isinstance(data, pd.Series):
             data = data.dropna().values
         else:
@@ -135,16 +264,39 @@ class UtilsStats:
             'interpretation': 'Normal' if shapiro_p > alpha else 'No Normal'
         }
 
-    def calculate_confidence_intervals(self, data: Union[pd.Series, np.ndarray], 
-                                     confidence_level: float = 0.95,
-                                     method: str = 'parametric') -> dict:
+    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:
         """
         Calcula intervalos de confianza para la media
+        
+        Parameters:
+        -----------
+        data : Series, ndarray, DataFrame, str o Path
+            Datos a analizar o ruta al archivo
+        column : str, optional
+            Columna a analizar
+        confidence_level : float
+            Nivel de confianza (default: 0.95)
+        method : str
+            'parametric' o 'bootstrap'
         """
+        # Resolver datos
+        data, source = self._resolve_data(data, column)
+        
+        # Extraer array
+        if isinstance(data, pd.DataFrame):
+            if column is None:
+                raise ValueError("Debe especificar 'column' cuando data es DataFrame")
+            data = data[column]
+        
         if isinstance(data, pd.Series):
             data_clean = data.dropna().values
         else:
-            data_clean = data[~np.isnan(data)]
+            data_clean = np.array(data)
+            data_clean = data_clean[~np.isnan(data_clean)]
         
         n = len(data_clean)
         mean = np.mean(data_clean)
@@ -185,16 +337,20 @@ class UtilsStats:
             'method': method
         }
 
-    def detect_outliers(self, data: Union[pd.Series, np.ndarray], 
-                       method: Literal['iqr', 'zscore', 'isolation_forest'] = 'iqr',
-                       **kwargs) -> np.ndarray:
+    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:
         """
         Detecta outliers usando diferentes métodos
         
         Parameters:
         -----------
-        data : array-like
-            Datos a analizar
+        data : Series, ndarray, DataFrame, str o Path
+            Datos a analizar o ruta al archivo
+        column : str, optional
+            Columna a analizar
         method : str
             'iqr', 'zscore', o 'isolation_forest'
         
@@ -203,6 +359,15 @@ class UtilsStats:
         np.ndarray
             Array booleano indicando outliers
         """
+        # Resolver datos
+        data, source = self._resolve_data(data, column)
+        
+        # Extraer array
+        if isinstance(data, pd.DataFrame):
+            if column is None:
+                raise ValueError("Debe especificar 'column' cuando data es DataFrame")
+            data = data[column]
+        
         if isinstance(data, pd.Series):
             data = data.values
         
@@ -234,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
         """
@@ -364,24 +529,25 @@ class UtilsStats:
         
         return fig
 
-    def plot_distribution(self, data: Union[pd.DataFrame, pd.Series, np.ndarray],
-                         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):
+    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):
         """
         Graficar distribución de una variable
         
         Parameters:
         -----------
-        data : DataFrame, Series o ndarray
-            Datos a graficar
+        data : DataFrame, Series, ndarray, str o Path
+            Datos a graficar o ruta al archivo
         column : str, optional
-            Columna a graficar (si data es DataFrame)
+            Columna a graficar (si data es DataFrame o archivo)
         plot_type : str
             Tipo de gráfico
         backend : str, optional
@@ -394,11 +560,19 @@ class UtilsStats:
             Si guardar la figura
         filename : str, optional
             Nombre del archivo
+            
+        Examples:
+        ---------
+        >>> utils.plot_distribution("datos.csv", column="edad")
+        >>> utils.plot_distribution(df, column="salario", plot_type="all")
         """
         backend = backend or self._plot_backend
         figsize = figsize or self._default_figsize
         save_fig = save_fig if save_fig is not None else self._save_fig
         
+        # Resolver datos
+        data, source = self._resolve_data(data, column)
+        
         # Extraer datos
         if isinstance(data, pd.DataFrame):
             if column is None:
@@ -478,20 +652,21 @@ class UtilsStats:
         
         return fig
 
-    def plot_correlation_matrix(self, data: pd.DataFrame,
-                               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):
+    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):
         """
         Visualizar matriz de correlación
         
         Parameters:
         -----------
-        data : DataFrame
-            Datos para calcular correlación
+        data : DataFrame, str o Path
+            Datos para calcular correlación o ruta al archivo
         method : str
             'pearson', 'spearman' o 'kendall'
         backend : str, optional
@@ -502,6 +677,12 @@ class UtilsStats:
         save_fig = save_fig if save_fig is not None else self._save_fig
         filename = filename or "matriz_correlacion"
         
+        # Resolver datos
+        data, source = self._resolve_data(data)
+        
+        if not isinstance(data, pd.DataFrame):
+            raise ValueError("Se requiere un DataFrame para calcular matriz de correlación")
+        
         # Calcular matriz de correlación
         corr_matrix = data.corr(method=method)
         
@@ -510,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()
             
@@ -553,21 +734,33 @@ class UtilsStats:
         
         return fig
 
-    def plot_scatter_matrix(self, data: pd.DataFrame,
-                           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):
+    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):
         """
         Matriz de gráficos de dispersión (pairplot)
+        
+        Parameters:
+        -----------
+        data : DataFrame, str o Path
+            Datos o ruta al archivo
         """
         backend = backend or self._plot_backend
         figsize = figsize or self._default_figsize
         save_fig = save_fig if save_fig is not None else self._save_fig
         filename = filename or "scatter_matrix"
         
+        # Resolver datos
+        data, source = self._resolve_data(data)
+        
+        if not isinstance(data, pd.DataFrame):
+            raise ValueError("Se requiere un DataFrame para matriz de dispersión")
+        
         if columns:
             data = data[columns]
         
@@ -603,16 +796,23 @@ class UtilsStats:
     # ============= GRÁFICOS CON INTERVALOS DE CONFIANZA =============
 
     def plot_distribution_with_ci(self,
-                               data: Union[pd.DataFrame, pd.Series, np.ndarray],
-                               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
+        
+        Ahora acepta rutas de archivos
+        """
+        # Resolver datos
+        data, source = self._resolve_data(data, column)
+        
         # ======= PREPARACIÓN =======
         if isinstance(data, pd.DataFrame):
             if column is None:
@@ -630,7 +830,7 @@ class UtilsStats:
         filename = filename or f"distribucion_ci_{data_name.lower().replace(' ', '_')}"
 
         # Estadísticas
-        ci_result = self.calculate_confidence_intervals(data_array, confidence_level, ci_method)
+        ci_result = self.calculate_confidence_intervals(data_array, confidence_level=confidence_level, method=ci_method)
         normality_result = self.check_normality(data_array)
 
         # KDE
@@ -711,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
         """
@@ -739,7 +939,7 @@ class UtilsStats:
                 data_array = data_array[~np.isnan(data_array)]
             
             # Calcular estadísticas
-            ci_result = self.calculate_confidence_intervals(data_array, confidence_level)
+            ci_result = self.calculate_confidence_intervals(data_array, confidence_level=confidence_level)
             
             # Gráfica izquierda: Distribución básica
             ax1.hist(data_array, bins=30, alpha=0.7, color=colors[idx], 
@@ -760,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)
             
@@ -779,11 +979,17 @@ class UtilsStats:
 
     # ============= MÉTODOS UTILITARIOS ADICIONALES =============
 
-    def get_descriptive_stats(self, data: Union[pd.DataFrame, pd.Series, np.ndarray],
-                             column: Optional[str] = None) -> dict:
+    def get_descriptive_stats(self, 
+                                data: Union[pd.DataFrame, pd.Series, np.ndarray, str, Path],
+                                column: Optional[str] = None) -> dict:
         """
         Obtiene estadísticas descriptivas completas
+        
+        Ahora acepta rutas de archivos
         """
+        # Resolver datos
+        data, source = self._resolve_data(data, column)
+        
         if isinstance(data, pd.DataFrame):
             if column is None:
                 raise ValueError("Debe especificar 'column' cuando data es DataFrame")

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: statslibx
-Version: 0.1.4
+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.6.dist-info/RECORD

@@ -0,0 +1,14 @@
+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.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,,

statslibx-0.1.4.dist-info/RECORD

@@ -1,13 +0,0 @@
-statslibx/__init__.py,sha256=bPO1pSgkpLHNZ4BIz3U9R7MriyeMaIdR9VB-xrWCkaQ,1173
-statslibx/descriptive.py,sha256=Hu7VuOGXs6oOq-zxQNiBKg7UtkNdNQ1Qy3PP-wEO5_k,36971
-statslibx/inferential.py,sha256=BVBxEdLnNCw2yC-3s5fZ84oeJ8LqJYR_IJquPEiyiOk,48234
-statslibx/utils.py,sha256=tdf1yZuR4fsmNq24ygv69BgCLzB0iE_x0ki1IV7Iwxs,60693
-statslibx/datasets/__init__.py,sha256=BXP4ZIbPdaManpvDhoYavfX79pLffh81AUEfzSKXM6w,433
-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.4.dist-info/METADATA,sha256=bZJ7IxGbZpnhUaMFj_B95S_-RRvBeQdq0jVbdyFW-yY,2943
-statslibx-0.1.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-statslibx-0.1.4.dist-info/top_level.txt,sha256=eeYZXyFm0hIjuI0ba3wF6XW938Mv9tv7Nk9qgjYfCtU,10
-statslibx-0.1.4.dist-info/RECORD,,