one-stop-analytics 1.13.11__py3-none-any.whl

one_stop_analytics/__init__.py

@@ -0,0 +1,49 @@
+"""One Stop Analytics - lazy, cross-platform data analytics toolkit."""
+
+__version__ = "1.13.11"
+__all__ = ["OSAError", "ConfigurationError", "ResourceLimitError", "BatchError","Analytics", "DataCleaner", "Metrics", "Profiler", "EDAEngine", "batch_analyze", "clear_cache", "Transformer", "time_series", "forecast", "auto_ml", "bootstrap_ci", "rfm", "abc_analysis", "cohort", "retention", "funnel", "clv", "pareto", "Workspace", "open_workspace", "CanonicalReport", "LargeDataEngine", "DatabaseConnector", "build_canonical_report", "export_report_bundle", "export_excel_report", "create_interactive_dashboard", "reconcile_credit_note_lines"]
+
+_LAZY = {
+    "OSAError": (".exceptions", "OSAError"),
+    "ConfigurationError": (".exceptions", "ConfigurationError"),
+    "ResourceLimitError": (".exceptions", "ResourceLimitError"),
+    "BatchError": (".exceptions", "BatchError"),
+    "Analytics": (".analytics", "Analytics"),
+    "Workspace": (".workspace", "Workspace"),
+    "open_workspace": (".workspace", "open_workspace"),
+    "CanonicalReport": (".platform", "CanonicalReport"),
+    "LargeDataEngine": (".platform", "LargeDataEngine"),
+    "DatabaseConnector": (".platform", "DatabaseConnector"),
+    "build_canonical_report": (".platform", "build_canonical_report"),
+    "export_report_bundle": (".platform", "export_report_bundle"),
+    "export_excel_report": (".platform", "export_excel_report"),
+    "create_interactive_dashboard": (".platform", "create_interactive_dashboard"),
+    "reconcile_credit_note_lines": (".credit_note_reconciliation", "reconcile_credit_note_lines"),
+    "DataCleaner": (".cleaning", "DataCleaner"),
+    "Metrics": (".metrics", "Metrics"),
+    "Profiler": (".profiling", "Profiler"),
+    "EDAEngine": (".eda", "EDAEngine"),
+    "batch_analyze": (".batch", "batch_analyze"),
+    "clear_cache": (".cache", "clear_cache"),
+    "Transformer": (".transform", "Transformer"),
+    "time_series": (".time_series", "analyze_timeseries"),
+    "forecast": (".time_series", "analyze_timeseries"),
+    "auto_ml": (".advanced_ml", "auto_ml"),
+    "bootstrap_ci": (".advanced_statistics", "bootstrap_ci"),
+    "rfm": (".business_analytics", "rfm"),
+    "abc_analysis": (".business_analytics", "abc_analysis"),
+    "cohort": (".business_analytics", "cohort"),
+    "retention": (".business_analytics", "retention"),
+    "funnel": (".business_analytics", "funnel"),
+    "clv": (".business_analytics", "clv"),
+    "pareto": (".business_analytics", "pareto"),
+}
+
+def __getattr__(name):
+    if name in _LAZY:
+        module_name, attr_name = _LAZY[name]
+        from importlib import import_module
+        value = getattr(import_module(module_name, __name__), attr_name)
+        globals()[name] = value
+        return value
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

one_stop_analytics/advanced_ml.py

@@ -0,0 +1,139 @@
+
+"""Advanced ML and lightweight AutoML without heavyweight external ML frameworks."""
+from __future__ import annotations
+
+def _clean_xy(X, y, max_rows=30000, random_state=42):
+    import pandas as pd
+    from .ml import _normalize_frame
+    X = _normalize_frame(X).reset_index(drop=True)
+    y = pd.Series(y).reset_index(drop=True)
+    if len(X) != len(y):
+        raise ValueError(f"X and y must have the same number of rows (got {len(X)} and {len(y)}).")
+    # Remove unlabeled rows before CV or fitting; pd.NA cannot be a target.
+    valid = y.notna()
+    X, y = X.loc[valid].reset_index(drop=True), y.loc[valid].reset_index(drop=True)
+    if pd.api.types.is_numeric_dtype(y.dtype):
+        y = y.astype("int64") if pd.api.types.is_integer_dtype(y.dtype) else y.astype("float64")
+    else:
+        y = y.astype(object)
+    # Make datetime predictors ML-safe while retaining temporal signal.
+    for c in list(X.columns):
+        if pd.api.types.is_datetime64_any_dtype(X[c]):
+            dt = pd.to_datetime(X[c], errors="coerce")
+            X[c] = (dt.astype("int64") / 86400000000000.0).replace({-9.223372036854776e+18: float("nan")})
+    valid = y.notna()
+    X, y = X.loc[valid].reset_index(drop=True), y.loc[valid].reset_index(drop=True)
+    if max_rows and len(X) > max_rows:
+        from sklearn.model_selection import train_test_split
+        try:
+            X, _, y, _ = train_test_split(X, y, train_size=max_rows, random_state=random_state,
+                                          stratify=y if y.nunique() <= 50 else None)
+        except Exception:
+            idx = X.sample(n=max_rows, random_state=random_state).index
+            X, y = X.loc[idx], y.loc[idx]
+        X, y = X.reset_index(drop=True), y.reset_index(drop=True)
+    return X, y
+
+def _prep(X, scale=False, max_categories=50):
+    import numpy as np
+    from sklearn.compose import ColumnTransformer
+    from sklearn.impute import SimpleImputer
+    from sklearn.pipeline import Pipeline
+    from sklearn.preprocessing import OneHotEncoder, StandardScaler
+    num = X.select_dtypes(include=np.number).columns.tolist()
+    cat = X.select_dtypes(exclude=np.number).columns.tolist()
+    ns = [("imputer", SimpleImputer(strategy="median"))]
+    if scale: ns.append(("scaler", StandardScaler()))
+    cs = [("imputer", SimpleImputer(strategy="most_frequent")),
+          ("onehot", OneHotEncoder(handle_unknown="ignore", min_frequency=2,
+                                   max_categories=max_categories))]
+    return ColumnTransformer([("num", Pipeline(ns), num), ("cat", Pipeline(cs), cat)],
+                             remainder="drop")
+
+def _metrics(task, y, pred, proba=None):
+    from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score
+    from sklearn.metrics import roc_auc_score, mean_absolute_error, mean_squared_error, r2_score
+    if task == "classification":
+        m = {"accuracy": float(accuracy_score(y,pred)),
+             "precision": float(precision_score(y,pred,average="weighted",zero_division=0)),
+             "recall": float(recall_score(y,pred,average="weighted",zero_division=0)),
+             "f1": float(f1_score(y,pred,average="weighted",zero_division=0))}
+        if proba is not None and len(getattr(proba, "shape", ())) == 2 and proba.shape[1] == 2:
+            try: m["roc_auc"] = float(roc_auc_score(y, proba[:,1]))
+            except (ValueError, TypeError, IndexError):
+                m["roc_auc"] = None
+        return m
+    return {"r2": float(r2_score(y,pred)),
+            "rmse": float(mean_squared_error(y,pred)**0.5),
+            "mae": float(mean_absolute_error(y,pred))}
+
+def auto_ml(X, y, task="auto", cv=3, max_rows=30000, random_state=42,
+            max_categories=50, scoring=None, include_svm=True, n_jobs=1):
+    """Small, robust AutoML model comparison with cross-validation."""
+    import numpy as np
+    from .ml import _normalize_frame
+    from sklearn.pipeline import Pipeline
+    from sklearn.preprocessing import FunctionTransformer
+    from sklearn.model_selection import cross_val_score
+    from sklearn.linear_model import LogisticRegression, Ridge
+    from sklearn.ensemble import RandomForestClassifier, ExtraTreesClassifier, GradientBoostingClassifier
+    from sklearn.ensemble import RandomForestRegressor, ExtraTreesRegressor, GradientBoostingRegressor
+    from sklearn.svm import SVC, SVR
+
+    X, y = _clean_xy(X,y,max_rows,random_state)
+    if task == "auto":
+        task = "classification" if y.dtype == "object" or y.nunique() <= 10 else "regression"
+    if task not in {"classification","regression"}:
+        raise ValueError("task must be auto, classification, or regression")
+    if task == "classification":
+        models = {
+            "logistic": LogisticRegression(max_iter=1200),
+            "random_forest": RandomForestClassifier(n_estimators=120,max_depth=18,n_jobs=1,random_state=random_state),
+            "extra_trees": ExtraTreesClassifier(n_estimators=120,max_depth=18,n_jobs=1,random_state=random_state),
+            "gradient_boosting": GradientBoostingClassifier(n_estimators=120,max_depth=3,random_state=random_state),
+        }
+        if include_svm: models["svm"] = SVC(probability=True, random_state=random_state)
+        default_scoring = scoring or "f1_weighted"
+    else:
+        models = {
+            "ridge": Ridge(),
+            "random_forest": RandomForestRegressor(n_estimators=120,max_depth=18,n_jobs=1,random_state=random_state),
+            "extra_trees": ExtraTreesRegressor(n_estimators=120,max_depth=18,n_jobs=1,random_state=random_state),
+            "gradient_boosting": GradientBoostingRegressor(n_estimators=120,max_depth=3,random_state=random_state),
+        }
+        if include_svm: models["svm"] = SVR()
+        default_scoring = scoring or "r2"
+
+    results=[]
+    best_name=None; best_score=-float("inf"); best_pipe=None
+    for name, model in models.items():
+        pipe=Pipeline([("normalize", FunctionTransformer(_normalize_frame, feature_names_out="one-to-one")),
+                       ("preprocess",_prep(X,scale=name in {"logistic","ridge","svm"},max_categories=max_categories)),
+                       ("model",model)])
+        try:
+            scores=cross_val_score(pipe,X,y,cv=cv,scoring=default_scoring,n_jobs=n_jobs)
+            score=float(np.mean(scores))
+            results.append({"model":name,"cv_score":score,"cv_std":float(np.std(scores)),"scoring":default_scoring})
+            if score > best_score:
+                best_score, best_name, best_pipe = score, name, pipe
+        except Exception as e:
+            results.append({"model":name,"cv_score":None,"error":str(e),"scoring":default_scoring})
+    if best_pipe is None:
+        raise RuntimeError("AutoML could not fit any candidate model.")
+    best_pipe.fit(X,y)
+    return {"task":task,"scoring":default_scoring,"leaderboard":results,
+            "best_model":best_name,"best_score":float(best_score),"model":best_pipe}
+
+def gradient_boosting(X,y,task="auto",max_rows=30000,random_state=42,**kwargs):
+    """Gradient boosting wrapper using histogram-based sklearn estimators."""
+    from .ml import _normalize_frame
+    from sklearn.ensemble import HistGradientBoostingClassifier, HistGradientBoostingRegressor
+    from sklearn.pipeline import Pipeline
+    from sklearn.preprocessing import FunctionTransformer
+    X, y = _clean_xy(X,y,max_rows,random_state)
+    if task=="auto": task="classification" if y.dtype=="object" or y.nunique()<=10 else "regression"
+    model = HistGradientBoostingClassifier(random_state=random_state, **kwargs) if task=="classification" else HistGradientBoostingRegressor(random_state=random_state, **kwargs)
+    pipe=Pipeline([("normalize", FunctionTransformer(_normalize_frame, feature_names_out="one-to-one")),
+                   ("preprocess",_prep(X,max_categories=50)),("model",model)])
+    pipe.fit(X,y)
+    return pipe

one_stop_analytics/advanced_statistics.py

@@ -0,0 +1,114 @@
+
+"""Advanced statistical analysis helpers."""
+from __future__ import annotations
+
+def _arr(x):
+    import numpy as np
+    a = np.asarray(x, dtype=float)
+    return a[np.isfinite(a)]
+
+def effect_size(a, b, kind="cohens_d"):
+    import numpy as np
+    x, y = _arr(a), _arr(b)
+    if len(x) < 2 or len(y) < 2:
+        return float("nan")
+    if kind.lower() in {"cohens_d", "d"}:
+        nx, ny = len(x), len(y)
+        pooled = np.sqrt(((nx-1)*np.var(x, ddof=1)+(ny-1)*np.var(y, ddof=1))/(nx+ny-2))
+        return float((np.mean(x)-np.mean(y))/pooled) if pooled else float("nan")
+    if kind.lower() in {"cliffs_delta", "cliff"}:
+        return float(_cliffs_delta(x, y))
+    raise ValueError("kind must be cohens_d or cliffs_delta")
+
+def _cliffs_delta(x, y):
+    import numpy as np
+    # Efficient rank-based calculation
+    z = np.concatenate([x, y])
+    # rankdata already performs the required sort and tie handling.
+    from scipy.stats import rankdata
+    ranks = rankdata(z, method="average")
+    rx = ranks[:len(x)].sum()
+    ry = ranks[len(x):].sum()
+    u_x = rx - len(x)*(len(x)+1)/2
+    return (2*u_x)/(len(x)*len(y))-1
+
+def mann_whitney(a, b):
+    from scipy import stats
+    return stats.mannwhitneyu(_arr(a), _arr(b), alternative="two-sided")
+
+def wilcoxon(a, b):
+    from scipy import stats
+    return stats.wilcoxon(_arr(a), _arr(b))
+
+def kruskal(*groups):
+    from scipy import stats
+    return stats.kruskal(*[_arr(g) for g in groups])
+
+def spearman(x, y):
+    from scipy import stats
+    return stats.spearmanr(_arr(x), _arr(y), nan_policy="omit")
+
+def kendall(x, y):
+    from scipy import stats
+    return stats.kendalltau(_arr(x), _arr(y), nan_policy="omit")
+
+def bootstrap_ci(x, statistic="mean", confidence=.95, n_resamples=2000, random_state=42):
+    import numpy as np
+    from scipy.stats import bootstrap
+    a = _arr(x)
+    if len(a) < 2:
+        return (float("nan"), float("nan"))
+    if statistic == "mean":
+        fn = lambda z, axis: np.mean(z, axis=axis)
+    elif statistic == "median":
+        fn = lambda z, axis: np.median(z, axis=axis)
+    else:
+        raise ValueError("statistic must be mean or median")
+    rng = np.random.default_rng(random_state)
+    res = bootstrap((a,), fn, confidence_level=confidence, n_resamples=n_resamples,
+                    random_state=rng, method="percentile")
+    return float(res.confidence_interval.low), float(res.confidence_interval.high)
+
+def regression_diagnostics(X, y):
+    """OLS coefficients, R², adjusted R², VIF and residual diagnostics."""
+    import numpy as np, pandas as pd
+    import statsmodels.api as sm
+    from statsmodels.stats.outliers_influence import variance_inflation_factor
+    Xn = X.select_dtypes(include=np.number).copy()
+    y = pd.Series(y).astype(float)
+    mask = y.notna()
+    Xn = Xn.loc[mask].replace([np.inf,-np.inf], np.nan)
+    data = pd.concat([Xn, y.loc[mask].rename("__y")], axis=1).dropna()
+    if data.empty or data.shape[1] < 2:
+        raise ValueError("Need numeric predictors and a numeric target.")
+    Xd = sm.add_constant(data.drop(columns="__y"), has_constant="add")
+    model = sm.OLS(data["__y"], Xd).fit()
+    vif = {}
+    for i, c in enumerate(Xd.columns):
+        if c == "const": continue
+        try: vif[c] = float(variance_inflation_factor(Xd.values, i))
+        except Exception: vif[c] = float("nan")
+    return {
+        "model": model,
+        "coefficients": model.params,
+        "pvalues": model.pvalues,
+        "r2": float(model.rsquared),
+        "adjusted_r2": float(model.rsquared_adj),
+        "aic": float(model.aic),
+        "bic": float(model.bic),
+        "vif": pd.Series(vif),
+        "residual_mean": float(model.resid.mean()),
+        "residual_std": float(model.resid.std(ddof=1)),
+    }
+
+def anova_effects(groups):
+    """One-way ANOVA plus eta-squared effect size."""
+    import numpy as np
+    from scipy import stats
+    clean = [_arr(g) for g in groups]
+    f, p = stats.f_oneway(*clean)
+    grand = np.mean(np.concatenate(clean))
+    ss_between = sum(len(g)*(np.mean(g)-grand)**2 for g in clean)
+    ss_total = sum(((g-grand)**2).sum() for g in clean)
+    eta2 = ss_between/ss_total if ss_total else float("nan")
+    return {"f": float(f), "p": float(p), "eta_squared": float(eta2)}