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

statslibx/__init__.py

@@ -1,30 +1,31 @@
 """
 StatsLibx - Librería de Estadística para Python
 Autor: Emmanuel Ascendra
-Versión: 0.1.6
+Versión: 0.2.0
 """
 
-__version__ = "0.1.6"
+__version__ = "0.2.0"
 __author__ = "Emmanuel Ascendra"
 
 # Importar las clases principales
 from .descriptive import DescriptiveStats, DescriptiveSummary
 from .inferential import InferentialStats, TestResult
+from .computacional import ComputationalStats
 from .utils import UtilsStats
 from .preprocessing import Preprocessing
-from .datasets import load_dataset
+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',
+    'ComputationalStats',
     'UtilsStats',
     'Preprocessing',
-    'load_dataset'
+    'load_dataset',
+    'generate_dataset'
 ]
 
 # Mensaje de bienvenida (opcional)
@@ -36,6 +37,9 @@ def welcome():
     print(f"\nClases disponibles:")
     print(f"  - DescriptiveStats: Estadística descriptiva")
     print(f"  - InferentialStats: Estadística inferencial")
+    print(f"  - ComputacionalStats: En desarrollo")
     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/computacional.py

@@ -0,0 +1,126 @@
+from typing import Union, Optional, Literal
+import numpy as np
+import pandas as pd
+import polars as pl
+import os
+
+class ComputationalStats:
+    """
+    Class for computational statistics
+    """
+    
+    def __init__(self, data: Union[pd.DataFrame, np.ndarray],
+                sep: str = None,
+                decimal: str = None,
+                thousand: str = None,
+                backend: Literal['pandas', 'polars'] = 'pandas'):
+        """
+        # Initialize DataFrame
+        
+        ## **Parameters:**
+
+        - **data** : Data to analyze
+        - **sep** : Column separator
+        - **decimal** : Decimal separator
+        - **thousand** : Thousand separator
+        - **backend** : 'pandas' or 'polars' for processing
+        (Proximamente estara habilitado polars para big data)
+
+        **Examples:**
+
+        ``Example 1:
+        stats = DescriptiveStats(data)
+        ``
+        """
+
+        if isinstance(data, str) and os.path.exists(data):
+                data = ComputationalStats.from_file(data).data
+
+        if isinstance(data, pl.DataFrame):
+            raise TypeError(
+                "Polars aún no soportado. Use pandas.DataFrame."
+            )
+
+
+        if isinstance(data, np.ndarray):
+            if data.ndim == 1:
+                data = pd.DataFrame({'var': data})
+            else:
+                data = pd.DataFrame(data, columns=[f'var_{i}' for i in range(data.shape[1])]) \
+                    if isinstance(data, pd.DataFrame) else pl.DataFrame(data, )
+        
+        self.data = data
+        self.backend = backend
+        self._numeric_cols = data.select_dtypes(include=[np.number]).columns.tolist()
+        self.sep = sep
+        self.decimal = decimal
+        self.thousand = thousand
+    
+    @classmethod
+    def from_file(self, path: str):
+        """
+        Carga automática de archivos y devuelve instancia de Intelligence.
+        Soporta CSV, Excel, TXT, JSON, Parquet, Feather, TSV.
+        Automatic file upload and returns Intelligence instance. 
+        Supports CSV, Excel, TXT, JSON, Parquet, Feather, TSV.
+
+        Parametros / Parameters:
+        ------------------------
+        path : str
+            Ruta del archivo
+            File path
+        """
+        if not os.path.exists(path):
+            raise FileNotFoundError(f"Archivo no encontrado / File not found: {path}")
+
+        ext = os.path.splitext(path)[1].lower()
+
+        if ext == ".csv":
+            df = pd.read_csv(path, sep=self.sep, decimal=self.decimal, thousand=self.thousand)
+
+        elif ext in [".xlsx", ".xls"]:
+            df = pd.read_excel(path, decimal=self.decimal, thousand=self.thousand)
+
+        elif ext in [".txt", ".tsv"]:
+            df = pd.read_table(path, sep=self.sep, decimal=self.decimal, thousand=self.thousand)
+
+        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 / Unsupported format: {ext}")
+
+        return ComputationalStats(df)
+    
+    def monte_carlo(self, function, n: int = 100, return_simulations: bool = False, **kwargs) -> pd.DataFrame:
+        """
+        Realiza simulaciones de Monte Carlo para una función y devuelve un DataFrame con las simulaciones y sus resultados.
+        """
+        samples = []
+
+        for _ in range(n):
+            sample = function(**kwargs)
+            samples.append(float(sample))
+
+        mean = sum(samples) / n
+        variance = sum((x - mean)**2 for x in samples) / n
+        std = variance**0.5
+
+        if return_simulations:
+            return {
+                "mean": float(mean),
+                "std": float(std),
+                "samples": samples
+            }
+
+        else:
+            return {
+                "mean": float(mean),
+                "std": float(std)
+            }

statslibx/datasets/__init__.py

@@ -1,71 +1,260 @@
-from typing import Optional, Union, Literal, List
-import polars as pl
-import pandas as pd
+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)
+
+    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."
+        )
+
+
 import io
+import pkgutil
+import pandas as pd
+import polars as pl
+from typing import Literal, Optional, Tuple, List, Union
+from numpy.typing import NDArray
+
+_SUPPORTED_BACKENDS = {"pandas", "polars"}
 
 def load_dataset(
-        name: str,
-        backend: Literal['pandas', 'polars'] = 'pandas'
-    ) -> Union[pd.DataFrame, pl.DataFrame]:
-    """Carga un dataset interno del paquete.
-    Datasets Disponibles:
+    name: str,
+    backend: Literal["pandas", "polars"] = "pandas",
+    return_X_y: Optional[Tuple[List[str], str]] = None,
+    save: Optional[bool] = False,
+    filename: Optional[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)
     """
-    data_bytes = pkgutil.get_data("statslibx.datasets", name)
-    if data_bytes is None:
-        raise FileNotFoundError(f"Dataset '{name}' no encontrado.")
-    
-    if backend == "pandas":
-        return pd.read_csv(io.BytesIO(data_bytes))
-    elif backend == "polars":
-        return pl.read_csv(io.BytesIO(data_bytes))
-    else:
+
+    if backend not in _SUPPORTED_BACKENDS:
         raise ValueError(
-            "Backend no soportado. Use 'pandas' o 'polars'."
+            f"Backend '{backend}' no soportado. "
+            f"Use uno de {_SUPPORTED_BACKENDS}."
         )
-    
+
+    df = None
+
+    # ---------- 1️⃣ Intentar cargar desde el paquete ----------
+    try:
+        data_bytes = pkgutil.get_data("statslibx.datasets", name)
+        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))
+            )
+    except FileNotFoundError:
+        pass  # seguimos al siguiente intento
+
+    # ---------- 2️⃣ Intentar cargar desde ruta local ----------
+    if df is None:
+        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'
-    ) -> Union[pd.DataFrame, pl.DataFrame]:
-    """Carga el dataset interno de la libreria: Iris
-    """
-    data_bytes = pkgutil.get_data("statslibx.datasets", "iris.csv")
-    if data_bytes is None:
-        raise FileNotFoundError(f"Dataset \"iris.csv\" no encontrado.")
-    
-    if backend == "pandas":
-        return pd.read_csv(io.BytesIO(data_bytes))
-    elif backend == "polars":
-        raise ValueError(
-            "Backend no soportado aun. Use 'pandas'."
-        )
-    else:
-        raise ValueError(
-            "Backend no soportado. Use 'pandas' o 'polars'."
-        )
-    
+    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'
-    ) -> Union[pd.DataFrame, pl.DataFrame]:
-    """Carga un dataset interno de la libreria: Penguins
-    """
-    data_bytes = pkgutil.get_data("statslibx.datasets", "penguins.csv")
-    if data_bytes is None:
-        raise FileNotFoundError(f"Dataset \"penguins.csv\" no encontrado.")
+    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")
     
-    if backend == "pandas":
-        return pd.read_csv(io.BytesIO(data_bytes))
-    elif backend == "polars":
-        raise ValueError(
-            "Backend no soportado aun. Use 'pandas'."
-        )
+
+
+    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:
-        raise ValueError(
-            "Backend no soportado. Use 'pandas' o 'polars'."
-        )
+        df = pd.DataFrame(data)
+        df.to_csv("dataset.csv", index=False)
 
+    return pd.DataFrame(data)

statslibx/descriptive.py

@@ -12,18 +12,82 @@ import base64
 import plotly.express as px
 
 class DescriptiveStats:
-    """
-    Clase para estadística descriptiva univariada y multivariada
-    Class for univariate and multivariate descriptive statistics
+    """    
+    DescriptiveStats
+    A class for performing univariate and multivariate descriptive statistical analysis. 
+    It provides tools for exploratory data analysis, measures of central tendency, 
+    dispersion, distribution shape, and linear regression.
+    Attributes:
+    -----------
+    data : pd.DataFrame
+        The dataset to analyze.
+    sep : str, optional
+        Column separator for file input.
+    decimal : str, optional
+        Decimal separator for file input.
+    thousand : str, optional
+        Thousand separator for file input.
+    backend : str, optional
+        Backend to use for processing ('pandas' or 'polars'). Default is 'pandas'.
+    lang : str, optional
+        Language for output ('es-ES' or 'en-US'). Default is 'es-ES'.
+    
+    Methods:
+    --------
+    from_file(path: str)
+        Load data from a file and return an instance of DescriptiveStats.
+    
+    mean(column: Optional[str] = None) -> Union[float, pd.Series]
+        Calculate the arithmetic mean of a column or all numeric columns.
+    
+    median(column: Optional[str] = None) -> Union[float, pd.Series]
+        Calculate the median of a column or all numeric columns.
+    
+    mode(column: Optional[str] = None)
+        Calculate the mode of a column or all numeric columns.
+    
+    variance(column: Optional[str] = None) -> Union[float, pd.Series]
+        Calculate the variance of a column or all numeric columns.
+    
+    std(column: Optional[str] = None) -> Union[float, pd.Series]
+        Calculate the standard deviation of a column or all numeric columns.
+    
+    skewness(column: Optional[str] = None) -> Union[float, pd.Series]
+        Calculate the skewness of a column or all numeric columns.
+    
+    kurtosis(column: Optional[str] = None) -> Union[float, pd.Series]
+        Calculate the kurtosis of a column or all numeric columns.
+    
+    quantile(q: Union[float, List[float]], column: Optional[str] = None)
+        Calculate quantiles for a column or all numeric columns.
+    
+    outliers(column: str, method: Literal['iqr', 'zscore'] = 'iqr', threshold: float = 1.5) -> pd.Series
+        Detect outliers in a column using IQR or z-score methods.
+    
+    correlation(method: Literal['pearson', 'spearman', 'kendall'] = 'pearson', columns: Optional[List[str]] = None) -> pd.DataFrame
+        Compute the correlation matrix for specified columns or all numeric columns.
+    
+    covariance(columns: Optional[List[str]] = None) -> pd.DataFrame
+        Compute the covariance matrix for specified columns or all numeric columns.
+    
+    summary(columns: Optional[List[str]] = None, show_plot: bool = False, plot_backend: str = 'seaborn') -> 'DescriptiveSummary'
+        Generate a complete descriptive statistics summary for specified columns or all numeric columns.
+    
+    linear_regression(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
+        Perform simple or multiple linear regression with optional visualization.
+    
+    help()
+        Display the complete help documentation for the DescriptiveStats class.
     """
     
     def __init__(self, data: Union[pd.DataFrame, np.ndarray],
                 sep: str = None,
                 decimal: str = None,
                 thousand: str = None,
-                backend: Literal['pandas', 'polars'] = 'pandas'):
+                backend: Literal['pandas', 'polars'] = 'pandas',
+                lang: Literal['es-ES', 'en-US'] = 'es-ES'):
         """
-        # Inicialize DataFrame
+        # Initialize DataFrame
         
         ## **Parameters:**
 
@@ -54,7 +118,8 @@ class DescriptiveStats:
             if data.ndim == 1:
                 data = pd.DataFrame({'var': data})
             else:
-                data = pd.DataFrame(data, columns=[f'var_{i}' for i in range(data.shape[1])])
+                data = pd.DataFrame(data, columns=[f'var_{i}' for i in range(data.shape[1])]) \
+                    if isinstance(data, pd.DataFrame) else pl.DataFrame(data, )
         
         self.data = data
         self.backend = backend
@@ -62,6 +127,7 @@ class DescriptiveStats:
         self.sep = sep
         self.decimal = decimal
         self.thousand = thousand
+        self.lang = lang
     
     @classmethod
     def from_file(self, path: str):
@@ -394,7 +460,7 @@ class DescriptiveStats:
 
 
     
-    def help(self, lang="es-Es"):
+    def help(self):
         """
         Muestra ayuda completa de la clase DescriptiveStats
 
@@ -404,12 +470,13 @@ class DescriptiveStats:
             Idioma Usuario: Codigo de Idioma (es-Es) o "Español"
             User Language: Languaje Code (en-Us) or "English"
         """
-        if lang in ["en-US", "English", "english"]:
-            lang = "en-US"
+        if self.lang in ["en-US", "English", "english"]:
+            self.lang = "en-US"
         else:
-            lang = ""
+            self.lang = "es-ES"
+        help_text = " "
 
-        match lang:
+        match self.lang:
             case "es-ES":
                 help_text = """
 ╔════════════════════════════════════════════════════════════════════════════╗
@@ -614,10 +681,9 @@ class DescriptiveStats:
 ╚════════════════════════════════════════════════════════════════════════════╝
     """
             case "en-US":
-                # --- Falta por traducir
                 help_text = """
 ╔════════════════════════════════════════════════════════════════════════════╗
-║                    📊 DescriptiveStats CLASS - COMPLETE HELP               ║
+║                    📊 CLASS DescriptiveStats  - COMPLETE HELP              ║
 ╚════════════════════════════════════════════════════════════════════════════╝
 
 📝 DESCRIPTION:
@@ -821,8 +887,7 @@ class DescriptiveStats:
         
         print(help_text)
 
-    
-    
+
 class DescriptiveSummary:
     """Clase para formatear salida de estadística descriptiva"""