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

statslibx/__init__.py

@@ -1,28 +1,32 @@
 """
 StatsLibx - Librería de Estadística para Python
 Autor: Emmanuel Ascendra
-Versión: 0.1.6
+Versión: 0.1.8
 """
 
-__version__ = "0.1.6"
+__version__ = "0.1.8"
 __author__ = "Emmanuel Ascendra"
 
 # Importar las clases principales
 from .descriptive import DescriptiveStats, DescriptiveSummary
 from .inferential import InferentialStats, TestResult
+from .probability import ProbabilityStats
+from .computacional import ComputacionalStats
 from .utils import UtilsStats
-from .datasets import load_dataset
+from .preprocessing import Preprocessing
+from .datasets import load_dataset, generate_dataset
 
 # Definir qué se expone cuando se hace: from statslib import *
 __all__ = [
     # Clases principales
     'DescriptiveStats',
-    'InferentialStats', 
-    'LinearRegressionResult',
-    'DescriptiveSummary',
-    'TestResult',
+    'InferentialStats',
+    'ProbabilityStats',
+    'ComputacionalStats',
     'UtilsStats',
-    'load_dataset'
+    'Preprocessing',
+    'load_dataset',
+    'generate_dataset'
 ]
 
 # Mensaje de bienvenida (opcional)
@@ -35,4 +39,7 @@ def welcome():
     print(f"  - DescriptiveStats: Estadística descriptiva")
     print(f"  - InferentialStats: Estadística inferencial")
     print(f"  - UtilsStats: Utilidades Extras")
+    print(f"\nMódulos disponibles:")
+    print(f"  - Datasets: Carga de Datasets")
+    print(f"  - Preprocessing: Preprocesamiento de datos")
     print(f"\nPara más información: help(statslibx)")

statslibx/cli.py

@@ -0,0 +1,47 @@
+import argparse
+from statslibx.io import load_file
+from statslibx.preprocessing import Preprocessing
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog="statslibx",
+        description="Statslibx - Data analysis from terminal"
+    )
+
+    subparsers = parser.add_subparsers(dest="command")
+
+    # describe
+    describe = subparsers.add_parser("describe")
+    describe.add_argument("file")
+
+    # quality
+    quality = subparsers.add_parser("quality")
+    quality.add_argument("file")
+
+    # preview
+    preview = subparsers.add_parser("preview")
+    preview.add_argument("file")
+    preview.add_argument("-n", "--rows", type=int, default=5)
+
+    args = parser.parse_args()
+
+    if not args.command:
+        parser.print_help()
+        return
+
+    df = load_file(args.file)
+    pp = Preprocessing(df)
+
+    if args.command == "describe":
+        print(pp.describe_numeric())
+
+    elif args.command == "quality":
+        print(pp.data_quality())
+
+    elif args.command == "preview":
+        print(pp.preview_data(args.rows))
+
+
+if __name__ == "__main__":
+    main()

statslibx/computacional.py

@@ -0,0 +1,2 @@
+class ComputacionalStats:
+    pass

statslibx/datasets/__init__.py

@@ -1,16 +1,244 @@
-import pandas as pd
-import pkgutil
+from typing import Optional, Union, Literal, List, Tuple
 import io
+import pkgutil
+
+import pandas as pd
+import polars as pl
+import numpy as np
+from numpy.typing import NDArray
+
+
+_SUPPORTED_BACKENDS = ("pandas", "polars")
+
+
+def _validate_columns(
+    df: Union[pd.DataFrame, pl.DataFrame],
+    X_columns: List[str],
+    y_column: str
+) -> None:
+    columns = set(df.columns)
+    missing = set(X_columns + [y_column]) - columns
+    if missing:
+        raise ValueError(f"Columnas no encontradas en el dataset: {missing}")
+
+
+def _X_y(
+    df: Union[pd.DataFrame, pl.DataFrame],
+    X_columns: List[str],
+    y_column: str
+) -> Tuple[NDArray, NDArray]:
+    """
+    Extrae X e y como arrays numpy desde pandas o polars.
+    """
+    _validate_columns(df, X_columns, y_column)
 
-def load_dataset(name: str):
-    """Carga un dataset interno del paquete.
-    Datasets Disponibles:
+    if isinstance(df, pd.DataFrame):
+        X = df[X_columns].to_numpy()
+        y = df[y_column].to_numpy().ravel()
+        return X, y
+
+    elif isinstance(df, pl.DataFrame):
+        X = df.select(X_columns).to_numpy()
+        y = df.select(y_column).to_numpy().ravel()
+        return X, y
+
+    else:
+        raise TypeError(
+            "Backend no soportado. Use pandas.DataFrame o polars.DataFrame."
+        )
+
+
+def load_dataset(
+    name: str,
+    backend: Literal["pandas", "polars"] = "pandas",
+    return_X_y: Optional[Tuple[List[str], str]] = None
+) -> Union[pd.DataFrame, pl.DataFrame, Tuple[NDArray, NDArray]]:
+    """
+    Carga un dataset interno del paquete.
+
+    Datasets disponibles:
     - iris.csv
     - penguins.csv
     - sp500_companies.csv
     - titanic.csv
+    - course_completion.csv
+
+    Parámetros
+    ----------
+    name : str
+        Nombre del archivo CSV.
+    backend : {'pandas', 'polars'}, default='pandas'
+        Backend de DataFrame a utilizar.
+    return_X_y : tuple[list[str], str], optional
+        Si se especifica, devuelve (X, y) como arrays numpy,
+
+    Retorna
+    -------
+    DataFrame o (X, y)
     """
+    if backend not in _SUPPORTED_BACKENDS:
+        raise ValueError(
+            f"Backend '{backend}' no soportado. "
+            f"Use uno de {_SUPPORTED_BACKENDS}."
+        )
+
+    # ---------- 1️⃣ Intentar cargar desde el paquete ----------
     data_bytes = pkgutil.get_data("statslibx.datasets", name)
-    if data_bytes is None:
-        raise FileNotFoundError(f"Dataset '{name}' no encontrado.")
-    return pd.read_csv(io.BytesIO(data_bytes))
+
+    if data_bytes is not None:
+        df = (
+            pd.read_csv(io.BytesIO(data_bytes))
+            if backend == "pandas"
+            else pl.read_csv(io.BytesIO(data_bytes))
+        )
+
+    # ---------- 2️⃣ Si no está en el paquete, buscar en ruta actual ----------
+    else:
+        try:
+            df = (
+                pd.read_csv(name)
+                if backend == "pandas"
+                else pl.read_csv(name)
+            )
+        except FileNotFoundError:
+            raise FileNotFoundError(
+                f"Dataset '{name}' no encontrado "
+                f"ni en statslibx.datasets ni en la ruta actual."
+            )
+
+    # ---------- 3️⃣ Devolver X, y si se solicita ----------
+    if return_X_y is not None:
+        X_columns, y_column = return_X_y
+        return _X_y(df, X_columns, y_column)
+
+    return df
+
+# =========================
+# Datasets específicos
+# =========================
+
+def load_iris(
+    backend: Literal["pandas", "polars"] = "pandas",
+    return_X_y: Optional[Tuple[List[str], str]] = None
+):
+    return load_dataset(
+        "iris.csv",
+        backend=backend,
+        return_X_y=return_X_y
+    )
+
+
+def load_penguins(
+    backend: Literal["pandas", "polars"] = "pandas",
+    return_X_y: Optional[Tuple[List[str], str]] = None
+):
+    return load_dataset(
+        "penguins.csv",
+        backend=backend,
+        return_X_y=return_X_y
+    )
+
+
+from typing import Optional
+
+def generate_dataset(n_rows, schema, seed=None, save: Optional[bool] = False, filename: Optional[str] = None):
+    if seed is not None:
+        if not isinstance(seed, int):
+            raise TypeError("seed debe ser un entero o None")
+        np.random.seed(seed)
+    else:
+        np.random.seed(42)
+
+    if not isinstance(schema, dict):
+        raise TypeError("schema debe ser un diccionario")
+    
+
+
+    data = {}
+
+    for col, config in schema.items():
+        if "dist" not in config:
+            raise ValueError(f"La columna '{col}' no tiene 'dist' definido")
+
+        dist = config["dist"]
+        dtype = config.get("type", "float")
+        nround = config.get("round", 0)
+
+        # ---------- DISTRIBUCIONES ----------
+        if dist == "normal":
+            values = np.random.normal(
+                loc=config.get("mean", 0),
+                scale=config.get("std", 1),
+                size=n_rows
+            )
+
+        elif dist == "uniform":
+            values = np.random.uniform(
+                low=config.get("low", 0),
+                high=config.get("high", 1),
+                size=n_rows
+            )
+
+        elif dist == "exponential":
+            values = np.random.exponential(
+                scale=config.get("scale", 1),
+                size=n_rows
+            )
+
+        elif dist == "lognormal":
+            values = np.random.lognormal(
+                mean=config.get("mean", 0),
+                sigma=config.get("std", 1),
+                size=n_rows
+            )
+
+        elif dist == "poisson":
+            values = np.random.poisson(
+                lam=config.get("lam", 1),
+                size=n_rows
+            )
+
+        elif dist == "binomial":
+            values = np.random.binomial(
+                n=config.get("n", 1),
+                p=config.get("p", 0.5),
+                size=n_rows
+            )
+
+        elif dist == "categorical":
+            if "choices" not in config:
+                raise ValueError(f"'choices' es requerido para categorical ({col})")
+            values = np.random.choice(
+                config["choices"],
+                size=n_rows
+            )
+            data[col] = values
+            continue
+
+        else:
+            raise ValueError(f"Distribución no soportada: {dist}")
+
+        # ---------- CASTEO DE TIPO ----------
+        if dtype == "int":
+            values = np.round(values).astype(int)
+        elif dtype == "float":
+            values = values.astype(float)
+        else:
+            raise ValueError(f"Tipo no soportado: {dtype}")
+        
+        # ---------- REDONDEO ----------
+        if nround > 0:
+            values = np.round(values, nround)
+        else:
+            values = np.round(values, 2)
+
+        data[col] = values
+
+    if save and filename:
+        df = pd.DataFrame(data)
+        df.to_csv(f"{filename}.csv", index=False)
+    else:
+        df = pd.DataFrame(data)
+        df.to_csv("dataset.csv", index=False)
+
+    return pd.DataFrame(data)