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

statslibx/inferential.py

@@ -12,9 +12,16 @@ class InferentialStats:
     """
     
     def __init__(self, data: Union[pd.DataFrame, np.ndarray],
-                 backend: Literal['pandas', 'polars'] = 'pandas'):
+                backend: Literal['pandas', 'polars'] = 'pandas'):
         """
         Inicializar con DataFrame o array numpy
+
+        Parameters:
+        -----------
+        data : DataFrame o ndarray
+            Datos a analizar
+        backend : str
+            'pandas' o 'polars' para procesamiento
         """
 
         if isinstance(data, str) and os.path.exists(data):
@@ -67,7 +74,7 @@ class InferentialStats:
     # ============= INTERVALOS DE CONFIANZA =============
     
     def confidence_interval(self, column: str, confidence: float = 0.95,
-                           statistic: Literal['mean', 'median', 'proportion'] = 'mean') -> tuple:
+                            statistic: Literal['mean', 'median', 'proportion'] = 'mean') -> tuple:
         """
         Intervalo de confianza para diferentes estadísticos
         
@@ -120,8 +127,8 @@ class InferentialStats:
     # ============= PRUEBAS DE HIPÓTESIS =============
     
     def t_test_1sample(self, column: str, popmean: float = None, 
-                       popmedian: float = None,
-                       alternative: Literal['two-sided', 'less', 'greater'] = 'two-sided') -> 'TestResult':
+                        popmedian: float = None,
+                        alternative: Literal['two-sided', 'less', 'greater'] = 'two-sided') -> 'TestResult':
         """
         Prueba t de una muestra (para media o mediana)
         
@@ -176,8 +183,8 @@ class InferentialStats:
             raise ValueError("Debe especificar popmean o popmedian")
     
     def t_test_2sample(self, column1: str, column2: str,
-                       equal_var: bool = True,
-                       alternative: Literal['two-sided', 'less', 'greater'] = 'two-sided') -> 'TestResult':
+                        equal_var: bool = True,
+                        alternative: Literal['two-sided', 'less', 'greater'] = 'two-sided') -> 'TestResult':
         """
         Prueba t de dos muestras independientes
         
@@ -211,9 +218,16 @@ class InferentialStats:
         )
     
     def t_test_paired(self, column1: str, column2: str,
-                     alternative: Literal['two-sided', 'less', 'greater'] = 'two-sided') -> 'TestResult':
+                        alternative: Literal['two-sided', 'less', 'greater'] = 'two-sided') -> 'TestResult':
         """
         Prueba t pareada
+
+        Parameters:
+        -----------
+        column1, column2: 
+            Datos a analizar
+        alternative:
+            "two-sided", "less" o "greater"
         """
         from scipy import stats
         
@@ -231,7 +245,7 @@ class InferentialStats:
         )
     
     def mann_whitney_test(self, column1: str, column2: str,
-                         alternative: Literal['two-sided', 'less', 'greater'] = 'two-sided') -> 'TestResult':
+                            alternative: Literal['two-sided', 'less', 'greater'] = 'two-sided') -> 'TestResult':
         """
         Prueba de Mann-Whitney U (alternativa no paramétrica al t-test)
         
@@ -339,8 +353,8 @@ class InferentialStats:
         )
     
     def normality_test(self, column: str, 
-                      method: Literal['shapiro', 'ks', 'anderson', 'jarque_bera', 'all'] = 'shapiro',
-                      test_statistic: Literal['mean', 'median', 'mode'] = 'mean') -> Union['TestResult', dict]:
+                        method: Literal['shapiro', 'ks', 'anderson', 'jarque_bera', 'all'] = 'shapiro',
+                        test_statistic: Literal['mean', 'median', 'mode'] = 'mean') -> Union['TestResult', dict]:
         """
         Prueba de normalidad con múltiples métodos y estadísticos
         
@@ -495,74 +509,88 @@ class InferentialStats:
             column1: str = None,
             column2: str = None,
             alpha: float = 0.05,
-            homoscedasticity: Literal["levene", "bartlett", "var_test"] = "levene"
-        ) -> Dict[str, Any]:
-
-            data = self.data
-
-            if column1 is None:
-                raise ValueError("Debes especificar 'column1'.")
-
-            x = data[column1].dropna()
-
-            if method in ["difference_mean", "variance"] and column2 is None:
-                raise ValueError("Para este método debes pasar 'column2'.")
-
-            y = data[column2].dropna() if column2 else None
-
-            # --- homoscedasticity test ---
-            homo_result = None
-            if method in ["difference_mean", "variance"]:
-                homo_result = self._homoscedasticity_test(x, y, homoscedasticity)
-
-            # --- MAIN HYPOTHESIS TESTS ---
-            if method == "mean":
-                # One-sample t-test
-                t_stat, p_value = stats.ttest_1samp(x, popmean=np.mean(x))
-                test_name = "One-sample t-test"
-
-            elif method == "difference_mean":
-                # Two-sample t-test
-                equal_var = homo_result["equal_var"]
-                t_stat, p_value = stats.ttest_ind(x, y, equal_var=equal_var)
-                test_name = "Two-sample t-test"
-
-            elif method == "proportion":
-                # Proportion test (z-test)
-                p_hat = np.mean(x)
-                n = len(x)
-                z_stat = (p_hat - 0.5) / np.sqrt(0.5 * 0.5 / n)
-                p_value = 2 * (1 - stats.norm.cdf(abs(z_stat)))
-                t_stat = z_stat
-                test_name = "Proportion Z-test"
-
-            elif method == "variance":
-                # Classic F-test
-                var_x = np.var(x, ddof=1)
-                var_y = np.var(y, ddof=1)
-                F = var_x / var_y
-                dfn = len(x) - 1
-                dfd = len(y) - 1
-
-                p_value = 2 * min(stats.f.cdf(F, dfn, dfd), 1 - stats.f.cdf(F, dfn, dfd))
-                t_stat = F
-                test_name = "Variance F-test"
+            homoscedasticity: Literal["levene", "bartlett", "var_test"] = "levene") -> Dict[str, Any]:
+            
+        """
+        Test de Hipotesis   
 
-            return {
-                "test": test_name,
-                "statistic": t_stat,
-                "p_value": p_value,
-                "alpha": alpha,
-                "reject_H0": p_value < alpha,
-                "homoscedasticity_test": homo_result
-            }
+        Parameters:
+        -----------
+        method : str
+            'mean', 'difference_mean', 'proportion' o 'variance'
+        column1, column2 : str
+            Columnas numéricas a comparar
+        alpha : float
+            Nivel de significancia (default 0.05)
+        homoscedasticity : str
+            Método de homocedasticidad
+            'levene', 'bartlett' o 'var_test' 
+        """
+
+        data = self.data
+
+        if column1 is None:
+            raise ValueError("Debes especificar 'column1'.")
+
+        x = data[column1].dropna()
+
+        if method in ["difference_mean", "variance"] and column2 is None:
+            raise ValueError("Para este método debes pasar 'column2'.")
+
+        y = data[column2].dropna() if column2 else None
+
+        # --- homoscedasticity test ---
+        homo_result = None
+        if method in ["difference_mean", "variance"]:
+            homo_result = self._homoscedasticity_test(x, y, homoscedasticity)
+
+        # --- MAIN HYPOTHESIS TESTS ---
+        if method == "mean":
+            # One-sample t-test
+            t_stat, p_value = stats.ttest_1samp(x, popmean=np.mean(x))
+            test_name = "One-sample t-test"
+
+        elif method == "difference_mean":
+            # Two-sample t-test
+            equal_var = homo_result["equal_var"]
+            t_stat, p_value = stats.ttest_ind(x, y, equal_var=equal_var)
+            test_name = "Two-sample t-test"
+
+        elif method == "proportion":
+            # Proportion test (z-test)
+            p_hat = np.mean(x)
+            n = len(x)
+            z_stat = (p_hat - 0.5) / np.sqrt(0.5 * 0.5 / n)
+            p_value = 2 * (1 - stats.norm.cdf(abs(z_stat)))
+            t_stat = z_stat
+            test_name = "Proportion Z-test"
+
+        elif method == "variance":
+            # Classic F-test
+            var_x = np.var(x, ddof=1)
+            var_y = np.var(y, ddof=1)
+            F = var_x / var_y
+            dfn = len(x) - 1
+            dfd = len(y) - 1
+
+            p_value = 2 * min(stats.f.cdf(F, dfn, dfd), 1 - stats.f.cdf(F, dfn, dfd))
+            t_stat = F
+            test_name = "Variance F-test"
+
+        return {
+            "test": test_name,
+            "statistic": t_stat,
+            "p_value": p_value,
+            "alpha": alpha,
+            "reject_H0": p_value < alpha,
+            "homoscedasticity_test": homo_result
+        }
 
     def _homoscedasticity_test(
         self,
         x,
         y,
-        method: Literal["levene", "bartlett", "var_test"] = "levene"
-    ) -> Dict[str, Any]:
+        method: Literal["levene", "bartlett", "var_test"] = "levene") -> Dict[str, Any]:
 
         if method == "levene":
             stat, p = stats.levene(x, y)

statslibx/io.py

@@ -0,0 +1,21 @@
+import pandas as pd
+import polars as pl
+from pathlib import Path
+
+
+def load_file(path: str):
+    path = Path(path)
+
+    if not path.exists():
+        raise FileNotFoundError(f"{path} not found")
+
+    if path.suffix == ".csv":
+        return pd.read_csv(path)
+
+    if path.suffix == ".json":
+        return pd.read_json(path)
+
+    if path.suffix in {".txt", ".tsv"}:
+        return pd.read_csv(path, sep="\t")
+
+    raise ValueError(f"Unsupported file type: {path.suffix}")

statslibx/preprocessing/__init__.py

@@ -0,0 +1,221 @@
+from typing import Optional, Union, List, Dict, Any
+import pandas as pd
+import polars as pl
+import numpy as np
+
+
+class Preprocessing:
+
+    def __init__(self, data: Union[pd.DataFrame, pl.DataFrame]):
+        if not isinstance(data, (pd.DataFrame, pl.DataFrame)):
+            raise TypeError("data must be a pandas or polars DataFrame")
+        self.data = data
+
+    # ------------------------------------------------------------------
+    # Internal helpers
+    # ------------------------------------------------------------------
+
+    def _is_pandas(self) -> bool:
+        return isinstance(self.data, pd.DataFrame)
+
+    def _is_polars(self) -> bool:
+        return isinstance(self.data, pl.DataFrame)
+
+    def _count_nulls(self, column: str) -> int:
+        if self._is_pandas():
+            return int(self.data[column].isna().sum())
+        return int(self.data[column].null_count())
+
+    def _get_columns(self, columns):
+        if columns is None:
+            return list(self.data.columns)
+        if isinstance(columns, str):
+            return [columns]
+        return columns
+
+    # ------------------------------------------------------------------
+    # Inspection
+    # ------------------------------------------------------------------
+
+    def detect_nulls(
+        self,
+        columns: Optional[Union[str, List[str]]] = None
+    ) -> pd.DataFrame:
+
+        columns = self._get_columns(columns)
+        total = self.data.shape[0]
+
+        rows = []
+        for col in columns:
+            nulls = self._count_nulls(col)
+            rows.append({
+                "column": col,
+                "nulls": nulls,
+                "non_nulls": total - nulls,
+                "null_pct": nulls / total
+            })
+
+        return pd.DataFrame(rows)
+
+    def check_uniqueness(self) -> pd.DataFrame:
+        if self._is_pandas():
+            unique = self.data.nunique()
+            return pd.DataFrame({
+                "column": unique.index,
+                "unique_values": unique.values
+            })
+
+        unique = self.data.select(pl.all().n_unique())
+        return unique.to_pandas().melt(
+            var_name="column",
+            value_name="unique_values"
+        )
+
+    def preview_data(self, n: int = 5):
+        return self.data.head(n)
+
+    # ------------------------------------------------------------------
+    # Description
+    # ------------------------------------------------------------------
+
+    def describe_numeric(self):
+        if self._is_pandas():
+            return self.data.select_dtypes(include=np.number).describe()
+
+        return self.data.select(pl.all().filter(pl.col(pl.NUMERIC))).describe()
+
+    def describe_categorical(self):
+        if self._is_pandas():
+            return self.data.select_dtypes(include="object").describe()
+
+        return self.data.select(pl.all().filter(pl.col(pl.Utf8))).describe()
+
+    # ------------------------------------------------------------------
+    # Transformations
+    # ------------------------------------------------------------------
+
+    def fill_nulls(
+        self,
+        fill_with: Any,
+        columns: Optional[Union[str, List[str]]] = None
+    ):
+        columns = self._get_columns(columns)
+
+        if self._is_pandas():
+            self.data[columns] = self.data[columns].fillna(fill_with)
+
+        else:
+            self.data = self.data.with_columns([
+                pl.col(col).fill_null(fill_with) for col in columns
+            ])
+
+        return self
+
+    def normalize(self, column: str):
+        if self._is_pandas():
+            col = self.data[column]
+            self.data[column] = (col - col.min()) / (col.max() - col.min())
+        else:
+            self.data = self.data.with_columns(
+                ((pl.col(column) - pl.col(column).min()) /
+                 (pl.col(column).max() - pl.col(column).min()))
+                .alias(column)
+            )
+        return self
+
+    def standardize(self, column: str):
+        if self._is_pandas():
+            col = self.data[column]
+            self.data[column] = (col - col.mean()) / col.std()
+        else:
+            self.data = self.data.with_columns(
+                ((pl.col(column) - pl.col(column).mean()) /
+                 pl.col(column).std())
+                .alias(column)
+            )
+        return self
+
+    # ------------------------------------------------------------------
+    # Filtering
+    # ------------------------------------------------------------------
+
+    def filter_rows(self, condition):
+        if self._is_pandas():
+            self.data = self.data.loc[condition]
+        else:
+            self.data = self.data.filter(condition)
+        return self
+
+    def filter_columns(self, columns: List[str]):
+        if self._is_pandas():
+            self.data = self.data[columns]
+        else:
+            self.data = self.data.select(columns)
+        return self
+
+    def rename_columns(self, mapping: Dict[str, str]):
+        if self._is_pandas():
+            self.data = self.data.rename(columns=mapping)
+        else:
+            self.data = self.data.rename(mapping)
+        return self
+
+    # ------------------------------------------------------------------
+    # Outliers
+    # ------------------------------------------------------------------
+
+    def detect_outliers(
+        self,
+        column: str,
+        method: str = "iqr"
+    ) -> pd.DataFrame:
+
+        if self._is_pandas():
+            series = self.data[column]
+        else:
+            series = self.data[column].to_pandas()
+
+        if method == "iqr":
+            q1 = series.quantile(0.25)
+            q3 = series.quantile(0.75)
+            iqr = q3 - q1
+            mask = (series < q1 - 1.5 * iqr) | (series > q3 + 1.5 * iqr)
+
+        elif method == "zscore":
+            z = (series - series.mean()) / series.std()
+            mask = z.abs() > 3
+
+        else:
+            raise ValueError("method must be 'iqr' or 'zscore'")
+
+        return self.data[mask]
+
+    # ------------------------------------------------------------------
+    # Data Quality Report
+    # ------------------------------------------------------------------
+
+    def data_quality(self) -> pd.DataFrame:
+        total_rows = self.data.shape[0]
+        rows = []
+
+        for col in self.data.columns:
+            nulls = self._count_nulls(col)
+
+            if self._is_pandas():
+                dtype = str(self.data[col].dtype)
+                unique = self.data[col].nunique()
+            else:
+                dtype = str(self.data.schema[col])
+                unique = self.data[col].n_unique()
+
+            rows.append({
+                "column": col,
+                "dtype": dtype,
+                "nulls": nulls,
+                "null_pct": nulls / total_rows,
+                "unique_values": unique,
+                "completeness_pct": 1 - (nulls / total_rows)
+            })
+
+        return pd.DataFrame(rows)
+