pytae 3.4.2__tar.gz → 3.4.3__tar.gz

{pytae-3.4.2 → pytae-3.4.3}/CHANGELOG.md

@@ -4,6 +4,18 @@ All notable changes to this project are documented in this file.
 
 ## [Unreleased]
 
+## [3.4.3] - 2026-09-20
+
+### Added
+- CLI `-drop`: subtract exact column names at that point in the pipeline (`df.drop(columns=...)`).
+  Names only — no `dtype=` / `contains=` / `regex=` / slices (those stay on `-select`). Remaining
+  columns keep their order. Repeatable; missing names error with a typo hint; dropping every
+  remaining column is an error.
+
+### Documentation
+- `docs/CLI.md`: `-mutate` example for string concat via `species.str.cat(island, sep='_')`
+  (pandas `eval()` does not support `+` for strings).
+
 ## [3.4.2] - 2026-09-20
 
 ### Changed

{pytae-3.4.2 → pytae-3.4.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: pytae
-Version: 3.4.2
+Version: 3.4.3
 Summary: A package to enhance common tasks in data and plotting
 Project-URL: Homepage, https://github.com/maddytae/pytae
 Project-URL: Bug Tracker, https://github.com/maddytae/pytae/issues

{pytae-3.4.2 → pytae-3.4.3}/docs/CLI.md

@@ -9,6 +9,7 @@ Inspect and convert tabular files (`.parquet`, `.csv`, `.txt`, `.dat`, `.sas7bda
   - [Sample datasets](#sample-datasets)
 - [Pytae-specific operations](#pytae-specific-operations)
   - [Column selection — `-select`](#select)
+  - [Drop columns — `-drop`](#drop)
   - [Row filtering — `-qry`](#qry)
   - [Mutated columns — `-mutate`](#mutate)
   - [SQL — `-sql`](#sql)
@@ -47,7 +48,7 @@ How the CLI pipeline works, and how to grab a real dataset to try it on.
 <a id="basics"></a>
 ### Basics
 
-Flag **order is the pipeline**, the same as a pandas/pytae method chain. `-select … -agg_df … -select … -shape` is `df.select(…).agg_df(…).select(…).shape`. Put `-qry` / `-query` first yourself if you need a column you later drop. **Only the last operation prints.** Earlier flags still run.
+Flag **order is the pipeline**, the same as a pandas/pytae method chain. `-select … -agg_df … -select … -shape` is `df.select(…).agg_df(…).select(…).shape`. Put `-qry` / `-query` first yourself if you need a column you later `-drop` / `-select` away. **Only the last operation prints.** Earlier flags still run.
 
 ```bash
 # first 3 rows, then shape of that 3-row frame → prints (3, n)
@@ -65,6 +66,9 @@ pytae penguins.parquet -select "species,body_mass_g" -agg_df mean
 # heaviest 5 penguins, name + weight only
 pytae penguins.parquet -select "species,body_mass_g" -sort_by "body_mass_g desc" -head 5
 
+# drop columns; the rest keep file order
+pytae penguins.parquet -drop "sex,island" -head 5
+
 # ad-hoc SQL over the same file
 pytae penguins.parquet -sql "select species, avg(body_mass_g) from df group by species"
 ```
@@ -178,10 +182,34 @@ Exact names must exist on the **current** columns; missing names error with a ty
 
 ---
 
+<a id="drop"></a>
+### Drop columns — `-drop`
+
+Subtract **exact column names**. Complements `-select`: `-select` picks (and may reorder); `-drop` removes and leaves the rest in their current order. No `dtype=` / `contains=` / `regex=` / slices — those stay on `-select`.
+
+```python
+df.drop(columns=["sex", "island"])
+```
+
+```bash
+# yank known columns
+pytae penguins.parquet -drop "sex,island" -head 5
+
+# keep a shape, then pull one column out of it
+pytae penguins.parquet -select "dtype=numeric,species" -drop "body_mass_g" -cols
+
+# filter on a column, then remove it
+pytae penguins.parquet -qry "species: 'Adelie'" -drop "species" -head
+```
+
+Same quoting as `-select` names (a space is not a separator; quote a name only to protect a comma). Missing names error with a typo suggestion. Repeat `-drop` to subtract more. Dropping every remaining column is an error.
+
+---
+
 <a id="qry"></a>
 ### Row filtering — `-qry`
 
-pytae's dict-based filter, `df.qry()` — safer than `-query` for odd strings (values with spaces or special characters). **Narrows rows** at this point in the pipeline. Put it **before** `-select` if you need a column you then drop. Can be combined with [`-query`](#query) (stacks sequentially — AND on the remaining rows).
+pytae's dict-based filter, `df.qry()` — safer than `-query` for odd strings (values with spaces or special characters). **Narrows rows** at this point in the pipeline. Put it **before** `-select` / `-drop` if you need a column you then drop. Can be combined with [`-query`](#query) (stacks sequentially — AND on the remaining rows).
 
 ```python
 df.qry({"species": "Adelie", "body_mass_g": (">", 3500)})
@@ -193,8 +221,8 @@ df.qry({"species": "Adelie"}).select("species", "body_mass_g")
 # vs 3500 vs ('>', 3500)). That is not the same as -select contains=bill.
 pytae penguins.parquet -qry "species: 'Adelie', body_mass_g: ('>', 3500)"
 
-# filter first, then drop the filter column — same as df.qry(...).select(...)
-pytae penguins.parquet -qry "species: 'Adelie'" -select "species,body_mass_g" -head
+# filter first, then drop the filter column — same as df.qry(...).drop(columns=...)
+pytae penguins.parquet -qry "species: 'Adelie'" -drop "species" -head
 
 # string-matching operators: startswith / endswith / contains / regex (search-anywhere,
 # like re.search — 'regex' is 'contains' with regex=True); missing values never match (na=False)
@@ -236,6 +264,9 @@ pytae penguins.parquet -mutate "mass_kg: body_mass_g / 1000, mass_lb: mass_kg *
 # key quoting optional (matches -qry); string literals in the expression still need quotes
 pytae penguins.parquet -mutate "is_adelie: species == 'Adelie'" -select "species,is_adelie" -head
 
+# string concat: pandas eval does not support + for strings; use .str.cat
+pytae penguins.parquet -mutate "dummy: species.str.cat(island, sep='_')" -select "species,island,dummy" -head
+
 # chains into -qry, filtering on a column just mutated
 pytae penguins.parquet -mutate "bmi: body_mass_g / bill_length_mm ** 2" -qry "bmi: ('>', 2)" -select "species,bmi" -head
 
@@ -682,7 +713,7 @@ Every structured flag is one of two families. Wrap the **whole spec** in `""` wh
 
 **kwargs** — `key=value,key=value`. Used by `-select` kwargs, `-agg`, `-group_x`, `-crosstab`, `-long`/`-wide`, `-merge`, `-concat`, `-replace_values`, `-clean_columns`, `-file` extras. Quote a value only when it contains a comma. `contains=bill`, `index=species`, and `dtype=numeric` stay unquoted — they are tokens, not Python literals (`contains='bill'` is accepted, not the style).
 
-**names and mappings** — `a,b` lists, or `name: payload`. Used by `-select` names/slices, `-group_by`, `-sort_by`, `-qry`, `-mutate`, `-rename`, and nested maps like `v=` / `on=` pairs. `-qry` is the exception that *requires* quotes on string values: they are typed literals (`'Adelie'` vs `3500` vs `('>', 3500)`), so unquoted `Adelie` is not valid. `-mutate` column names inside an expression must stay unquoted.
+**names and mappings** — `a,b` lists, or `name: payload`. Used by `-select` names/slices, `-drop`, `-group_by`, `-sort_by`, `-qry`, `-mutate`, `-rename`, and nested maps like `v=` / `on=` pairs. `-qry` is the exception that *requires* quotes on string values: they are typed literals (`'Adelie'` vs `3500` vs `('>', 3500)`), so unquoted `Adelie` is not valid. `-mutate` column names inside an expression must stay unquoted.
 
 Simple flags (`-head 5`, `-sql "..."`, `-query "..."`, `-pretty`, `-dropna false`) are neither family.
 
@@ -702,6 +733,7 @@ pytae -file "a.csv=df1;b.csv=df2" -concat "frames='df1,df2'"
 # names: comma list; quote a name only to protect a comma
 pytae data.parquet -select "bill length mm,body mass g"
 pytae data.parquet -select "'city, state',other_col"
+pytae penguins.parquet -drop "sex,island"
 pytae penguins.parquet -sort_by "species,body_mass_g desc"
 
 # mappings: name: payload. -qry strings are typed literals, so they need quotes
@@ -724,6 +756,7 @@ Some flags/keys are thin passthroughs to standard pandas methods and parameter n
 | Flag / key | Pandas equivalent |
 |---|---|
 | `-query` | `df.query()` |
+| `-drop` | `df.drop(columns=...)` — exact names only; patterns/dtypes/slices stay on `-select` |
 | `-describe` / `-info` / `-shape` / `-cols` / `-dtype` / `-nulls` | `df.describe()` / `df.info()` / `df.shape` / `df.columns` / `df.dtypes` / `df.isna().sum()` |
 | `-sort_by` | `df.sort_values()` |
 | `-crosstab`'s `values=` / `aggfunc=` / `normalize=` / `margins=` | same keyword names as `pd.crosstab()` |
@@ -883,6 +916,7 @@ pytae penguins.parquet -qry "island: 'Dream'" -select "species,island,body_mass_
 | Flag | Description |
 |---|---|
 | `-select SPEC` | Restrict columns at this point in the pipeline (union in one spec; repeat to filter remaining) |
+| `-drop COLUMNS` | Drop columns by exact name at this point (comma-separated names only; remaining keep their order) |
 | `-qry CONDITIONS` | Filter rows at this point (`df.qry()`); surrounding `{}` and column-name quotes optional |
 | `-mutate SPEC` | Create/overwrite columns at this point (`df.mutate()`); `"new_col: expression"` entries, same tokenizer/key-quoting rules as `-qry` (no surrounding `{}`), but the value is a pandas `eval()` expression, not a literal |
 | `-query EXPR` | Filter rows at this point (`df.query()`) |

{pytae-3.4.2 → pytae-3.4.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "pytae"
-version = "3.4.2"
+version = "3.4.3"
 description = "A package to enhance common tasks in data and plotting"
 authors = [{ name = "Madhukar Kumar Jha", email = "madhukar.k.jha@gmail.com" }]
 readme = "README.md"

{pytae-3.4.2 → pytae-3.4.3}/src/pytae/cli.py

@@ -20,6 +20,7 @@ from pytae.cli_parsing import (
     parse_columns,
     parse_concat_arg,
     parse_crosstab_arg,
+    parse_drop_spec,
     parse_file_arg,
     parse_fraction,
     parse_group_agg,
@@ -194,6 +195,10 @@ def build_parser() -> argparse.ArgumentParser:
                               "names, start:end slices, and key=value (dtype, contains, startswith, endswith, "
                               "regex, exclude_dtype); repeat to filter remaining columns, including after "
                               '-agg_df/-long/-wide, e.g. -select "dtype=numeric" -select "contains=bill"')
+    parser.add_argument("--drop", "-drop", dest="drop", action=_OrderedAppend, default=None, metavar="COLUMNS",
+                         help="drop columns by exact name at this point in the pipeline (comma-separated names "
+                              "only; use -select for dtype=/contains=/regex=/slices); remaining columns keep "
+                              'their order, e.g. -drop "sex,island"')
     parser.add_argument("-convert", "--convert", dest="convert",
                          action=_OrderedFlag,
                          help="convert to another format (.parquet/.csv/.txt/.dat, inferred from -o's extension, "
@@ -356,6 +361,7 @@ def _process_path(
     *,
     show_all: bool,
     select_specs: list[tuple[list[str], dict]],
+    drop_specs: list[list[str]],
     qry_specs: list[dict],
     mutate_specs: list[str],
     query_specs: list[str],
@@ -397,6 +403,7 @@ def _process_path(
     op_order = getattr(args, "op_order", [])
     last_idx = len(op_order) - 1
     select_iter = iter(select_specs)
+    drop_iter = iter(drop_specs)
     qry_iter = iter(qry_specs)
     mutate_iter = iter(mutate_specs)
     query_iter = iter(query_specs)
@@ -425,6 +432,11 @@ def _process_path(
             if err:
                 return _fail(parser, batch, err)
             emit_frame(idx)
+        elif op == "drop":
+            err = pipeline.apply_drop(next(drop_iter))
+            if err:
+                return _fail(parser, batch, err)
+            emit_frame(idx)
         elif op == "qry":
             err = pipeline.apply_qry(next(qry_iter))
             if err:
@@ -766,7 +778,7 @@ def main(argv: list[str] | None = None) -> int:
                          args.convert, args.agg_df is not None, args.agg is not None,
                          args.group_x is not None, args.handle_missing is not None,
                          args.long is not None, args.wide is not None, args.crosstab is not None,
-                         args.select, args.qry, args.query, args.sql, args.replace_values,
+                         args.select, args.drop, args.qry, args.query, args.sql, args.replace_values,
                          args.clean_columns is not None, args.merge, args.concat])
 
     wants_df = any([args.cols, args.dtype, args.nulls, args.describe, show_all,
@@ -790,6 +802,7 @@ def main(argv: list[str] | None = None) -> int:
 
     rename_map = parse_rename(args.rename) if args.rename else None
     select_specs = [parse_select_spec(raw) for raw in (args.select or [])]
+    drop_specs = [parse_drop_spec(raw) for raw in (args.drop or [])]
     qry_specs = [parse_qry(raw) for raw in (args.qry or [])]
     mutate_specs = list(args.mutate or [])
     query_specs = list(args.query or [])
@@ -813,6 +826,7 @@ def main(argv: list[str] | None = None) -> int:
             except UnicodeError as exc:
                 parser.error(_encoding_error_message(entry_path, entry["encoding"], exc))
         failed = _process_path(None, args, parser, False, show_all=show_all, select_specs=select_specs,
+                                drop_specs=drop_specs,
                                 qry_specs=qry_specs, mutate_specs=mutate_specs, query_specs=query_specs, sql_specs=sql_specs,
                                 replace_specs=replace_specs, rename_map=rename_map, frames=frames,
                                 merge_specs=merge_specs, concat_specs=concat_specs)
@@ -830,6 +844,7 @@ def main(argv: list[str] | None = None) -> int:
             print(f"== {path} ==")
         try:
             failed = _process_path(path, args, parser, batch, show_all=show_all, select_specs=select_specs,
+                                    drop_specs=drop_specs,
                                     qry_specs=qry_specs, mutate_specs=mutate_specs, query_specs=query_specs, sql_specs=sql_specs,
                                     replace_specs=replace_specs, rename_map=rename_map)
         except UnicodeError as exc:

{pytae-3.4.2 → pytae-3.4.3}/src/pytae/cli_parsing.py

@@ -90,6 +90,26 @@ def _split_groups(raw: str, sep: str = ";") -> list[str]:
     return [t for t in _tokenize(raw, sep, keep_quotes=True) if t]
 
 
+def parse_drop_spec(raw: str) -> list[str]:
+    """Parse -drop into exact column names.
+
+    Names only: comma-separated, same quoting as -select names (a space is not
+    a separator). key=value tokens and select matchers (dtype=/contains=/regex=/
+    slices) are rejected — those stay on -select.
+    """
+    tokens = _split_tokens(raw)
+    if not tokens:
+        raise SystemExit("-drop: expected column names")
+    names: list[str] = []
+    for token in tokens:
+        if "=" in token:
+            raise SystemExit(
+                "-drop: only column names; use -select for dtype=/contains=/regex=/exclude_dtype="
+            )
+        names.append(token)
+    return names
+
+
 def parse_select_spec(raw: str) -> tuple[list[str], dict]:
     """Parse -select into positional names/slices and select() kwargs.
 

{pytae-3.4.2 → pytae-3.4.3}/src/pytae/cli_pipeline.py

@@ -36,8 +36,8 @@ def _mask_quoted(spec: str) -> str:
 
 
 class _Pipeline:
-    """Flag order is the method chain. Each -select/-qry/-query/-head/… call
-    runs on the current view, same as df.select().qry().head().
+    """Flag order is the method chain. Each -select/-drop/-qry/-query/-head/… call
+    runs on the current view, same as df.select().drop(columns=…).qry().head().
     Only the last flag prints. Schema-only ops (-cols/-dtype/-shape) avoid loading
     row data until something actually requires it. -shape/-cols/-dtype/-nulls/-info
     don't return a DataFrame/Series in pandas either, so (like main()'s validation)
@@ -82,6 +82,28 @@ class _Pipeline:
             return f"-select: {exc}"
         return None
 
+    def apply_drop(self, names: list[str]) -> str | None:
+        """Apply one -drop spec (exact column names) to the current view.
+
+        Remaining columns keep their existing order. Returns an error message or None.
+        """
+        available = self._available_columns()
+        unknown = [c for c in names if c not in available]
+        if unknown:
+            msg = unknown_columns_message("-drop", unknown, available)
+            if any(":" in c for c in unknown):
+                msg += " (-drop does not accept slices; use -select)"
+            return msg
+        drop_set = set(names)
+        remaining = [c for c in available if c not in drop_set]
+        if not remaining:
+            return "-drop: no columns left"
+        if self._df is not None:
+            self._df = self._df.drop(columns=list(dict.fromkeys(names)))
+        else:
+            self._pending_exact = remaining
+        return None
+
     def apply_qry(self, conditions: dict) -> str | None:
         """Apply one -qry spec to the current view. Returns an error message or None."""
         df = self.dataframe()

{pytae-3.4.2 → pytae-3.4.3}/tests/test_cli_order.py

@@ -797,6 +797,21 @@ def test_parse_select_spec_quoted_name_and_repeated_key():
     assert kwargs == {"contains": ["bill", "body"]}
 
 
+def test_parse_drop_spec_names_and_quoted():
+    assert cli.parse_drop_spec("sex,year") == ["sex", "year"]
+    assert cli.parse_drop_spec("'bill length mm',body_mass_g") == ["bill length mm", "body_mass_g"]
+    assert cli.parse_drop_spec("a:b") == ["a:b"]  # exact name, not a slice
+
+
+def test_parse_drop_spec_rejects_select_kwargs_and_empty():
+    with pytest.raises(SystemExit, match="only column names"):
+        cli.parse_drop_spec("dtype=numeric")
+    with pytest.raises(SystemExit, match="only column names"):
+        cli.parse_drop_spec("sex,contains=bill")
+    with pytest.raises(SystemExit, match="expected column names"):
+        cli.parse_drop_spec("")
+
+
 def test_parse_agg_name_list_and_mapping():
     from pytae.cli_parsing import parse_agg
     assert parse_agg("mean") == "mean"
@@ -918,6 +933,160 @@ def test_select_unknown_exact_name_errors(tmp_path, capsys):
     assert "'d'" in err
 
 
+def test_drop_does_not_collide_with_dropna():
+    parser = cli.build_parser()
+    args, extras = parser.parse_known_args(["file.csv", "-drop", "sex", "-dropna", "false"])
+    assert extras == []
+    assert args.drop == ["sex"]
+    assert args.dropna is False
+
+
+def test_drop_removes_names_and_keeps_order(tmp_path, capsys):
+    path = _write_csv(tmp_path, pd.DataFrame({"a": [1], "c": [2], "b": [3], "d": [4]}))
+
+    exit_code = cli.main([path, "-drop", "c,d", "-cols"])
+
+    assert exit_code == 0
+    assert capsys.readouterr().out.strip().splitlines() == ["a", "b"]
+
+
+def test_drop_quoted_name_with_space(tmp_path, capsys):
+    path = _write_csv(tmp_path, pd.DataFrame({"bill length mm": [1], "body mass g": [2], "keep": [3]}))
+
+    exit_code = cli.main([path, "-drop", "bill length mm", "-cols"])
+
+    assert exit_code == 0
+    assert capsys.readouterr().out.strip().splitlines() == ["body mass g", "keep"]
+
+
+def test_drop_after_select_subtracts_from_kept(tmp_path, capsys):
+    path = _write_csv(tmp_path, pd.DataFrame({"a": [1], "b": [2], "c": [3], "d": [4]}))
+
+    exit_code = cli.main([path, "-select", "a,b,c", "-drop", "b", "-cols"])
+
+    assert exit_code == 0
+    assert capsys.readouterr().out.strip().splitlines() == ["a", "c"]
+
+
+def test_drop_rejects_name_not_kept_by_select(tmp_path, capsys):
+    path = _write_csv(tmp_path, pd.DataFrame({"a": [1], "b": [2], "c": [3]}))
+
+    with pytest.raises(SystemExit) as exc_info:
+        cli.main([path, "-select", "a,b", "-drop", "c", "-cols"])
+    assert exc_info.value.code == 2
+    err = capsys.readouterr().err
+    assert "unknown column" in err
+    assert "'c'" in err
+
+
+def test_select_then_drop_from_dtype_union(tmp_path, capsys):
+    path = _write_csv(
+        tmp_path,
+        pd.DataFrame({"species": ["A"], "n": [1], "x": [2.0], "label": ["z"]}),
+    )
+
+    exit_code = cli.main([path, "-select", "dtype=numeric,species", "-drop", "x", "-cols"])
+
+    assert exit_code == 0
+    # -select puts explicit names first, then dtype matches; -drop leaves that order
+    assert capsys.readouterr().out.strip().splitlines() == ["species", "n"]
+
+
+def test_repeated_drop_subtracts_sequentially(tmp_path, capsys):
+    path = _write_csv(tmp_path, pd.DataFrame({"a": [1], "b": [2], "c": [3], "d": [4]}))
+
+    exit_code = cli.main([path, "-drop", "b", "-drop", "d", "-cols"])
+
+    assert exit_code == 0
+    assert capsys.readouterr().out.strip().splitlines() == ["a", "c"]
+
+
+def test_drop_unknown_name_errors_with_typo_hint(tmp_path, capsys):
+    path = _write_csv(tmp_path, pd.DataFrame({"species": [1], "island": [2]}))
+
+    with pytest.raises(SystemExit) as exc_info:
+        cli.main([path, "-drop", "speces", "-cols"])
+    assert exc_info.value.code == 2
+    err = capsys.readouterr().err
+    assert "unknown column" in err
+    assert "'speces'" in err
+    assert "species" in err
+
+
+def test_drop_slice_token_is_not_a_slice(tmp_path, capsys):
+    path = _write_csv(tmp_path, pd.DataFrame({"a": [1], "b": [2], "c": [3]}))
+
+    with pytest.raises(SystemExit) as exc_info:
+        cli.main([path, "-drop", "a:c", "-cols"])
+    assert exc_info.value.code == 2
+    err = capsys.readouterr().err
+    assert "unknown column" in err
+    assert "does not accept slices" in err
+
+
+def test_drop_colon_column_name_is_exact(tmp_path, capsys):
+    path = _write_csv(tmp_path, pd.DataFrame({"a:b": [1], "c": [2]}))
+
+    exit_code = cli.main([path, "-drop", "a:b", "-cols"])
+
+    assert exit_code == 0
+    assert capsys.readouterr().out.strip().splitlines() == ["c"]
+
+
+def test_drop_rejects_select_kwargs(tmp_path, capsys):
+    path = _write_csv(tmp_path, pd.DataFrame({"a": [1], "b": [2]}))
+
+    with pytest.raises(SystemExit, match="only column names"):
+        cli.main([path, "-drop", "dtype=numeric", "-cols"])
+    with pytest.raises(SystemExit, match="only column names"):
+        cli.main([path, "-drop", "contains=a", "-cols"])
+
+
+def test_drop_all_columns_errors(tmp_path, capsys):
+    path = _write_csv(tmp_path, pd.DataFrame({"a": [1], "b": [2]}))
+
+    with pytest.raises(SystemExit) as exc_info:
+        cli.main([path, "-drop", "a,b", "-cols"])
+    assert exc_info.value.code == 2
+    assert "no columns left" in capsys.readouterr().err
+
+
+def test_drop_only_prints_remaining_table(tmp_path, capsys):
+    path = _write_csv(tmp_path, pd.DataFrame({"a": [1], "b": [2], "c": [3]}))
+
+    exit_code = cli.main([path, "-drop", "c"])
+
+    out = capsys.readouterr().out
+    assert exit_code == 0
+    assert "a" in out and "b" in out
+    assert "c" not in out.split()
+
+
+def test_drop_after_agg_df_sees_agg_columns(tmp_path, capsys):
+    path = _write_csv(
+        tmp_path,
+        pd.DataFrame({"grp": ["x", "x", "y"], "val": [1, 2, 3], "z": [9, 8, 7]}),
+    )
+
+    exit_code = cli.main(
+        [path, "-agg_df", "val: sum, n: n", "-drop", "val", "-cols"]
+    )
+    assert exit_code == 0
+    assert capsys.readouterr().out.strip().splitlines() == ["grp", "n"]
+
+
+def test_qry_then_drop_filter_column(tmp_path, capsys):
+    path = _write_csv(
+        tmp_path,
+        pd.DataFrame({"keep": [1, 2], "flt": ["A", "B"], "val": [10, 20]}),
+    )
+
+    exit_code = cli.main([path, "-qry", "flt: 'A'", "-drop", "flt", "-cols"])
+
+    assert exit_code == 0
+    assert capsys.readouterr().out.strip().splitlines() == ["keep", "val"]
+
+
 def test_select_after_agg_df_sees_agg_columns(tmp_path, capsys):
     path = _write_csv(
         tmp_path,