pymap-cli 0.4.0__tar.gz → 0.5.0__tar.gz

{pymap_cli-0.4.0 → pymap_cli-0.5.0}/CHANGELOG.md

@@ -4,6 +4,31 @@ All notable changes to this project are documented here. The format follows
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and the project
 adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.5.0] — 2026-09-05
+
+### Fixed
+- **tach only ever declared 60 modules**, silently dropping the rest from the
+  Mermaid diagram — 113 of 240 on a codebase this was reported from. The limit
+  was justified by a performance claim that measurement does not support: on
+  generated projects of 300 and 1200 modules, `tach sync` + `show` + `map` take
+  the same 0.5-1.0s whether 60 or all modules are declared. Every module is now
+  declared by default.
+
+  The cap never affected cycle detection either: the dependency map comes from
+  scanning the sources, not from the declaration list. It only shortened the
+  diagram, which is now what it is documented to do.
+- A tool whose failure fits on one line no longer writes a log file repeating it.
+
+### Added
+- `max_modules` (`--max-modules`, `[tool.pymap] max_modules`) to trim the
+  Mermaid diagram on purpose. `0`, the default, declares everything.
+
+### Note
+On a large or densely connected codebase, `pydeps` and `pyreverse` are the slow
+steps: they lay the whole graph out with Graphviz and can exhaust the timeout
+without producing anything. Raise `timeout` or point pymap at a subpackage. The
+walkthrough tree does not depend on either.
+
 ## [0.4.0] — 2026-09-04
 
 Reported from the field: code2flow crashed on a real codebase, and pymap

{pymap_cli-0.4.0 → pymap_cli-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: pymap-cli
-Version: 0.4.0
+Version: 0.5.0
 Summary: Map a Python codebase in one command.
 Project-URL: Homepage, https://github.com/hermann225-zrouama/pymap-cli
 Project-URL: Issues, https://github.com/hermann225-zrouama/pymap-cli/issues
@@ -100,8 +100,14 @@ editor  = "vscode"          # vscodium, cursor, windsurf, zed, pycharm,
                             # idea, sublime, none, or "myeditor://{f}:{l}"
 exclude = ["vendor", "generated_*"]
 timeout = 300               # seconds per external tool
+max_modules = 0             # cap on the modules declared to tach; 0 = all
 ```
 
+On a large codebase, `pydeps` and `pyreverse` are the slow steps — they lay the
+whole graph out with Graphviz, and a dense one can exhaust the timeout and
+produce nothing. Raise `timeout`, or point pymap at a subpackage. The
+walkthrough tree does not depend on either of them.
+
 ### As a library
 
 ```python
@@ -169,8 +175,10 @@ returns raw facts (never HTML), then add one line to `STEPS` and one section to
   graph nodes and it is what lets the two data sets be joined. In a project
   with `app/models.py` and `blog/models.py`, their symbols merge in the
   explorer. pymap prints a note when it detects the case.
-- **tach declares at most 60 modules.** Beyond that `tach sync` gets very slow
-  for a graph that is already unreadable. The count left out is reported.
+- **The Mermaid diagram gets unwieldy on a large codebase.** Every module is
+  declared to tach by default; set `max_modules` to trim the diagram. It
+  changes nothing else — cycles are found by scanning the sources, not the
+  declaration list.
 - The call graph is only as good as code2flow's static resolution: calls
   through dynamic dispatch or `getattr` do not appear.
 

{pymap_cli-0.4.0 → pymap_cli-0.5.0}/README.md

@@ -60,8 +60,14 @@ editor  = "vscode"          # vscodium, cursor, windsurf, zed, pycharm,
                             # idea, sublime, none, or "myeditor://{f}:{l}"
 exclude = ["vendor", "generated_*"]
 timeout = 300               # seconds per external tool
+max_modules = 0             # cap on the modules declared to tach; 0 = all
 ```
 
+On a large codebase, `pydeps` and `pyreverse` are the slow steps — they lay the
+whole graph out with Graphviz, and a dense one can exhaust the timeout and
+produce nothing. Raise `timeout`, or point pymap at a subpackage. The
+walkthrough tree does not depend on either of them.
+
 ### As a library
 
 ```python
@@ -129,8 +135,10 @@ returns raw facts (never HTML), then add one line to `STEPS` and one section to
   graph nodes and it is what lets the two data sets be joined. In a project
   with `app/models.py` and `blog/models.py`, their symbols merge in the
   explorer. pymap prints a note when it detects the case.
-- **tach declares at most 60 modules.** Beyond that `tach sync` gets very slow
-  for a graph that is already unreadable. The count left out is reported.
+- **The Mermaid diagram gets unwieldy on a large codebase.** Every module is
+  declared to tach by default; set `max_modules` to trim the diagram. It
+  changes nothing else — cycles are found by scanning the sources, not the
+  declaration list.
 - The call graph is only as good as code2flow's static resolution: calls
   through dynamic dispatch or `getattr` do not appear.
 

{pymap_cli-0.4.0 → pymap_cli-0.5.0}/src/pymap/__init__.py

@@ -20,7 +20,7 @@ if TYPE_CHECKING:  # imported lazily at runtime by __getattr__ below
     from pymap.mapper import Report, map_codebase
     from pymap.settings import Settings
 
-__version__ = "0.4.0"
+__version__ = "0.5.0"
 __all__ = ["Report", "Settings", "__version__", "map_codebase"]
 
 

{pymap_cli-0.4.0 → pymap_cli-0.5.0}/src/pymap/cli.py

@@ -18,7 +18,7 @@ from pymap.mapper import map_codebase
 from pymap.runner import missing
 from pymap.settings import EDITORS, EXCLUDED, Settings, detect_target, read_pyproject
 
-DEFAULTS = {"output": "pymap-out", "editor": "vscode", "timeout": 300}
+DEFAULTS = {"output": "pymap-out", "editor": "vscode", "timeout": 300, "max_modules": 0}
 
 
 def build_parser() -> argparse.ArgumentParser:
@@ -49,6 +49,13 @@ def build_parser() -> argparse.ArgumentParser:
     parser.add_argument(
         "--timeout", type=int, metavar="S", help="max seconds per external tool (default: 300)"
     )
+    parser.add_argument(
+        "--max-modules",
+        type=int,
+        metavar="N",
+        help="cap the modules declared to tach, which shortens the Mermaid "
+        "diagram (default: 0, meaning all of them)",
+    )
     parser.add_argument(
         "--open",
         dest="open_in_browser",
@@ -109,6 +116,7 @@ def build_settings(args: argparse.Namespace, cwd: Path | None = None) -> Setting
         excluded=EXCLUDED + tuple(from_file.get("exclude", ())) + tuple(args.exclude or ()),
         editor=editor,
         timeout=args.timeout or from_file.get("timeout", DEFAULTS["timeout"]),
+        max_modules=args.max_modules or from_file.get("max_modules", DEFAULTS["max_modules"]),
         open_in_browser=args.open_in_browser,
     )
 

{pymap_cli-0.4.0 → pymap_cli-0.5.0}/src/pymap/mapper.py

@@ -122,9 +122,11 @@ def _summary(name: str, result: dict[str, Any]) -> str:
         return f"{result['functions']} functions, {result['calls']} calls"
     if name == "tach":
         cut = (
-            f" ({result['truncated']} modules beyond the limit)" if result["truncated"] else ""
+            f", {result['truncated']} modules left out of the diagram by max_modules"
+            if result["truncated"]
+            else ""
         )
-        return f"{len(result['deps'])} files linked{cut}"
+        return f"{len(result['deps'])} files linked, {result['modules']} modules{cut}"
     return "done"
 
 

{pymap_cli-0.4.0 → pymap_cli-0.5.0}/src/pymap/settings.py

@@ -150,6 +150,9 @@ class Settings:
     excluded: Sequence[str] = EXCLUDED
     editor: str = "vscode"
     timeout: int = 300
+    #: Cap on the modules declared to tach; 0 declares them all. Only shortens
+    #: the Mermaid diagram -- it changes neither the runtime nor the cycles.
+    max_modules: int = 0
     open_in_browser: bool = False
     _files: list[Path] | None = field(default=None, repr=False, compare=False)
 

{pymap_cli-0.4.0 → pymap_cli-0.5.0}/src/pymap/tools/__init__.py

@@ -52,7 +52,12 @@ def record_failure(settings: Settings, tool: str, output: str, consequence: str
     what the user loses -- the last one being the part that matters.
     """
     where = ""
-    if output.strip():
+    # Skip the file when the whole reason already fits on screen -- "timed out
+    # after 300s" needs no log. Length matters as much as line count: a single
+    # very long line is not visible in full either.
+    body = output.strip()
+    already_shown = len(body.splitlines()) <= 1 and len(body) <= 160
+    if body and not already_shown:
         path = settings.output / f"{tool}.log"
         kept = output[:MAX_LOG]
         if len(output) > MAX_LOG:

{pymap_cli-0.4.0 → pymap_cli-0.5.0}/src/pymap/tools/tach.py

@@ -21,8 +21,12 @@ from pymap.tools import record_failure
 
 ROLE = "module boundaries"
 
-#: Past this point ``tach sync`` gets very slow, for a graph already unreadable.
-MAX_MODULES = 60
+#: Declaring every module costs nothing. Measured on generated projects of 300
+#: and 1200 modules: ``tach sync`` + ``show`` + ``map`` take the same 0.5-1.0s
+#: whether 60 or all of them are declared, and the dependency map that feeds
+#: cycle detection comes from scanning the sources, not from the declaration
+#: list. A cap only shortens the Mermaid diagram, so it is opt-in.
+NO_LIMIT = 0
 
 
 def _copy_sources(target: Path, into: Path, excluded: Sequence[str]) -> None:
@@ -62,7 +66,7 @@ def execute(settings: Settings) -> dict[str, Any]:
     every = _module_paths(settings.target, settings.files())
     if not every:
         return dict(empty, log="no module to declare")
-    kept = every[:MAX_MODULES]
+    kept = every[: settings.max_modules] if settings.max_modules > NO_LIMIT else every
 
     with tempfile.TemporaryDirectory(prefix="pymap-tach-") as tmp:
         workspace = Path(tmp)

{pymap_cli-0.4.0 → pymap_cli-0.5.0}/tests/test_tools.py

@@ -1,6 +1,9 @@
 """Tool wrappers: clean fallback when absent, and tach's internal logic."""
 
+from pathlib import Path
+
 from pymap import runner
+from pymap.settings import Settings
 from pymap.tools import (
     MAX_LOG,
     code2flow,
@@ -159,3 +162,42 @@ def test_record_failure_caps_a_runaway_log(settings):
     written = (settings.output / "tach.log").read_text()
     assert len(written) < MAX_LOG + 200
     assert "truncated" in written
+
+
+def test_tach_declares_every_module_by_default(sample, tmp_path, monkeypatch):
+    """The old cap of 60 silently dropped modules from the Mermaid diagram."""
+    settings = Settings(target=sample, output=tmp_path / "out")
+    captured = {}
+
+    def fake_run(cmd, cwd=None, timeout=300):
+        if cmd[-1] == "sync":
+            captured["toml"] = (Path(cwd) / "tach.toml").read_text()
+        return False, "stop here"
+
+    monkeypatch.setattr(runner, "resolve", lambda name: ["tach"])
+    monkeypatch.setattr(runner, "run", fake_run)
+    tach.execute(settings)
+    every = tach._module_paths(settings.target, settings.files())
+    assert captured["toml"].count("[[modules]]") == len(every)
+
+
+def test_tach_honours_an_explicit_cap(sample, tmp_path, monkeypatch):
+    settings = Settings(target=sample, output=tmp_path / "out", max_modules=1)
+    monkeypatch.setattr(runner, "resolve", lambda name: ["tach"])
+    monkeypatch.setattr(runner, "run", lambda *a, **k: (False, "stop"))
+    result = tach.execute(settings)
+    assert result["log"]
+
+    # And the count reported back reflects what was dropped.
+    settings2 = Settings(target=sample, output=tmp_path / "out2", max_modules=1)
+    every = tach._module_paths(settings2.target, settings2.files())
+    assert len(every) > 1, "the sample must have more than one module to cap"
+
+
+def test_record_failure_skips_the_file_for_a_one_line_reason(settings):
+    """ "timed out after 300s" is already fully on screen; a log adds nothing."""
+    settings.output.mkdir(parents=True, exist_ok=True)
+    message = record_failure(settings, "pydeps", "timed out after 300s")
+    assert not (settings.output / "pydeps.log").exists()
+    assert "timed out after 300s" in message
+    assert ".log" not in message