descry-codegraph 1.0.0__tar.gz → 1.0.2__tar.gz

descry_codegraph-1.0.0/CLAUDE.md → descry_codegraph-1.0.2/AGENTS.md

@@ -1,6 +1,6 @@
-# CLAUDE.md
+# AGENTS.md
 
-This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+This file provides guidance to coding agents when working with code in this repository.
 
 ## Commands
 
@@ -23,7 +23,7 @@ just test tests/test_config.py::TestFromToml::test_from_toml_basic  # one test
 just test -k "cross_lang and not slow"                            # by expression
 ```
 
-Python 3.11+ required (enforced by `pyproject.toml`). Pre-commit gate: `just lint && just fmt && just test` all pass (3306 tests pass; a handful more are skipped where the environment lacks their fixture — a drop is a regression signal).
+Python 3.11+ required (enforced by `pyproject.toml`). Pre-commit gate: `just lint && just fmt && just test` all pass (3343 tests pass; a handful more are skipped where the environment lacks their fixture — a drop is a regression signal).
 
 Invoke the tool while developing:
 

{descry_codegraph-1.0.0 → descry_codegraph-1.0.2}/CHANGELOG.md

@@ -4,6 +4,38 @@ All notable changes to Descry will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and this project adheres to [semver](https://semver.org/) from 1.0.0.
 
+## [1.0.2] — 2026-10-31
+
+### Fixed
+
+- Rust glob re-exports (`pub use m::*`) that reach a module by several
+  routes, or lead back round a cycle, no longer make indexing exponential:
+  each name a glob brings, and each type alias, is looked up once per
+  file.
+- Rust: `<Self>::f(x)` is read as `Self::f(x)`; it, and a crate-root path
+  `::f(x)` with an argument of a project type, stopped the index.
+- Rust: indexing a nested `vec![vec![..]; n]` twice stopped the index.
+- Rust: a `static` or `const` in a `quote!` template, its type written
+  with `#` interpolations, stopped the index.
+- MCP: arguments a tool cannot read are refused naming what is wrong with
+  each (`terms: Field required`), not the field alone.
+- CLI: without a terminal on stderr, loading the embedding model prints no
+  progress bars or Hugging Face Hub notices; `HF_HUB_DISABLE_PROGRESS_BARS`,
+  `HF_HUB_VERBOSITY` and `TRANSFORMERS_VERBOSITY` set by the user are kept.
+- README: `[timeouts] index_minutes = 0` is no time limit.
+
+## [1.0.1] — 2026-10-30
+
+### Fixed
+
+- On macOS, stopping `descry index` (Ctrl-C, `SIGINT`) stops the run as
+  `SIGTERM` and `SIGHUP` do; it reported "Index error: Operation not
+  permitted" and exited 2.
+
+### Changed
+
+- `CLAUDE.md` is `AGENTS.md`.
+
 ## [1.0.0] — 2026-10-29
 
 ### Breaking

{descry_codegraph-1.0.0 → descry_codegraph-1.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: descry-codegraph
-Version: 1.0.0
+Version: 1.0.2
 Summary: Codebase knowledge graph: polyglot indexer, semantic search, call-graph analysis
 Project-URL: Homepage, https://github.com/06chaynes/descry
 Project-URL: Repository, https://github.com/06chaynes/descry
@@ -308,7 +308,7 @@ timeout = 30
 scip_minutes = 30      # per indexer; 0 = unlimited
 embedding_seconds = 60 # MCP and web answer `loading` past it; the CLI waits
 query_ms = 4000         # 0 = no time limit
-index_minutes = 30     # Timeout for `descry index` subprocess
+index_minutes = 30     # Timeout for `descry index` subprocess; 0 = unlimited
 
 [query]
 max_depth = 3

{descry_codegraph-1.0.0 → descry_codegraph-1.0.2}/README.md

@@ -247,7 +247,7 @@ timeout = 30
 scip_minutes = 30      # per indexer; 0 = unlimited
 embedding_seconds = 60 # MCP and web answer `loading` past it; the CLI waits
 query_ms = 4000         # 0 = no time limit
-index_minutes = 30     # Timeout for `descry index` subprocess
+index_minutes = 30     # Timeout for `descry index` subprocess; 0 = unlimited
 
 [query]
 max_depth = 3

{descry_codegraph-1.0.0 → descry_codegraph-1.0.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "descry-codegraph"
-version = "1.0.0"
+version = "1.0.2"
 description = "Codebase knowledge graph: polyglot indexer, semantic search, call-graph analysis"
 requires-python = ">=3.11"
 authors = [{name = "Christian Haynes"}]

{descry_codegraph-1.0.0 → descry_codegraph-1.0.2}/src/descry/__init__.py

@@ -1,4 +1,4 @@
 """Descry — Codebase knowledge graph: polyglot indexer, semantic search, call-graph analysis."""
 
-__version__ = "1.0.0"
+__version__ = "1.0.2"
 __all__ = ["__version__"]

{descry_codegraph-1.0.0 → descry_codegraph-1.0.2}/src/descry/cli.py

@@ -11,6 +11,7 @@ Usage:
 import argparse
 import asyncio
 import json
+import os
 import sys
 
 from descry._answers import fail
@@ -516,6 +517,14 @@ def build_parser():
 
 def main():
     write_utf8()
+    if not sys.stderr.isatty():
+        # Scripted use: no model-loading progress bars or Hub notices.
+        for name, value in (
+            ("HF_HUB_DISABLE_PROGRESS_BARS", "1"),
+            ("HF_HUB_VERBOSITY", "error"),
+            ("TRANSFORMERS_VERBOSITY", "error"),
+        ):
+            os.environ.setdefault(name, value)
     parser = build_parser()
     args = parser.parse_args()
 

{descry_codegraph-1.0.0 → descry_codegraph-1.0.2}/src/descry/handlers.py

@@ -1058,7 +1058,7 @@ def _kill_process_tree(proc: asyncio.subprocess.Process) -> None:
         )
     else:
         # The child may have exited without the event loop having seen it yet.
-        with contextlib.suppress(ProcessLookupError):
+        with contextlib.suppress(ProcessLookupError, PermissionError):
             os.killpg(proc.pid, signal.SIGKILL)
 
 

{descry_codegraph-1.0.0 → descry_codegraph-1.0.2}/src/descry/mcp_server.py

@@ -115,13 +115,13 @@ class _Server(MCPServer):
             if isinstance(exc.__cause__, ValidationError):
                 fields = sorted(
                     {
-                        ".".join(str(part) for part in err["loc"])
+                        f"{'.'.join(str(part) for part in err['loc'])}: {err['msg']}"
                         for err in exc.__cause__.errors()
                     }
                 )
                 answer = fail(
                     "invalid",
-                    f"Invalid arguments for {name}: {', '.join(fields)}.",
+                    f"Invalid arguments for {name}: {'; '.join(fields)}.",
                 )
                 return _answered(json.dumps(public(answer), indent=2), answer)
             raise

{descry_codegraph-1.0.0 → descry_codegraph-1.0.2}/src/descry/resolver.py

@@ -1297,7 +1297,9 @@ class CallResolver:
         # signature a call of it is of
         "overloads",
         "reaches",  # file ID -> the files its includes reach (C/C++)
+        "rust_aliases",  # (Rust module, name) -> see _alias_in
         "rust_in_scope",  # Rust scope ID -> the modules named there
+        "rust_used",  # (Rust module, name) -> see _rust_used
         "rust_uses",  # Rust scope ID -> what the `use`s in force bind
         "shared_declaration",  # candidate node IDs -> node ID or None
         # Language -> the last name segments of the types and functions its
@@ -1327,6 +1329,8 @@ class CallResolver:
         "_forwarding",
         "open_aliases",
         "standard",
+        "_rust_walked",
+        "_rust_begun",
     )
 
     def begin_file(self):
@@ -1593,6 +1597,9 @@ class CallResolver:
             builder.rust_mods, files
         )
         self._importing = set()  # (scope ID, name) of the Rust `use`s being read
+        self._rust_cuts = 0  # times a Rust cycle guard stopped a walk
+        self._rust_walked = {}  # see _rust_keep
+        self._rust_begun = []  # see _rust_recall
         # A module is importable by its path below its topmost package and,
         # through namespace packages, by any longer path no other module owns.
         for top, parts, file_id in py_files:
@@ -2104,10 +2111,11 @@ class CallResolver:
         elif (
             verdict == (None, _EXTERNAL)
             and self._path_call
+            and (split := _split_callee(callee))[0]
             and (owner := self._receiver_type())
         ):
             # An outside trait's path: the receiver's project impl of it.
-            path, name = _split_callee(callee)
+            path, name = split
             own = [
                 m
                 for m in self._rust_trait_methods(owner, name, path[-1])
@@ -3124,7 +3132,9 @@ class CallResolver:
                 (target,),
             )
             found = None
-            if (scope_id, name) not in self._importing:
+            if (scope_id, name) in self._importing:
+                self._rust_cuts += 1
+            else:
                 # A `use` may lead back to itself through the module tree.
                 self._importing.add((scope_id, name))
                 try:
@@ -3357,11 +3367,42 @@ class CallResolver:
         ]
         return defined or found
 
+    def _rust_recall(self, memo, key, seen):
+        """``[value]`` kept for the Rust walk through `use`s and globs for
+        ``key`` whose cycle guard holds ``seen`` (see `_rust_keep`); else
+        None, and the walk is begun."""
+        if key in memo:
+            return [memo[key]]
+        if seen and key in self._rust_walked:
+            self._rust_cuts += 1
+            return [self._rust_walked[key]]
+        self._rust_begun.append((self._rust_cuts, self._rust_walked))
+        if not seen:
+            self._rust_walked = {}
+        return None
+
+    def _rust_keep(self, memo, key, seen, found):
+        """``found``, what the walk `_rust_recall` began gives: kept in
+        ``memo`` for the file; where a cycle guard cut it short, only until
+        the walk that began with no ``seen`` ends. A module that globs reach
+        by several routes is then walked once."""
+        cuts, outer = self._rust_begun.pop()
+        if not seen:
+            self._rust_walked = outer
+        if self._rust_cuts == cuts:
+            memo[key] = found
+        elif seen:
+            self._rust_walked[key] = found
+        return found
+
     def _rust_used(self, module, segment, seen):
         """What a `use` of the Rust module ``module`` binds ``segment`` to,
         a path from the module or from a crate, else what each glob `use`
         of the module's own does: IDs, ``"external"`` where one leads
         outside the project. ``seen`` as `_rust_path`'s."""
+        key = (module, segment)
+        if kept := self._rust_recall(self.rust_used, key, seen):
+            return kept[0]
         uses = self._uses(module)
         alternatives = self.builder.rust_use_alternatives.get((module, segment))
         written = [uses[segment]] if segment in uses else []
@@ -3376,16 +3417,18 @@ class CallResolver:
             if segment in uses and not self._rust_rooted(target, module):
                 held = self._imported(segment, module)
             elif self._rust_rooted(target, module):
-                if (module, segment) not in seen:
-                    followed = seen | {(module, segment)}
-                    held = self._rust_path(target.split("::"), module, followed)
+                if key in seen:
+                    self._rust_cuts += 1
+                else:
+                    held = self._rust_path(target.split("::"), module, seen | {key})
             else:
                 # A glob of another crate's module may bring the name.
                 held = _EXTERNAL
             if held == _EXTERNAL:
-                return _EXTERNAL
+                hits = _EXTERNAL
+                break
             hits += held or []
-        return hits
+        return self._rust_keep(self.rust_used, key, seen, hits)
 
     def _rust_library(self, name, scope_id):
         """The root of the library of the project crate ``name`` written in
@@ -4820,7 +4863,7 @@ class CallResolver:
                     value = self._called(member, value if len(value) > 2 else value[1])
                     value = value[1] if value and value[0] == "pointer" else value
                 continue
-            if step == "[]" and isinstance(value, tuple):
+            if step == "[]" and isinstance(value, tuple) and value[0] != "literal":
                 # A subscript gives what the type's `operator[]` returns, in
                 # Rust its `Index` impl's `Output`, the element an iterator
                 # gives where the index decides it: by the data for a
@@ -8152,17 +8195,24 @@ class CallResolver:
         found = self.builder.rust_alias_types.get((module, name))
         if found:
             return module, name, _rust_declared(found)
+        key = (module, name)
+        if kept := self._rust_recall(self.rust_aliases, key, seen):
+            return kept[0]
         uses = self._uses(module)
         written = [uses[name]] if name in uses else []
         written = written or [
             f"{path[:-1]}{name}" for path in uses.values() if path[-3:] == "::*"
         ]
+        hit = None
         for target in written:
             *qualifier, leaf = target.split("::")
             if qualifier and self._rust_child(module, qualifier[0]):
                 qualifier = ["self", *qualifier]
             path = "::".join([*qualifier, leaf])
-            if not qualifier or (module, path) in seen:
+            if not qualifier:
+                continue
+            if (module, path) in seen:
+                self._rust_cuts += 1
                 continue
             if not self._rust_rooted(path, module):
                 continue
@@ -8170,8 +8220,10 @@ class CallResolver:
             for scope in held if isinstance(held, list) else ():
                 hit = self._alias_in(scope, leaf, seen | {(module, path)})
                 if hit:
-                    return hit
-        return None
+                    break
+            if hit:
+                break
+        return self._rust_keep(self.rust_aliases, key, seen, hit)
 
     def _alias_value(self, alias, written, scope_id, receiver):
         """Value of the type ``written`` in ``scope_id`` that names the Rust

{descry_codegraph-1.0.0 → descry_codegraph-1.0.2}/src/descry/rust_parser.py

@@ -50,7 +50,7 @@ _RUST_STRING_LET_RE = re.compile(
 
 _RUST_CONST_RE = re.compile(
     r"\b(?:const|static)\s+(?:mut\s+)?(?P<name>[A-Z][A-Z0-9_]*)\s*:\s*"
-    r"(?P<type>[^=;().]+?)\s*="
+    r"(?P<type>[^=;().#]+?)\s*="
 )
 
 
@@ -1960,6 +1960,10 @@ class RustParser(BaseParser):
                     # with its arguments.
                     typed = re.fullmatch(r"(\w+)::<(.+)>::(\w+)", callee)
                     typed = typed and f"{typed[1]}<{typed[2]}>.{typed[3]}"
+                    # `<Self>::f` is `Self::f`.
+                    closed = callee[:1] == "<" and _angle_end(callee, 0)
+                    if closed and callee[closed + 1 : closed + 3] == "::":
+                        callee = callee[1:closed] + callee[closed + 1 :]
                     # `parse::<T>` calls `parse`; the type arguments are the
                     # call site's, not part of the callee's name.
                     callee = _strip_generics(callee)

{descry_codegraph-1.0.0 → descry_codegraph-1.0.2}/tests/test_backtracking.py

@@ -21,45 +21,80 @@ from descry.generate import CodeGraphBuilder
 
 _GO_FIELD = next(r for r in go_parser._DECLARATIONS if "(?!(?:return" in r.pattern)
 
-# 3,000 characters took seconds to minutes where the time was cubic, and
-# 20,000 seconds where it was quadratic; each now takes milliseconds.
-_RUN = " " * 3000
-_LONG_RUN = " " * 20000
 
+def _seconds(run):
+    """The least CPU time of three calls of `run`."""
+
+    def once():
+        start = time.process_time()
+        run()
+        return time.process_time() - start
+
+    return min(once() for _ in range(3))
+
+
+def assert_linear(run, n):
+    """`run(n)` takes under ten times the CPU time of `run(n // 4)`: time
+    linear in `n` gives four times, quadratic sixteen."""
+    quarter = _seconds(lambda: run(n // 4))
+    assert _seconds(lambda: run(n)) < 10 * max(quarter, 0.05)
 
+
+# 3,000 characters took seconds to minutes where the time was cubic, and
+# 20,000 seconds where it was quadratic.
 @pytest.mark.parametrize(
-    ("find", "text"),
+    ("find", "text", "length"),
     [
-        (_RE_LOCAL_FUNCTION.match, _RUN + "!"),
-        (DartParser.binding_re.search, "const" + _RUN),
-        (java_parser._RE_METHOD.match, "final" + _RUN),
-        (java_parser._RE_FIELD.match, "final" + _RUN),
-        (ts_parser._TS_IMPORT_RE.findall, "import" + _RUN + "x;\n"),
-        (rust_parser._RUST_ARM_RE.search, _RUN + "!"),
-        (java_parser._RE_METHOD.match, "public <T>" + _RUN),
-        (java_parser._RE_METHOD.match, "public @A" + _RUN),
-        (java_parser._RE_ENUM_CONSTANT.match, "A" + _RUN + ")"),
-        (rust_parser._RUST_BINDER_RES[1].findall, "for" + _RUN),
-        (rust_parser._RUST_FOR_RE.search, "    for" + _RUN + "x"),
-        (rust_parser._RUST_IF_LET_RE.search, "while let" + _RUN),
-        (rust_parser._RUST_MATCH_RE.search, "match" + _RUN + "a b"),
-        (ruby_parser._RE_INLINE_BODY.match, "x" + "\r\n" * 1500 + ")"),
-        (dotnet_parser._RE_MEMBER.match, "partial unsafe" + _LONG_RUN + ")"),
-        (dotnet_parser._RE_PARAMETER.search, "scoped readonly" + _LONG_RUN + "x;"),
-        (_GO_FIELD.search, "  chan a" + _LONG_RUN + "x("),
-        (ruby_parser._RE_ALIAS.search, "alias" + _LONG_RUN + ")"),
-        (ruby_parser._RE_MIXIN.match, "  prepend" + _LONG_RUN + "="),
-        (_RE_TYPE.fullmatch, _LONG_RUN + ")"),
-        (java_parser._RE_METHOD.match, "private final a" + _LONG_RUN + "b"),
-        (java_parser._RE_FIELD.match, "public static a" + _LONG_RUN + "b("),
-        (ruby_parser._RE_ENDLESS.match, _LONG_RUN * 3 + "x"),
-        (ruby_parser._RE_INLINE_BODY.match, "end" + "\n" * 60000 + "x"),
-        (dotnet_parser._RE_PRIMARY_CONSTRUCTOR.match, _LONG_RUN * 3 + "x"),
-        (dotnet_parser._RE_PARAMETER.findall, "readonly" + "\t\n " * 20000 + ")"),
-        (_RE_CLOSURE.findall, "\n" * 60000),
-        (ts_parser._TS_IMPORT_RE.findall, "\n" * 60000),
-        (ts_parser._TS_DEFAULT_EXPORT_RE.findall, "\u2028" * 60000),
-        (rust_parser._RUST_USE_RE.findall, "\n" * 60000),
+        (_RE_LOCAL_FUNCTION.match, lambda n: " " * n + "!", 3000),
+        (DartParser.binding_re.search, lambda n: "const" + " " * n, 3000),
+        (java_parser._RE_METHOD.match, lambda n: "final" + " " * n, 3000),
+        (java_parser._RE_FIELD.match, lambda n: "final" + " " * n, 3000),
+        (ts_parser._TS_IMPORT_RE.findall, lambda n: "import" + " " * n + "x;\n", 3000),
+        (rust_parser._RUST_ARM_RE.search, lambda n: " " * n + "!", 3000),
+        (java_parser._RE_METHOD.match, lambda n: "public <T>" + " " * n, 3000),
+        (java_parser._RE_METHOD.match, lambda n: "public @A" + " " * n, 3000),
+        (java_parser._RE_ENUM_CONSTANT.match, lambda n: "A" + " " * n + ")", 3000),
+        (rust_parser._RUST_BINDER_RES[1].findall, lambda n: "for" + " " * n, 3000),
+        (rust_parser._RUST_FOR_RE.search, lambda n: "    for" + " " * n + "x", 3000),
+        (rust_parser._RUST_IF_LET_RE.search, lambda n: "while let" + " " * n, 3000),
+        (rust_parser._RUST_MATCH_RE.search, lambda n: "match" + " " * n + "a b", 3000),
+        (ruby_parser._RE_INLINE_BODY.match, lambda n: "x" + "\r\n" * n + ")", 1500),
+        (
+            dotnet_parser._RE_MEMBER.match,
+            lambda n: "partial unsafe" + " " * n + ")",
+            20000,
+        ),
+        (
+            dotnet_parser._RE_PARAMETER.search,
+            lambda n: "scoped readonly" + " " * n + "x;",
+            20000,
+        ),
+        (_GO_FIELD.search, lambda n: "  chan a" + " " * n + "x(", 20000),
+        (ruby_parser._RE_ALIAS.search, lambda n: "alias" + " " * n + ")", 20000),
+        (ruby_parser._RE_MIXIN.match, lambda n: "  prepend" + " " * n + "=", 20000),
+        (_RE_TYPE.fullmatch, lambda n: " " * n + ")", 20000),
+        (
+            java_parser._RE_METHOD.match,
+            lambda n: "private final a" + " " * n + "b",
+            20000,
+        ),
+        (
+            java_parser._RE_FIELD.match,
+            lambda n: "public static a" + " " * n + "b(",
+            20000,
+        ),
+        (ruby_parser._RE_ENDLESS.match, lambda n: " " * n + "x", 60000),
+        (ruby_parser._RE_INLINE_BODY.match, lambda n: "end" + "\n" * n + "x", 60000),
+        (dotnet_parser._RE_PRIMARY_CONSTRUCTOR.match, lambda n: " " * n + "x", 60000),
+        (
+            dotnet_parser._RE_PARAMETER.findall,
+            lambda n: "readonly" + "\t\n " * n + ")",
+            20000,
+        ),
+        (_RE_CLOSURE.findall, lambda n: "\n" * n, 60000),
+        (ts_parser._TS_IMPORT_RE.findall, lambda n: "\n" * n, 60000),
+        (ts_parser._TS_DEFAULT_EXPORT_RE.findall, lambda n: "\u2028" * n, 60000),
+        (rust_parser._RUST_USE_RE.findall, lambda n: "\n" * n, 60000),
     ],
     ids=[
         "dart-local-function",
@@ -94,34 +129,30 @@ _LONG_RUN = " " * 20000
         "rust-use-blank-lines",
     ],
 )
-def test_a_whitespace_run_is_taken_once(find, text):
-    start = time.process_time()
-
-    find(text)
-
-    assert time.process_time() - start < 1
+def test_a_whitespace_run_is_taken_once(find, text, length):
+    assert_linear(lambda n: find(text(n)), length)
 
 
 @pytest.mark.parametrize(
     ("name", "source", "count"),
     [
-        ("m.js", lambda n: "const b = { a: g() };\n" * n, 20000),
-        ("m.js", lambda n: "let b = 1;\n" + "b = g();\nb.x();\n" * n, 10000),
+        ("m.js", lambda n: "const b = { a: g() };\n" * n, 10000),
+        ("m.js", lambda n: "let b = 1;\n" + "b = g();\nb.x();\n" * n, 5000),
         (
             "m.js",
             lambda n: (
                 "function f(xs) {\n" + "  for (const x of xs) { x.a(); }\n" * n + "}\n"
             ),
-            15000,
+            7500,
         ),
-        ("m.rb", lambda n: "b = 2\n" * n, 20000),
-        ("m.rb", lambda n: "a = []\n" + "a <<-b\n" * n, 60000),
-        ("m.dart", lambda n: "void main() {\n" + "  var b = 2;\n" * n + "}\n", 20000),
-        ("m.py", lambda n: "def f():\n" + "    b = B()\n    b.x()\n" * n, 20000),
+        ("m.rb", lambda n: "b = 2\n" * n, 10000),
+        ("m.rb", lambda n: "a = []\n" + "a <<-b\n" * n, 30000),
+        ("m.dart", lambda n: "void main() {\n" + "  var b = 2;\n" * n + "}\n", 10000),
+        ("m.py", lambda n: "def f():\n" + "    b = B()\n    b.x()\n" * n, 10000),
         (
             "m.py",
             lambda n: "def f(xs):\n" + "    for x in xs:\n        x.a()\n" * n,
-            10000,
+            5000,
         ),
         (
             "M.java",
@@ -130,7 +161,7 @@ def test_a_whitespace_run_is_taken_once(find, text):
                 + "    B b = new B();\n    b.x();\n" * n
                 + "  }\n}\n"
             ),
-            10000,
+            5000,
         ),
         (
             "M.cs",
@@ -139,14 +170,14 @@ def test_a_whitespace_run_is_taken_once(find, text):
                 + "    var b = new B();\n    b.X();\n" * n
                 + "  }\n}\n"
             ),
-            8000,
+            4000,
         ),
         (
             "M.cs",
             lambda n: "".join(
                 f"class C{i} {{ int M() {{ return {i}; }} }}\n" for i in range(n)
             ),
-            3000,
+            1500,
         ),
         (
             "m.go",
@@ -156,7 +187,7 @@ def test_a_whitespace_run_is_taken_once(find, text):
                 * n
                 + "\treturn nil\n}\n"
             ),
-            10000,
+            5000,
         ),
         (
             "m.php",
@@ -165,14 +196,14 @@ def test_a_whitespace_run_is_taken_once(find, text):
                 + "    foreach ($xs as $x) { $x->a(); }\n" * n
                 + "}\n"
             ),
-            8000,
+            4000,
         ),
         (
             "src/lib.rs",
             lambda n: "".join(
                 f"fn f{i}<T: Clone>(a: T) -> T {{ a.clone() }}\n" for i in range(n)
             ),
-            12000,
+            6000,
         ),
         (
             "m.js",
@@ -182,7 +213,7 @@ def test_a_whitespace_run_is_taken_once(find, text):
                 * n
                 + "}\n"
             ),
-            5000,
+            2500,
         ),
         (
             "src/lib.rs",
@@ -191,7 +222,7 @@ def test_a_whitespace_run_is_taken_once(find, text):
                 + "    match v { Some(b) => b.a(), None => () }\n" * n
                 + "}\n"
             ),
-            10000,
+            5000,
         ),
     ],
     ids=[
@@ -216,22 +247,18 @@ def test_a_whitespace_run_is_taken_once(find, text):
 def test_a_repeated_line_is_read_in_linear_time(name, source, count, tmp_path):
     """A line that binds a name again, loops over it, matches it, or
     declares a type or a generic function costs the same time however many
-    came before it: four times the lines take about four times as long,
-    where they took sixteen times, minutes in all. The ratio, not a time,
-    is checked, so a slow machine does not fail it."""
+    came before it, where four times the lines took sixteen times as long,
+    minutes in all."""
 
     def reading(lines):
         root = tmp_path / str(lines)
         (root / name).parent.mkdir(parents=True, exist_ok=True)
         (root / name).write_text(source(lines))
-        start = time.process_time()
         builder = CodeGraphBuilder(root)
         builder.process_directory()
         builder.resolve_references()
-        return time.process_time() - start
 
-    quarter = reading(count // 4)
-    assert reading(count) < 8 * max(quarter, 0.05)
+    assert_linear(reading, count)
 
 
 def test_the_patterns_still_match_source():

{descry_codegraph-1.0.0 → descry_codegraph-1.0.2}/tests/test_cli.py

@@ -65,6 +65,29 @@ class TestCliNoCommand:
         assert result.returncode == 1
 
 
+class TestCliHubOutput:
+    _NAMES = (
+        "HF_HUB_DISABLE_PROGRESS_BARS",
+        "HF_HUB_VERBOSITY",
+        "TRANSFORMERS_VERBOSITY",
+    )
+
+    @pytest.mark.parametrize("terminal", [False, True])
+    def test_scripted_use_quiets_model_loading(self, monkeypatch, terminal):
+        """Without a terminal on stderr, model loading shows no progress bars
+        or Hub notices; a value the user set is kept."""
+        for name in self._NAMES:
+            monkeypatch.delenv(name, raising=False)
+        monkeypatch.setenv("HF_HUB_VERBOSITY", "info")
+        monkeypatch.setattr(sys.stderr, "isatty", lambda: terminal)
+        monkeypatch.setattr(sys, "argv", ["descry"])
+        with pytest.raises(SystemExit):
+            cli.main()
+        assert [os.environ.get(name) for name in self._NAMES] == (
+            [None, "info", None] if terminal else ["1", "info", "error"]
+        )
+
+
 class TestCliArguments:
     @pytest.mark.parametrize(
         "args", [["callers", "x", "--limit", "ten"], ["search", "x", "--frob", "1"]]