bdsc-cli 0.2.1__tar.gz → 0.2.3__tar.gz

{bdsc_cli-0.2.1/src/bdsc_cli.egg-info → bdsc_cli-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bdsc-cli
-Version: 0.2.1
+Version: 0.2.3
 Summary: Sync and query BDSC datasets locally
 Author: Gustavo Madeira Santana
 License-Expression: MIT
@@ -21,6 +21,9 @@ Dynamic: license-file
 
 # bdsc-cli
 
+> This package has been renamed. Install `bdsc` now:
+> `pipx install bdsc`
+
 Small CLI for syncing public Bloomington Drosophila Stock Center datasets and
 querying them locally.
 
@@ -50,16 +53,16 @@ brew tap gumadeiras/tap
 brew install bdsc-cli
 ```
 
-Or install the release wheel directly with `pipx`:
+PyPI with `pipx`:
 
 ```bash
-pipx install 'bdsc-cli @ https://github.com/gumadeiras/bdsc-cli/releases/download/v0.2.1/bdsc_cli-0.2.1-py3-none-any.whl'
+pipx install bdsc-cli
 ```
 
-Or with plain `pip`:
+PyPI with plain `pip`:
 
 ```bash
-python3 -m pip install 'bdsc-cli @ https://github.com/gumadeiras/bdsc-cli/releases/download/v0.2.1/bdsc_cli-0.2.1-py3-none-any.whl'
+python3 -m pip install bdsc-cli
 ```
 
 Source install:
@@ -91,19 +94,8 @@ Build release artifacts locally:
 python -m pip install -e .[release]
 python -m build
 python -m twine check dist/*
-python scripts/render_homebrew_formula.py dist/bdsc_cli-$(python - <<'PY'
-from bdsc_cli import __version__
-print(__version__)
-PY
-).tar.gz
 ```
 
-PyPI note:
-
-- the GitHub release is live
-- PyPI trusted publishing is not configured yet for `bdsc-cli`
-- `pip install bdsc-cli` will work after that publisher is added
-
 ## Quickstart
 
 Create a local cache and index:
@@ -190,6 +182,9 @@ bdsc export components --limit 5 --format jsonl
 bdsc stock 77118 --json
 ```
 
+Query commands return all matches by default. Use `--limit N` when you want a
+bounded result set.
+
 ## Commands
 
 - `bdsc sync`: download the BDSC CSV datasets; builds the index by default
@@ -354,9 +349,7 @@ bdsc terms property-descriptions --query optogenetic --jsonl
 - use `property-exact` or `driver-family` when `property` is too broad for a
   reliable LexA/QF/GAL4-style answer.
 - tag pushes like `vX.Y.Z` run the release workflow: build artifacts, create a
-  GitHub release, and publish to PyPI.
-- `scripts/render_homebrew_formula.py` renders a Homebrew formula from a built
-  sdist; use it when updating a tap after a release.
+  GitHub release, publish to PyPI, and update `gumadeiras/homebrew-tap`.
 - The live endpoint is undocumented and may change without notice.
 - BDSC data is large enough that the first full sync/index can take a few
   minutes depending on network and disk speed.

{bdsc_cli-0.2.1 → bdsc_cli-0.2.3}/README.md

@@ -1,5 +1,8 @@
 # bdsc-cli
 
+> This package has been renamed. Install `bdsc` now:
+> `pipx install bdsc`
+
 Small CLI for syncing public Bloomington Drosophila Stock Center datasets and
 querying them locally.
 
@@ -29,16 +32,16 @@ brew tap gumadeiras/tap
 brew install bdsc-cli
 ```
 
-Or install the release wheel directly with `pipx`:
+PyPI with `pipx`:
 
 ```bash
-pipx install 'bdsc-cli @ https://github.com/gumadeiras/bdsc-cli/releases/download/v0.2.1/bdsc_cli-0.2.1-py3-none-any.whl'
+pipx install bdsc-cli
 ```
 
-Or with plain `pip`:
+PyPI with plain `pip`:
 
 ```bash
-python3 -m pip install 'bdsc-cli @ https://github.com/gumadeiras/bdsc-cli/releases/download/v0.2.1/bdsc_cli-0.2.1-py3-none-any.whl'
+python3 -m pip install bdsc-cli
 ```
 
 Source install:
@@ -70,19 +73,8 @@ Build release artifacts locally:
 python -m pip install -e .[release]
 python -m build
 python -m twine check dist/*
-python scripts/render_homebrew_formula.py dist/bdsc_cli-$(python - <<'PY'
-from bdsc_cli import __version__
-print(__version__)
-PY
-).tar.gz
 ```
 
-PyPI note:
-
-- the GitHub release is live
-- PyPI trusted publishing is not configured yet for `bdsc-cli`
-- `pip install bdsc-cli` will work after that publisher is added
-
 ## Quickstart
 
 Create a local cache and index:
@@ -169,6 +161,9 @@ bdsc export components --limit 5 --format jsonl
 bdsc stock 77118 --json
 ```
 
+Query commands return all matches by default. Use `--limit N` when you want a
+bounded result set.
+
 ## Commands
 
 - `bdsc sync`: download the BDSC CSV datasets; builds the index by default
@@ -333,9 +328,7 @@ bdsc terms property-descriptions --query optogenetic --jsonl
 - use `property-exact` or `driver-family` when `property` is too broad for a
   reliable LexA/QF/GAL4-style answer.
 - tag pushes like `vX.Y.Z` run the release workflow: build artifacts, create a
-  GitHub release, and publish to PyPI.
-- `scripts/render_homebrew_formula.py` renders a Homebrew formula from a built
-  sdist; use it when updating a tap after a release.
+  GitHub release, publish to PyPI, and update `gumadeiras/homebrew-tap`.
 - The live endpoint is undocumented and may change without notice.
 - BDSC data is large enough that the first full sync/index can take a few
   minutes depending on network and disk speed.

{bdsc_cli-0.2.1 → bdsc_cli-0.2.3}/src/bdsc_cli/__init__.py

@@ -1,3 +1,3 @@
 __all__ = ["__version__"]
 
-__version__ = "0.2.1"
+__version__ = "0.2.3"

{bdsc_cli-0.2.1 → bdsc_cli-0.2.3}/src/bdsc_cli/cli.py

@@ -75,6 +75,12 @@ LEGACY_COMMANDS = {
 PUBLIC_COMMAND_METAVAR = "{sync,build-index,export,report,terms,status,find,stock}"
 
 
+class HelpOnErrorArgumentParser(argparse.ArgumentParser):
+    def error(self, message: str) -> None:
+        self.print_help(sys.stderr)
+        self.exit(2, f"\nerror: {message}\n")
+
+
 def _filter_dest(kind: str) -> str:
     return f"{kind.replace('-', '_')}_filters"
 
@@ -85,6 +91,24 @@ def add_json_flags(parser: argparse.ArgumentParser, *, jsonl: bool = True) -> No
         parser.add_argument("--jsonl", action="store_true")
 
 
+def add_limit_argument(parser: argparse.ArgumentParser) -> None:
+    parser.add_argument("--limit", type=int, help="max rows to emit")
+
+
+def add_subcommand(subparsers, name: str, **kwargs):
+    parser = subparsers.add_parser(name, **kwargs)
+    parser.set_defaults(_command_parser=parser)
+    return parser
+
+
+def command_error(
+    root_parser: argparse.ArgumentParser,
+    args: argparse.Namespace,
+    message: str,
+) -> None:
+    getattr(args, "_command_parser", root_parser).error(message)
+
+
 def add_query_parser(
     subparsers,
     name: str,
@@ -93,10 +117,10 @@ def add_query_parser(
     jsonl: bool = True,
     hidden: bool = False,
 ):
-    parser = subparsers.add_parser(name, help=LEGACY_HELP if hidden else help_text)
+    parser = add_subcommand(subparsers, name, help=LEGACY_HELP if hidden else help_text)
     parser.add_argument("query")
     parser.add_argument("--state-dir", help="cache/index directory")
-    parser.add_argument("--limit", type=int, default=20)
+    add_limit_argument(parser)
     add_json_flags(parser, jsonl=jsonl)
     return parser
 
@@ -110,15 +134,16 @@ def hide_legacy_commands(subparsers_action) -> None:
 
 
 def build_parser() -> argparse.ArgumentParser:
-    parser = argparse.ArgumentParser(prog="bdsc", description="Sync and query BDSC data")
+    parser = HelpOnErrorArgumentParser(prog="bdsc", description="Sync and query BDSC data")
     parser.add_argument("--version", action="version", version=f"%(prog)s {__version__}")
     subparsers = parser.add_subparsers(
         dest="command",
         required=True,
         metavar=PUBLIC_COMMAND_METAVAR,
+        parser_class=HelpOnErrorArgumentParser,
     )
 
-    sync_parser = subparsers.add_parser("sync", help="download public BDSC CSV datasets")
+    sync_parser = add_subcommand(subparsers, "sync", help="download public BDSC CSV datasets")
     sync_parser.add_argument("--state-dir", help="cache/index directory")
     sync_parser.add_argument("--force", action="store_true", help="skip conditional HTTP headers")
     sync_parser.add_argument(
@@ -127,17 +152,19 @@ def build_parser() -> argparse.ArgumentParser:
         help="download only; do not rebuild the local SQLite index",
     )
 
-    build_parser_cmd = subparsers.add_parser(
+    build_parser_cmd = add_subcommand(
+        subparsers,
         "build-index", help="rebuild the local SQLite index from downloaded CSVs"
     )
     build_parser_cmd.add_argument("--state-dir", help="cache/index directory")
 
-    export_parser = subparsers.add_parser(
+    export_parser = add_subcommand(
+        subparsers,
         "export", help="stream normalized rows for stocks/components/genes/properties"
     )
     export_parser.add_argument("dataset", choices=EXPORT_DATASETS)
     export_parser.add_argument("--state-dir", help="cache/index directory")
-    export_parser.add_argument("--limit", type=int, help="max rows to emit")
+    add_limit_argument(export_parser)
     export_parser.add_argument("--query", help="filter exported rows by a query value")
     export_parser.add_argument(
         "--kind",
@@ -157,7 +184,8 @@ def build_parser() -> argparse.ArgumentParser:
         help="output path; defaults to stdout",
     )
 
-    report_parser = subparsers.add_parser(
+    report_parser = add_subcommand(
+        subparsers,
         "report",
         help="canned reports for common BDSC retrieval tasks",
     )
@@ -168,11 +196,12 @@ def build_parser() -> argparse.ArgumentParser:
         help="override the report's default dataset",
     )
     report_parser.add_argument("--state-dir", help="cache/index directory")
-    report_parser.add_argument("--limit", type=int, default=20)
+    add_limit_argument(report_parser)
     report_parser.add_argument("--json", action="store_true")
     report_parser.add_argument("--jsonl", action="store_true")
 
-    filter_parser = subparsers.add_parser(
+    filter_parser = add_subcommand(
+        subparsers,
         "filter",
         help=LEGACY_HELP,
     )
@@ -183,12 +212,13 @@ def build_parser() -> argparse.ArgumentParser:
         help="row shape to return",
     )
     filter_parser.add_argument("--state-dir", help="cache/index directory")
-    filter_parser.add_argument("--limit", type=int, default=20)
+    add_limit_argument(filter_parser)
     add_filter_arguments(filter_parser)
     filter_parser.add_argument("--json", action="store_true")
     filter_parser.add_argument("--jsonl", action="store_true")
 
-    terms_parser = subparsers.add_parser(
+    terms_parser = add_subcommand(
+        subparsers,
         "terms",
         help="list available property/relationship vocab with counts",
     )
@@ -199,19 +229,21 @@ def build_parser() -> argparse.ArgumentParser:
     terms_parser.add_argument("--json", action="store_true")
     terms_parser.add_argument("--jsonl", action="store_true")
 
-    status_parser = subparsers.add_parser(
+    status_parser = add_subcommand(
+        subparsers,
         "status", help="show local dataset/index status for the current state dir"
     )
     status_parser.add_argument("--state-dir", help="cache/index directory")
     add_json_flags(status_parser, jsonl=False)
 
-    find_parser = subparsers.add_parser(
+    find_parser = add_subcommand(
+        subparsers,
         "find",
         help="primary query command; free-text lookup or structured compound filters",
     )
     find_parser.add_argument("query", nargs="?")
     find_parser.add_argument("--state-dir", help="cache/index directory")
-    find_parser.add_argument("--limit", type=int, default=20)
+    add_limit_argument(find_parser)
     find_parser.add_argument(
         "--kind",
         choices=LOOKUP_KINDS,
@@ -231,7 +263,7 @@ def build_parser() -> argparse.ArgumentParser:
         "search",
         "query the local SQLite index",
         hidden=True,
-    ).set_defaults(limit=10)
+    )
     add_query_parser(
         subparsers,
         "gene",
@@ -251,12 +283,12 @@ def build_parser() -> argparse.ArgumentParser:
         hidden=True,
     )
 
-    stock_parser = subparsers.add_parser("stock", help="show local details for one stock")
+    stock_parser = add_subcommand(subparsers, "stock", help="show local details for one stock")
     stock_parser.add_argument("stknum", type=int)
     stock_parser.add_argument("--state-dir", help="cache/index directory")
     add_json_flags(stock_parser, jsonl=False)
 
-    rrid_parser = subparsers.add_parser("rrid", help=LEGACY_HELP)
+    rrid_parser = add_subcommand(subparsers, "rrid", help=LEGACY_HELP)
     rrid_parser.add_argument("query")
     rrid_parser.add_argument("--state-dir", help="cache/index directory")
     add_json_flags(rrid_parser, jsonl=False)
@@ -286,25 +318,27 @@ def build_parser() -> argparse.ArgumentParser:
         hidden=True,
     )
 
-    lookup_parser = subparsers.add_parser(
+    lookup_parser = add_subcommand(
+        subparsers,
         "lookup",
         help=LEGACY_HELP,
     )
     lookup_parser.add_argument("queries", nargs="*")
     lookup_parser.add_argument("--state-dir", help="cache/index directory")
     lookup_parser.add_argument("--kind", choices=LOOKUP_KINDS, default="auto")
-    lookup_parser.add_argument("--limit", type=int, default=20)
+    add_limit_argument(lookup_parser)
     lookup_parser.add_argument(
         "--input",
         help="read newline-delimited queries from a file path or '-' for stdin",
     )
     add_json_flags(lookup_parser)
 
-    live_parser = subparsers.add_parser(
+    live_parser = add_subcommand(
+        subparsers,
         "live-search", help=LEGACY_HELP
     )
     live_parser.add_argument("query")
-    live_parser.add_argument("--limit", type=int, default=10)
+    add_limit_argument(live_parser)
     add_json_flags(live_parser)
 
     hide_legacy_commands(subparsers)
@@ -446,7 +480,7 @@ def run_find(parser: argparse.ArgumentParser, args: argparse.Namespace) -> int:
     query = (args.query or "").strip()
     criteria = build_filter_criteria(args)
     if not query and not criteria:
-        parser.error("find requires a query or at least one filter flag")
+        command_error(parser, args, "find requires a query or at least one filter flag")
 
     state_dir = resolve_state_dir(args.state_dir)
     if query and not criteria and not args.dataset:
@@ -477,7 +511,7 @@ def run_find(parser: argparse.ArgumentParser, args: argparse.Namespace) -> int:
 def run_legacy_lookup(parser: argparse.ArgumentParser, args: argparse.Namespace) -> int:
     queries = load_queries(args.queries, args.input)
     if not queries:
-        parser.error("lookup requires at least one query or --input")
+        command_error(parser, args, "lookup requires at least one query or --input")
     state_dir = resolve_state_dir(args.state_dir)
     lookup_results = [
         lookup_query(state_dir, query, kind=args.kind, limit=args.limit)
@@ -542,7 +576,7 @@ def main(argv: list[str] | None = None) -> int:
         if args.command == "filter":
             criteria = build_filter_criteria(args)
             if not criteria:
-                parser.error("filter requires at least one filter flag")
+                command_error(parser, args, "filter requires at least one filter flag")
             rows = list(
                 iter_export_rows(
                     state_dir,

{bdsc_cli-0.2.1 → bdsc_cli-0.2.3}/src/bdsc_cli/core.py

@@ -857,11 +857,30 @@ def _merge_ranked_matches(
     )
 
 
+def _limit_sql(limit: int | None) -> tuple[str, list[int]]:
+    if limit is None:
+        return "", []
+    return "LIMIT ?", [limit]
+
+
+def _scaled_limit(limit: int | None, multiplier: int, floor: int) -> int | None:
+    if limit is None:
+        return None
+    return max(limit * multiplier, floor)
+
+
+def _limit_rows(rows: list[Any], limit: int | None) -> list[Any]:
+    if limit is None:
+        return rows
+    return rows[:limit]
+
+
 def _search_candidates_from_prefix_fts(
     conn: sqlite3.Connection,
     query: str,
-    limit: int,
+    limit: int | None,
 ) -> list[dict[str, Any]]:
+    limit_clause, limit_params = _limit_sql(limit)
     has_fts = bool(
         conn.execute(
             "SELECT 1 FROM sqlite_master WHERE type='table' AND name='stock_fts'"
@@ -869,7 +888,7 @@ def _search_candidates_from_prefix_fts(
     )
     if not has_fts:
         rows = conn.execute(
-            """
+            f"""
             SELECT
               s.stknum,
               s.genotype,
@@ -881,14 +900,14 @@ def _search_candidates_from_prefix_fts(
             JOIN stocks s ON s.stknum = sd.stknum
             WHERE sd.search_text LIKE ?
             ORDER BY s.stknum
-            LIMIT ?
+            {limit_clause}
             """,
-            (f"%{query}%", limit),
+            (f"%{query}%", *limit_params),
         ).fetchall()
         return [{"row": row, "score": _score_search_document(query, row) + 20.0} for row in rows]
 
     rows = conn.execute(
-        """
+        f"""
         SELECT
           s.stknum,
           s.genotype,
@@ -902,9 +921,9 @@ def _search_candidates_from_prefix_fts(
         JOIN search_documents sd ON sd.stknum = s.stknum
         WHERE stock_fts MATCH ?
         ORDER BY bm25(stock_fts), s.stknum
-        LIMIT ?
+        {limit_clause}
         """,
-        (build_fts_query(query), limit),
+        (build_fts_query(query), *limit_params),
     ).fetchall()
     return [
         {
@@ -918,11 +937,12 @@ def _search_candidates_from_prefix_fts(
 def _search_candidates_from_trigram_fts(
     conn: sqlite3.Connection,
     query: str,
-    limit: int,
+    limit: int | None,
 ) -> list[dict[str, Any]]:
     trigram_query = build_trigram_query(query)
     if not trigram_query:
         return []
+    limit_clause, limit_params = _limit_sql(limit)
 
     has_trigram = bool(
         conn.execute(
@@ -933,7 +953,7 @@ def _search_candidates_from_trigram_fts(
         return []
 
     rows = conn.execute(
-        """
+        f"""
         SELECT
           s.stknum,
           s.genotype,
@@ -947,9 +967,9 @@ def _search_candidates_from_trigram_fts(
         JOIN search_documents sd ON sd.stknum = s.stknum
         WHERE stock_trigram MATCH ?
         ORDER BY bm25(stock_trigram), s.stknum
-        LIMIT ?
+        {limit_clause}
         """,
-        (trigram_query, limit),
+        (trigram_query, *limit_params),
     ).fetchall()
 
     matches: list[dict[str, Any]] = []
@@ -963,21 +983,21 @@ def _search_candidates_from_trigram_fts(
 def _candidate_stock_ids_for_query(
     conn: sqlite3.Connection,
     query: str,
-    limit: int,
+    limit: int | None,
 ) -> list[int]:
     candidates: dict[int, float] = {}
-    for match in _search_candidates_from_prefix_fts(conn, query, max(limit * 2, 20)):
+    for match in _search_candidates_from_prefix_fts(conn, query, _scaled_limit(limit, 2, 20)):
         candidates[match["row"]["stknum"]] = max(
             match["score"],
             candidates.get(match["row"]["stknum"], float("-inf")),
         )
-    for match in _search_candidates_from_trigram_fts(conn, query, max(limit * 6, 60)):
+    for match in _search_candidates_from_trigram_fts(conn, query, _scaled_limit(limit, 6, 60)):
         candidates[match["row"]["stknum"]] = max(
             match["score"],
             candidates.get(match["row"]["stknum"], float("-inf")),
         )
     ranked = sorted(candidates.items(), key=lambda item: (-item[1], item[0]))
-    return [stknum for stknum, _ in ranked[:limit]]
+    return _limit_rows([stknum for stknum, _ in ranked], limit)
 
 
 def _score_field_match(query: str, text: str) -> float:
@@ -1031,7 +1051,7 @@ def _rank_direct_rows(
     rows: list[sqlite3.Row],
     *,
     field_names: list[str],
-    limit: int,
+    limit: int | None,
     min_score: float = 5.0,
     key_fn=None,
 ) -> list[dict[str, Any]]:
@@ -1044,10 +1064,10 @@ def _rank_direct_rows(
     if key_fn is None:
         key_fn = _default_row_key
     ranked = _merge_ranked_matches(scored, key_fn)
-    return [dict(item["row"]) for item in ranked[:limit]]
+    return [dict(item["row"]) for item in _limit_rows(ranked, limit)]
 
 
-def search_local(state_dir: Path, query: str, limit: int = 10) -> list[dict[str, Any]]:
+def search_local(state_dir: Path, query: str, limit: int | None = None) -> list[dict[str, Any]]:
     query = query.strip()
     if not query:
         return []
@@ -1059,14 +1079,14 @@ def search_local(state_dir: Path, query: str, limit: int = 10) -> list[dict[str,
             return [stock] if stock else []
 
         candidates: dict[int, dict[str, Any]] = {}
-        for match in _search_candidates_from_prefix_fts(conn, query, max(limit * 3, 20)):
+        for match in _search_candidates_from_prefix_fts(conn, query, _scaled_limit(limit, 3, 20)):
             stknum = match["row"]["stknum"]
             existing = candidates.get(stknum)
             if existing is None or match["score"] > existing["score"]:
                 candidates[stknum] = match
 
         if not candidates:
-            for match in _search_candidates_from_trigram_fts(conn, query, max(limit * 12, 60)):
+            for match in _search_candidates_from_trigram_fts(conn, query, _scaled_limit(limit, 12, 60)):
                 stknum = match["row"]["stknum"]
                 existing = candidates.get(stknum)
                 if existing is None or match["score"] > existing["score"]:
@@ -1076,21 +1096,22 @@ def search_local(state_dir: Path, query: str, limit: int = 10) -> list[dict[str,
             candidates.values(),
             key=lambda item: (-item["score"], item["row"]["stknum"]),
         )
-        return [_search_result_payload(item["row"]) for item in ranked[:limit]]
+        return [_search_result_payload(item["row"]) for item in _limit_rows(ranked, limit)]
     finally:
         conn.close()
 
 
-def search_gene(state_dir: Path, query: str, limit: int = 20) -> list[dict[str, Any]]:
+def search_gene(state_dir: Path, query: str, limit: int | None = None) -> list[dict[str, Any]]:
     query = query.strip()
     if not query:
         return []
 
     conn = _connect(state_dir)
     try:
+        limit_clause, limit_params = _limit_sql(limit)
         if query.upper().startswith("FBGN"):
             rows = conn.execute(
-                """
+                f"""
                 SELECT DISTINCT
                   sg.stknum,
                   sg.genotype,
@@ -1100,13 +1121,13 @@ def search_gene(state_dir: Path, query: str, limit: int = 20) -> list[dict[str,
                 FROM stockgenes sg
                 WHERE UPPER(sg.fbgn) = UPPER(?)
                 ORDER BY sg.stknum, sg.component_symbol, sg.gene_symbol
-                LIMIT ?
+                {limit_clause}
                 """,
-                (query, limit),
+                (query, *limit_params),
             ).fetchall()
         else:
             rows = conn.execute(
-                """
+                f"""
                 SELECT DISTINCT
                   sg.stknum,
                   sg.genotype,
@@ -1121,14 +1142,14 @@ def search_gene(state_dir: Path, query: str, limit: int = 20) -> list[dict[str,
                   sg.stknum,
                   sg.component_symbol,
                   sg.gene_symbol
-                LIMIT ?
+                {limit_clause}
                 """,
-                (query, f"{query}%", query, limit),
+                (query, f"{query}%", query, *limit_params),
             ).fetchall()
         if rows:
             return _rows_to_dicts(rows)
 
-        stock_ids = _candidate_stock_ids_for_query(conn, query, max(limit * 4, 40))
+        stock_ids = _candidate_stock_ids_for_query(conn, query, _scaled_limit(limit, 4, 40))
         if not stock_ids:
             return []
         placeholders = ", ".join("?" for _ in stock_ids)
@@ -1223,7 +1244,7 @@ def _search_component_table(
     conn: sqlite3.Connection | None = None,
     column: str,
     query: str,
-    limit: int,
+    limit: int | None,
 ) -> list[dict[str, Any]]:
     query = query.strip()
     if not query:
@@ -1235,6 +1256,7 @@ def _search_component_table(
     close_conn = conn is None
     conn = conn or _connect(state_dir)
     try:
+        limit_clause, limit_params = _limit_sql(limit)
         rows = conn.execute(
             f"""
             SELECT
@@ -1255,14 +1277,14 @@ def _search_component_table(
               CASE WHEN LOWER(cc.{column}) = LOWER(?) THEN 0 ELSE 1 END,
               cc.stknum,
               cc.component_symbol
-            LIMIT ?
+            {limit_clause}
             """,
-            (query, f"{query}%", query, limit),
+            (query, f"{query}%", query, *limit_params),
         ).fetchall()
         if rows:
             return _rows_to_dicts(rows)
 
-        stock_ids = _candidate_stock_ids_for_query(conn, query, max(limit * 4, 40))
+        stock_ids = _candidate_stock_ids_for_query(conn, query, _scaled_limit(limit, 4, 40))
         if not stock_ids:
             return []
         placeholders = ", ".join("?" for _ in stock_ids)
@@ -1302,11 +1324,12 @@ def _search_component_table(
 def _fetch_component_domain_rows(
     conn: sqlite3.Connection,
     query: str,
-    limit: int,
+    limit: int | None,
     *,
     cte_sql: str,
     cte_params: list[Any],
 ) -> list[sqlite3.Row]:
+    limit_clause, limit_params = _limit_sql(limit)
     rows = conn.execute(
         f"""
         {cte_sql}
@@ -1331,14 +1354,14 @@ def _fetch_component_domain_rows(
           cc.mapstatement,
           sg0.bdsc_symbol_id
         ORDER BY cc.stknum, cc.component_symbol
-        LIMIT ?
+        {limit_clause}
         """,
-        (*cte_params, limit),
+        (*cte_params, *limit_params),
     ).fetchall()
     if rows:
         return rows
 
-    stock_ids = _candidate_stock_ids_for_query(conn, query, max(limit * 4, 40))
+    stock_ids = _candidate_stock_ids_for_query(conn, query, _scaled_limit(limit, 4, 40))
     if not stock_ids:
         return []
     placeholders = ", ".join("?" for _ in stock_ids)
@@ -1370,7 +1393,7 @@ def _fetch_component_domain_rows(
 def _search_component_domain(
     state_dir: Path,
     query: str,
-    limit: int,
+    limit: int | None,
     *,
     cte_sql: str,
     cte_params: list[Any],
@@ -1400,7 +1423,7 @@ def _search_component_domain(
         conn.close()
 
 
-def search_property(state_dir: Path, query: str, limit: int = 20) -> list[dict[str, Any]]:
+def search_property(state_dir: Path, query: str, limit: int | None = None) -> list[dict[str, Any]]:
     query = query.strip()
     return _search_component_domain(
         state_dir,
@@ -1420,7 +1443,7 @@ def search_property(state_dir: Path, query: str, limit: int = 20) -> list[dict[s
     )
 
 
-def search_property_exact(state_dir: Path, query: str, limit: int = 20) -> list[dict[str, Any]]:
+def search_property_exact(state_dir: Path, query: str, limit: int | None = None) -> list[dict[str, Any]]:
     query = query.strip()
     return _search_component_domain(
         state_dir,
@@ -1439,7 +1462,7 @@ def search_property_exact(state_dir: Path, query: str, limit: int = 20) -> list[
     )
 
 
-def search_driver_family(state_dir: Path, query: str, limit: int = 20) -> list[dict[str, Any]]:
+def search_driver_family(state_dir: Path, query: str, limit: int | None = None) -> list[dict[str, Any]]:
     query = query.strip()
     _, tokens = normalize_driver_family(query)
     clause, params = _driver_family_clause(
@@ -1469,7 +1492,7 @@ def search_driver_family(state_dir: Path, query: str, limit: int = 20) -> list[d
     )
 
 
-def search_relationship(state_dir: Path, query: str, limit: int = 20) -> list[dict[str, Any]]:
+def search_relationship(state_dir: Path, query: str, limit: int | None = None) -> list[dict[str, Any]]:
     query = query.strip()
     return _search_component_domain(
         state_dir,
@@ -1504,11 +1527,11 @@ def get_stock_by_rrid(state_dir: Path, query: str) -> dict[str, Any] | None:
     return get_stock(state_dir, stknum)
 
 
-def search_fbid(state_dir: Path, query: str, limit: int = 20) -> list[dict[str, Any]]:
+def search_fbid(state_dir: Path, query: str, limit: int | None = None) -> list[dict[str, Any]]:
     return _search_component_table(state_dir, column="fbid", query=query, limit=limit)
 
 
-def search_component(state_dir: Path, query: str, limit: int = 20) -> list[dict[str, Any]]:
+def search_component(state_dir: Path, query: str, limit: int | None = None) -> list[dict[str, Any]]:
     return _search_component_table(
         state_dir,
         column="component_symbol",
@@ -1963,7 +1986,7 @@ def lookup_query(
     query: str,
     *,
     kind: str = "auto",
-    limit: int = 20,
+    limit: int | None = None,
 ) -> dict[str, Any]:
     requested_kind = kind
     resolved_kind = detect_query_kind(query) if kind == "auto" else kind
@@ -2073,7 +2096,7 @@ def get_stock(state_dir: Path, stknum: int) -> dict[str, Any] | None:
         conn.close()
 
 
-def live_search(query: str, limit: int = 10) -> list[dict[str, Any]]:
+def live_search(query: str, limit: int | None = None) -> list[dict[str, Any]]:
     simple_payload = parse.urlencode({"presearch": query, "type": "contains"}).encode("utf-8")
     req = request.Request(
         "https://bdsc.indiana.edu/Home/GetSearchResults",
@@ -2089,7 +2112,7 @@ def live_search(query: str, limit: int = 10) -> list[dict[str, Any]]:
         data = json.loads(response.read().decode("utf-8"))
     rows = data.get("Data") or []
     if rows:
-        return rows[:limit]
+        return _limit_rows(rows, limit)
 
     advanced_payload = parse.urlencode(
         {
@@ -2119,7 +2142,7 @@ def live_search(query: str, limit: int = 10) -> list[dict[str, Any]]:
     )
     with request.urlopen(advanced_req) as response:
         advanced_data = json.loads(response.read().decode("utf-8"))
-    return (advanced_data.get("Data") or [])[:limit]
+    return _limit_rows(advanced_data.get("Data") or [], limit)
 
 
 def get_status(state_dir: Path) -> dict[str, Any]:
@@ -2282,11 +2305,10 @@ def iter_dataset_rows(
             sql += f"\n{where_clause}"
         sql += f"\n{_dataset_sort_clause(dataset)}"
 
-        if limit is not None:
-            sql += "\nLIMIT ?"
-            cursor = conn.execute(sql, (*params, limit))
-        else:
-            cursor = conn.execute(sql, params)
+        limit_clause, limit_params = _limit_sql(limit)
+        if limit_clause:
+            sql += f"\n{limit_clause}"
+        cursor = conn.execute(sql, (*params, *limit_params))
 
         columns = [description[0] for description in cursor.description]
         try:
@@ -2400,9 +2422,7 @@ def iter_report_rows(
             break
 
     deduped = _merge_report_rows(resolved_dataset, merged_rows)
-    if limit is not None:
-        deduped = deduped[:limit]
-    for row in deduped:
+    for row in _limit_rows(deduped, limit):
         yield row
 
 

{bdsc_cli-0.2.1 → bdsc_cli-0.2.3/src/bdsc_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bdsc-cli
-Version: 0.2.1
+Version: 0.2.3
 Summary: Sync and query BDSC datasets locally
 Author: Gustavo Madeira Santana
 License-Expression: MIT
@@ -21,6 +21,9 @@ Dynamic: license-file
 
 # bdsc-cli
 
+> This package has been renamed. Install `bdsc` now:
+> `pipx install bdsc`
+
 Small CLI for syncing public Bloomington Drosophila Stock Center datasets and
 querying them locally.
 
@@ -50,16 +53,16 @@ brew tap gumadeiras/tap
 brew install bdsc-cli
 ```
 
-Or install the release wheel directly with `pipx`:
+PyPI with `pipx`:
 
 ```bash
-pipx install 'bdsc-cli @ https://github.com/gumadeiras/bdsc-cli/releases/download/v0.2.1/bdsc_cli-0.2.1-py3-none-any.whl'
+pipx install bdsc-cli
 ```
 
-Or with plain `pip`:
+PyPI with plain `pip`:
 
 ```bash
-python3 -m pip install 'bdsc-cli @ https://github.com/gumadeiras/bdsc-cli/releases/download/v0.2.1/bdsc_cli-0.2.1-py3-none-any.whl'
+python3 -m pip install bdsc-cli
 ```
 
 Source install:
@@ -91,19 +94,8 @@ Build release artifacts locally:
 python -m pip install -e .[release]
 python -m build
 python -m twine check dist/*
-python scripts/render_homebrew_formula.py dist/bdsc_cli-$(python - <<'PY'
-from bdsc_cli import __version__
-print(__version__)
-PY
-).tar.gz
 ```
 
-PyPI note:
-
-- the GitHub release is live
-- PyPI trusted publishing is not configured yet for `bdsc-cli`
-- `pip install bdsc-cli` will work after that publisher is added
-
 ## Quickstart
 
 Create a local cache and index:
@@ -190,6 +182,9 @@ bdsc export components --limit 5 --format jsonl
 bdsc stock 77118 --json
 ```
 
+Query commands return all matches by default. Use `--limit N` when you want a
+bounded result set.
+
 ## Commands
 
 - `bdsc sync`: download the BDSC CSV datasets; builds the index by default
@@ -354,9 +349,7 @@ bdsc terms property-descriptions --query optogenetic --jsonl
 - use `property-exact` or `driver-family` when `property` is too broad for a
   reliable LexA/QF/GAL4-style answer.
 - tag pushes like `vX.Y.Z` run the release workflow: build artifacts, create a
-  GitHub release, and publish to PyPI.
-- `scripts/render_homebrew_formula.py` renders a Homebrew formula from a built
-  sdist; use it when updating a tap after a release.
+  GitHub release, publish to PyPI, and update `gumadeiras/homebrew-tap`.
 - The live endpoint is undocumented and may change without notice.
 - BDSC data is large enough that the first full sync/index can take a few
   minutes depending on network and disk speed.

{bdsc_cli-0.2.1 → bdsc_cli-0.2.3}/src/bdsc_cli.egg-info/SOURCES.txt

@@ -10,5 +10,4 @@ src/bdsc_cli.egg-info/dependency_links.txt
 src/bdsc_cli.egg-info/entry_points.txt
 src/bdsc_cli.egg-info/requires.txt
 src/bdsc_cli.egg-info/top_level.txt
-tests/test_core.py
-tests/test_release_tools.py
+tests/test_core.py

{bdsc_cli-0.2.1 → bdsc_cli-0.2.3}/tests/test_core.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import contextlib
 import io
+import json
 import tempfile
 import unittest
 from pathlib import Path
@@ -123,6 +124,44 @@ class CoreTests(unittest.TestCase):
     def tearDown(self) -> None:
         self.temp_dir.cleanup()
 
+    def add_many_cschrimson_rows(self, count: int = 60) -> None:
+        raw_dir = self.state_dir / "raw"
+        bloomington_rows = []
+        component_rows = []
+        stockgene_rows = []
+        for index in range(count):
+            stknum = 78000 + index
+            component = f"P{{20XUAS-CsChrimson.synthetic{index}}}attP2"
+            genotype = f"w[1118]; {component}"
+            bloomington_rows.append(
+                f'{stknum},"{genotype}","2","","5/21/2019","Donor: Janelia","synthetic CsChrimson row"'
+            )
+            component_rows.append(
+                f'{stknum},"{genotype}","{component}","FBti78{index:04d}","","CsChrimson synthetic construct","",""'
+            )
+            stockgene_rows.append(
+                f'{stknum},"{genotype}","{component}","CsChrimson","FBto0000558",{78000 + index},20'
+            )
+
+        for filename, rows in (
+            ("bloomington.csv", bloomington_rows),
+            ("stockcomps_map_comments.csv", component_rows),
+            ("stockgenes.csv", stockgene_rows),
+        ):
+            path = raw_dir / filename
+            path.write_text(path.read_text(encoding="utf-8") + "\n".join(rows) + "\n", encoding="utf-8")
+
+    def assert_cli_error_shows_help(self, argv: list[str], *expected: str) -> str:
+        stderr = io.StringIO()
+        with contextlib.redirect_stderr(stderr):
+            with self.assertRaises(SystemExit) as raised:
+                main(argv)
+        self.assertEqual(raised.exception.code, 2)
+        output = stderr.getvalue()
+        for text in expected:
+            self.assertIn(text, output)
+        return output
+
     def test_build_fts_query_tokenizes_text(self) -> None:
         self.assertEqual(build_fts_query("10XUAS-Chronos"), "10xuas* chronos*")
 
@@ -368,6 +407,75 @@ class CoreTests(unittest.TestCase):
         self.assertIn('"kind": "gene"', payload)
         self.assertIn('"Chronos"', payload)
 
+    def test_find_and_search_have_no_default_limit(self) -> None:
+        self.add_many_cschrimson_rows()
+        build_index(self.state_dir)
+
+        stdout = io.StringIO()
+        with contextlib.redirect_stdout(stdout):
+            exit_code = main(
+                [
+                    "find",
+                    "CsChrimson",
+                    "--state-dir",
+                    str(self.state_dir),
+                    "--json",
+                ]
+            )
+        self.assertEqual(exit_code, 0)
+        find_payload = json.loads(stdout.getvalue())
+        self.assertEqual(find_payload["result_count"], 63)
+        self.assertIn(82182, {row["stknum"] for row in find_payload["results"]})
+
+        stdout = io.StringIO()
+        with contextlib.redirect_stdout(stdout):
+            exit_code = main(
+                [
+                    "search",
+                    "CsChrimson",
+                    "--state-dir",
+                    str(self.state_dir),
+                    "--json",
+                ]
+            )
+        self.assertEqual(exit_code, 0)
+        search_payload = json.loads(stdout.getvalue())
+        self.assertEqual(len(search_payload), 63)
+        self.assertIn(82182, {row["stknum"] for row in search_payload})
+
+    def test_missing_arguments_show_relevant_help(self) -> None:
+        self.assert_cli_error_shows_help([], "usage: bdsc", "find", "stock")
+        self.assert_cli_error_shows_help(
+            ["export"],
+            "usage: bdsc export",
+            "stocks",
+            "error: the following arguments are required: dataset",
+        )
+        self.assert_cli_error_shows_help(
+            ["stock"],
+            "usage: bdsc stock",
+            "stknum",
+            "error: the following arguments are required: stknum",
+        )
+        self.assert_cli_error_shows_help(
+            ["find"],
+            "usage: bdsc find",
+            "--gene",
+            "error: find requires a query or at least one filter flag",
+        )
+        self.assert_cli_error_shows_help(
+            ["filter"],
+            "usage: bdsc filter",
+            "--gene",
+            "error: filter requires at least one filter flag",
+        )
+        self.assert_cli_error_shows_help(
+            ["lookup"],
+            "usage: bdsc lookup",
+            "--input",
+            "error: lookup requires at least one query or --input",
+        )
+
     def test_find_command_filter_mode(self) -> None:
         build_index(self.state_dir)
         stdout = io.StringIO()

bdsc_cli-0.2.1/tests/test_release_tools.py

@@ -1,35 +0,0 @@
-from __future__ import annotations
-
-import hashlib
-import importlib.util
-import tempfile
-import unittest
-from pathlib import Path
-
-
-SPEC = importlib.util.spec_from_file_location(
-    "render_homebrew_formula",
-    Path(__file__).resolve().parents[1] / "scripts" / "render_homebrew_formula.py",
-)
-assert SPEC is not None and SPEC.loader is not None
-MODULE = importlib.util.module_from_spec(SPEC)
-SPEC.loader.exec_module(MODULE)
-
-
-class ReleaseToolTests(unittest.TestCase):
-    def test_render_formula_uses_sdist_version_and_sha(self) -> None:
-        with tempfile.TemporaryDirectory() as temp_dir:
-            sdist = Path(temp_dir) / "bdsc_cli-1.2.3.tar.gz"
-            sdist.write_bytes(b"bdsc-cli-test")
-            formula = MODULE.render_formula(sdist)
-
-        self.assertIn('url "https://github.com/gumadeiras/bdsc-cli/releases/download/v1.2.3/bdsc_cli-1.2.3.tar.gz"', formula)
-        self.assertIn(hashlib.sha256(b"bdsc-cli-test").hexdigest(), formula)
-
-    def test_version_from_sdist_rejects_unexpected_name(self) -> None:
-        with self.assertRaises(ValueError):
-            MODULE.version_from_sdist(Path("not-bdsc.tar.gz"))
-
-
-if __name__ == "__main__":
-    unittest.main()