expr-tracker 0.2.6__tar.gz → 0.2.7__tar.gz

{expr_tracker-0.2.6 → expr_tracker-0.2.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: expr_tracker
-Version: 0.2.6
+Version: 0.2.7
 Summary: Local-first experiment tracking with queryable history and expression-based alerts on your training metrics
 Project-URL: Homepage, https://hspk.github.io/expr_tracker/
 Project-URL: Documentation, https://hspk.github.io/expr_tracker/

{expr_tracker-0.2.6 → expr_tracker-0.2.7}/docs/guide/distributed.md

@@ -73,6 +73,12 @@ together with `group`, which both backends understand:
 | rank 2 | `sft-1-rank2` | `sft-1` |
 | rank 2 of stream `data` | `sft-1-data-rank2` | `sft-1` |
 
+`rank_aware` does not affect this. It decides whether the *local* file is
+sharded; the remote id is decided by `backend_on_rank`. They stay independent on
+purpose — `rank_aware=False` says you serialise the writes to one file yourself,
+and there is no equivalent lock between two processes' wandb clients, so a rank
+that reports still needs an id of its own.
+
 ## Typical setup
 
 ```python

{expr_tracker-0.2.6 → expr_tracker-0.2.7}/docs/guide/spans.md

@@ -158,7 +158,7 @@ await asyncio.gather(work("a"), work("b"))
 
 ## Printing a span as it runs
 
-Pass `print_fn` and the span announces itself, indented one tab per level:
+Pass `print_fn` and the span announces itself, indented two spaces per level:
 
 ```python
 with et.span("step", print_fn=print):
@@ -169,10 +169,10 @@ with et.span("step", print_fn=print):
 
 ```
 -> step  16:41:38
-	-> forward  16:41:38
-		-> attention  16:41:38
-		<- attention  16:41:38  3.074ms
-	<- forward  16:41:38  5.481ms
+  -> forward  16:41:38
+    -> attention  16:41:38
+    <- attention  16:41:38  3.074ms
+  <- forward  16:41:38  5.481ms
 <- step  16:41:38  9.641ms
 ```
 
@@ -188,7 +188,9 @@ and interleave their lines; each is still indented by its own depth, and the
 `->` and `<-` markers pair them up.
 
 Any callable taking one string works — `print`, `logger.info`, a list's `append`
-in tests. It is called on the thread that ran the span, and an exception in it is
+in tests. The indent is spaces rather than a tab so that it survives a log
+prefix: a terminal measures tab stops from the start of the line, so behind
+`... | INFO | ` the first level would collapse to whatever is left of the stop. It is called on the thread that ran the span, and an exception in it is
 logged and swallowed.
 
 Set it for the whole run instead of per span with `span_print_fn`:

{expr_tracker-0.2.6 → expr_tracker-0.2.7}/docs/reference/api.md

@@ -177,7 +177,7 @@ span.metrics                                    # what the plugins measured
 `<path>/duration_ms`, `<path>/count` and one key per plugin metric to the open
 row, and appends the full record to `spans.jsonl`.
 
-`print_fn(line)` announces the span's start and end, indented one tab per level.
+`print_fn(line)` announces the span's start and end, indented two spaces per level.
 `plugins` measure a resource across the span; both are inherited by child spans
 and default to the run's `span_print_fn` and `span_plugins`.
 

{expr_tracker-0.2.6 → expr_tracker-0.2.7}/src/expr_tracker/spans.py

@@ -26,6 +26,10 @@ _STACK: ContextVar[tuple[Span, ...]] = ContextVar("et_span_stack", default=())
 DURATION_SUFFIX = "duration_ms"
 COUNT_SUFFIX = "count"
 RESERVED_METRICS = frozenset({DURATION_SUFFIX, COUNT_SUFFIX})
+# Spaces, not a tab: a terminal measures tab stops from the start of the line, so
+# behind a log prefix the first level collapses to whatever is left of the stop.
+# Two spaces render the same width wherever the line begins.
+INDENT = "  "
 
 
 _WARNED: set[tuple[str, str, str]] = set()
@@ -180,7 +184,7 @@ class Span:
     def _announce(self, marker: str, duration_ms: float | None):
         if self.print_fn is None:
             return
-        indent = "\t" * self.print_depth
+        indent = INDENT * self.print_depth
         stamp = time.strftime("%H:%M:%S", time.localtime())
         if duration_ms is None:
             line = f"{indent}{marker} {self.name}  {stamp}"

{expr_tracker-0.2.6 → expr_tracker-0.2.7}/tests/test_distributed.py

@@ -456,3 +456,25 @@ def test_streams_and_ranks_both_reach_the_backend_name(rank, tmp_path):
     call = backend.inits[0]
     assert call["id"] == "job-data-rank3"
     assert call["group"] == "job" and call["job_type"] == "data"
+
+
+def test_the_backend_id_does_not_follow_rank_aware(rank, tmp_path):
+    """Local sharding and the remote id are separate concerns.
+
+    rank_aware=False promises you serialise writes to one file. Two processes'
+    wandb clients have no such lock, so a reporting rank still needs its own id.
+    """
+    backend = RecordingBackend()
+    rank(2)
+    run = Run(
+        project="dist",
+        name="job",
+        dir=str(tmp_path),
+        backends=[backend],
+        backend_on_rank=None,
+        rank_aware=False,
+    )
+    run.log({"loss": 1.0})
+    run.finish()
+    assert backend.inits[0]["id"] == "job-rank2"
+    assert run.history.log_fp.name == "metrics.jsonl"  # unsharded, as asked

{expr_tracker-0.2.6 → expr_tracker-0.2.7}/tests/test_examples.py

@@ -342,7 +342,7 @@ def test_printing_spans_is_opt_in(profile_step, tmp_path, capsys):
     assert "-> step" not in capsys.readouterr().out
     profile_step.main([*argv(**{"--steps": 2, "--dir": tmp_path}), "--print-spans"])
     printed = capsys.readouterr().out
-    assert "-> step" in printed and "\t-> data" in printed
+    assert "-> step" in printed and "\n  -> data" in printed
 
 
 # ------------------------------------------------------------------ early_stopping

{expr_tracker-0.2.6 → expr_tracker-0.2.7}/tests/test_span_plugins.py

@@ -14,6 +14,7 @@ import expr_tracker as et
 from expr_tracker import plugins as pl
 from expr_tracker.history.naming import spans_filename
 from expr_tracker.plugins import CpuTime, GpuStats, TorchMemory, stop_samplers
+from expr_tracker.spans import INDENT
 
 
 @pytest.fixture
@@ -45,6 +46,11 @@ def lines():
     return []
 
 
+def depth_of(line):
+    """Nesting depth of a printed line, measured from its leading indent."""
+    return (len(line) - len(line.lstrip(" "))) // len(INDENT)
+
+
 def span_records(run_obj):
     path = run_obj.history.log_dir / spans_filename(None, True)
     if not path.exists():
@@ -71,8 +77,8 @@ def test_indents_one_tab_per_level(run, lines):
     run()
     with et.span("a", print_fn=lines.append), et.span("b"), et.span("c"):
         pass
-    assert [line.count("\t") for line in lines] == [0, 1, 2, 2, 1, 0]
-    assert lines[2].startswith("\t\t-> c")
+    assert [depth_of(line) for line in lines] == [0, 1, 2, 2, 1, 0]
+    assert lines[2].startswith(INDENT * 2 + "-> c")
 
 
 def test_indentation_is_relative_to_where_printing_started(run, lines):
@@ -85,8 +91,8 @@ def test_indentation_is_relative_to_where_printing_started(run, lines):
         et.span("leaf"),
     ):
         pass
-    assert [line.count("\t") for line in lines] == [0, 1, 1, 0]
-    assert lines[0] == lines[0].lstrip("\t")
+    assert [depth_of(line) for line in lines] == [0, 1, 1, 0]
+    assert lines[0] == lines[0].lstrip(" ")
 
 
 def test_an_overriding_child_roots_its_own_indentation(run, lines):
@@ -99,7 +105,7 @@ def test_an_overriding_child_roots_its_own_indentation(run, lines):
         et.span("d"),
     ):
         pass
-    assert [line.count("\t") for line in other] == [0, 1, 1, 0]
+    assert [depth_of(line) for line in other] == [0, 1, 1, 0]
 
 
 def test_the_run_default_still_indents_the_whole_tree(run, lines):
@@ -107,7 +113,7 @@ def test_the_run_default_still_indents_the_whole_tree(run, lines):
     run(span_print_fn=lines.append)
     with et.span("a"), et.span("b"), et.span("c"):
         pass
-    assert [line.count("\t") for line in lines] == [0, 1, 2, 2, 1, 0]
+    assert [depth_of(line) for line in lines] == [0, 1, 2, 2, 1, 0]
 
 
 def test_indentation_keeps_up_with_deep_nesting(run, lines):
@@ -117,7 +123,7 @@ def test_indentation_keeps_up_with_deep_nesting(run, lines):
     spans += [et.span(f"s{i}").__enter__() for i in range(1, depth)]
     for sp in reversed(spans):
         sp.end()
-    assert [line.count("\t") for line in lines[:depth]] == list(range(depth))
+    assert [depth_of(line) for line in lines[:depth]] == list(range(depth))
 
 
 def test_a_new_thread_starts_a_fresh_tree(run, lines):
@@ -133,7 +139,7 @@ def test_a_new_thread_starts_a_fresh_tree(run, lines):
         thread = threading.Thread(target=work)
         thread.start()
         thread.join()
-    assert [line.count("\t") for line in inner] == [0, 0]
+    assert [depth_of(line) for line in inner] == [0, 0]
 
 
 def test_concurrent_tasks_are_each_indented_by_their_own_depth(run, lines):
@@ -151,7 +157,7 @@ def test_concurrent_tasks_are_each_indented_by_their_own_depth(run, lines):
     by_name = {}
     for line in lines:
         parts = line.split()
-        by_name.setdefault(parts[1], []).append(line.count("\t"))
+        by_name.setdefault(parts[1], []).append(depth_of(line))
     assert by_name["gather"] == [0, 0]
     assert by_name["a"] == [1, 1] and by_name["b"] == [1, 1]
     assert by_name["sub"] == [2, 2, 2, 2]
@@ -165,7 +171,7 @@ def test_a_recursive_span_indents_by_recursion_depth(run, lines):
         return n if n < 2 else fib(n - 1) + fib(n - 2)
 
     fib(2)
-    assert [line.count("\t") for line in lines] == [0, 1, 1, 1, 1, 0]
+    assert [depth_of(line) for line in lines] == [0, 1, 1, 1, 1, 0]
 
 
 def test_a_span_ended_out_of_order_does_not_resurrect_itself(run):
@@ -192,7 +198,7 @@ def test_out_of_order_ends_keep_the_indentation_honest(run, lines):
     inner.end()
     later = et.start_span("later", print_fn=lines.append)
     later.end()
-    assert [line.count("\t") for line in lines] == [0, 1, 0, 1, 0, 0]
+    assert [depth_of(line) for line in lines] == [0, 1, 0, 1, 0, 0]
 
 
 def test_a_slashed_name_does_not_fake_a_level(run, lines):
@@ -202,11 +208,38 @@ def test_a_slashed_name_does_not_fake_a_level(run, lines):
         pass
     et.log({"loss": 1.0})
     et.finish()
-    assert [line.count("\t") for line in lines] == [0, 1, 1, 0]
+    assert [depth_of(line) for line in lines] == [0, 1, 1, 0]
     records = {rec["name"]: rec["depth"] for rec in span_records(r)}
     assert records == {"data/load": 0, "data/load/decode": 1}
 
 
+def test_the_indent_survives_a_log_prefix(run, lines):
+    """A tab is measured from the start of the line, so behind a logger prefix
+    the first level collapses to whatever is left of the tab stop. Spaces do
+    not care where the line begins."""
+    run()
+    with et.span("a", print_fn=lines.append), et.span("b"), et.span("c"):
+        pass
+    assert "\t" not in "".join(lines)
+    for prefix in ("", "x" * 11, "x" * 71, "x" * 72):
+        columns = [_visual_indent(prefix + line) for line in lines]
+        relative = [column - len(prefix) for column in columns]
+        assert relative == [0, 2, 4, 4, 2, 0], prefix
+
+
+def _visual_indent(line, tabsize=8):
+    """Where the marker lands once a terminal has expanded the tabs."""
+    column = 0
+    for index, char in enumerate(line):
+        if char == "\t":
+            column += tabsize - (column % tabsize)
+        elif line.startswith(("-> ", "<- "), index):
+            return column
+        else:
+            column += 1
+    return column
+
+
 def test_children_inherit_the_handler(run, lines):
     run()
     with et.span("outer", print_fn=lines.append), et.span("inner"):
@@ -351,7 +384,7 @@ def test_sibling_spans_restart_the_indentation(run, lines):
             pass
         with et.span("two"):
             pass
-    assert [line.count("\t") for line in lines] == [0, 1, 1, 1, 1, 0]
+    assert [depth_of(line) for line in lines] == [0, 1, 1, 1, 1, 0]
 
 
 # --------------------------------------------------------------------------- #