data-sampler 3.5.0__tar.gz → 3.5.2__tar.gz

{data_sampler-3.5.0 → data_sampler-3.5.2}/CHANGELOG.md

@@ -1,5 +1,46 @@
 # Changelog
 
+## v3.5.2 — 2026-07-24
+
+- **Continuous numeric columns are skipped by auto-stratification.** A numeric
+  column with any fractional values (prices, rates, measurements) is no longer
+  a stratification candidate, even at low cardinality — sampling proportionally
+  over arbitrary points on a continuum doesn't preserve anything meaningful.
+  Whole-number columns (ratings, counts — including float columns that hold
+  only whole numbers, the usual dtype once NaNs appear) remain candidates. The
+  rule applies uniformly to the pandas path (`is_stratifiable`), the DuckDB
+  engine (`find_stratification_columns` and the `stratifiable` stats flag, via
+  a same-pass `bool_or(x <> trunc(x))` probe on float-typed columns), and
+  therefore to the TUI's strat column display. Explicit `strat_cols=` still
+  forces any column.
+- **The rule is value-based, not dtype-based**, so both paths reach the same
+  verdict on every representation of the same numbers: parquet DECIMAL columns
+  (object-of-`Decimal` after `read_parquet`, or Arrow-backed decimal under
+  `dtype_backend='pyarrow'`), float-backed categorical columns (judged on
+  observed values — unused categories left behind by row filtering don't
+  count, matching what DuckDB registration sees), and object columns of
+  floats all count as continuous when their values are fractional. Caught by
+  pre-release adversarial review — the initial dtype-gated pandas check let a
+  DECIMAL parquet file stratify differently depending on whether the DuckDB
+  engine handled it.
+- **Fixed: `engine.stats()` crashed with `STDDEV_SAMP is out of range` on any
+  numeric column containing ±inf** (pre-existing since the engine shipped in
+  v3.2). The shared aggregate filter now keeps only finite values — as its own
+  comment always promised — instead of filtering just NaN.
+- The TUI's "not a stratification candidate" hint now lists continuous values
+  among the possible reasons.
+
+## v3.5.1 — 2026-07-24
+
+- **The "skip from reduction (PCA)" toggle is hidden for non-numeric columns.**
+  PCA reduction only ever operates on continuous numeric columns (booleans and
+  datetimes are explicitly rejected; strings/categoricals never qualify), so the
+  toggle is meaningless on those columns. It now appears in the detail panel only
+  when the selected column is numeric — matching the columns table, which already
+  renders `—` in the reduce cell for non-numeric columns. No behavior change to
+  the reduction itself: skipped columns were, and remain, held out of the PCA
+  math entirely and passed through to the output unchanged.
+
 ## v3.5.0 — 2026-07-24
 
 - **Names anonymizer is now gender- and ethnicity-aware.** The bundled library

{data_sampler-3.5.0 → data_sampler-3.5.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: data-sampler
-Version: 3.5.0
+Version: 3.5.2
 Summary: Hand someone data that looks and behaves like your production data, isn't your production data, and provably kept its statistical variety — stratified sampling + consistent anonymization, with a terminal UI.
 Project-URL: Homepage, https://github.com/aaronified/data-sampler
 Project-URL: Changelog, https://github.com/aaronified/data-sampler/blob/main/CHANGELOG.md
@@ -420,8 +420,13 @@ are left alone so the categories you stratify on survive).
 
 **Stratified (default):** columns suitable for stratification are detected
 automatically — categorical or low-cardinality columns with 2–100 unique
-values; long text and ID-like numeric columns are avoided, as are any
-columns you mark as skipped. Rows are grouped by the joint combination of
+values; long text, ID-like numeric, and continuous numeric columns (any
+fractional values — prices, rates, measurements) are avoided, as are any
+columns you mark as skipped. The continuous check looks at values, not
+storage types: parquet DECIMAL and float-backed categorical columns count
+too. Whole-number numeric columns (ratings, counts — including floats that
+hold only whole numbers) remain candidates. Rows are grouped by the joint
+combination of
 all selected columns and sampled proportionally per group, so the sample
 mirrors the original joint distribution. Missing values count as their own
 category. A side-by-side distribution report is produced for every run.

{data_sampler-3.5.0 → data_sampler-3.5.2}/README.md

@@ -365,8 +365,13 @@ are left alone so the categories you stratify on survive).
 
 **Stratified (default):** columns suitable for stratification are detected
 automatically — categorical or low-cardinality columns with 2–100 unique
-values; long text and ID-like numeric columns are avoided, as are any
-columns you mark as skipped. Rows are grouped by the joint combination of
+values; long text, ID-like numeric, and continuous numeric columns (any
+fractional values — prices, rates, measurements) are avoided, as are any
+columns you mark as skipped. The continuous check looks at values, not
+storage types: parquet DECIMAL and float-backed categorical columns count
+too. Whole-number numeric columns (ratings, counts — including floats that
+hold only whole numbers) remain candidates. Rows are grouped by the joint
+combination of
 all selected columns and sampled proportionally per group, so the sample
 mirrors the original joint distribution. Missing values count as their own
 category. A side-by-side distribution report is produced for every run.

{data_sampler-3.5.0 → data_sampler-3.5.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "data-sampler"
-version = "3.5.0"
+version = "3.5.2"
 description = "Hand someone data that looks and behaves like your production data, isn't your production data, and provably kept its statistical variety — stratified sampling + consistent anonymization, with a terminal UI."
 readme = "README.md"
 license = { file = "LICENSE" }

{data_sampler-3.5.0 → data_sampler-3.5.2}/src/data_sampler/__init__.py

@@ -18,7 +18,7 @@ Public API::
 
 from __future__ import annotations
 
-__version__ = "3.5.0"
+__version__ = "3.5.2"
 
 from .io import SUPPORTED_EXTENSIONS, list_sheets, load_file, save_output
 from .reduce import ReductionResult, reduce_columns

{data_sampler-3.5.0 → data_sampler-3.5.2}/src/data_sampler/engine.py

@@ -122,6 +122,15 @@ def _duckdb_kind(dtype: str) -> str:
     return "other"
 
 
+def _duckdb_can_be_fractional(dtype: str) -> bool:
+    """Whether a scalar DuckDB numeric type can hold fractional values.
+
+    Integer types cannot, so the continuous-column probe (a value scan) is
+    skipped for them.
+    """
+    return dtype.lower().startswith(("decimal", "double", "float", "real", "numeric"))
+
+
 def _proportional_allocation(sizes: np.ndarray, count: int) -> np.ndarray:
     """Largest-remainder proportional allocation summing exactly to ``count``.
 
@@ -295,30 +304,43 @@ class DuckDBEngine:
         # classify via _duckdb_kind so type rules match stats() (and never
         # match INTERVAL against the "int" numeric prefix)
         cols = [
-            (r[0], _duckdb_kind(str(r[1]))) for r in info if r[0] not in exclude
+            (r[0], _duckdb_kind(str(r[1])), str(r[1]))
+            for r in info
+            if r[0] not in exclude
         ]
         if not cols:
             return []
 
         # one pass: approx distinct per column (HLL) + avg text length for
-        # string-ish columns (VARCHAR and ENUM both take this rule)
+        # string-ish columns (VARCHAR and ENUM both take this rule) + a
+        # fractional-values probe for float-typed columns (continuous columns
+        # are skipped as strata, mirroring stats.is_stratifiable)
         parts = []
-        for name, kind in cols:
+        for name, kind, dtype in cols:
             q = _quote_ident(name)
             parts.append(f"approx_count_distinct({q}) AS {_quote_ident(name + '::nd')}")
             if kind == "categorical":
                 parts.append(
                     f"avg(length(CAST({q} AS VARCHAR))) AS {_quote_ident(name + '::len')}"
                 )
+            elif kind == "numeric" and _duckdb_can_be_fractional(dtype):
+                parts.append(
+                    f"bool_or({q}::DOUBLE <> trunc({q}::DOUBLE)) "
+                    f"FILTER (WHERE isfinite({q}::DOUBLE)) "
+                    f"AS {_quote_ident(name + '::frac')}"
+                )
         row = self.con.execute(f"SELECT {', '.join(parts)} FROM {src}").fetchdf().iloc[0]
 
         candidates: list[tuple[str, int]] = []
-        for name, kind in cols:
+        for name, kind, _dtype in cols:
             n_unique = int(row[name + "::nd"] or 0)
             if n_unique < 2 or n_unique > min(100, n_rows * 0.5):
                 continue
             if kind == "numeric" and n_unique > min(20, n_rows * 0.3):
                 continue
+            frac = row.get(name + "::frac")
+            if frac is not None and pd.notna(frac) and bool(frac):
+                continue
             if (name + "::len") in row and (row[name + "::len"] or 0) > 50:
                 continue
             candidates.append((name, n_unique))
@@ -384,9 +406,9 @@ class DuckDBEngine:
             )
             if kind == "numeric":
                 # NaN is a VALUE to DuckDB, not NULL: unfiltered, it poisons
-                # min/max and makes stddev_samp raise "out of range" — filter
-                # every NaN-sensitive aggregate down to finite values
-                fin = f"FILTER (WHERE NOT isnan({q}::DOUBLE))"
+                # min/max; and ±inf makes stddev_samp raise "out of range" —
+                # filter every sensitive aggregate down to finite values
+                fin = f"FILTER (WHERE isfinite({q}::DOUBLE))"
                 parts += [
                     f"min({q}::DOUBLE) {fin} AS {a}_min",
                     f"max({q}::DOUBLE) {fin} AS {a}_max",
@@ -395,6 +417,10 @@ class DuckDBEngine:
                     (f"approx_quantile({q}::DOUBLE, 0.5)" if approximate
                      else f"quantile_cont({q}::DOUBLE, 0.5)") + f" {fin} AS {a}_med",
                 ]
+                if _duckdb_can_be_fractional(col_types[c]):
+                    parts.append(
+                        f"bool_or({q}::DOUBLE <> trunc({q}::DOUBLE)) {fin} AS {a}_frac"
+                    )
             elif kind == "categorical":
                 parts.append(f"avg(length(CAST({q} AS VARCHAR))) AS {a}_len")
         row = con.execute(f"SELECT {', '.join(parts)} FROM {src}").fetchdf().iloc[0]
@@ -421,6 +447,9 @@ class DuckDBEngine:
             strat = 2 <= unique <= min(100, total * 0.5)
             if kind == "numeric" and unique > min(20, total * 0.3):
                 strat = False
+            frac = row.get(f"{a}_frac")
+            if pd.notna(frac) and bool(frac):
+                strat = False  # continuous (fractional-valued) numeric column
             if kind == "text":
                 strat = False
             cs.stratifiable = strat
@@ -445,12 +474,13 @@ class DuckDBEngine:
             width = hi - lo
             # equal-width bins via floor (width_bucket isn't available in
             # DuckDB); clamp to [0, bins-1] so the max value lands in the last
-            # bin, and drop NaN explicitly (NaN is a value, not NULL, in DuckDB)
+            # bin, and drop NaN/±inf explicitly (NaN is a value, not NULL, in
+            # DuckDB, and inf would overflow the INTEGER bin cast)
             rows = con.execute(
                 f"SELECT least({bins - 1}, greatest(0, CAST(floor("
                 f"({q}::DOUBLE - {lo!r}) / {width!r} * {bins}) AS INTEGER))) AS b, "
                 f"count(*) AS n FROM {src} "
-                f"WHERE {q} IS NOT NULL AND NOT isnan({q}::DOUBLE) GROUP BY b"
+                f"WHERE {q} IS NOT NULL AND isfinite({q}::DOUBLE) GROUP BY b"
             ).fetchall()
             counts = [0] * bins
             for b, n in rows:

{data_sampler-3.5.0 → data_sampler-3.5.2}/src/data_sampler/sampling.py

@@ -40,9 +40,10 @@ def find_stratification_columns(
     """Pick columns suitable for stratification.
 
     Candidates are categorical / low-cardinality columns with 2–100 unique
-    values; long text and ID-like numeric columns are skipped. Columns listed
-    in ``exclude`` are never considered (the user's "skip" selections). The
-    final set is pruned so the intersection-group count fits ``sample_count``.
+    values; long text, ID-like numeric, and continuous numeric columns
+    (fractional values) are skipped. Columns listed in ``exclude`` are never
+    considered (the user's "skip" selections). The final set is pruned so the
+    intersection-group count fits ``sample_count``.
     """
     exclude = set(exclude)
     candidates = []

{data_sampler-3.5.0 → data_sampler-3.5.2}/src/data_sampler/stats.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import numbers
 from dataclasses import dataclass, field
 
 import numpy as np
@@ -81,6 +82,47 @@ def sparkline(counts: list[int]) -> str:
     return "".join(out)
 
 
+def _fractionable_values(series: pd.Series) -> np.ndarray | None:
+    """Unique non-null OBSERVED values as float64 for columns whose
+    representation can hold fractional numbers — float dtypes (numpy,
+    nullable, or Arrow-backed), decimal extension dtypes (Arrow decimal128
+    from ``read_parquet(dtype_backend='pyarrow')``), float-backed
+    categoricals, and object columns of floats/Decimals (how parquet DECIMAL
+    and SQL drivers arrive by default). None for everything else (ints,
+    bools, strings, dates): those can never be continuous. Mirrors which
+    DuckDB types get the engine-side probe
+    (:func:`data_sampler.engine._duckdb_can_be_fractional`), and rules on
+    observed values — not declared categories — because that is all the
+    engine ever sees, so both paths reach the same verdict. Callers gate on
+    cardinality first — the returned array is only ever unique values, so it
+    stays small.
+    """
+    non_null = series.dropna()
+    if isinstance(series.dtype, pd.CategoricalDtype):
+        if not pd.api.types.is_float_dtype(series.cat.categories.dtype):
+            return None
+        return np.asarray(non_null.unique(), dtype=float)
+    if (
+        pd.api.types.is_numeric_dtype(series)
+        and not pd.api.types.is_integer_dtype(series)
+        and not pd.api.types.is_bool_dtype(series)
+        and not pd.api.types.is_complex_dtype(series)
+    ):
+        try:
+            return np.asarray(non_null.unique(), dtype=float)
+        except (TypeError, ValueError, OverflowError):
+            return None
+    if series.dtype == object:
+        uniq = non_null.unique()
+        if len(uniq) == 0 or not all(isinstance(v, numbers.Number) for v in uniq):
+            return None
+        try:
+            return np.array([float(v) for v in uniq], dtype=float)
+        except (TypeError, ValueError, OverflowError):
+            return None
+    return None
+
+
 def is_stratifiable(series: pd.Series, n_rows: int, n_unique: int | None = None) -> bool:
     """Whether a column passes the auto-stratification candidate checks.
 
@@ -100,6 +142,18 @@ def is_stratifiable(series: pd.Series, n_rows: int, n_unique: int | None = None)
     if pd.api.types.is_numeric_dtype(series):
         if n_unique > min(20, n_rows * 0.3):
             return False
+    # continuous columns (fractional values — prices, rates, measurements)
+    # make poor strata even at low cardinality: skip them by default. The
+    # check is value-based, not dtype-based, so parquet DECIMAL (object of
+    # decimal.Decimal) and float-backed categorical columns rule the same way
+    # the DuckDB engine's probe does. Whole-number floats stay candidates —
+    # integer-coded columns (ratings, counts) usually arrive as float64 once
+    # NaNs appear.
+    vals = _fractionable_values(series)
+    if vals is not None:
+        finite = vals[np.isfinite(vals)]
+        if finite.size and not np.all(finite == np.round(finite)):
+            return False
     return True
 
 

{data_sampler-3.5.0 → data_sampler-3.5.2}/src/data_sampler/tui/app.py

@@ -826,7 +826,10 @@ class ColumnsScreen(Screen):
                 t.append(f" {count:,} ({count / total * 100:.1f}%)\n", style=DIM)
         if not s.stratifiable:
             t.append("\nnot a stratification candidate ", style=DIM)
-            t.append("(too many unique values, long text, or constant)", style=DIM)
+            t.append(
+                "(too many unique values, continuous values, long text, or constant)",
+                style=DIM,
+            )
         self.query_one("#detail", Static).update(t)
 
     # ── config panel sync ────────────────────────────────────────────────────
@@ -882,6 +885,12 @@ class ColumnsScreen(Screen):
             skip_reduce = self.query_one("#skip-reduce", Switch)
             if skip_reduce.value != cfg.skip_reduce:
                 skip_reduce.value = cfg.skip_reduce
+            # PCA reduction only ever touches continuous numeric columns, so the
+            # "skip from reduction" toggle is meaningless for string / categorical
+            # / boolean / datetime columns — hide the whole row for those
+            self.query_one("#reduce-skip-row").set_class(
+                self.stats[name].kind != "numeric", "hidden"
+            )
             # names gender / ethnicity controls
             gsel = self.query_one("#opt-names-gender", Select)
             if gsel.value != cfg.gender:

{data_sampler-3.5.0 → data_sampler-3.5.2}/tests/test_engine.py

@@ -135,6 +135,65 @@ def test_auto_stratification_picks_low_cardinality(engine, big_df):
     assert "id" not in cols and "note" not in cols
 
 
+def test_auto_stratification_skips_continuous_numeric(engine, big_df):
+    # low-cardinality but fractional-valued (continuous) → skipped by default;
+    # whole-number floats (integer codes stored as DOUBLE) stay candidates
+    df = big_df.copy()
+    df["price"] = np.tile([9.99, 19.99, 29.99, 39.99], len(df) // 4)
+    df["rating"] = np.tile([1.0, 2.0, 3.0, 4.0], len(df) // 4)
+    cols = engine.find_stratification_columns(df, 1000)
+    assert "price" not in cols
+    assert "rating" in cols
+
+
+def test_stats_stratifiable_flag_skips_continuous_numeric(engine, big_df):
+    df = big_df.copy()
+    df["price"] = np.tile([9.99, 19.99, 29.99, 39.99], len(df) // 4)
+    df["rating"] = np.tile([1.0, 2.0, 3.0, 4.0], len(df) // 4)
+    by_name = {s.name: s for s in engine.stats(df, columns=["price", "rating", "tier"])}
+    assert not by_name["price"].stratifiable
+    assert by_name["rating"].stratifiable
+    assert by_name["tier"].stratifiable
+
+
+def test_decimal_parquet_agrees_across_paths(tmp_path, engine):
+    # parquet DECIMAL loads as object-of-Decimal in pandas; both paths must
+    # exclude the fractional column and keep the categorical
+    p = str(tmp_path / "dec.parquet").replace("\\", "/")
+    engine.con.execute(
+        "COPY (SELECT CAST(9.99 + (i % 4) * 10 AS DECIMAL(6,2)) AS price, "
+        f"'g' || (i % 3) AS grp FROM range(1000) t(i)) TO '{p}' (FORMAT PARQUET)"
+    )
+    assert engine.find_stratification_columns(p, 200) == ["grp"]
+    from data_sampler.sampling import find_stratification_columns
+
+    assert find_stratification_columns(pd.read_parquet(p), 200) == ["grp"]
+
+
+def test_categorical_float_agrees_across_paths(engine):
+    # DuckDB registration flattens category-of-float to DOUBLE — the pandas
+    # path must reach the same verdict on the same DataFrame
+    df = pd.DataFrame(
+        {
+            "band": pd.Series([1.5, 2.5, 3.5, 4.5] * 250).astype("category"),
+            "grp": ["a", "b"] * 500,
+        }
+    )
+    assert engine.find_stratification_columns(df, 200) == ["grp"]
+    from data_sampler.sampling import find_stratification_columns
+
+    assert find_stratification_columns(df, 200) == ["grp"]
+
+
+def test_stats_handles_infinite_values(engine):
+    # ±inf passed the old NOT-isnan filter and blew up stddev_samp, crashing
+    # the whole Pass-A query; aggregates are finite-only now
+    df = pd.DataFrame({"x": [1.0, 2.0, 3.0, np.inf] * 250, "cat": ["a", "b"] * 500})
+    by_name = {s.name: s for s in engine.stats(df)}
+    assert by_name["x"].max == 3.0
+    assert by_name["cat"].stratifiable
+
+
 def test_sample_all_when_count_exceeds_rows(engine):
     small = pd.DataFrame({"a": [1, 2, 3], "b": ["x", "y", "z"]})
     result = engine.sample(small, 10)

{data_sampler-3.5.0 → data_sampler-3.5.2}/tests/test_sampling.py

@@ -53,6 +53,16 @@ def test_exclude_columns_are_not_stratified(demo_df):
     assert "active" not in result.strat_cols
 
 
+def test_continuous_numeric_not_auto_selected(demo_df):
+    # 4 unique values would pass the cardinality gate, but the fractional
+    # values mark the column as continuous → skipped by default
+    df = demo_df.copy()
+    df["price"] = np.tile([9.99, 19.99, 29.99, 39.99], len(df) // 4)
+    cols = find_stratification_columns(df, 400)
+    assert "price" not in cols
+    assert "region" in cols  # the categorical candidates are unaffected
+
+
 def test_exclude_all_falls_back_to_random(demo_df):
     result = sample(
         demo_df, 100, exclude_columns=list(demo_df.columns), random_state=3

{data_sampler-3.5.0 → data_sampler-3.5.2}/tests/test_stats.py

@@ -1,5 +1,6 @@
 import numpy as np
 import pandas as pd
+import pytest
 
 from data_sampler.stats import (
     ColumnStats,
@@ -91,6 +92,83 @@ def test_single_value_column_not_stratifiable():
     assert not is_stratifiable(series, 50)
 
 
+def test_continuous_numeric_not_stratifiable():
+    # low cardinality but fractional values → continuous, skipped by default
+    series = pd.Series([9.99, 19.99, 29.99, 39.99] * 25, name="price")
+    assert not is_stratifiable(series, 100)
+
+
+def test_decimal_object_column_rules_like_the_engine():
+    # parquet DECIMAL / SQL drivers arrive as object-of-Decimal: the fractional
+    # rule is value-based, so these must rule identically to the DuckDB probe
+    from decimal import Decimal
+
+    frac = pd.Series(
+        [Decimal("9.99"), Decimal("19.99"), Decimal("29.99"), Decimal("39.99")] * 25,
+        name="price",
+    )
+    assert not is_stratifiable(frac, 100)
+    whole = pd.Series([Decimal("1"), Decimal("2"), Decimal("3")] * 34, name="code")
+    assert is_stratifiable(whole, 102)
+
+
+def test_float_backed_categorical_rules_like_the_engine():
+    # DuckDB registration flattens category-of-float to DOUBLE; the pandas
+    # side must rule on the category values the same way
+    frac = pd.Series([1.5, 2.5, 3.5, 4.5] * 25, name="band").astype("category")
+    assert not is_stratifiable(frac, 100)
+    whole = pd.Series([1.0, 2.0, 3.0, 4.0] * 25, name="code").astype("category")
+    assert is_stratifiable(whole, 100)
+
+
+def test_unused_fractional_category_ignored():
+    # row-filtering keeps unused categories around; the rule must judge
+    # observed values only — all the engine ever sees after registration
+    s = pd.Series(
+        pd.Categorical([1.0, 2.0] * 50, categories=[1.0, 2.0, 3.5]), name="band"
+    )
+    assert is_stratifiable(s, 100)
+
+
+def test_arrow_decimal_column_rules_like_the_engine():
+    # read_parquet(dtype_backend='pyarrow') yields ArrowDtype(decimal128) for
+    # parquet DECIMAL — same verdict as the engine's DECIMAL probe required
+    pa = pytest.importorskip("pyarrow")
+    from decimal import Decimal
+
+    frac = pd.Series(
+        [Decimal("9.99"), Decimal("19.99"), Decimal("29.99")] * 34,
+        dtype=pd.ArrowDtype(pa.decimal128(6, 2)),
+        name="price",
+    )
+    assert not is_stratifiable(frac, 102)
+    whole = pd.Series(
+        [Decimal("10"), Decimal("20"), Decimal("30")] * 34,
+        dtype=pd.ArrowDtype(pa.decimal128(6, 2)),
+        name="code",
+    )
+    assert is_stratifiable(whole, 102)
+
+
+def test_object_float_column_fractional_not_stratifiable():
+    frac = pd.Series([9.99, 19.99, 29.99, 39.99] * 25, dtype=object, name="price")
+    assert not is_stratifiable(frac, 100)
+    mixed = pd.Series(["a", "b", 1.5, 2.5] * 25, dtype=object, name="junk")
+    assert is_stratifiable(mixed, 100)  # not number-valued → old rules apply
+
+
+def test_whole_number_float_still_stratifiable():
+    # integer-coded columns arrive as float64 once NaNs appear — they stay
+    # candidates as long as every value is a whole number
+    series = pd.Series([1.0, 2.0, 3.0, np.nan] * 25, name="rating")
+    assert is_stratifiable(series, 100)
+
+
+def test_discrete_int_column_stratifiable():
+    series = pd.Series([1, 2, 3, 4, 5] * 20, name="stars")
+    assert is_stratifiable(series, 100)
+
+
 def test_boolean_column_kind(demo_df):
     assert compute_column_stats(demo_df["active"]).kind == "boolean"
 

{data_sampler-3.5.0 → data_sampler-3.5.2}/tests/test_tui.py

@@ -584,6 +584,31 @@ def test_non_numeric_skip_reduce_shows_dash(csv_file):
     run(go())
 
 
+def test_reduce_skip_toggle_hidden_for_non_numeric(csv_file):
+    """PCA reduction only ever touches continuous numeric columns, so the
+    'skip from reduction (PCA)' row must be shown for numeric columns and
+    hidden for string / categorical / boolean columns."""
+    async def go():
+        app = DataSamplerApp(path=str(csv_file))
+        async with app.run_test(size=(160, 45)) as pilot:
+            screen = await wait_for_screen(app, pilot, ColumnsScreen)
+            row = screen.query_one("#reduce-skip-row")
+
+            screen._sync_config_panel("score")   # numeric → shown
+            assert not row.has_class("hidden")
+
+            screen._sync_config_panel("region")  # categorical → hidden
+            assert row.has_class("hidden")
+
+            screen._sync_config_panel("active")  # boolean → hidden
+            assert row.has_class("hidden")
+
+            screen._sync_config_panel("id")      # numeric again → shown
+            assert not row.has_class("hidden")
+
+    run(go())
+
+
 def test_refresh_browser_action(csv_file):
     async def go():
         app = DataSamplerApp()