runledger-cli 0.1.3__tar.gz → 0.1.5__tar.gz

{runledger_cli-0.1.3 → runledger_cli-0.1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: runledger-cli
-Version: 0.1.3
+Version: 0.1.5
 Summary: Zero‑instrumentation experiment registry CLI
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown

{runledger_cli-0.1.3 → runledger_cli-0.1.5}/cli/guided.py

@@ -112,6 +112,14 @@ def fetch_verbose_metrics(batch):
         return resp.json()
     return []
 
+def build_shorthand_map(batch):
+    """Return dict {shorthand_key: [full_path, ...]} from verbose metrics."""
+    entries = fetch_verbose_metrics(batch)
+    mapping = {}
+    for e in entries:
+        mapping.setdefault(e['key'], []).append(e['path'])
+    return mapping
+
 def perform_search(metric=None, op=None, value=None, q=None, fuzzy=False, batch=None, pointers=True, block=None):
     params = {"page": 0, "size": 50, "sort": "created_at,desc"}
     if batch:
@@ -179,12 +187,18 @@ def show_blocks(run: dict, dot_path: str = None, block_levels: list = None):
         console.print()
 
     if dot_path is None:
-        try:
-            pretty = json.dumps(payload, indent=2)
-        except Exception:
-            pretty = str(payload)
-        console.print(Panel(pretty, title=f"Run {run['id']} · {source_file}"))
-        return
+        # If we have matched pointers, derive a path from the first concrete pointer
+        if matched:
+            concrete = matched[0]['pointer']
+            parts = concrete.replace('[', '.').replace(']', '').split('.')
+            dot_path = '.'.join(parts)
+        else:
+            try:
+                pretty = json.dumps(payload, indent=2)
+            except Exception:
+                pretty = str(payload)
+            console.print(Panel(pretty, title=f"Run {run['id']} · {source_file}"))
+            return
 
     parts = [seg.replace("[]", "") for seg in dot_path.split(".")]
     max_block = len(parts) - 1
@@ -207,9 +221,17 @@ def show_blocks(run: dict, dot_path: str = None, block_levels: list = None):
                 title = f"Run {run['id']} · {source_file}  |  metric: {dot_path}  |  depth: 0 (match {i+1}/{len(matched)})"
                 console.print(Panel(pretty, title=title))
         else:
-            ancestor_parts = parts[:len(parts) - (block + 1)]
-            pointer = "/" + "/".join(ancestor_parts) if ancestor_parts else ""
-            node = navigate_json_pointer(payload, pointer) if pointer else payload
+            if block > 0 and matched:
+                concrete = matched[0]['pointer']
+                segments = concrete.replace('[', '.').replace(']', '').split('.')
+                ancestor_segments = segments[:len(segments) - (block + 1)]
+                pointer = "/" + "/".join(ancestor_segments) if ancestor_segments else ""
+                node = navigate_json_pointer(payload, pointer) if pointer else payload
+            else:
+                ancestor_parts = parts[:len(parts) - (block + 1)]
+                pointer = "/" + "/".join(ancestor_parts) if ancestor_parts else ""
+                node = navigate_json_pointer(payload, pointer) if pointer else payload
+
             depth_label = ""
             if block == max_block:
                 depth_label = " (full run)"
@@ -243,15 +265,14 @@ def run_guided_search():
                          "Answer a few questions and we'll find your best experiments.",
                          title="Welcome"))
 
-    # ── Step 1: Folder & Batch ──
-    console.print("\n[bold][Step 1/5] Select your experiment folder[/bold]")
-    folder = Prompt.ask("Folder path (drag‑and‑drop or type)",
-                        default="")
-    batch  = Prompt.ask("Batch name (optional, default: folder name)", default="")
+    # 1. Folder
+    folder = Prompt.ask("[bold]Folder containing your JSON/JSONL files[/bold]\n"
+                        "(drag‑and‑drop or type a path)")
+    batch  = Prompt.ask("[bold]Batch name (optional, default: folder name)[/bold]", default="")
     if not batch:
         batch = Path(folder).name
 
-    # ── Step 2: Scan if needed ──
+    # 2. Scan if needed
     console.print(f"\n[bold][Step 2/5] Ingest data from '{batch}'[/bold]")
     metrics = fetch_verbose_metrics(batch)
     if metrics:
@@ -267,6 +288,9 @@ def run_guided_search():
             console.print("[red]Metric discovery failed. Exiting.[/red]")
             return
 
+    # Build shorthand -> full paths map
+    shorthand_map = build_shorthand_map(batch)
+
     # Show schema summary table
     table = Table(title="Available Metrics")
     table.add_column("#", justify="right")
@@ -276,14 +300,14 @@ def run_guided_search():
         table.add_row(str(i), m["key"], m["path"])
     console.print(table)
 
-    # ── Step 3: Build conditions ──
+    # 3. Build one or more conditions
     console.print(f"\n[bold][Step 3/5] Define your search conditions[/bold]")
     filters = []
     combine = "and"
     first_condition = True
 
     while True:
-        # Metric selection (filter‑as‑you‑type)
+        # Metric selection (filter‑as‑you‑type with explicit path and sub‑list support)
         metric_names = [m["key"] for m in metrics]
         selected_metric = None
         filtered = metric_names[:]
@@ -304,6 +328,32 @@ def run_guided_search():
             console.print(ftable)
 
             query = Prompt.ask("Type to filter metrics (or 'all' to reset, number to select)", default="")
+
+            # Explicit dot‑path / array‑path – accept directly
+            if '.' in query or '[]' in query:
+                selected_metric = query
+                break
+
+            # Shorthand with multiple possible full paths – show sub‑list
+            if query in shorthand_map:
+                paths = shorthand_map[query]
+                if len(paths) == 1:
+                    selected_metric = paths[0]
+                    break
+                else:
+                    sub_table = Table(title=f"Select full path for '{query}'")
+                    sub_table.add_column("#", justify="right")
+                    sub_table.add_column("Full Path", style="cyan")
+                    for i, p in enumerate(paths, 1):
+                        sub_table.add_row(str(i), p)
+                    console.print(sub_table)
+                    sub_choice = Prompt.ask("Choose a path", default="1")
+                    if sub_choice.isdigit():
+                        idx = int(sub_choice) - 1
+                        if 0 <= idx < len(paths):
+                            selected_metric = paths[idx]
+                            break
+
             if query.lower() == "all":
                 filtered = metric_names[:]
                 continue
@@ -335,24 +385,24 @@ def run_guided_search():
         conds = " [bold yellow]" + f" {combine.upper()} ".join(f"{f['metric']} {f['op']} {f['value']}" for f in filters) + "[/bold yellow]"
         console.print(f"\n[bold]Current filter(s):[/bold]{conds}")
 
-        if first_condition and len(metric_names) > 1:
-            another = Confirm.ask("Add another condition?", default=False)
-            if not another:
-                break
-            if len(filters) >= 2:
-                combine = Prompt.ask("Combine with", choices=["and", "or"], default="and")
-        else:
+        # Ask for another condition
+        another = Confirm.ask("Add another condition?", default=False)
+        if not another:
             break
+
+        # If this is about to be the second condition, ask for combine operator BEFORE adding it
+        if len(filters) == 1:
+            combine = Prompt.ask("Combine with", choices=["and", "or"], default="and")
         first_condition = False
 
-    # ── Step 4: Block depth ──
+    # Block depth
     console.print(f"\n[bold][Step 4/5] Choose output detail[/bold]")
     block = None
     if Confirm.ask("Limit output to a specific block depth? (block‑0 = tightest match)", default=False):
         block = Prompt.ask("Block depth", default="0")
         block = int(block)
 
-    # ── Step 5: Search & Results ──
+    # 5. Run search
     console.print(f"\n[bold][Step 5/5] Searching...[/bold]")
     if len(filters) == 1:
         f = filters[0]
@@ -366,7 +416,7 @@ def run_guided_search():
         for run in data["content"]:
             show_blocks(run, filters[0]["metric"] if len(filters) == 1 else None, [block] if block is not None else None)
 
-    # ── Post‑search menu ──
+    # Post‑search menu
     while True:
         console.print("\n[bold]What would you like to do next?[/bold]")
         console.print("  [1] Save this search")
@@ -385,23 +435,20 @@ def run_guided_search():
             if save_search(name, batch, params):
                 console.print(f"[green]Saved search '{name}'.[/green]")
         elif choice == "2":
-            # Simple text export to a file
             out_file = Prompt.ask("Output file path", default="runledger_export.txt")
             if data and data.get("content"):
-                from ledgger import build_export_blocks, format_blocks_as_text
+                from ledger import build_export_blocks, format_blocks_as_text
                 blocks = build_export_blocks(data["content"], filters[0]["metric"] if len(filters) == 1 else None, [block] if block is not None else None, include_pointers=True)
                 Path(out_file).write_text(format_blocks_as_text(blocks), encoding="utf-8")
                 console.print(f"[green]Exported {len(blocks)} block(s) to {out_file}[/green]")
             else:
                 console.print("[yellow]No data to export.[/yellow]")
         elif choice == "3":
-            # Restart the guided flow
             run_guided_search()
             return
         elif choice == "4":
             id1 = Prompt.ask("First Run ID")
             id2 = Prompt.ask("Second Run ID")
-            # Quick diff using the API
             resp1 = requests.get(f"{API_BASE}/{id1}")
             resp2 = requests.get(f"{API_BASE}/{id2}")
             if resp1.status_code == 200 and resp2.status_code == 200:

{runledger_cli-0.1.3 → runledger_cli-0.1.5}/cli/ledger.py

@@ -47,9 +47,10 @@ except Exception:
 # ------------------------------------------------------------
 # Configuration
 # ------------------------------------------------------------
-API_BASE = "http://localhost:8080/api/runs"
+_BASE = os.environ.get("RUNLEDGER_BASE_URL", "http://localhost:8080")
+API_BASE = f"{_BASE}/api/runs"
+HEALTH_URL = f"{_BASE}/actuator/health"
 COMPOSE_FILE = os.path.join(os.path.dirname(__file__), "docker-compose.yml")
-HEALTH_URL = "http://localhost:8080/actuator/health"
 PAGE_SIZE = 10
 
 console = Console()
@@ -58,7 +59,7 @@ console = Console()
 # Helpers
 # ------------------------------------------------------------
 def check_docker():
-    result = subprocess.run("docker version", shell=True,
+    result = subprocess.run(["docker", "version"],
                             capture_output=True, text=True)
     if result.returncode != 0:
         console.print("[bold red]Docker is not installed or not reachable.[/bold red]")
@@ -93,7 +94,7 @@ def start_backend():
     console.print("Starting RunLedger backend...")
     subprocess.run(
         ["docker", "compose", "-f", compose_file, "-p", "runledger", "up", "-d"],
-        shell=True, check=True
+        check=True
     )
     if wait_for_backend():
         console.print("[green]RunLedger backend is running.[/green]")
@@ -106,7 +107,7 @@ def stop_backend():
     if os.path.exists(compose_file):
         subprocess.run(
             ["docker", "compose", "-f", compose_file, "-p", "runledger", "down"],
-            shell=True, check=True
+            check=True
         )
         console.print("RunLedger backend stopped.")
     else:
@@ -353,13 +354,19 @@ def show_blocks(run: dict, dot_path: str = None, block_levels: list = None):
         console.print()
 
     if dot_path is None:
-        label = "-- full run (full‑text/fuzzy match)"
-        try:
-            pretty = json.dumps(payload, indent=2)
-        except Exception:
-            pretty = str(payload)
-        console.print(Panel(pretty, title=f"Run {run['id']} · {source_file}"))
-        return
+        # If we have matched pointers, derive a path from the first concrete pointer
+        if matched:
+            concrete = matched[0]['pointer']
+            parts = concrete.replace('[', '.').replace(']', '').split('.')
+            dot_path = '.'.join(parts)
+        else:
+            label = "-- full run (full‑text/fuzzy match)"
+            try:
+                pretty = json.dumps(payload, indent=2)
+            except Exception:
+                pretty = str(payload)
+            console.print(Panel(pretty, title=f"Run {run['id']} · {source_file}"))
+            return
 
     # Strip "[]" so JSON Pointer navigation works
     parts = [seg.replace("[]", "") for seg in dot_path.split(".")]
@@ -576,6 +583,14 @@ def compute_delta(val1, val2):
 # ------------------------------------------------------------
 # Non‑interactive CLI outputs
 # ------------------------------------------------------------
+def build_shorthand_map(batch):
+    """Return dict {shorthand_key: [full_path, ...]} from verbose metrics."""
+    entries = fetch_verbose_metrics(batch)
+    mapping = {}
+    for e in entries:
+        mapping.setdefault(e['key'], []).append(e['path'])
+    return mapping
+
 def cli_metrics(args):
     if args.verbose:
         entries = fetch_verbose_metrics(args.batch)
@@ -812,6 +827,9 @@ def interactive_search(batch: str = None):
             console.print("[yellow]No metrics available yet. Ingest some runs first.[/yellow]")
             break
 
+        # Build shorthand -> full paths map
+        shorthand_map = build_shorthand_map(batch)
+
         selected_metric = None
         filtered = metrics[:]
         while True:
@@ -831,6 +849,32 @@ def interactive_search(batch: str = None):
             console.print(table)
 
             query = Prompt.ask("Type to filter metrics (or 'all' to reset, number to select)", default="")
+
+            # Explicit dot‑path / array‑path – accept directly
+            if '.' in query or '[]' in query:
+                selected_metric = query
+                break
+
+            # Shorthand with multiple possible full paths – show sub‑list
+            if query in shorthand_map:
+                paths = shorthand_map[query]
+                if len(paths) == 1:
+                    selected_metric = paths[0]
+                    break
+                else:
+                    sub_table = Table(title=f"Select full path for '{query}'")
+                    sub_table.add_column("#", justify="right")
+                    sub_table.add_column("Full Path", style="cyan")
+                    for i, p in enumerate(paths, 1):
+                        sub_table.add_row(str(i), p)
+                    console.print(sub_table)
+                    sub_choice = Prompt.ask("Choose a path", default="1")
+                    if sub_choice.isdigit():
+                        idx = int(sub_choice) - 1
+                        if 0 <= idx < len(paths):
+                            selected_metric = paths[idx]
+                            break
+
             if query.lower() == "all":
                 filtered = metrics[:]
                 continue

{runledger_cli-0.1.3 → runledger_cli-0.1.5}/cli/tests/test_integration.py

@@ -9,49 +9,87 @@ from pathlib import Path
 import pytest
 import requests
 
+# ------------------------------------------------------------
+# Global settings – will be overridden dynamically by the fixture
+# ------------------------------------------------------------
 PROJECT_ROOT = Path(__file__).parent.parent.parent
 COMPOSE_FILE = PROJECT_ROOT / "docker-compose.test.yml"
-HEALTH_URL = "http://localhost:8081/actuator/health"
-API_BASE = "http://localhost:8080/api/runs"
 
-def wait_for_health(timeout=120):
-    start = time.time()
-    while time.time() - start < timeout:
-        try:
-            resp = requests.get(HEALTH_URL, timeout=2)
-            if resp.status_code == 200:
-                return True
-        except Exception:
-            pass
-        time.sleep(2)
-    return False
+# Prevent CLI from ever auto‑starting Docker
+os.environ["RUNLEDGER_NO_DOCKER"] = "1"
+
+# These will be set to the actual random host port once the stack is up
+HEALTH_URL = None
+API_BASE = None
+
+
+def get_host_port(project, service="app", container_port="8080"):
+    """
+    Return the host port that Docker assigned to *container_port* for the
+    given service inside the Compose project.
+    """
+    cmd = [
+        "docker", "compose", "-f", str(COMPOSE_FILE), "-p", project,
+        "port", service, container_port
+    ]
+    result = subprocess.run(cmd, capture_output=True, text=True, cwd=str(PROJECT_ROOT))
+    # Example output: "0.0.0.0:54321" or "127.0.0.1:12345"
+    return result.stdout.strip().split(":")[-1]
+
 
 @pytest.fixture(scope="session")
 def docker_stack():
-    """Start the Docker Compose stack and wait for it to be healthy."""
-    subprocess.run(
-        ["docker", "compose", "-f", str(COMPOSE_FILE), "up", "-d", "--build"],
-        cwd=str(PROJECT_ROOT),
-        check=True,
-        capture_output=True,
-    )
-    if not wait_for_health():
-        subprocess.run(
-            ["docker", "compose", "-f", str(COMPOSE_FILE), "down"],
-            cwd=str(PROJECT_ROOT),
-            capture_output=True,
-        )
-        pytest.fail("Backend did not become healthy in time")
-    yield
+    """Start a completely isolated test stack with random host ports."""
+    project = f"rl-test-{uuid.uuid4().hex[:8]}"
+    compose_cmd = [
+        "docker", "compose", "-f", str(COMPOSE_FILE),
+        "-p", project,
+        "up", "-d", "--build"
+    ]
+    subprocess.run(compose_cmd, cwd=str(PROJECT_ROOT), check=True, capture_output=True)
+
+    # Dynamically discover the random port Docker assigned to the app
+    host_port = get_host_port(project)
+    health_url = f"http://localhost:{host_port}/actuator/health"
+    api_base = f"http://localhost:{host_port}/api/runs"
+
+    # Update global variables so all tests use the correct address
+    globals()["HEALTH_URL"] = health_url
+    globals()["API_BASE"] = api_base
+
+    # Make CLI commands (run_cli) use the same port
+    os.environ["RUNLEDGER_BASE_URL"] = f"http://localhost:{host_port}"
+    os.environ["RUNLEDGER_PORT"] = host_port
+
+    # Wait for the backend to become healthy
+    for _ in range(60):
+        try:
+            if requests.get(health_url, timeout=2).status_code == 200:
+                break
+        except Exception:
+            time.sleep(2)
+    else:
+        pytest.fail("Backend did not become healthy")
+
+    yield api_base   # tests that need it can receive it, but most use globals
+
+    # Tear everything down
     subprocess.run(
-        ["docker", "compose", "-f", str(COMPOSE_FILE), "down"],
-        cwd=str(PROJECT_ROOT),
-        capture_output=True,
+        ["docker", "compose", "-f", str(COMPOSE_FILE), "-p", project, "down", "-v"],
+        cwd=str(PROJECT_ROOT), capture_output=True
     )
 
+
 def run_cli(*args):
+    """Run the CLI in a subprocess, inheriting the environment (port, no-docker)."""
     cmd = ["python", str(PROJECT_ROOT / "cli" / "ledger.py"), *args]
-    return subprocess.run(cmd, capture_output=True, encoding='utf-8', cwd=str(PROJECT_ROOT))
+    return subprocess.run(
+        cmd,
+        capture_output=True,
+        encoding='utf-8',
+        cwd=str(PROJECT_ROOT)
+    )
+
 
 @pytest.fixture
 def sample_folder():
@@ -71,12 +109,14 @@ def sample_folder():
         (folder / "bad.json").write_text("this is not json")
         yield folder
 
+
 pytestmark = pytest.mark.integration
 
+
 def test_full_golden_path(docker_stack, sample_folder):
     batch = f"golden-{uuid.uuid4()}"
 
-    # 1. scan folder (non‑interactive)
+    # 1. scan folder
     result = run_cli("scan", str(sample_folder), "--batch", batch)
     assert result.returncode == 0, result.stderr
     assert "Successfully ingested 4 run(s)" in result.stdout
@@ -111,7 +151,7 @@ def test_full_golden_path(docker_stack, sample_folder):
     assert result.returncode == 0, result.stderr
     assert "running" in result.stdout.lower()
 
-    # 6. deep API verification
+    # 6. deep API verification (uses dynamic API_BASE)
     resp = requests.get(API_BASE, params={"batch": batch})
     assert resp.status_code == 200
     runs = resp.json()["content"]
@@ -123,25 +163,28 @@ def test_full_golden_path(docker_stack, sample_folder):
     for r in runs:
         assert r["payload"]["_source"]["file"] in ["run1.json", "run2.json", "batch.json"]
         assert r["createdAt"] is not None
-    # Verify ordering (descending by createdAt)
     timestamps = [r["createdAt"] for r in runs]
     assert timestamps == sorted(timestamps, reverse=True), "runs must be ordered by createdAt desc"
 
+
 def test_scan_nonexistent_folder(docker_stack):
     result = run_cli("scan", "/no/such/path")
     assert result.returncode != 0 or "Folder not found" in result.stdout
 
+
 def test_scan_corrupt_file_skipped(docker_stack, sample_folder):
     batch = f"corrupt-{uuid.uuid4()}"
     result = run_cli("scan", str(sample_folder), "--batch", batch)
     assert result.returncode == 0, result.stderr
     assert "Successfully ingested 4 run(s)" in result.stdout
 
+
 def test_metrics_empty_batch(docker_stack):
     result = run_cli("metrics", "--batch", f"nonexistent-{uuid.uuid4()}")
     assert result.returncode == 0, result.stderr
     assert json.loads(result.stdout) == []
 
+
 def test_search_no_results(docker_stack, sample_folder):
     batch = f"noresults-{uuid.uuid4()}"
     run_cli("scan", str(sample_folder), "--batch", batch)
@@ -151,20 +194,18 @@ def test_search_no_results(docker_stack, sample_folder):
     assert data["totalElements"] == 0
     assert data["content"] == []
 
+
 def test_multi_filter_and_returns_results():
-    # Ensure the compound test data folder exists
     compound_dir = "test-data/sample-compound-runs"
     if not os.path.isdir(compound_dir):
         pytest.skip(f"Folder {compound_dir} not found")
 
-    # Scan the folder with explicit UTF-8 encoding to avoid UnicodeDecodeError
     scan_result = subprocess.run(
         ["python", "cli/ledger.py", "scan", compound_dir, "--batch", "compound-int"],
         capture_output=True, text=True, encoding="utf-8", errors="replace"
     )
     assert scan_result.returncode == 0, f"Scan failed: {scan_result.stderr}"
 
-    # Search with AND
     result = subprocess.run(
         ["python", "cli/ledger.py", "search", "--metric", "accuracy", "--op", "gt", "--value", "0.9",
          "--metric", "loss", "--op", "lt", "--value", "0.2", "--combine", "and", "--batch", "compound-int"],
@@ -172,6 +213,4 @@ def test_multi_filter_and_returns_results():
     )
     assert result.returncode == 0, f"Search failed: {result.stderr}"
     assert result.stdout is not None, "stdout is None (decoding issue)"
-
-    # compound_run1.json has accuracy=0.95, loss=0.15 → should match
     assert "compound_run1" in result.stdout, f"Output: {result.stdout}"

{runledger_cli-0.1.3 → runledger_cli-0.1.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name           = "runledger-cli"
-version        = "0.1.3"
+version        = "0.1.5"
 description    = "Zero‑instrumentation experiment registry CLI"
 readme         = "README.md"
 requires-python = ">=3.10"

{runledger_cli-0.1.3 → runledger_cli-0.1.5}/runledger_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: runledger-cli
-Version: 0.1.3
+Version: 0.1.5
 Summary: Zero‑instrumentation experiment registry CLI
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown