dataframe-toolkit 0.7.0__tar.gz → 0.7.2__tar.gz

{dataframe_toolkit-0.7.0 → dataframe_toolkit-0.7.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: dataframe-toolkit
-Version: 0.7.0
+Version: 0.7.2
 Summary: A command-line toolkit for DataFrame analysis and manipulation
 Keywords: dataframe,statistics,data analysis,CLI,TSV,pandas
 Author: Gunnar Pálsson
@@ -17,6 +17,7 @@ Requires-Dist: numpy>=1.24
 Requires-Dist: pyarrow>=12.0
 Requires-Dist: scipy>=1.10
 Requires-Dist: statsmodels>=0.14
+Requires-Dist: patsy>=0.5.6
 Requires-Dist: duckdb>=0.8
 Requires-Dist: matplotlib>=3.7
 Requires-Dist: seaborn>=0.12
@@ -73,6 +74,20 @@ cd dataframe-toolkit
 uv tool install .
 ```
 
+### Skill for coding agents
+
+`skills/dftk/` is an agent skill: a short guide that coding agents such as
+Codex and Claude Code load when a task involves dftk. It covers the piping
+conventions, which command to use for what, and patterns for Snakemake and
+Make. Copy it into your agent's skills directory, for example:
+
+```bash
+cp -r skills/dftk ~/.codex/skills/     # Codex
+cp -r skills/dftk ~/.claude/skills/    # Claude Code
+```
+
+Copy it again after upgrading dftk so it matches the installed version.
+
 ## Quick example
 
 ```bash

{dataframe_toolkit-0.7.0 → dataframe_toolkit-0.7.2}/README.md

@@ -45,6 +45,20 @@ cd dataframe-toolkit
 uv tool install .
 ```
 
+### Skill for coding agents
+
+`skills/dftk/` is an agent skill: a short guide that coding agents such as
+Codex and Claude Code load when a task involves dftk. It covers the piping
+conventions, which command to use for what, and patterns for Snakemake and
+Make. Copy it into your agent's skills directory, for example:
+
+```bash
+cp -r skills/dftk ~/.codex/skills/     # Codex
+cp -r skills/dftk ~/.claude/skills/    # Claude Code
+```
+
+Copy it again after upgrading dftk so it matches the installed version.
+
 ## Quick example
 
 ```bash

{dataframe_toolkit-0.7.0 → dataframe_toolkit-0.7.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "dataframe-toolkit"
-version = "0.7.0"
+version = "0.7.2"
 description = "A command-line toolkit for DataFrame analysis and manipulation"
 readme = "README.md"
 keywords = [
@@ -26,6 +26,7 @@ dependencies = [
     "pyarrow>=12.0",
     "scipy>=1.10",
     "statsmodels>=0.14",
+    "patsy>=0.5.6",
     "duckdb>=0.8",
     "matplotlib>=3.7",
     "seaborn>=0.12",

{dataframe_toolkit-0.7.0 → dataframe_toolkit-0.7.2}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "dataframe-toolkit"
-version = "0.7.0"
+version = "0.7.2"
 description = "A command-line toolkit for DataFrame analysis and manipulation"
 readme = "README.md"
 authors = [
@@ -23,6 +23,7 @@ dependencies = [
     "pyarrow>=12.0",
     "scipy>=1.10",
     "statsmodels>=0.14",
+    "patsy>=0.5.6",
     "duckdb>=0.8",
     "matplotlib>=3.7",
     "seaborn>=0.12",

{dataframe_toolkit-0.7.0 → dataframe_toolkit-0.7.2}/src/dftk/cli.py

@@ -1,9 +1,13 @@
 """
 dftk.cli — entry point for the ``dftk`` command.
 
-All subcommands are discovered through the COMMANDS list in
+All subcommands are discovered through the registry in
 dftk/commands/__init__.py.  This file contains no command-specific
 logic and never needs to change when a new subcommand is added.
+
+Only the command being run is imported, so e.g. ``dftk print`` does not pay
+for importing scipy, statsmodels or matplotlib.  The full set is imported only
+when it is needed: ``dftk --help``, no command, or an unknown command name.
 """
 
 import argparse
@@ -13,13 +17,28 @@ import signal
 import sys
 
 from dftk import __version__
-from dftk.commands import COMMANDS
+from dftk.commands import COMMAND_NAMES, load_command, load_command_groups
+from dftk.commands.base import BaseCommand
 from dftk.common.io import DFTK_TMPDIR
 
 logger = logging.getLogger("dftk")
 logging.basicConfig(format="%(asctime)s %(module)s %(message)s", level=logging.INFO)
 
 
+def _commands_for(argv: list[str]) -> list[BaseCommand]:
+    """Return the commands whose subparsers *argv* needs.
+
+    The top-level parser has no options that take a value, so a valid
+    invocation always has the command name first.
+    """
+    if argv and argv[0] in COMMAND_NAMES:
+        return [load_command(argv[0])]
+    # `dftk --help`, no command, or an unknown name: load everything so the
+    # command listing and argparse's "invalid choice" message are complete.
+    grouped = [cmd for _, cmds in load_command_groups() for cmd in cmds]
+    return grouped + [load_command("help")]
+
+
 def main() -> None:
     parser = argparse.ArgumentParser(
         prog="dftk",
@@ -40,7 +59,7 @@ def main() -> None:
     subparsers = parser.add_subparsers(dest="command", metavar="COMMAND")
     subparsers.required = True
 
-    for cmd in COMMANDS:
+    for cmd in _commands_for(sys.argv[1:]):
         cmd_parser = subparsers.add_parser(cmd.name, help=cmd.help)
         cmd.add_arguments(cmd_parser)
         cmd_parser.set_defaults(command_instance=cmd)

dataframe_toolkit-0.7.2/src/dftk/commands/__init__.py

@@ -0,0 +1,98 @@
+# dftk.commands — registry of all dftk subcommands.
+#
+# Commands are registered by name and import path instead of being imported
+# here, so that running one command imports only that command's module and its
+# dependencies (scipy, statsmodels, matplotlib, …), not every command's.
+#
+# To add a new subcommand:
+#   1. Create src/dftk/commands/<name>_cmd.py with a class that inherits
+#      from BaseCommand (see base.py for the contract and an example skeleton).
+#   2. Add a ("<name>", "<name>_cmd:<ClassName>") entry to COMMAND_GROUPS below.
+#   That's it — cli.py discovers commands solely through this registry.
+#   tests/commands/test_registry.py checks that every entry imports and that
+#   every *_cmd.py module is registered.
+
+import importlib
+
+from dftk.commands.base import BaseCommand
+
+# Ported subcommands — add as each one is implemented:
+#   ("color", "color_cmd:ColorCommand")
+#   ("wavelet", "wavelet_cmd:WaveletCommand")
+#   ("fisher", ...)  — superseded by eval's fisher_test/fisher_OR
+
+COMMAND_GROUPS: list[tuple[str, list[tuple[str, str]]]] = [
+    (
+        "Data transformation",
+        [
+            ("eval", "eval_cmd:EvalCommand"),
+            ("query", "query_cmd:QueryCommand"),
+            ("merge", "merge_cmd:MergeCommand"),
+            ("concat", "concat_cmd:ConcatCommand"),
+            ("melt", "melt_cmd:MeltCommand"),
+            ("pivot", "pivot_cmd:PivotCommand"),
+            ("func", "func_cmd:FuncCommand"),
+            ("scale", "scale_cmd:ScaleCommand"),
+            ("interp", "interp_cmd:InterpCommand"),
+            ("binx", "binx_cmd:BinxCommand"),
+            ("transpose", "transpose_cmd:TransposeCommand"),
+            ("segid", "segid_cmd:SegidCommand"),
+        ],
+    ),
+    (
+        "Statistics",
+        [
+            ("stat", "stat_cmd:StatCommand"),
+            ("wstat", "wstat_cmd:WstatCommand"),
+            ("fit", "fit_cmd:FitCommand"),
+            ("test", "test_cmd:TestCommand"),
+            ("corr", "corr_cmd:CorrCommand"),
+            ("describe", "describe_cmd:DescribeCommand"),
+            ("info", "info_cmd:InfoCommand"),
+            ("randvar", "randvar_cmd:RandvarCommand"),
+        ],
+    ),
+    (
+        "Plots",
+        [
+            ("scat", "scat_cmd:ScatCommand"),
+            ("line", "line_cmd:LineCommand"),
+            ("hist", "hist_cmd:HistCommand"),
+            ("chi", "chi_cmd:ChiCommand"),
+        ],
+    ),
+    (
+        "Utilities",
+        [
+            ("dataset", "dataset_cmd:DatasetCommand"),
+            ("sample", "sample_cmd:SampleCommand"),
+            ("split", "split_cmd:SplitCommand"),
+            ("annotate", "annotate_cmd:AnnotateCommand"),
+            ("print", "print_cmd:PrintCommand"),
+            ("clean", "clean_cmd:CleanCommand"),
+        ],
+    ),
+]
+
+# `help` is a command like the others but is not listed under a group heading.
+_REGISTRY: dict[str, str] = dict(
+    [entry for _, entries in COMMAND_GROUPS for entry in entries]
+    + [("help", "help:HelpCommand")]
+)
+
+COMMAND_NAMES: list[str] = list(_REGISTRY)
+
+
+def load_command(name: str) -> BaseCommand:
+    """Import and instantiate the command registered as *name*."""
+    module_name, class_name = _REGISTRY[name].split(":")
+    module = importlib.import_module(f"dftk.commands.{module_name}")
+    return getattr(module, class_name)()
+
+
+def load_command_groups() -> list[tuple[str, list[BaseCommand]]]:
+    """Import and instantiate every grouped command (slow: imports everything)."""
+    return [
+        (header, [load_command(name) for name, _ in entries])
+        for header, entries in COMMAND_GROUPS
+    ]

{dataframe_toolkit-0.7.0 → dataframe_toolkit-0.7.2}/src/dftk/commands/concat_cmd.py

@@ -40,6 +40,8 @@ COLUMN ALIGNMENT
 ----------------
   Columns present in all files are aligned by name.
   Columns missing from some files are filled with NaN (or --fill value).
+  --fill applies only to those missing columns: a cell that is empty within
+  a file stays empty.
   Use --select to enforce a fixed output column set.
 
 EXAMPLES
@@ -79,7 +81,8 @@ Mismatched columns are outer-joined and filled (NaN by default, or --fill):
             metavar="VALUE",
             help=(
                 "Fill value for columns absent in some files "
-                "(default: NaN).  Use 0 or '' for numeric/string defaults."
+                "(default: NaN).  Use 0 or '' for numeric/string defaults.  "
+                "Cells that are empty within a file stay empty."
             ),
         )
 
@@ -152,8 +155,6 @@ Mismatched columns are outer-joined and filled (NaN by default, or --fill):
         if not dfs:
             raise ValueError("concat: no data read from any input file")
 
-        result = pd.concat(dfs, ignore_index=True)
-
         if args.fill is not None:
             fill: int | float | str
             try:
@@ -163,6 +164,14 @@ Mismatched columns are outer-joined and filled (NaN by default, or --fill):
                     fill = float(args.fill)
                 except ValueError:
                     fill = args.fill
-            result = result.fillna(fill)
+            # Add each file's missing columns before stacking, so --fill
+            # touches only those, not cells that were already empty in a file.
+            columns = list(dict.fromkeys(c for df in dfs for c in df.columns))
+            dfs = [
+                df.assign(**{c: fill for c in columns if c not in df.columns})[columns]
+                for df in dfs
+            ]
+
+        result = pd.concat(dfs, ignore_index=True)
 
         io.printdf(result, args)

{dataframe_toolkit-0.7.0 → dataframe_toolkit-0.7.2}/src/dftk/commands/eval_cmd.py

@@ -19,11 +19,9 @@ from pathlib import Path
 
 import numpy as np
 import pandas as pd
-from scipy import special as _sp
 
 from dftk.commands.base import BaseCommand
 from dftk.common import seq as _seq
-from dftk.common import stats as _stats
 from dftk.common.io import io
 
 logger = logging.getLogger(__name__)
@@ -190,18 +188,23 @@ def _parse_formula(formula: str) -> tuple[str, str, list[str], str]:
 # Special functions (used as pandas agg fallback inside -f)
 # ---------------------------------------------------------------------------
 
+# The function tables below hold names, not function objects: dftk.common.stats
+# and scipy.special are imported only when a formula actually uses one of them,
+# so plain `dftk eval -f` formulas don't pay scipy's import time.
+
+# dftk.common.stats functions, same name in the formula as in the module
 _STATS_DISPATCH = {
-    "binom_test": _stats.binom_test,
-    "fisher_test": _stats.fisher_test,
-    "fisher_OR": _stats.fisher_OR,
-    "boschloo_test": _stats.boschloo_test,
-    "boschloo_OR": _stats.boschloo_OR,
-    "pval2se": _stats.pval2se,
-    "t2pval": _stats.t2pval,
-    "chi2_to_neglogp": _stats.chi2_to_neglogp,
-    "neglogp_to_chi2": _stats.neglogp_to_chi2,
-    "pval_to_chi2": _stats.pval_to_chi2,
-    "generalized_poisson_nll": _stats.generalized_poisson_nll,
+    "binom_test",
+    "fisher_test",
+    "fisher_OR",
+    "boschloo_test",
+    "boschloo_OR",
+    "pval2se",
+    "t2pval",
+    "chi2_to_neglogp",
+    "neglogp_to_chi2",
+    "pval_to_chi2",
+    "generalized_poisson_nll",
 }
 
 _PATH_FUNCS = {"basename", "dirname", "exists", "getsize", "realpath"}
@@ -209,35 +212,33 @@ _NP_FUNCS = {"sign", "cbrt", "log1p", "expm1"}
 _ROW_AGG_FUNCS = {"sum", "mean", "std", "min", "max", "median"}
 _ROW_IDX_FUNCS = {"idxmax", "idxmin"}
 
-# scipy.special single-column functions (element-wise, vectorised)
+# scipy.special single-column functions (element-wise, vectorised):
+# formula name -> scipy.special attribute name
 _SCIPY_SINGLE = {
-    "gamma": _sp.gamma,  # Γ(x)
-    "lgamma": _sp.gammaln,  # log Γ(x)
-    "digamma": _sp.digamma,  # ψ(x)  (log-derivative of Γ)
-    "erf": _sp.erf,  # error function
-    "erfc": _sp.erfc,  # complementary error function
-    "erfinv": _sp.erfinv,  # inverse error function
-    "expit": _sp.expit,  # logistic sigmoid  1/(1+exp(-x))
-    "logit": _sp.logit,  # log(x/(1-x))
+    "gamma": "gamma",  # Γ(x)
+    "lgamma": "gammaln",  # log Γ(x)
+    "digamma": "digamma",  # ψ(x)  (log-derivative of Γ)
+    "erf": "erf",  # error function
+    "erfc": "erfc",  # complementary error function
+    "erfinv": "erfinv",  # inverse error function
+    "expit": "expit",  # logistic sigmoid  1/(1+exp(-x))
+    "logit": "logit",  # log(x/(1-x))
     # Bessel J (first kind), fixed order
-    "j0": _sp.j0,
-    "j1": _sp.j1,
+    "j0": "j0",
+    "j1": "j1",
     # Bessel Y (second kind), fixed order
-    "y0": _sp.y0,
-    "y1": _sp.y1,
+    "y0": "y0",
+    "y1": "y1",
     # Modified Bessel I, fixed order
-    "i0": _sp.i0,
-    "i1": _sp.i1,
+    "i0": "i0",
+    "i1": "i1",
     # Modified Bessel K, fixed order
-    "k0": _sp.k0,
-    "k1": _sp.k1,
+    "k0": "k0",
+    "k1": "k1",
 }
 
 # scipy.special two-column functions: func(col_a, col_b)
-_SCIPY_DUAL = {
-    "beta": lambda x: _sp.beta(x[0], x[1]),  # B(a, b)
-    "betaln": lambda x: _sp.betaln(x[0], x[1]),  # log B(a, b)
-}
+_SCIPY_DUAL = {"beta", "betaln"}  # B(a, b), log B(a, b)
 
 # scipy.special parametric Bessel: func_name(order_literal, col)
 # Covers all-order variants: jn(n,x), yn(n,x), iv(v,x), kv(v,x)
@@ -365,12 +366,21 @@ def _special_function(formula: str, df_columns: list[str]):
     elif func_name in _PATH_FUNCS:
         func = np.frompyfunc(getattr(os.path, func_name), 1, 1)
     elif func_name in _STATS_DISPATCH:
-        func = _STATS_DISPATCH[func_name]
+        from dftk.common import stats as _stats
+
+        func = getattr(_stats, func_name)
     elif func_name in _SCIPY_SINGLE:
-        func = _SCIPY_SINGLE[func_name]
+        from scipy import special as _sp
+
+        func = getattr(_sp, _SCIPY_SINGLE[func_name])
     elif func_name in _SCIPY_DUAL:
-        func = _SCIPY_DUAL[func_name]
+        from scipy import special as _sp
+
+        dual = getattr(_sp, func_name)
+        func = partial(lambda x: dual(x[0], x[1]))
     elif func_name in _SCIPY_BESSEL_ORDER:
+        from scipy import special as _sp
+
         try:
             order = float(cols[0])
         except (ValueError, IndexError):

{dataframe_toolkit-0.7.0 → dataframe_toolkit-0.7.2}/src/dftk/commands/fit_cmd.py

@@ -34,10 +34,12 @@ tidy coefficient tables into one output dataframe.
 import argparse
 import logging
 
+import numpy as np  # noqa: F401 — for formulas such as "np.log(y) ~ x", see below
 import pandas as pd
 import statsmodels.api as sm
 import statsmodels.formula.api as smf
 import statsmodels.stats.anova as sa
+from patsy import PatsyError
 
 from dftk.commands.base import BaseCommand
 from dftk.common.io import check_cols, io
@@ -50,6 +52,11 @@ logger = logging.getLogger(__name__)
 # ---------------------------------------------------------------------------
 
 
+# Formulas are evaluated in the namespace of the function that builds the
+# model (statsmodels' default eval_env), i.e. this module's globals — which
+# is why numpy is imported above as np.
+
+
 def standard_model(df: pd.DataFrame, args: argparse.Namespace):
     """Return an OLS or RLM (robust) model, not yet fitted."""
     if getattr(args, "robust", False):
@@ -67,11 +74,18 @@ def weighted_model(df: pd.DataFrame, args: argparse.Namespace):
 
 
 def regress_it(df: pd.DataFrame, args: argparse.Namespace):
-    """Fit the appropriate model and return the fitted result object."""
-    if getattr(args, "weights", None) is not None:
-        mod = weighted_model(df, args)
-    else:
-        mod = standard_model(df, args)
+    """Fit the appropriate model and return the fitted result object.
+
+    A formula that cannot be evaluated (unknown column or function) raises
+    ValueError, which the CLI reports as an input error.
+    """
+    try:
+        if getattr(args, "weights", None) is not None:
+            mod = weighted_model(df, args)
+        else:
+            mod = standard_model(df, args)
+    except PatsyError as exc:
+        raise ValueError(f"cannot evaluate formula {args.formula!r}: {exc}") from None
     return mod.fit()
 
 

{dataframe_toolkit-0.7.0 → dataframe_toolkit-0.7.2}/src/dftk/commands/help.py

@@ -7,6 +7,7 @@ dftk.commands.help — the ``dftk help`` subcommand.
 
 import argparse
 
+from dftk.commands import COMMAND_NAMES, load_command, load_command_groups
 from dftk.commands.base import BaseCommand
 
 
@@ -16,14 +17,6 @@ class HelpCommand(BaseCommand):
     name = "help"
     help = "Show detailed help for a subcommand"
 
-    def __init__(
-        self,
-        available_commands: list[BaseCommand] | None = None,
-        command_groups: list[tuple[str, list[BaseCommand]]] | None = None,
-    ) -> None:
-        self.available_commands: list[BaseCommand] = available_commands or []
-        self.command_groups: list[tuple[str, list[BaseCommand]]] = command_groups or []
-
     def add_arguments(self, parser: argparse.ArgumentParser) -> None:
         parser.add_argument(
             "command_name",
@@ -34,24 +27,16 @@ class HelpCommand(BaseCommand):
 
     def execute(self, args: argparse.Namespace) -> None:
         if args.command_name is None:
-            if self.command_groups:
-                for header, cmds in self.command_groups:
-                    print(f"\n{header}:")
-                    for cmd in cmds:
-                        print(f"  {cmd.name:<16} {cmd.help}")
-            else:
-                print("Available commands:")
-                for cmd in self.available_commands:
+            for header, cmds in load_command_groups():
+                print(f"\n{header}:")
+                for cmd in cmds:
                     print(f"  {cmd.name:<16} {cmd.help}")
             print("\nUse 'dftk help <command>' for detailed help on a command.")
             return
 
-        cmd = next(
-            (c for c in self.available_commands if c.name == args.command_name),
-            None,
-        )
-        if cmd is None:
+        if args.command_name not in COMMAND_NAMES:
             raise ValueError(f"Unknown command: {args.command_name!r}")
+        cmd = load_command(args.command_name)
 
         # Build a temporary parser for this command so argparse formats the
         # help text exactly as it would appear during normal use.

{dataframe_toolkit-0.7.0 → dataframe_toolkit-0.7.2}/src/dftk/commands/stat_cmd.py

@@ -132,6 +132,9 @@ def _compute_stats(df: pd.DataFrame, args: argparse.Namespace) -> pd.DataFrame:
         stats = (
             df[cols].agg(agg_funcs).T.reset_index().rename(columns={"index": "name"})
         )
+        # Before the transpose each column held count and the float stats
+        # together, so count came out as float; a count is never missing.
+        stats["count"] = stats["count"].astype("int64")
         return stats[["name"] + _STAT_NAMES]
 
     else:

dataframe_toolkit-0.7.0/src/dftk/commands/__init__.py

@@ -1,105 +0,0 @@
-# dftk.commands — explicit registry of all dftk subcommands.
-#
-# To add a new subcommand:
-#   1. Create src/dftk/commands/<name>.py with a class that inherits
-#      from BaseCommand (see base.py for the contract and an example skeleton).
-#   2. Import the class here and add an instance to command_list below.
-#   That's it — cli.py discovers commands solely through this COMMANDS list.
-
-from dftk.commands.annotate_cmd import AnnotateCommand
-from dftk.commands.binx_cmd import BinxCommand
-from dftk.commands.chi_cmd import ChiCommand
-from dftk.commands.clean_cmd import CleanCommand
-from dftk.commands.concat_cmd import ConcatCommand
-from dftk.commands.corr_cmd import CorrCommand
-from dftk.commands.dataset_cmd import DatasetCommand
-from dftk.commands.describe_cmd import DescribeCommand
-from dftk.commands.eval_cmd import EvalCommand
-from dftk.commands.fit_cmd import FitCommand
-from dftk.commands.func_cmd import FuncCommand
-from dftk.commands.help import HelpCommand
-from dftk.commands.hist_cmd import HistCommand
-from dftk.commands.info_cmd import InfoCommand
-from dftk.commands.interp_cmd import InterpCommand
-from dftk.commands.line_cmd import LineCommand
-from dftk.commands.melt_cmd import MeltCommand
-from dftk.commands.merge_cmd import MergeCommand
-from dftk.commands.pivot_cmd import PivotCommand
-from dftk.commands.print_cmd import PrintCommand
-from dftk.commands.query_cmd import QueryCommand
-from dftk.commands.randvar_cmd import RandvarCommand
-from dftk.commands.sample_cmd import SampleCommand
-from dftk.commands.scale_cmd import ScaleCommand
-from dftk.commands.scat_cmd import ScatCommand
-from dftk.commands.segid_cmd import SegidCommand
-from dftk.commands.split_cmd import SplitCommand
-from dftk.commands.stat_cmd import StatCommand
-from dftk.commands.test_cmd import TestCommand
-from dftk.commands.transpose_cmd import TransposeCommand
-from dftk.commands.wstat_cmd import WstatCommand
-
-# Ported subcommands — uncomment as each one is added:
-# from dftk.commands.color     import ColorCommand
-# from dftk.commands.wavelet   import WaveletCommand
-# from dftk.commands.fisher    import FisherCommand  # superseded by eval's
-#                                                         # fisher_test/fisher_OR
-
-COMMAND_GROUPS: list[tuple[str, list]] = [
-    (
-        "Data transformation",
-        [
-            EvalCommand(),
-            QueryCommand(),
-            MergeCommand(),
-            ConcatCommand(),
-            MeltCommand(),
-            PivotCommand(),
-            FuncCommand(),
-            ScaleCommand(),
-            InterpCommand(),
-            BinxCommand(),
-            TransposeCommand(),
-            SegidCommand(),
-        ],
-    ),
-    (
-        "Statistics",
-        [
-            StatCommand(),
-            WstatCommand(),
-            FitCommand(),
-            TestCommand(),
-            CorrCommand(),
-            DescribeCommand(),
-            InfoCommand(),
-            RandvarCommand(),
-        ],
-    ),
-    (
-        "Plots",
-        [
-            ScatCommand(),
-            LineCommand(),
-            HistCommand(),
-            ChiCommand(),
-        ],
-    ),
-    (
-        "Utilities",
-        [
-            DatasetCommand(),
-            SampleCommand(),
-            SplitCommand(),
-            AnnotateCommand(),
-            PrintCommand(),
-            CleanCommand(),
-        ],
-    ),
-]
-
-command_list = [cmd for _, cmds in COMMAND_GROUPS for cmd in cmds]
-
-# HelpCommand receives the live list and groups so it can introspect any peer.
-help_command = HelpCommand(command_list, COMMAND_GROUPS)
-
-COMMANDS = command_list + [help_command]