runmap 0.1.0__py3-none-any.whl

runmap/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

runmap/__main__.py

@@ -0,0 +1,145 @@
+from __future__ import annotations
+
+import argparse
+import runpy
+import sys
+import traceback as tb
+from pathlib import Path
+
+from runmap import __version__
+from runmap import exporter, diff as diff_mod
+from runmap.tracer import Tracer
+from runmap.tree import build
+from runmap.renderer import render
+
+
+def _run_script(script: str, args: list[str]) -> None:
+    """Execute target script in its own namespace, replacing sys.argv"""
+    script_path = Path(script).resolve()
+    if not script_path.exists():
+        sys.exit(f"runmap: file not found: {script}")
+
+    sys.argv = [str(script_path)] + args
+    sys.path.insert(0, str(script_path.parent))
+    runpy.run_path(str(script_path), run_name="__main__")
+
+
+def _build_run_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(
+        prog="runmap",
+        description="Visualize Python function call trees with timing",
+    )
+    p.add_argument("--version", action="version", version=f"runmap {__version__}")
+    p.add_argument("--no-color", action="store_true", help="Disable rich styling")
+    p.add_argument("--depth", type=int, default=None, metavar="INT",
+                   help="Max tree depth (default: unlimited)")
+    p.add_argument("--min-ms", type=float, default=0.0, metavar="MS",
+                   help="Hide nodes below this threshold in ms (default: 0)")
+    p.add_argument("--sample", action="store_true",
+                   help="Use signal-based sampler instead of sys.settrace (Unix only)")
+    p.add_argument("--out", default=None, metavar="FILE",
+                   help="Save .trace JSON to file")
+    p.add_argument("script", help="Path to script to profile")
+    p.add_argument("script_args", nargs=argparse.REMAINDER,
+                   help="Arguments passed to the script")
+    return p
+
+
+def _build_diff_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(
+        prog="runmap diff",
+        description="Compare two .trace files",
+    )
+    p.add_argument("a", metavar="A.trace")
+    p.add_argument("b", metavar="B.trace")
+    p.add_argument("--min-delta-ms", type=float, default=0.0, metavar="MS",
+                   help="Hide entries with |delta| below this value (default: 0)")
+    p.add_argument("--no-color", action="store_true", help="Disable rich styling")
+    return p
+
+
+def _cmd_run(args: argparse.Namespace) -> None:
+    if args.sample:
+        if sys.platform == "win32":
+            sys.exit(
+                "runmap: --sample is not available on Windows. "
+                "signal.setitimer is Unix-only. Use the default tracer mode."
+            )
+        from runmap.sampler import Sampler
+        sampler = Sampler()
+        sampler.start()
+        exc_info = None
+        try:
+            _run_script(args.script, args.script_args)
+        except SystemExit:
+            raise
+        except Exception:
+            exc_info = sys.exc_info()
+        finally:
+            sampler.stop()
+        records = sampler.to_records()
+    else:
+        tracer = Tracer()
+        tracer.start()
+        exc_info = None
+        try:
+            _run_script(args.script, args.script_args)
+        except SystemExit:
+            raise
+        except Exception:
+            exc_info = sys.exc_info()
+        finally:
+            tracer.stop()
+        records = tracer.records
+
+    root = build(records)
+    render(
+        root,
+        depth_limit=args.depth,
+        min_ms=args.min_ms,
+        no_color=args.no_color,
+    )
+
+    if args.out:
+        exporter.save(records, args.out)
+
+    if exc_info is not None:
+        # Re-raise with original traceback after showing the partial tree
+        raise exc_info[1].with_traceback(exc_info[2])
+
+
+def _cmd_diff(args: argparse.Namespace) -> None:
+    old_records = exporter.load(args.a)
+    new_records = exporter.load(args.b)
+    results = diff_mod.compare(old_records, new_records)
+    diff_mod.render_diff(results, min_delta_ms=args.min_delta_ms, no_color=args.no_color)
+
+
+def main() -> None:
+    # Ensure stdout uses UTF-8 regardless of the system codepage (e.g. CP1251 on Windows)
+    if hasattr(sys.stdout, "reconfigure"):
+        sys.stdout.reconfigure(encoding="utf-8", errors="replace")
+
+    argv = sys.argv[1:]
+
+    # Detect diff subcommand before handing to argparse so that a script path
+    # like "example.py" is never mistaken for an invalid subcommand choice
+    if argv and argv[0] == "diff":
+        parser = _build_diff_parser()
+        args = parser.parse_args(argv[1:])
+        _cmd_diff(args)
+        return
+
+    # Handle --version / --help with no script given
+    if not argv or argv == ["--version"]:
+        parser = _build_run_parser()
+        parser.parse_args(argv)  # prints version or help and exits
+        return
+
+    parser = _build_run_parser()
+    args = parser.parse_args(argv)
+    _cmd_run(args)
+
+
+if __name__ == "__main__":
+    main()

runmap/diff.py

@@ -0,0 +1,84 @@
+from __future__ import annotations
+
+import math
+
+from rich.console import Console
+from rich.table import Table
+
+from runmap.models import DiffResult, TraceRecord
+
+
+def _aggregate(records: list[TraceRecord]) -> dict[str, float]:
+    """Sum total_ms per qualname"""
+    totals: dict[str, float] = {}
+    for r in records:
+        ms = (r.end_time - r.start_time) * 1000
+        totals[r.qualname] = totals.get(r.qualname, 0.0) + ms
+    return totals
+
+
+def compare(old_records: list[TraceRecord], new_records: list[TraceRecord]) -> list[DiffResult]:
+    old = _aggregate(old_records)
+    new = _aggregate(new_records)
+
+    all_names = set(old) | set(new)
+    results: list[DiffResult] = []
+
+    for name in all_names:
+        old_ms = old.get(name, 0.0)
+        new_ms = new.get(name, 0.0)
+        delta_ms = new_ms - old_ms
+        if old_ms == 0:
+            delta_pct = math.inf if new_ms > 0 else 0.0
+        else:
+            delta_pct = (delta_ms / old_ms) * 100
+
+        results.append(DiffResult(
+            node_name=name,
+            old_ms=old_ms,
+            new_ms=new_ms,
+            delta_ms=delta_ms,
+            delta_pct=delta_pct,
+        ))
+
+    # Sort by abs delta descending
+    results.sort(key=lambda r: abs(r.delta_ms), reverse=True)
+    return results
+
+
+def render_diff(
+    results: list[DiffResult],
+    min_delta_ms: float = 0.0,
+    no_color: bool = False,
+) -> None:
+    console = Console(highlight=False, no_color=no_color, legacy_windows=False)
+
+    filtered = [r for r in results if abs(r.delta_ms) >= min_delta_ms]
+    if not filtered:
+        console.print("[dim]No differences above threshold.[/dim]")
+        return
+
+    table = Table(show_header=True, header_style="bold")
+    table.add_column("Function", style="", no_wrap=True)
+    table.add_column("Old (ms)", justify="right")
+    table.add_column("New (ms)", justify="right")
+    table.add_column("Delta (ms)", justify="right")
+
+    for r in filtered:
+        pct = r.delta_pct
+        old_str = f"{r.old_ms:.1f}" if r.old_ms else "-"
+        new_str = f"{r.new_ms:.1f}" if r.new_ms else "-"
+
+        if math.isinf(pct) or abs(pct) < 5:
+            delta_str = f"{r.delta_ms:+.1f}"
+            style = "dim"
+        elif r.delta_ms < 0:
+            delta_str = f"{r.delta_ms:+.1f} ({pct:+.1f}%)"
+            style = "green"
+        else:
+            delta_str = f"{r.delta_ms:+.1f} ({pct:+.1f}%)"
+            style = "red"
+
+        table.add_row(r.node_name, old_str, new_str, f"[{style}]{delta_str}[/{style}]")
+
+    console.print(table)

runmap/exporter.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from runmap.models import TraceRecord
+
+
+def save(records: list[TraceRecord], path: str | Path) -> None:
+    data = [
+        {
+            "qualname": r.qualname,
+            "filename": r.filename,
+            "lineno": r.lineno,
+            "start_time": r.start_time,
+            "end_time": r.end_time,
+            "depth": r.depth,
+            "parent_name": r.parent_name,
+        }
+        for r in records
+    ]
+    Path(path).write_text(json.dumps(data, indent=2), encoding="utf-8")
+
+
+def load(path: str | Path) -> list[TraceRecord]:
+    p = Path(path)
+    if not p.exists():
+        raise FileNotFoundError(
+            f"Trace file not found: {p}\n"
+            "Generate one with: python -m runmap script.py --out output.trace"
+        )
+    data = json.loads(p.read_text(encoding="utf-8"))
+    return [
+        TraceRecord(
+            qualname=d["qualname"],
+            filename=d["filename"],
+            lineno=d["lineno"],
+            start_time=d["start_time"],
+            end_time=d["end_time"],
+            depth=d["depth"],
+            parent_name=d["parent_name"],
+        )
+        for d in data
+    ]

runmap/models.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+
+@dataclass
+class TraceRecord:
+    qualname: str
+    filename: str
+    lineno: int
+    start_time: float  # perf_counter seconds
+    end_time: float    # perf_counter seconds
+    depth: int
+    parent_name: str | None
+
+
+@dataclass
+class CallNode:
+    qualname: str
+    total_ms: float
+    self_ms: float
+    call_count: int
+    children: list[CallNode] = field(default_factory=list)
+    is_hot: bool = False
+
+
+@dataclass
+class DiffResult:
+    node_name: str
+    old_ms: float
+    new_ms: float
+    delta_ms: float
+    delta_pct: float  # relative to old_ms; inf if old_ms == 0

runmap/renderer.py

@@ -0,0 +1,89 @@
+from __future__ import annotations
+
+from rich.console import Console
+from rich.tree import Tree
+
+from runmap.models import CallNode
+
+_BAR_CHAR = "\u2588"  # full block
+_BAR_MAX = 30
+
+
+def _bar(fraction: float) -> str:
+    count = round(fraction * _BAR_MAX)
+    return _BAR_CHAR * count
+
+
+def _format_ms(ms: float) -> str:
+    if ms == 0.0:
+        return "0ms"
+    if ms < 1.0:
+        formatted = f"{ms:.2f}"
+        if formatted == "0.00":
+            return "<0.01ms"
+        return f"{formatted}ms"
+    return f"{ms:.0f}ms"
+
+
+def _add_nodes(
+    rich_node: Tree,
+    node: CallNode,
+    parent_ms: float,
+    total_ms: float,
+    depth_limit: int | None,
+    min_ms: float,
+    current_depth: int,
+    no_color: bool,
+) -> None:
+    visible = [c for c in node.children if c.total_ms >= min_ms]
+    hidden = len(node.children) - len(visible)
+
+    for child in visible:
+        fraction = child.total_ms / parent_ms if parent_ms > 0 else 0
+        pct_of_total = child.total_ms / total_ms if total_ms > 0 else 0
+
+        bar = _bar(fraction)
+        hot = " :fire:" if child.is_hot else ""
+        label = f"{child.qualname}  {_format_ms(child.total_ms)} {bar}{hot}"
+
+        if not no_color and pct_of_total < 0.02:
+            label = f"[dim]{label}[/dim]"
+
+        child_node = rich_node.add(label)
+
+        at_limit = depth_limit is not None and current_depth >= depth_limit
+        if not at_limit and child.children:
+            _add_nodes(
+                child_node,
+                child,
+                child.total_ms,
+                total_ms,
+                depth_limit,
+                min_ms,
+                current_depth + 1,
+                no_color,
+            )
+        elif at_limit and child.children:
+            child_node.add(f"[dim]... {len(child.children)} more[/dim]")
+
+    if hidden:
+        rich_node.add(f"[dim]... {hidden} more (below --min-ms)[/dim]")
+
+
+def render(
+    root: CallNode,
+    depth_limit: int | None = None,
+    min_ms: float = 0.0,
+    no_color: bool = False,
+) -> None:
+    """Render the call tree to stdout using rich"""
+    console = Console(highlight=False, no_color=no_color, legacy_windows=False)
+    total_ms = root.total_ms
+
+    if total_ms == 0:
+        console.print("[dim]No calls recorded.[/dim]")
+        return
+
+    tree = Tree(f"[bold]{root.qualname}[/bold]  {_format_ms(total_ms)}")
+    _add_nodes(tree, root, total_ms, total_ms, depth_limit, min_ms, 1, no_color)
+    console.print(tree)

runmap/sampler.py

@@ -0,0 +1,90 @@
+from __future__ import annotations
+
+import sys
+import traceback
+from collections import defaultdict
+from time import perf_counter
+from typing import Any
+
+from runmap.models import TraceRecord
+
+
+def _check_unix() -> None:
+    if sys.platform == "win32":
+        raise RuntimeError(
+            "--sample is not available on Windows. "
+            "signal.setitimer is a Unix-only API. "
+            "Use the default tracer mode instead."
+        )
+
+
+class Sampler:
+    """Signal-based 100 Hz stack sampler, Unix only"""
+
+    def __init__(self, interval: float = 0.01) -> None:
+        _check_unix()
+        import signal  # noqa: PLC0415 - intentional lazy import; fails on Windows
+        self._signal = signal
+        self._interval = interval
+        self._counts: dict[tuple[str, ...], int] = defaultdict(int)
+        self._start_time: float = 0.0
+        self._end_time: float = 0.0
+        self._prev_handler: Any = signal.SIG_DFL
+
+    def _handle(self, signum: int, frame: Any) -> None:  # noqa: ARG002
+        stack = traceback.extract_stack(frame)
+        # Build a tuple of qualnames from bottom (oldest) to top (newest)
+        names = tuple(
+            f"{s.name}" for s in stack
+            if s.filename and "<" not in s.filename  # skip builtins / frozen
+        )
+        if names:
+            self._counts[names] += 1
+
+    def start(self) -> None:
+        self._start_time = perf_counter()
+        self._prev_handler = self._signal.signal(self._signal.SIGALRM, self._handle)
+        self._signal.setitimer(self._signal.ITIMER_REAL, self._interval, self._interval)
+
+    def stop(self) -> None:
+        self._signal.setitimer(self._signal.ITIMER_REAL, 0)
+        self._signal.signal(self._signal.SIGALRM, self._prev_handler)
+        self._end_time = perf_counter()
+
+    def to_records(self) -> list[TraceRecord]:
+        """Convert sample counts to a flat list of TraceRecord approximations"""
+        total_samples = sum(self._counts.values())
+        if total_samples == 0:
+            return []
+
+        elapsed = self._end_time - self._start_time
+        # Each sample represents ~interval seconds of wall time
+        seconds_per_sample = elapsed / total_samples
+
+        # Aggregate: for each unique (parent, child) pair count inclusive samples
+        inclusive: dict[str, int] = defaultdict(int)
+        parent_map: dict[str, str | None] = {}
+        depth_map: dict[str, int] = {}
+
+        for stack, count in self._counts.items():
+            for i, name in enumerate(stack):
+                inclusive[name] += count
+                if name not in parent_map:
+                    parent_map[name] = stack[i - 1] if i > 0 else None
+                    depth_map[name] = i
+
+        records: list[TraceRecord] = []
+        for name, count in inclusive.items():
+            dur = count * seconds_per_sample
+            records.append(
+                TraceRecord(
+                    qualname=name,
+                    filename="<sampled>",
+                    lineno=0,
+                    start_time=0.0,
+                    end_time=dur,
+                    depth=depth_map[name],
+                    parent_name=parent_map[name],
+                )
+            )
+        return records

runmap/tracer.py

@@ -0,0 +1,82 @@
+from __future__ import annotations
+
+import sys
+import threading
+from time import perf_counter
+from types import FrameType
+from typing import Any
+
+from runmap.models import TraceRecord
+
+# Modules whose frames we never want to record
+_SKIP_PREFIXES = ("runmap.", "importlib.", "_frozen_importlib")
+
+
+def _qualname(frame: FrameType) -> str:
+    code = frame.f_code
+    # f_qualname is available from Python 3.3 on the code object as co_qualname (3.11+)
+    # fall back to co_name for older 3.10
+    name = getattr(code, "co_qualname", None) or code.co_name
+    mod = frame.f_globals.get("__name__") or ""
+    return f"{mod}.{name}" if mod else name
+
+
+def _should_skip(frame: FrameType) -> bool:
+    mod = frame.f_globals.get("__name__") or ""
+    return any(mod.startswith(p) for p in _SKIP_PREFIXES)
+
+
+class Tracer:
+    """sys.settrace-based call interceptor, thread-safe via threading.local"""
+
+    def __init__(self) -> None:
+        self._local = threading.local()
+        self._records: list[TraceRecord] = []
+        self._lock = threading.Lock()
+
+    @property
+    def _stack(self) -> list[tuple[str, str, int, float]]:
+        if not hasattr(self._local, "stack"):
+            self._local.stack = []
+        return self._local.stack
+
+    def _hook(self, frame: FrameType, event: str, arg: Any) -> Any:
+        if _should_skip(frame):
+            return self._hook
+
+        if event == "call":
+            qn = _qualname(frame)
+            self._stack.append((qn, frame.f_code.co_filename, frame.f_lineno, perf_counter()))
+            return self._hook
+
+        if event == "return" and self._stack:
+            qn, filename, lineno, t0 = self._stack.pop()
+            depth = len(self._stack)
+            parent_name = self._stack[-1][0] if self._stack else None
+            record = TraceRecord(
+                qualname=qn,
+                filename=filename,
+                lineno=lineno,
+                start_time=t0,
+                end_time=perf_counter(),
+                depth=depth,
+                parent_name=parent_name,
+            )
+            with self._lock:
+                self._records.append(record)
+
+        return self._hook
+
+    def start(self) -> None:
+        self._local.stack = []
+        sys.settrace(self._hook)
+        threading.settrace(self._hook)
+
+    def stop(self) -> None:
+        sys.settrace(None)
+        threading.settrace(None)
+
+    @property
+    def records(self) -> list[TraceRecord]:
+        with self._lock:
+            return list(self._records)

runmap/tree.py

@@ -0,0 +1,93 @@
+from __future__ import annotations
+
+from collections import defaultdict
+
+from runmap.models import CallNode, TraceRecord
+
+
+def build(records: list[TraceRecord]) -> CallNode:
+    """
+    Convert a flat list of TraceRecord into a CallNode tree
+
+    Returns a synthetic <root> node whose children are the top-level calls
+    """
+    if not records:
+        return CallNode(qualname="<root>", total_ms=0.0, self_ms=0.0, call_count=0)
+
+    # Group records by qualname to detect recursion and merge call counts
+    # We'll reconstruct the tree by walking records in emission order (deepest first,
+    # since "return" events fire innermost first)
+
+    # Build a working set of nodes keyed by qualname
+    node_map: dict[str, CallNode] = {}
+    children_of: dict[str | None, list[str]] = defaultdict(list)
+
+    # Track which qualnames appear as ancestors of a given call (for recursion detection)
+    # We process records sorted by depth descending so children are handled before parents
+    sorted_records = sorted(records, key=lambda r: r.depth, reverse=True)
+
+    for rec in sorted_records:
+        duration_ms = (rec.end_time - rec.start_time) * 1000
+
+        if rec.qualname not in node_map:
+            node_map[rec.qualname] = CallNode(
+                qualname=rec.qualname,
+                total_ms=0.0,
+                self_ms=0.0,
+                call_count=0,
+            )
+        node = node_map[rec.qualname]
+        node.total_ms += duration_ms
+        node.call_count += 1
+
+        # Skip recursive frames: if this qualname already appears as its own ancestor
+        # in the same call chain, don't register a child edge again
+        if rec.parent_name != rec.qualname:
+            key = (rec.parent_name, rec.qualname)
+            if rec.qualname not in children_of[rec.parent_name]:
+                children_of[rec.parent_name].append(rec.qualname)
+
+    # Only count edges where the parent is a real node (not None)
+    all_children: set[str] = set()
+    for parent_name, child_names in children_of.items():
+        if parent_name is not None:
+            all_children.update(child_names)
+
+    # Compute self_ms for every node: total_ms minus the sum of direct children
+    # This covers both interior nodes (whose children appear in children_of)
+    # and leaf nodes (which never appear as a parent key)
+    for qn, node in node_map.items():
+        child_names = children_of.get(qn, [])
+        children_total = sum(node_map[c].total_ms for c in child_names if c in node_map)
+        node.self_ms = max(0.0, node.total_ms - children_total)
+
+    # Wire up children lists and sort by total_ms descending
+    for qn, node in node_map.items():
+        child_names = children_of.get(qn, [])
+        node.children = sorted(
+            [node_map[c] for c in child_names if c in node_map],
+            key=lambda n: n.total_ms,
+            reverse=True,
+        )
+
+    root_children = sorted(
+        [node_map[qn] for qn in node_map if qn not in all_children],
+        key=lambda n: n.total_ms,
+        reverse=True,
+    )
+    root_total = sum(n.total_ms for n in root_children)
+
+    # Mark hot nodes: self_ms > 20% of wall-clock time (root total)
+    hot_threshold = root_total * 0.20
+    for node in node_map.values():
+        node.is_hot = node.self_ms > hot_threshold
+
+    # Build root
+    root = CallNode(
+        qualname="<root>",
+        total_ms=root_total,
+        self_ms=0.0,
+        call_count=1,
+        children=root_children,
+    )
+    return root

runmap-0.1.0.dist-info/METADATA

@@ -0,0 +1,68 @@
+Metadata-Version: 2.4
+Name: runmap
+Version: 0.1.0
+Summary: Python call tree profiler for the terminal
+Project-URL: Homepage, https://github.com/nazarhktwitch/runmap
+Project-URL: Repository, https://github.com/nazarhktwitch/runmap
+Project-URL: Issues, https://github.com/nazarhktwitch/runmap/issues
+Author: Nazar Burlai
+License-Expression: MIT
+License-File: LICENSE
+Keywords: call-tree,cli,performance,profiler,tracing
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Debuggers
+Classifier: Topic :: Software Development :: Testing
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: rich>=13.0
+Provides-Extra: dev
+Requires-Dist: pytest; extra == 'dev'
+Requires-Dist: pytest-cov; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# runmap
+
+Visualize Python function call trees with timing in the terminal
+
+Run any script through runmap and see a tree of every function call, how long
+each took, and where the hot spots are
+
+## Getting Started
+
+```bash
+pip install runmap
+```
+
+```bash
+python -m runmap script.py
+python -m runmap script.py --min-ms 5 --depth 3
+python -m runmap script.py --out run.trace
+python -m runmap diff before.trace after.trace
+```
+
+## Features
+
+- Call tree view: shows the full function call hierarchy with per-node timing.
+- Time bars: proportional block bars next to each node for quick visual scanning.
+- Hot markers: flags functions whose self time exceeds 20% of total runtime.
+- Depth and threshold filters: `--depth` and `--min-ms` trim noise from large trees.
+- Trace files: `--out` saves a `.trace` JSON file for later comparison.
+- Diff mode: `runmap diff A.trace B.trace` shows a delta table (faster/slower/new).
+- Sampling mode: `--sample` uses signal-based 100 Hz sampling instead of `sys.settrace` (Unix only).
+
+## Requirements
+
+- Python 3.10+
+- [rich](https://github.com/Textualize/rich) >= 13.0
+
+## License
+
+[MIT](LICENSE)

runmap-0.1.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+runmap/__init__.py,sha256=kUR5RAFc7HCeiqdlX36dZOHkUI5wI6V_43RpEcD8b-0,22
+runmap/__main__.py,sha256=rocVo9JTvM0B749nCk0fzjO9gmiU_Q_T-wTJKMWqzcc,4841
+runmap/diff.py,sha256=rW70H-p6UQCQZkRumu8-RxFRRQCIAKU5bsIXjsQs0oE,2529
+runmap/exporter.py,sha256=lN30osAzf1KW-0I0d_VXDKBuwd8QvNelXc64QXlAVYs,1201
+runmap/models.py,sha256=6L_m1CfDEethflyFVdoPSlHEI_syhA3gyXU48eGPXKY,655
+runmap/renderer.py,sha256=s4s9wKc_1dEvK5Xy0g6e55bZdMv0NLJFgxD2BjjBja0,2456
+runmap/sampler.py,sha256=eUDuLvoJYAmx8jJqMq-0WhbYlyBN63LKpa60QLsA5FA,3210
+runmap/tracer.py,sha256=cJleQs3vF13e9RLYdGf4NjouTTUfCXAtZwfno4BbMA4,2499
+runmap/tree.py,sha256=DYTwRI27d3uX4gnkFpVpDHmF3QmdQrLuVmLkJ0djKBM,3474
+runmap-0.1.0.dist-info/METADATA,sha256=heM9637Koe1HGgeuMGMXLz0OD0uhc6MFdZs8cKv_qIc,2301
+runmap-0.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+runmap-0.1.0.dist-info/entry_points.txt,sha256=6tpDJla0y9OkDIoBPVYTeV6HWNeIVnu_O3fh6-OI0n8,48
+runmap-0.1.0.dist-info/licenses/LICENSE,sha256=pxXvJ1lzC3MwZwvnczIgMQ9vr9Z0U39h4D9piEJp8VY,1064
+runmap-0.1.0.dist-info/RECORD,,

runmap-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any

runmap-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+runmap = runmap.__main__:main

runmap-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 NazarHK
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.