scope-profiler 0.3.0__tar.gz → 0.3.2__tar.gz

{scope_profiler-0.3.0 → scope_profiler-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scope-profiler
-Version: 0.3.0
+Version: 0.3.2
 Summary: Profile code regions in python, optionally with LIKWID markers.
 Author: Max
 Project-URL: Source, https://github.com/max-models/scope-profiler
@@ -29,18 +29,20 @@ Provides-Extra: mcp
 Requires-Dist: mcp<2.0.0,>=1.6.0; extra == "mcp"
 Provides-Extra: mpi
 Requires-Dist: mpi4py; extra == "mpi"
-Provides-Extra: plot
-Requires-Dist: ipykernel; extra == "plot"
-Requires-Dist: jupyterlab; extra == "plot"
-Requires-Dist: matplotlib; extra == "plot"
-Requires-Dist: maxplotlibx>=0.1.6; extra == "plot"
-Requires-Dist: pandas; extra == "plot"
-Requires-Dist: snakeviz; extra == "plot"
+Provides-Extra: pproc
+Requires-Dist: ipykernel; extra == "pproc"
+Requires-Dist: jupyterlab; extra == "pproc"
+Requires-Dist: matplotlib; extra == "pproc"
+Requires-Dist: maxplotlibx>=0.1.6; extra == "pproc"
+Requires-Dist: pandas; extra == "pproc"
+Requires-Dist: snakeviz; extra == "pproc"
+Requires-Dist: tabulate; extra == "pproc"
+Requires-Dist: textual>=0.86; extra == "pproc"
 Provides-Extra: dev
 Requires-Dist: black[jupyter]; extra == "dev"
 Requires-Dist: isort; extra == "dev"
 Requires-Dist: ruff; extra == "dev"
-Requires-Dist: scope-profiler[docs,fortran,line-profiler,mcp,mpi,nvtx,plot,test]; extra == "dev"
+Requires-Dist: scope-profiler[docs,fortran,line-profiler,mcp,mpi,nvtx,pproc,test,tui]; extra == "dev"
 Provides-Extra: docs
 Requires-Dist: myst-parser; extra == "docs"
 Requires-Dist: nbconvert; extra == "docs"
@@ -49,10 +51,13 @@ Requires-Dist: pre-commit; extra == "docs"
 Requires-Dist: pyproject-fmt; extra == "docs"
 Requires-Dist: sphinx; extra == "docs"
 Requires-Dist: sphinx-book-theme; extra == "docs"
-Requires-Dist: scope-profiler[line-profiler,plot]; extra == "docs"
+Requires-Dist: scope-profiler[line-profiler,pproc,tui]; extra == "docs"
 Provides-Extra: test
 Requires-Dist: coverage; extra == "test"
 Requires-Dist: pytest; extra == "test"
+Provides-Extra: tui
+Requires-Dist: tabulate; extra == "tui"
+Requires-Dist: textual>=0.86; extra == "tui"
 
 # scope-profiler
 
@@ -110,11 +115,11 @@ Execution:
 ```bash
 ❯ python test.py
 profiling_data.h5  (1 rank(s))
-  region     ranks  calls    total [s]      avg [s]      min [s]      max [s]      std [s]
-  ----------------------------------------------------------------------------------------
-  main           1      1   0.00150371   0.00150371   0.00150371   0.00150371            0
-  iteration      1     10    3.832e-06    3.832e-07     2.08e-07     8.75e-07  2.24319e-07
-  ----------------------------------------------------------------------------------------
+  region     ranks  calls    total [s]      avg [s]
+  --------------------------------------------------
+  main           1      1   0.00150371   0.00150371
+  iteration      1     10    3.832e-06    3.832e-07
+  --------------------------------------------------
   TOTAL                11   0.00150754
 
 ```
@@ -158,13 +163,13 @@ Metadata
     python/3.11.7
 
 Regions (4)
-  region    ranks  calls  total [s]    avg [s]     min [s]    max [s]      std [s]
-  --------------------------------------------------------------------------------
-  timestep      2      8   0.139235  0.0174044   0.0165256  0.0176325  0.000338551
-  solve         2      8  0.0991292  0.0123911   0.0115046  0.0125382  0.000335212
-  setup         2      2  0.0473326  0.0236663   0.0222938  0.0250388   0.00137254
-  assemble      2      8  0.0399496  0.0049937  0.00484729  0.0050345   5.5882e-05
-  --------------------------------------------------------------------------------
+  region    ranks  calls  total [s]    avg [s]
+  ---------------------------------------------
+  timestep      2      8   0.139235  0.0174044
+  solve         2      8  0.0991292  0.0123911
+  setup         2      2  0.0473326  0.0236663
+  assemble      2      8  0.0399496  0.0049937
+  ---------------------------------------------
   TOTAL               26   0.325647
 ```
 
@@ -314,7 +319,8 @@ script's own code is instrumented (the standard library and installed
 packages are skipped) to keep overhead low; pass `--all` to trace
 everything. Results are written to `profiling_data.h5` by default
 (`-o`/`--outfile` to change it), and a per-region summary is printed unless
-`-q`/`--quiet` is given.
+`-q`/`--quiet` is given. Pass `--line-profile` to also persist line-by-line
+timings for the traced functions; this requires `scope-profiler[line-profiler]`.
 
 See `examples/ex_cli_profiling.py` for a script with no scope-profiler
 imports at all, run with:

{scope_profiler-0.3.0 → scope_profiler-0.3.2}/README.md

@@ -54,11 +54,11 @@ Execution:
 ```bash
 ❯ python test.py
 profiling_data.h5  (1 rank(s))
-  region     ranks  calls    total [s]      avg [s]      min [s]      max [s]      std [s]
-  ----------------------------------------------------------------------------------------
-  main           1      1   0.00150371   0.00150371   0.00150371   0.00150371            0
-  iteration      1     10    3.832e-06    3.832e-07     2.08e-07     8.75e-07  2.24319e-07
-  ----------------------------------------------------------------------------------------
+  region     ranks  calls    total [s]      avg [s]
+  --------------------------------------------------
+  main           1      1   0.00150371   0.00150371
+  iteration      1     10    3.832e-06    3.832e-07
+  --------------------------------------------------
   TOTAL                11   0.00150754
 
 ```
@@ -102,13 +102,13 @@ Metadata
     python/3.11.7
 
 Regions (4)
-  region    ranks  calls  total [s]    avg [s]     min [s]    max [s]      std [s]
-  --------------------------------------------------------------------------------
-  timestep      2      8   0.139235  0.0174044   0.0165256  0.0176325  0.000338551
-  solve         2      8  0.0991292  0.0123911   0.0115046  0.0125382  0.000335212
-  setup         2      2  0.0473326  0.0236663   0.0222938  0.0250388   0.00137254
-  assemble      2      8  0.0399496  0.0049937  0.00484729  0.0050345   5.5882e-05
-  --------------------------------------------------------------------------------
+  region    ranks  calls  total [s]    avg [s]
+  ---------------------------------------------
+  timestep      2      8   0.139235  0.0174044
+  solve         2      8  0.0991292  0.0123911
+  setup         2      2  0.0473326  0.0236663
+  assemble      2      8  0.0399496  0.0049937
+  ---------------------------------------------
   TOTAL               26   0.325647
 ```
 
@@ -258,7 +258,8 @@ script's own code is instrumented (the standard library and installed
 packages are skipped) to keep overhead low; pass `--all` to trace
 everything. Results are written to `profiling_data.h5` by default
 (`-o`/`--outfile` to change it), and a per-region summary is printed unless
-`-q`/`--quiet` is given.
+`-q`/`--quiet` is given. Pass `--line-profile` to also persist line-by-line
+timings for the traced functions; this requires `scope-profiler[line-profiler]`.
 
 See `examples/ex_cli_profiling.py` for a script with no scope-profiler
 imports at all, run with:

{scope_profiler-0.3.0 → scope_profiler-0.3.2}/pyproject.toml

@@ -5,7 +5,7 @@ requires = [ "setuptools", "wheel" ]
 
 [project]
 name = "scope-profiler"
-version = "0.3.0"
+version = "0.3.2"
 description = "Profile code regions in python, optionally with LIKWID markers."
 readme = "README.md"
 keywords = [ "python" ]
@@ -53,20 +53,22 @@ optional-dependencies.mpi = [
   "mpi4py",
 ]
 
-optional-dependencies.plot = [
+optional-dependencies.pproc = [
   "ipykernel",
   "jupyterlab",
   "matplotlib",
   "maxplotlibx >= 0.1.6",
   "pandas",
   "snakeviz",
+  "tabulate",
+  "textual>=0.86",
 ]
 
 optional-dependencies.dev = [
   "black[jupyter]",
   "isort",
   "ruff",
-  "scope-profiler[docs,fortran,line-profiler,mcp,mpi,nvtx,plot,test]",
+  "scope-profiler[docs,fortran,line-profiler,mcp,mpi,nvtx,pproc,test,tui]",
 ]
 # https://medium.com/@pratikdomadiya123/build-project-documentation-quickly-with-the-sphinx-python-2a9732b66594
 optional-dependencies.docs = [
@@ -77,12 +79,17 @@ optional-dependencies.docs = [
   "pyproject-fmt",
   "sphinx",
   "sphinx-book-theme",
-  "scope-profiler[line-profiler,plot]",
+  "scope-profiler[line-profiler,pproc,tui]",
 ]
 optional-dependencies.test = [
   "coverage",
   "pytest",
 ]
+
+optional-dependencies.tui = [
+  "tabulate",
+  "textual>=0.86",
+]
 urls."Source" = "https://github.com/max-models/scope-profiler"
 
 scripts.scope-profiler = "scope_profiler.__main__:main"

{scope_profiler-0.3.0 → scope_profiler-0.3.2}/src/scope_profiler/__main__.py

@@ -18,6 +18,11 @@ Six subcommands:
   per-region statistics table (including LIKWID hardware counters, when the
   run recorded any) for merged HDF5 profiling output, without producing any
   plots. See ``scope_profiler.inspection``.
+- ``scope-profiler tui file.h5`` -- opens an interactive Textual browser for
+  metadata, region statistics, per-rank calls, LIKWID counters and the raw
+  HDF5 tree.
+- ``scope-profiler line-profile file.h5 [...]`` -- prints persisted
+  line-profiler timings from an HDF5 profile.
 - ``scope-profiler diff a.h5 b.h5`` -- compares region statistics between two
   merged HDF5 profiling files, region by region, so a regression (or
   improvement) between two runs shows up in one table. See
@@ -62,6 +67,12 @@ def _parse_run_args(argv):
         help="Also instrument standard-library and installed-package calls "
         "(default: only the script's own code)",
     )
+    parser.add_argument(
+        "--line-profile",
+        action="store_true",
+        help="Also collect line-by-line timings via line_profiler "
+        "(requires scope-profiler[line-profiler])",
+    )
     parser.add_argument(
         "--buffer-limit",
         type=int,
@@ -91,7 +102,7 @@ def _run(argv):
     ProfileManager.setup(
         recursive_profile=True,
         use_likwid=False,
-        use_line_profiler=False,
+        use_line_profiler=args.line_profile,
         buffer_limit=args.buffer_limit,
         file_path=args.outfile,
     )
@@ -127,6 +138,20 @@ def _inspect(argv):
     return inspect_main(argv)
 
 
+def _tui(argv):
+    """Handle ``scope-profiler tui``: open the interactive HDF5 browser."""
+    from scope_profiler.tui import main as tui_main
+
+    return tui_main(argv)
+
+
+def _line_profile(argv):
+    """Handle ``scope-profiler line-profile``."""
+    from scope_profiler.line_profile_cli import main as line_profile_main
+
+    return line_profile_main(argv)
+
+
 def _diff(argv):
     """Handle ``scope-profiler diff``: delegate to the diff CLI."""
     from scope_profiler.diff import main as diff_main
@@ -213,6 +238,8 @@ _COMMANDS = {
     "plot": _plot,
     "export": _export,
     "inspect": _inspect,
+    "tui": _tui,
+    "line-profile": _line_profile,
     "diff": _diff,
     "check": _check,
     "import-native": _import_fortran,
@@ -256,6 +283,18 @@ def main(argv=None):
         help="Print metadata and region statistics of HDF5 profiling data "
         "(see `scope-profiler inspect --help`)",
     )
+    subparsers.add_parser(
+        "tui",
+        add_help=False,
+        help="Interactively browse HDF5 profiling data "
+        "(see `scope-profiler tui --help`)",
+    )
+    subparsers.add_parser(
+        "line-profile",
+        add_help=False,
+        help="Print persisted line-profiler timings from HDF5 data "
+        "(see `scope-profiler line-profile --help`)",
+    )
     subparsers.add_parser(
         "diff",
         add_help=False,

{scope_profiler-0.3.0 → scope_profiler-0.3.2}/src/scope_profiler/h5reader.py

@@ -66,6 +66,26 @@ def _read_likwid_group(group) -> dict:
     return results
 
 
+def _read_line_profile_group(group) -> list:
+    """Read one rank's persisted line-profiler records."""
+    records = []
+    for function_grp in group.values():
+        attrs = function_grp.attrs
+        records.append(
+            {
+                "region": _decode_attribute(attrs.get("region", "")),
+                "filename": _decode_attribute(attrs.get("filename", "")),
+                "function": _decode_attribute(attrs.get("function", "")),
+                "first_lineno": int(attrs.get("first_lineno", 0)),
+                "line_numbers": function_grp["line_numbers"][()],
+                "hits": function_grp["hits"][()],
+                "times": function_grp["times"][()],
+                "unit": float(attrs.get("unit", 1.0)),
+            }
+        )
+    return records
+
+
 def load_h5(file_path: str | Path, verbose: bool = False) -> dict:
     """
     Parse a merged profiling file into :class:`ProfilingResults` arguments.
@@ -98,6 +118,7 @@ def load_h5(file_path: str | Path, verbose: bool = False) -> dict:
     metadata: dict = {}
     # rank -> {tag: LikwidRegionResult}; empty unless the run used LIKWID.
     likwid: dict[int, dict[str, LikwidRegionResult]] = {}
+    line_profile: dict[int, list] = {}
     if not file_path.exists():
         raise FileNotFoundError(f"HDF5 file not found: {file_path}")
 
@@ -130,6 +151,10 @@ def load_h5(file_path: str | Path, verbose: bool = False) -> dict:
 
             if LIKWID_GROUP in rank_group:
                 likwid[rank] = _read_likwid_group(rank_group[LIKWID_GROUP])
+            if "line_profile" in rank_group:
+                line_profile[rank] = _read_line_profile_group(
+                    rank_group["line_profile"]
+                )
 
             if "regions" not in rank_group:
                 continue
@@ -176,6 +201,7 @@ def load_h5(file_path: str | Path, verbose: bool = False) -> dict:
         "metadata": metadata,
         "num_ranks": num_ranks,
         "likwid": likwid,
+        "line_profile": line_profile,
         "file_path": file_path,
     }
 

{scope_profiler-0.3.0 → scope_profiler-0.3.2}/src/scope_profiler/h5writer.py

@@ -91,6 +91,22 @@ def write_regions(
             region_grp.attrs.create("tags", list(tags[name]), dtype=h5py.string_dtype())
 
 
+def write_line_profile(group, records: list | None) -> None:
+    """Write copied line-profiler records for one rank."""
+    if not records:
+        return
+    profile_grp = group.create_group("line_profile")
+    for index, record in enumerate(records):
+        function_grp = profile_grp.create_group(str(index))
+        for key in ("region", "filename", "function"):
+            function_grp.attrs[key] = record[key]
+        function_grp.attrs["first_lineno"] = record["first_lineno"]
+        function_grp.attrs["unit"] = record["unit"]
+        function_grp.create_dataset("line_numbers", data=record["line_numbers"])
+        function_grp.create_dataset("hits", data=record["hits"])
+        function_grp.create_dataset("times", data=record["times"])
+
+
 def write_rank_payload(h5file, rank: int, payload) -> bool:
     """Write one rank's payload into ``rank<N>``.
 
@@ -111,7 +127,7 @@ def write_rank_payload(h5file, rank: int, payload) -> bool:
     bool
         True if a group was created, False if the payload was empty.
     """
-    if not payload.regions and not payload.likwid:
+    if not payload.regions and not payload.likwid and not payload.line_profile:
         return False
 
     # create_group, not require_group: each rank is written exactly once, so a
@@ -125,6 +141,7 @@ def write_rank_payload(h5file, rank: int, payload) -> bool:
             payload.likwid.values(),
             environment=payload.likwid_environment,
         )
+    write_line_profile(group, payload.line_profile)
     return True
 
 

{scope_profiler-0.3.0 → scope_profiler-0.3.2}/src/scope_profiler/inspection.py

@@ -18,6 +18,7 @@ import numpy as np
 from scope_profiler.h5reader import read_h5
 from scope_profiler.results import ProfilingResults
 from scope_profiler.summary import (
+    REGION_TABLE_COLUMNS,
     SORT_KEYS,
     print_likwid_tables,
     print_region_table,
@@ -171,6 +172,7 @@ def inspect_file(
     show_regions: bool = True,
     full: bool = False,
     source: list | None = None,
+    columns=None,
     stream=None,
 ) -> None:
     """Print a summary of one profiling HDF5 file.
@@ -195,6 +197,9 @@ def inspect_file(
         block or decorated function that defines each region -- see
         ``ProfileManager.profile_region`` and issue #161). Printed after the
         region table, regardless of ``include``/``exclude``.
+    columns : list of str or str, optional
+        Region summary columns to print. Defaults to ``region``, ``ranks``,
+        ``calls``, ``total`` and ``avg``.
     stream : file-like, optional
         Where to write (default: stdout).
     """
@@ -233,6 +238,7 @@ def inspect_file(
             title=f"Regions ({len(rows)})",
             stream=stream,
             total_time=results.total_time,
+            columns=columns,
         )
         print_likwid_tables(
             results, include=include, exclude=exclude, ranks=ranks, stream=stream
@@ -357,6 +363,12 @@ def build_parser() -> argparse.ArgumentParser:
         default="total",
         help="Order regions by this column (default: total)",
     )
+    parser.add_argument(
+        "--columns",
+        nargs="+",
+        choices=REGION_TABLE_COLUMNS,
+        help="Region table columns to print (default: region ranks calls total avg)",
+    )
     parser.add_argument(
         "--full",
         action="store_true",
@@ -424,6 +436,7 @@ def main(argv: list | None = None):
             show_regions=not args.metadata_only,
             full=args.full,
             source=args.source,
+            columns=args.columns,
         )
         printed += 1
 

scope_profiler-0.3.2/src/scope_profiler/line_profile_cli.py

@@ -0,0 +1,78 @@
+"""CLI for displaying line-profiler records persisted in HDF5 files."""
+
+import argparse
+import linecache
+import re
+import sys
+
+from scope_profiler.h5reader import read_h5
+
+
+def print_line_profile(file_path, ranks=None, function=None, region=None, stream=None):
+    """Print persisted line-profiler timings from one HDF5 profile."""
+    stream = sys.stdout if stream is None else stream
+    results = read_h5(file_path)
+    selected_ranks = results.line_profile.keys() if ranks is None else ranks
+    function_re = re.compile(function) if function else None
+    region_re = re.compile(region) if region else None
+    record_count = 0
+
+    print(f"Line profile: {results.file_path}", file=stream)
+    for rank in sorted(selected_ranks):
+        for record in results.line_profile.get(rank, []):
+            if function_re and not function_re.search(record["function"]):
+                continue
+            if region_re and not region_re.search(record["region"]):
+                continue
+            record_count += 1
+            unit = record["unit"]
+            print(
+                f"\nRank {rank} | {record['region']} | {record['function']} "
+                f"({record['filename']}:{record['first_lineno']})",
+                file=stream,
+            )
+            total_time = float(record["times"].sum())
+            print(
+                "line        hits       time [s]   per hit [s]  % time  source",
+                file=stream,
+            )
+            for line, hits, elapsed in zip(
+                record["line_numbers"], record["hits"], record["times"]
+            ):
+                seconds = float(elapsed) * unit
+                per_hit = seconds / int(hits) if hits else 0.0
+                percent = float(elapsed) / total_time * 100 if total_time else 0.0
+                source = linecache.getline(record["filename"], int(line)).rstrip()
+                print(
+                    f"{int(line):4d} {int(hits):11d} {seconds:14.6g} "
+                    f"{per_hit:14.6g} {percent:7.2f}  {source}",
+                    file=stream,
+                )
+
+    if record_count == 0:
+        print("\nNo line-profile records matched.", file=stream)
+
+
+def main(argv=None):
+    """Handle ``scope-profiler line-profile``."""
+    parser = argparse.ArgumentParser(
+        prog="scope-profiler line-profile",
+        description="Print persisted line-profiler timings from an HDF5 profile.",
+    )
+    parser.add_argument("file", help="HDF5 profiling file")
+    parser.add_argument(
+        "--rank",
+        type=int,
+        action="append",
+        dest="ranks",
+        help="rank to show (repeatable)",
+    )
+    parser.add_argument(
+        "--function", help="regular expression selecting function names"
+    )
+    parser.add_argument("--region", help="regular expression selecting region names")
+    args = parser.parse_args(argv)
+    print_line_profile(
+        args.file, ranks=args.ranks, function=args.function, region=args.region
+    )
+    return 0

{scope_profiler-0.3.0 → scope_profiler-0.3.2}/src/scope_profiler/plotting_scripts.py

@@ -154,12 +154,16 @@ def _render(
     show: bool,
     backend: str,
     plotly_layout: dict | None = None,
+    x_tick_rotation: float | None = None,
 ) -> None:
     """Save and/or display a canvas."""
     if backend == "plotly":
         fig = canvas.plot_plotly(show=False)
-        if plotly_layout:
-            fig.update_layout(**plotly_layout)
+        layout = dict(plotly_layout or {})
+        if x_tick_rotation is not None:
+            layout["xaxis_tickangle"] = x_tick_rotation
+        if layout:
+            fig.update_layout(**layout)
         if filepath:
             if Path(filepath).suffix.lower() in {".html", ".htm"}:
                 fig.write_html(filepath)
@@ -176,6 +180,30 @@ def _render(
             fig.show()
         return
 
+    if x_tick_rotation is not None and backend == "matplotlib":
+        # maxplotlib does not currently expose tick-label rotation through
+        # its backend-neutral Canvas API, so rotate the labels after the
+        # Matplotlib figure has been materialized and before saving/showing.
+        fig, axes = canvas.plot(backend="matplotlib", savefig=bool(filepath))
+        for axis in np.asarray(axes).reshape(-1):
+            for label in axis.get_xticklabels():
+                label.set_rotation(x_tick_rotation)
+                # Anchor the end of each vertical label at the tick so the
+                # text grows upward into the figure instead of below it.
+                label.set_ha("right")
+        if filepath:
+            savefig_kwargs = {}
+            if getattr(canvas, "dpi", None) is not None:
+                savefig_kwargs["dpi"] = canvas.dpi
+            fig.savefig(filepath, **savefig_kwargs)
+        if show:
+            import matplotlib.pyplot as plt
+
+            plt.show()
+        else:
+            _close_matplotlib_figure(canvas)
+        return
+
     if filepath:
         canvas.savefig(filepath, backend=backend)
     if show:
@@ -1129,7 +1157,13 @@ def plot_durations(
     num_readers = len(runs)
     colors = _get_cmap_colors(cmap, max(num_readers, 1))
     fig_width = max(10, 0.85 * len(region_names) + 2)
-    fig_height = max(4.5, 2.5 + 0.35 * num_readers)
+    # Angled tick labels consume space below the axes in proportion to the
+    # longest region name. Grow both the figure and its bottom margin so long
+    # labels remain inside the exported figure without reserving excessive
+    # space for short names.
+    label_space = max(0.8, 0.06 * max(map(len, region_names), default=0) + 0.25)
+    fig_height = max(4.5, 2.5 + 0.35 * num_readers, 3.0 + label_space)
+    bottom_margin = (label_space + 0.25) / fig_height
     width = min(0.8 / max(num_readers, 1), 0.35)
 
     saved_paths: list[str] = []
@@ -1153,7 +1187,10 @@ def plot_durations(
                 for region_name, value in zip(region_names, file_values):
                     data_rows.append([label, region_name, metric_key, value])
 
-        canvas = Canvas(figsize=(fig_width, fig_height))
+        canvas = Canvas(
+            figsize=(fig_width, fig_height),
+            gridspec_kw={"bottom": bottom_margin},
+        )
 
         # Create grouped bar chart
         x_positions = np.arange(len(region_names))
@@ -1187,7 +1224,13 @@ def plot_durations(
             )
             saved_paths.append(metric_filepath)
 
-        _render(canvas, metric_filepath, show, backend)
+        _render(
+            canvas,
+            metric_filepath,
+            show,
+            backend,
+            x_tick_rotation=45,
+        )
 
     if data_filepath:
         if data_format == "json":

{scope_profiler-0.3.0 → scope_profiler-0.3.2}/src/scope_profiler/post_processing.py

@@ -3,6 +3,7 @@
 import argparse
 import glob
 import os
+import sys
 from dataclasses import dataclass
 from pathlib import Path
 
@@ -28,10 +29,10 @@ from scope_profiler.speedscope_export import export_speedscope
 # so the three can never drift out of sync.
 _PLOT_CATALOG: dict[str, tuple[str, bool]] = {
     "gantt": ("per-rank timeline of every call", True),
-    "flame": ("reconstructed call-stack flame graph", True),
+    "flame": ("reconstructed call-stack flame graph", False),
     "durations": ("bar chart of duration statistics per region", True),
-    "timeseries": ("duration per call over wall-clock time", True),
-    "speedup": ("scaling across multiple files (2+ files only)", True),
+    "timeseries": ("duration per call over wall-clock time", False),
+    "speedup": ("scaling across multiple files (2+ files only)", False),
     "histogram": ("call-duration distribution per region", False),
     "imbalance": ("per-rank duration comparison, to spot stragglers", False),
     "likwid": ("one LIKWID hardware-counter metric (needs --likwid-metric)", False),
@@ -799,7 +800,18 @@ def _render_selected_plots(
 def main(argv: list[str] | None = None):
     """Render one plot kind or plot preset from HDF5 profiling data."""
     parser = build_parser()
-    args = parser.parse_args(argv)
+    plot_argv = list(sys.argv[1:] if argv is None else argv)
+    # Keep the concise form ``scope-profiler plot FILE [OPTIONS]`` as an
+    # alias for the default preset. Explicit plot kinds continue to work as
+    # subcommands, e.g. ``scope-profiler plot gantt FILE``.
+    plot_kinds = {"list", "default", "all", "quick", *_PLOT_CATALOG}
+    if (
+        plot_argv
+        and not plot_argv[0].startswith("-")
+        and plot_argv[0] not in plot_kinds
+    ):
+        plot_argv.insert(0, "default")
+    args = parser.parse_args(plot_argv)
 
     if args.plot_kind == "list":
         _print_plot_list()