lessPython 0.1.0__py3-none-any.whl

lessPy/rename.py

@@ -0,0 +1,33 @@
+# rename.py — analog of rename.R.
+#
+# rename(): rename one or more columns of a data frame, reporting
+# each old --> new change, and return the renamed data frame.
+# R's from/to are `old` and `new` here (`from` is a Python
+# keyword); each is a column name or a list of names.
+
+import pandas as pd
+
+
+def rename(data, old, new):
+    """Rename columns of data: old (a name or list of names) to
+    new (the same length). Prints each change and returns the
+    renamed DataFrame (a copy). R analog: rename() (from/to)."""
+    if not isinstance(data, pd.DataFrame):
+        raise TypeError("data must be a pandas DataFrame")
+    old = [old] if isinstance(old, str) else list(old)
+    new = [new] if isinstance(new, str) else list(new)
+    if len(old) != len(new):
+        raise ValueError(
+            f"old has {len(old)} name(s) but new has {len(new)}; "
+            "they must match")
+    missing = [c for c in old if c not in data.columns]
+    if missing:
+        raise ValueError(
+            f"not columns of data: {', '.join(map(str, missing))}")
+
+    out = data.rename(columns=dict(zip(old, new)))
+    print("Change the following variable names:\n")
+    for o, n in zip(old, new):
+        print(f"{o} --> {n}")
+    print()
+    return out

lessPy/reshape.py

@@ -0,0 +1,95 @@
+# reshape.py — analog of reshape_long.R and reshape_wide.R.
+#
+# reshape_long(): wide -> long, either the "rect" melt of a set of
+# columns into a group/response pair, or the "square" conversion
+# of a matrix (rows x cols) into a Row/Col/value long form for a
+# heat map. reshape_wide(): the inverse long -> wide pivot.
+# Thin wrappers over pandas melt / pivot that reproduce lessR's
+# column naming, ID handling, and (square) factor-level order.
+
+import numpy as np
+import pandas as pd
+
+_DEFAULT = object()          # prefix sentinel: default to the ID
+
+
+def reshape_long(data, transform=None, group=None,
+                 response="Response", ID="ID", prefix=_DEFAULT,
+                 sep="", shape="rect", reverse_y=None):
+    """Reshape wide data to long. shape="rect" stacks the
+    transform columns into a group column (their names) and a
+    response column (their values), adding an ID for the original
+    row. shape="square" turns a matrix (a correlation or
+    frequency table) into Row/Col/value long form for a heat map.
+    R analog: reshape_long()"""
+    if shape not in ("rect", "square"):
+        raise ValueError('shape: "rect" or "square"')
+    if shape == "square":
+        return _reshape_square(data, group, response, reverse_y)
+
+    if transform is None:
+        raise ValueError("reshape_long needs transform=, the "
+                         "columns to stack into long form")
+    transform = [transform] if isinstance(transform, str) \
+        else list(transform)
+    grp = "Group" if group is None else group
+    id_vars = [c for c in data.columns if c not in transform]
+    long = data.melt(id_vars=id_vars, value_vars=transform,
+                     var_name=grp, value_name=response)
+
+    if ID is not None:
+        if prefix is _DEFAULT:
+            prefix = ID
+        if ID not in data.columns:        # synthetic row id 1..n
+            long.insert(0, ID, np.tile(
+                np.arange(1, len(data) + 1), len(transform)))
+        if prefix is not None:
+            long[ID] = [f"{prefix}{sep}{v}" for v in long[ID]]
+            long = long[[ID] + [c for c in long.columns
+                                if c != ID]]
+    return long.reset_index(drop=True)
+
+
+def _reshape_square(data, group, response, reverse_y):
+    """Matrix -> long, column-major (Row varies fastest within
+    Col), as R's as.data.frame(as.table()). ~ reshape_long square"""
+    var1, var2 = (("Row", "Col") if group is None
+                  else (f"{group}1", f"{group}2"))
+    df = pd.DataFrame(data)
+    rows = [str(r) for r in df.index]
+    cols = [str(c) for c in df.columns]
+    tmp = df.copy()
+    tmp.index, tmp.columns = rows, cols
+    tmp.index.name = var1
+    long = tmp.reset_index().melt(id_vars=var1, var_name=var2,
+                                  value_name=response)
+    if reverse_y is None:
+        reverse_y = True
+        print('reshape_long: for shape="square", row levels are '
+              "reversed by default so the first row appears at "
+              'the top of a heat map y-axis.\n  Set '
+              "reverse_y=False to keep the original row order.")
+    long[var1] = pd.Categorical(
+        long[var1], categories=rows[::-1] if reverse_y else rows)
+    long[var2] = pd.Categorical(long[var2], categories=cols)
+    return long
+
+
+def reshape_wide(data, widen, response, ID, prefix=None,
+                 sep="_"):
+    """Reshape long data to wide: each value of widen becomes a
+    column, filled from response, one row per ID. Extra columns
+    are dropped. By default the response prefix on the new column
+    names is kept only when widen is numeric. R analog:
+    reshape_wide()"""
+    wide = data[[ID, widen, response]].pivot(
+        index=ID, columns=widen, values=response)
+    if prefix is None:
+        prefix = pd.api.types.is_numeric_dtype(data[widen])
+    if prefix:
+        wide.columns = [f"{response}{sep}{c}" for c in wide.columns]
+    else:
+        wide.columns = [str(c) for c in wide.columns]
+    wide = wide.reset_index()
+    wide.columns.name = None
+    return wide

lessPy/showColors.py

@@ -0,0 +1,130 @@
+# showColors.py — analog of showColors.R.
+#
+# showColors(): display the named colors as a labeled grid of
+# swatches, each with its name and RGB, optionally filtered to
+# names containing a substring. R shows its colors() database and
+# writes a PDF; here the standard CSS named colors (which plotly
+# accepts) are shown, returning a plotly figure.
+
+from .plotly_utils import hex_to_rgb3
+
+# the 148 standard CSS (Color Module Level 4) named colors
+_NAMED = {
+    "aliceblue": "#F0F8FF", "antiquewhite": "#FAEBD7",
+    "aqua": "#00FFFF", "aquamarine": "#7FFFD4",
+    "azure": "#F0FFFF", "beige": "#F5F5DC",
+    "bisque": "#FFE4C4", "black": "#000000",
+    "blanchedalmond": "#FFEBCD", "blue": "#0000FF",
+    "blueviolet": "#8A2BE2", "brown": "#A52A2A",
+    "burlywood": "#DEB887", "cadetblue": "#5F9EA0",
+    "chartreuse": "#7FFF00", "chocolate": "#D2691E",
+    "coral": "#FF7F50", "cornflowerblue": "#6495ED",
+    "cornsilk": "#FFF8DC", "crimson": "#DC143C",
+    "cyan": "#00FFFF", "darkblue": "#00008B",
+    "darkcyan": "#008B8B", "darkgoldenrod": "#B8860B",
+    "darkgray": "#A9A9A9", "darkgreen": "#006400",
+    "darkgrey": "#A9A9A9", "darkkhaki": "#BDB76B",
+    "darkmagenta": "#8B008B", "darkolivegreen": "#556B2F",
+    "darkorange": "#FF8C00", "darkorchid": "#9932CC",
+    "darkred": "#8B0000", "darksalmon": "#E9967A",
+    "darkseagreen": "#8FBC8F", "darkslateblue": "#483D8B",
+    "darkslategray": "#2F4F4F", "darkslategrey": "#2F4F4F",
+    "darkturquoise": "#00CED1", "darkviolet": "#9400D3",
+    "deeppink": "#FF1493", "deepskyblue": "#00BFFF",
+    "dimgray": "#696969", "dimgrey": "#696969",
+    "dodgerblue": "#1E90FF", "firebrick": "#B22222",
+    "floralwhite": "#FFFAF0", "forestgreen": "#228B22",
+    "fuchsia": "#FF00FF", "gainsboro": "#DCDCDC",
+    "ghostwhite": "#F8F8FF", "gold": "#FFD700",
+    "goldenrod": "#DAA520", "gray": "#808080",
+    "green": "#008000", "greenyellow": "#ADFF2F",
+    "grey": "#808080", "honeydew": "#F0FFF0",
+    "hotpink": "#FF69B4", "indianred": "#CD5C5C",
+    "indigo": "#4B0082", "ivory": "#FFFFF0",
+    "khaki": "#F0E68C", "lavender": "#E6E6FA",
+    "lavenderblush": "#FFF0F5", "lawngreen": "#7CFC00",
+    "lemonchiffon": "#FFFACD", "lightblue": "#ADD8E6",
+    "lightcoral": "#F08080", "lightcyan": "#E0FFFF",
+    "lightgoldenrodyellow": "#FAFAD2", "lightgray": "#D3D3D3",
+    "lightgreen": "#90EE90", "lightgrey": "#D3D3D3",
+    "lightpink": "#FFB6C1", "lightsalmon": "#FFA07A",
+    "lightseagreen": "#20B2AA", "lightskyblue": "#87CEFA",
+    "lightslategray": "#778899", "lightslategrey": "#778899",
+    "lightsteelblue": "#B0C4DE", "lightyellow": "#FFFFE0",
+    "lime": "#00FF00", "limegreen": "#32CD32",
+    "linen": "#FAF0E6", "magenta": "#FF00FF",
+    "maroon": "#800000", "mediumaquamarine": "#66CDAA",
+    "mediumblue": "#0000CD", "mediumorchid": "#BA55D3",
+    "mediumpurple": "#9370DB", "mediumseagreen": "#3CB371",
+    "mediumslateblue": "#7B68EE", "mediumspringgreen": "#00FA9A",
+    "mediumturquoise": "#48D1CC", "mediumvioletred": "#C71585",
+    "midnightblue": "#191970", "mintcream": "#F5FFFA",
+    "mistyrose": "#FFE4E1", "moccasin": "#FFE4B5",
+    "navajowhite": "#FFDEAD", "navy": "#000080",
+    "oldlace": "#FDF5E6", "olive": "#808000",
+    "olivedrab": "#6B8E23", "orange": "#FFA500",
+    "orangered": "#FF4500", "orchid": "#DA70D6",
+    "palegoldenrod": "#EEE8AA", "palegreen": "#98FB98",
+    "paleturquoise": "#AFEEEE", "palevioletred": "#DB7093",
+    "papayawhip": "#FFEFD5", "peachpuff": "#FFDAB9",
+    "peru": "#CD853F", "pink": "#FFC0CB",
+    "plum": "#DDA0DD", "powderblue": "#B0E0E6",
+    "purple": "#800080", "rebeccapurple": "#663399",
+    "red": "#FF0000", "rosybrown": "#BC8F8F",
+    "royalblue": "#4169E1", "saddlebrown": "#8B4513",
+    "salmon": "#FA8072", "sandybrown": "#F4A460",
+    "seagreen": "#2E8B57", "seashell": "#FFF5EE",
+    "sienna": "#A0522D", "silver": "#C0C0C0",
+    "skyblue": "#87CEEB", "slateblue": "#6A5ACD",
+    "slategray": "#708090", "slategrey": "#708090",
+    "snow": "#FFFAFA", "springgreen": "#00FF7F",
+    "steelblue": "#4682B4", "tan": "#D2B48C",
+    "teal": "#008080", "thistle": "#D8BFD8",
+    "tomato": "#FF6347", "turquoise": "#40E0D0",
+    "violet": "#EE82EE", "wheat": "#F5DEB3",
+    "white": "#FFFFFF", "whitesmoke": "#F5F5F5",
+    "yellow": "#FFFF00", "yellowgreen": "#9ACD32",
+}
+
+
+def showColors(color=None, n_col=6):
+    """Show the named colors as a labeled grid of swatches, one
+    per color with its name and RGB. color= keeps only the names
+    that contain that substring. Returns a plotly figure.
+    R analog: showColors()"""
+    names = sorted(_NAMED)
+    if color is not None:
+        names = [n for n in names if color.lower() in n.lower()]
+    if not names:
+        raise ValueError(f"no named color contains '{color}'")
+
+    import plotly.graph_objects as go
+    n = len(names)
+    n_row = (n + n_col - 1) // n_col
+    xs, ys, cols, texts, hovers = [], [], [], [], []
+    for i, nm in enumerate(names):
+        r, c = i // n_col, i % n_col
+        xs.append(c)
+        ys.append(n_row - 1 - r)           # first color at top
+        hx = _NAMED[nm]
+        cols.append(hx)
+        texts.append(nm)
+        rr, gg, bb = hex_to_rgb3(hx)
+        hovers.append(f"{nm}<br>{hx}<br>rgb({rr},{gg},{bb})")
+
+    fig = go.Figure(go.Scatter(
+        x=xs, y=ys, mode="markers+text",
+        marker=dict(symbol="square", size=34, color=cols,
+                    line=dict(color="#999999", width=1)),
+        text=texts, textposition="bottom center",
+        textfont=dict(size=9),
+        hovertext=hovers, hoverinfo="text"))
+    fig.update_xaxes(visible=False, range=[-0.5, n_col - 0.5])
+    fig.update_yaxes(visible=False, range=[-0.7, n_row - 0.3])
+    fig.update_layout(
+        template=None, plot_bgcolor="white", paper_bgcolor="white",
+        margin=dict(t=30, r=20, b=20, l=20),
+        height=max(200, 60 * n_row),
+        title=dict(text="Named Colors", x=0.5,
+                   xanchor="center"))
+    return fig

lessPy/simCImean.py

@@ -0,0 +1,165 @@
+# simCImean.py — analog of simCImean.R.
+#
+# simCImean(): draw ns samples of size n from a normal population
+# and form a confidence interval for the mean from each. Plot the
+# intervals as vertical bars against a centerline at the true mean
+# mu, colored by whether they capture mu, and report the miss
+# rate — a demonstration that a cl-level interval misses mu about
+# (1 - cl) of the time. Prints the per-sample table and the
+# structure/performance summaries, and returns a results object
+# with the plotly figure in .plots.
+#
+# The draws use numpy's RNG (seed=), so they do not reproduce R's
+# stream value-for-value (a simulation, like the other sim*).
+# R's interactive "pause" mode is not ported.
+
+import numpy as np
+
+from .utils import fmt
+
+
+class SimCImeanResults:
+    """Numeric results of simCImean(): the per-sample means, SDs,
+    interval bounds (lb/ub) and hit/miss flags, the miss count and
+    rate, the t cutoff, and the plotly figure in .plots ("ci")."""
+
+    def __init__(self, **kw):
+        self.__dict__.update(kw)
+
+    def __repr__(self):
+        return (f"<lessPy simCImean: ns={self.n_samples}, "
+                f"n={self.n}, misses={self.n_miss}>")
+
+
+def simCImean(ns=None, n=None, mu=0, sigma=1, cl=0.95, seed=None,
+              show_data=False, show_title=True, miss_only=False,
+              color_hit="gray", color_miss="red", grid="#E5E5E5",
+              ylim_bound=None, digits_d=3):
+    """Simulate ns confidence intervals for a mean: ns samples of
+    size n from a normal population (mean mu, sd sigma), each
+    giving a cl-level t interval. Plots the intervals about a
+    centerline at mu, colored by hit/miss, and reports the miss
+    rate. miss_only lists only the intervals that miss mu;
+    show_data overlays the raw values. Prints the tables and
+    returns a SimCImeanResults with .plots. R analog: simCImean()"""
+    from scipy.stats import t as t_dist
+    if ns is None:
+        raise ValueError("specify the number of samples: ns")
+    if n is None:
+        raise ValueError("specify the size of each sample: n")
+    if sigma < 0:
+        raise ValueError("sigma cannot be negative")
+    if not 0 < cl < 1:
+        raise ValueError("cl must be between 0 and 1")
+
+    alpha = 1 - cl
+    tcut = t_dist.ppf(1 - alpha / 2, df=n - 1)
+
+    rng = np.random.default_rng(seed)
+    data = rng.normal(mu, sigma, ns * n).reshape(ns, n)
+    ymean = data.mean(axis=1)
+    ysd = data.std(axis=1, ddof=1)
+
+    se = ysd / np.sqrt(n)
+    E = tcut * se
+    lb, ub = ymean - E, ymean + E
+    hit = (lb < mu) & (ub > mu)
+    n_miss = int((~hit).sum())
+    miss_rate = round(n_miss / ns * 100, 2)
+
+    if ylim_bound is None:
+        if show_data:
+            lo0, hi0 = data.min(), data.max()
+        else:
+            lo0, hi0 = lb.min(), ub.max()
+        dev = max(abs(mu - lo0), abs(hi0 - mu))
+        lo, hi = mu - dev, mu + dev
+    else:
+        lo, hi = mu - ylim_bound, mu + ylim_bound
+
+    fig = _plot(ns, n, ymean, E, lb, ub, hit, mu, sigma, cl, data,
+                lo, hi, grid, color_hit, color_miss, show_data,
+                show_title)
+
+    _report(ns, n, ymean, ysd, se, E, lb, ub, hit, mu, sigma, cl,
+            n_miss, miss_rate, miss_only, digits_d)
+
+    return SimCImeanResults(
+        mu=mu, sigma=sigma, cl=cl, n_samples=ns, n=n, tcut=tcut,
+        ymean=ymean, ysd=ysd, lb=lb, ub=ub, hit=hit,
+        n_miss=n_miss, miss_rate=miss_rate,
+        mean_of_means=ymean.mean(), sd_of_means=ymean.std(ddof=1),
+        plots={"ci": fig})
+
+
+def _plot(ns, n, ymean, E, lb, ub, hit, mu, sigma, cl, data, lo,
+          hi, grid, color_hit, color_miss, show_data, show_title):
+    import plotly.graph_objects as go
+    x = np.arange(1, ns + 1)
+    fig = go.Figure()
+    if show_data:
+        fig.add_trace(go.Scatter(
+            x=np.repeat(x, n), y=data.ravel(), mode="markers",
+            marker=dict(size=2.5, color="gray"), opacity=0.5,
+            showlegend=False, hoverinfo="skip"))
+    fig.add_hline(y=mu, line=dict(color="darkslateblue",
+                                  width=1.5))
+    for mask, col, nm in ((hit, color_hit, "capture μ"),
+                          (~hit, color_miss, "miss μ")):
+        if not mask.any():
+            continue
+        fig.add_trace(go.Scatter(
+            x=x[mask], y=ymean[mask], mode="markers",
+            marker=dict(size=3, color=col),
+            error_y=dict(type="data", array=E[mask], color=col,
+                         thickness=1.5, width=3),
+            name=nm, showlegend=False,
+            hovertemplate="sample %{x}<br>mean %{y:.3f}"
+                          "<extra></extra>"))
+    title = (f"μ={mu}  σ={sigma}  cl={round(cl * 100, 2)}%  "
+             f"n={n}") if show_title else ""
+    fig.update_layout(
+        plot_bgcolor="#FAFAFA", paper_bgcolor="white",
+        margin=dict(t=36, r=30, b=30, l=50),
+        xaxis=dict(title="", range=[0, ns + 1], showgrid=False,
+                   linecolor="black", mirror=True),
+        yaxis=dict(title="", range=[lo, hi], showgrid=True,
+                   gridcolor=grid, gridwidth=0.5,
+                   linecolor="black", mirror=True),
+        title=dict(text=title, x=0.5, xanchor="center",
+                   font=dict(size=12)))
+    return fig
+
+
+def _report(ns, n, ymean, ysd, se, E, lb, ub, hit, mu, sigma, cl,
+            n_miss, miss_rate, miss_only, digits_d):
+    w = 8
+    def c(v):
+        return f"{fmt(v, digits_d):>{w}}"
+    print(f"\n{'Sample':>6}{'Mean':>{w}}{'StdDev':>{w}}"
+          f"{'StdErr':>{w}}{'Error':>{w}}{'LB':>{w}}{'UB':>{w}}")
+    for i in range(ns):
+        if miss_only and hit[i]:
+            continue
+        row = (f"{i + 1:>6}{c(ymean[i])}{c(ysd[i])}{c(se[i])}"
+               f"{c(E[i])}{c(lb[i])}{c(ub[i])}")
+        if not hit[i]:
+            row += "  *** MISS ***"
+        print(row)
+
+    print("\nStructure")
+    print(f"Population mean, mu : {mu}")
+    print(f"Pop std dev, sigma  : {sigma}")
+    print(f"Number of samples   : {ns}")
+    print(f"Size of each sample : {n}")
+    print(f"Confidence level    : {cl}")
+
+    print("\nPerformance")
+    print(f"Number of Misses: {n_miss}")
+    print(f"Percent Misses  : {miss_rate:.2f}")
+
+    d2 = digits_d + 1
+    print("\nAnalysis of Sample Means")
+    print(f"   Mean: {fmt(ymean.mean(), d2):>{w}}")
+    print(f"Std Dev: {fmt(ymean.std(ddof=1), d2):>{w}}")
+    print()