jsrc 0.2.2__tar.gz → 0.2.4__tar.gz

{jsrc-0.2.2/src/jsrc.egg-info → jsrc-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jsrc
-Version: 0.2.2
+Version: 0.2.4
 Summary: Python library for bioinformatics and scientific computing
 Author-email: Jiaoyuan <imjiaoyuan@gmail.com>
 License-Expression: MIT

{jsrc-0.2.2 → jsrc-0.2.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "jsrc"
-version = "0.2.2"
+version = "0.2.4"
 description = "Python library for bioinformatics and scientific computing"
 readme = "README.md"
 requires-python = ">=3.10"

jsrc-0.2.4/src/jsrc/analyze/__init__.py

@@ -0,0 +1,39 @@
+import importlib
+from typing import Any
+
+_SUBCOMMANDS: dict[str, tuple[str, str]] = {
+    "phylo": ("jsrc.analyze.phylo", "Build phylogenetic trees"),
+    "motif": ("jsrc.analyze.motif", "Motif discovery and reporting"),
+    "qc": ("jsrc.analyze.qc", "Alignment/sequence QC"),
+    "msa_consensus": ("jsrc.analyze.msa_consensus", "MSA consensus statistics"),
+    "snpindel": ("jsrc.analyze.snpindel", "SNP/INDEL analysis from alignments"),
+    "bootstrap_phylo": ("jsrc.analyze.bootstrap_phylo", "Bootstrap phylogeny support"),
+}
+
+
+def _register_stub_subcommands(subparsers: Any) -> None:
+    for name, (_, help_text) in _SUBCOMMANDS.items():
+        subparsers.add_parser(name, help=help_text)
+
+
+def _register_selected_subcommand(subparsers: Any, selected: str) -> bool:
+    module_path, _ = _SUBCOMMANDS.get(selected, ("", ""))
+    if not module_path:
+        return False
+    mod = importlib.import_module(module_path)
+    reg = getattr(mod, "register", None)
+    if reg is None:
+        raise AttributeError(f"{module_path}: missing register")
+    reg(subparsers)
+    return True
+
+
+def register_subparser(subparsers: Any, selected_subcommand: str | None = None) -> None:
+    analyze_parser = subparsers.add_parser("analyze", help="Analysis tools")
+    analyze_sub = analyze_parser.add_subparsers(dest="analyze_cmd")
+    analyze_parser.set_defaults(_group_parser=analyze_parser)
+    if selected_subcommand and _register_selected_subcommand(
+        analyze_sub, selected_subcommand
+    ):
+        return
+    _register_stub_subcommands(analyze_sub)

{jsrc-0.2.2 → jsrc-0.2.4}/src/jsrc/cli.py

@@ -1,5 +1,6 @@
 import argparse
 import importlib
+import inspect
 import logging
 import os
 import sys
@@ -24,6 +25,16 @@ MODULES = {
     "job": "jsrc.job",
 }
 
+MODULE_HELP = {
+    "seq": "Sequence tools",
+    "plot": "Visualization",
+    "analyze": "Analysis workflows",
+    "gs": "Genomic selection",
+    "grn": "GRN tools",
+    "vision": "Image analysis",
+    "job": "Background jobs",
+}
+
 
 def _iter_enabled_modules() -> list[str]:
     only = [x.strip() for x in os.getenv("JSRC_MODULES", "").split(",") if x.strip()]
@@ -34,31 +45,7 @@ def _iter_enabled_modules() -> list[str]:
     return [n for n in names if n in MODULES and n not in disabled]
 
 
-def _register_modules(
-    subparsers: argparse.Action, *, debug: bool = False
-) -> tuple[list[str], list[str]]:
-    loaded: list[str] = []
-    errors: list[str] = []
-    for name in _iter_enabled_modules():
-        try:
-            mod = importlib.import_module(MODULES[name])
-            reg = getattr(mod, "register_subparser", None)
-            if reg is None:
-                errors.append(f"{name}: missing register_subparser")
-                continue
-            reg(subparsers)
-            loaded.append(name)
-        except (ImportError, AttributeError) as exc:
-            if debug:
-                raise
-            errors.append(f"{name}: {exc}")
-    return loaded, errors
-
-
-def main() -> None:
-    debug_mode = "--debug" in sys.argv[1:]
-    verbose = "--verbose" in sys.argv[1:] or debug_mode
-    setup_logging(verbose=verbose)
+def _build_base_parser() -> argparse.ArgumentParser:
     parser = argparse.ArgumentParser(
         prog="jsrc", description="General-purpose bioinformatics and data toolkit"
     )
@@ -69,17 +56,76 @@ def main() -> None:
         action="store_true",
         help="Show traceback for module loading and runtime errors",
     )
-    subparsers = parser.add_subparsers(dest="command", help="Available modules")
+    return parser
+
+
+def _register_stub_modules(
+    subparsers: argparse.Action, enabled_modules: list[str]
+) -> None:
+    for name in enabled_modules:
+        subparsers.add_parser(name, help=MODULE_HELP.get(name, f"{name} module"))
 
-    loaded, errors = _register_modules(subparsers, debug=debug_mode)
-    if errors:
-        logging.warning("some modules failed to load:")
-        for item in errors:
-            logging.warning("  - %s", item)
-    if not loaded:
+
+def _register_one_module(
+    subparsers: argparse.Action,
+    module_name: str,
+    *,
+    selected_subcommand: str | None = None,
+    debug: bool = False,
+) -> bool:
+    try:
+        mod = importlib.import_module(MODULES[module_name])
+        reg = getattr(mod, "register_subparser", None)
+        if reg is None:
+            raise AttributeError("missing register_subparser")
+        params = inspect.signature(reg).parameters
+        if "selected_subcommand" in params:
+            reg(subparsers, selected_subcommand=selected_subcommand)
+        else:
+            reg(subparsers)
+        return True
+    except (ImportError, AttributeError) as exc:
+        if debug:
+            raise
+        logging.error("Error: failed to load module '%s': %s", module_name, exc)
+        return False
+
+
+def _probe_route(argv: list[str]) -> tuple[str | None, str | None]:
+    probe = argparse.ArgumentParser(add_help=False)
+    probe.add_argument("--verbose", action="store_true")
+    probe.add_argument("--debug", action="store_true")
+    probe.add_argument("-v", "--version", action="store_true")
+    probe.add_argument("command", nargs="?")
+    probe.add_argument("subcommand", nargs="?")
+    args, _ = probe.parse_known_args(argv)
+    return args.command, args.subcommand
+
+
+def main() -> None:
+    argv = sys.argv[1:]
+    debug_mode = "--debug" in argv
+    verbose = "--verbose" in argv or debug_mode
+    setup_logging(verbose=verbose)
+    enabled_modules = _iter_enabled_modules()
+    if not enabled_modules:
         logging.error("no module loaded")
         sys.exit(2)
 
+    requested_module, requested_subcommand = _probe_route(argv)
+    parser = _build_base_parser()
+    subparsers = parser.add_subparsers(dest="command", help="Available modules")
+    if requested_module and requested_module in enabled_modules:
+        if not _register_one_module(
+            subparsers,
+            requested_module,
+            selected_subcommand=requested_subcommand,
+            debug=debug_mode,
+        ):
+            sys.exit(2)
+    else:
+        _register_stub_modules(subparsers, enabled_modules)
+
     args = parser.parse_args()
     if not args.command:
         parser.print_help()

jsrc-0.2.4/src/jsrc/grn/__init__.py

@@ -0,0 +1,38 @@
+import importlib
+from typing import Any
+
+_SUBCOMMANDS: dict[str, tuple[str, str]] = {
+    "build": ("jsrc.grn.build", "Build GRN viewer package"),
+    "net2json": ("jsrc.grn.net2json", "Convert GRN edge table to grn.json"),
+    "anno2json": ("jsrc.grn.anno2json", "Convert annotation table to annotation.json"),
+    "serve": ("jsrc.grn.serve", "Start GRN viewer service"),
+    "centrality": ("jsrc.grn.centrality", "Compute GRN centrality metrics"),
+}
+
+
+def _register_stub_subcommands(subparsers: Any) -> None:
+    for name, (_, help_text) in _SUBCOMMANDS.items():
+        subparsers.add_parser(name, help=help_text)
+
+
+def _register_selected_subcommand(subparsers: Any, selected: str) -> bool:
+    module_path, _ = _SUBCOMMANDS.get(selected, ("", ""))
+    if not module_path:
+        return False
+    mod = importlib.import_module(module_path)
+    reg = getattr(mod, "register", None)
+    if reg is None:
+        raise AttributeError(f"{module_path}: missing register")
+    reg(subparsers)
+    return True
+
+
+def register_subparser(subparsers: Any, selected_subcommand: str | None = None) -> None:
+    grn_parser = subparsers.add_parser("grn", help="GRN conversion and local viewer")
+    grn_sub = grn_parser.add_subparsers(dest="grn_cmd")
+    grn_parser.set_defaults(_group_parser=grn_parser)
+    if selected_subcommand and _register_selected_subcommand(
+        grn_sub, selected_subcommand
+    ):
+        return
+    _register_stub_subcommands(grn_sub)

{jsrc-0.2.2 → jsrc-0.2.4}/src/jsrc/grn/anno2json.py

@@ -15,10 +15,10 @@ def annotation_to_json(input_path: str, output_path: str) -> dict[str, dict[str,
         for row in reader:
             if not row:
                 continue
-            gid = str(row[0]).replace("_", "-")
-            ptr = str(row[1]) if len(row) > 1 else ""
-            desc = str(row[2]) if len(row) > 2 else ""
-            anno[gid] = {"p": ptr, "d": desc}
+            gid = str(row[0])
+            desc = str(row[1]) if len(row) > 1 else ""
+            map_id = str(row[2]) if len(row) > 2 else ""
+            anno[gid] = {"p": map_id, "d": desc}
     write_json(output_path, anno)
     logger.info("Annotation JSON written: %s", output_path)
     return anno

{jsrc-0.2.2 → jsrc-0.2.4}/src/jsrc/grn/build.py

@@ -57,7 +57,7 @@ def _zip_viewer(viewer_dir: Path, zip_output: str) -> None:
 
 def cmd(args: Namespace) -> None:
     root = Path(args.dir).expanduser().resolve()
-    view_mode = "expand" if args.expand else "auto"
+    view_mode = "full" if args.all else "expand" if args.expand else "auto"
     _sync_assets(str(root), view_mode, args.threshold, args.max_nodes)
     if args.grn_json:
         shutil.copy(args.grn_json, root / "json" / "grn.json")

{jsrc-0.2.2 → jsrc-0.2.4}/src/jsrc/grn/net2json.py

@@ -17,8 +17,8 @@ def network_to_json(
         for row in reader:
             if len(row) < 3:
                 continue
-            source_id = str(row[0]).replace("_", "-")
-            target_id = str(row[1]).replace("_", "-")
+            source_id = str(row[0])
+            target_id = str(row[1])
             try:
                 weight = float(row[2])
             except ValueError:

{jsrc-0.2.2 → jsrc-0.2.4}/src/jsrc/grn/serve.py

@@ -10,7 +10,7 @@ from jsrc.grn.build import _sync_assets
 
 
 def cmd(args: Namespace) -> None:
-    view_mode = "expand" if args.expand else "auto"
+    view_mode = "full" if args.all else "expand" if args.expand else "auto"
     _sync_assets(args.dir, view_mode, args.threshold, 0)
     ensure_dir(f"{args.dir}/json")
     src_grn = os.path.abspath(args.grn_json)

{jsrc-0.2.2 → jsrc-0.2.4}/src/jsrc/grn/sources/script.js

@@ -229,7 +229,7 @@ function highlightNode(id) {
 function downloadListInfo() {
     if (!currentCenterId) return;
 
-    let content = "GeneID\tPotriID\tAnnotation\tRelation\tWeight\n";
+    let content = "GeneID\tMapID\tAnnotation\tRelation\tWeight\n";
 
     const centerInfo = annotations[currentCenterId] || { p: "", d: "" };
     content += `${currentCenterId}\t${centerInfo.p}\t${centerInfo.d.replace(/[\n\r]/g, " ")}\tCenter\t-\n`;
@@ -278,7 +278,7 @@ function updateInfoPanel() {
     header.innerHTML = `
         <div class="panel-title">${currentCenterId}</div>
         <div class="panel-desc">
-            <b>Ptr:</b> ${info.p || '-'}<br>
+            <b>MapID:</b> ${info.p || '-'}<br>
             ${info.d || '-'}
         </div>
         <div class="panel-stats">
@@ -308,7 +308,7 @@ function updateInfoPanel() {
                 <span class="item-val">w:${n.val}</span>
             </div>
             <div class="item-details" onclick="event.stopPropagation()">
-                <div class="detail-line"><span class="detail-label">Potri:</span> ${nInfo.p || '-'}</div>
+                <div class="detail-line"><span class="detail-label">MapID:</span> ${nInfo.p || '-'}</div>
                 <div class="detail-line"><span class="detail-label">Desc:</span> ${nInfo.d || '-'}</div>
             </div>
         `;

jsrc-0.2.4/src/jsrc/gs/__init__.py

@@ -0,0 +1,38 @@
+import importlib
+from typing import Any
+
+_SUBCOMMANDS: dict[str, tuple[str, str]] = {
+    "build": ("jsrc.gs.build", "Build genomic selection datasets"),
+    "split": ("jsrc.gs.split", "Split GS datasets into folds"),
+    "train": ("jsrc.gs.train", "Train and evaluate GS models"),
+}
+
+
+def _register_stub_subcommands(subparsers: Any) -> None:
+    for name, (_, help_text) in _SUBCOMMANDS.items():
+        subparsers.add_parser(name, help=help_text)
+
+
+def _register_selected_subcommand(subparsers: Any, selected: str) -> bool:
+    module_path, _ = _SUBCOMMANDS.get(selected, ("", ""))
+    if not module_path:
+        return False
+    mod = importlib.import_module(module_path)
+    reg = getattr(mod, "register", None)
+    if reg is None:
+        raise AttributeError(f"{module_path}: missing register")
+    reg(subparsers)
+    return True
+
+
+def register_subparser(subparsers: Any, selected_subcommand: str | None = None) -> None:
+    gs_parser = subparsers.add_parser(
+        "gs", help="Genomic selection dataset and model workflows"
+    )
+    gs_sub = gs_parser.add_subparsers(dest="gs_cmd")
+    gs_parser.set_defaults(_group_parser=gs_parser)
+    if selected_subcommand and _register_selected_subcommand(
+        gs_sub, selected_subcommand
+    ):
+        return
+    _register_stub_subcommands(gs_sub)

jsrc-0.2.4/src/jsrc/job/__init__.py

@@ -0,0 +1,39 @@
+import importlib
+from typing import Any
+
+_SUBCOMMANDS: dict[str, tuple[str, str]] = {
+    "submit": ("jsrc.job.submit", "Submit a background job"),
+    "ls": ("jsrc.job.ls", "List jobs"),
+    "logs": ("jsrc.job.logs", "Show job logs"),
+    "kill": ("jsrc.job.kill", "Terminate a running job"),
+    "history": ("jsrc.job.history", "Show job history"),
+    "gc": ("jsrc.job.gc", "Garbage-collect old job artifacts"),
+}
+
+
+def _register_stub_subcommands(subparsers: Any) -> None:
+    for name, (_, help_text) in _SUBCOMMANDS.items():
+        subparsers.add_parser(name, help=help_text)
+
+
+def _register_selected_subcommand(subparsers: Any, selected: str) -> bool:
+    module_path, _ = _SUBCOMMANDS.get(selected, ("", ""))
+    if not module_path:
+        return False
+    mod = importlib.import_module(module_path)
+    reg = getattr(mod, "register", None)
+    if reg is None:
+        raise AttributeError(f"{module_path}: missing register")
+    reg(subparsers)
+    return True
+
+
+def register_subparser(subparsers: Any, selected_subcommand: str | None = None) -> None:
+    job_parser = subparsers.add_parser("job", help="Track and manage background jobs")
+    job_sub = job_parser.add_subparsers(dest="job_cmd")
+    job_parser.set_defaults(_group_parser=job_parser)
+    if selected_subcommand and _register_selected_subcommand(
+        job_sub, selected_subcommand
+    ):
+        return
+    _register_stub_subcommands(job_sub)

{jsrc-0.2.2 → jsrc-0.2.4}/src/jsrc/job/core.py

@@ -17,7 +17,6 @@ _PLATFORM_NOTE_EMITTED = False
 
 FIELDS = [
     "job_id",
-    "name",
     "submit_time",
     "start_time",
     "end_time",
@@ -35,6 +34,8 @@ FIELDS = [
     "command",
 ]
 
+DEFAULT_KEEP = 100
+
 
 def now_iso() -> str:
     return datetime.now(timezone.utc).astimezone().isoformat(timespec="seconds")
@@ -54,6 +55,13 @@ def to_float(value: str, default: float = 0.0) -> float:
         return default
 
 
+def config_home() -> Path:
+    xdg = os.getenv("XDG_CONFIG_HOME")
+    if xdg:
+        return Path(xdg).expanduser() / "jsrc"
+    return Path.home() / ".config" / "jsrc"
+
+
 def data_home() -> Path:
     xdg = os.getenv("XDG_DATA_HOME")
     if xdg:
@@ -65,7 +73,7 @@ def history_path() -> Path:
     override = os.getenv("JSRC_JOBS_FILE", "")
     if override:
         return Path(override).expanduser()
-    return data_home() / "jobs"
+    return config_home() / "job" / "history"
 
 
 def default_log_dir() -> Path:
@@ -82,20 +90,35 @@ def ensure_dirs() -> None:
     state_dir().mkdir(parents=True, exist_ok=True)
 
 
+def _migrate_old_history() -> None:
+    old = data_home() / "jobs"
+    new = history_path()
+    if old.exists() and not new.exists():
+        new.parent.mkdir(parents=True, exist_ok=True)
+        old.rename(new)
+
+
 def load_jobs() -> list[dict[str, str]]:
+    _migrate_old_history()
     path = history_path()
     if not path.exists():
         return []
+    rows = []
     with path.open("r", encoding="utf-8", newline="") as fh:
         reader = csv.DictReader(fh, delimiter="\t")
-        rows = []
-        for row in reader:
-            rows.append({k: row.get(k, "") for k in FIELDS})
-        return rows
+        for i, row in enumerate(reader):
+            try:
+                rows.append({k: row.get(k, "") for k in FIELDS})
+            except Exception:
+                logger.warning("job history line %d: skipping malformed entry", i + 2)
+                continue
+    return rows
 
 
 def write_jobs(rows: list[dict[str, str]], keep: int | None = None) -> None:
-    if keep is not None and keep > 0 and len(rows) > keep:
+    if keep is None:
+        keep = DEFAULT_KEEP
+    if keep > 0 and len(rows) > keep:
         rows = rows[-keep:]
     path = history_path()
     with path.open("w", encoding="utf-8", newline="") as fh:
@@ -275,7 +298,11 @@ def to_row_view(row: dict[str, str], live: dict[str, str]) -> dict[str, str]:
     avg_kb = int(sum_kb / samples) if samples > 0 else rss_kb
     runtime_sec = runtime_seconds(row, live)
     out = dict(row)
-    out["rss_mb"] = f"{rss_kb / 1024:.1f}"
+    rss_mb_val = rss_kb / 1024
+    rss_display = f"{rss_mb_val:.1f}" if rss_mb_val < 1024 else f"{rss_mb_val / 1024:.1f}g"
+    out["rss_mb"] = rss_display
+    out["rss"] = rss_display
+    out["mem"] = rss_display
     out["rss_min_mb"] = f"{min_kb / 1024:.1f}"
     out["rss_avg_mb"] = f"{avg_kb / 1024:.1f}"
     out["rss_peak_mb"] = f"{peak_kb / 1024:.1f}"
@@ -285,6 +312,19 @@ def to_row_view(row: dict[str, str], live: dict[str, str]) -> dict[str, str]:
     out["runtime"] = format_duration(runtime_sec)
     out["cpu_pct"] = f"{to_float(live.get('pcpu', '0'), 0.0):.1f}"
     out["state"] = live.get("stat", "")
+    st = row.get("status", "")
+    out["s"] = {"running": "R", "exited": "E", "failed": "F", "killed": "K", "lost": "L"}.get(
+        st, st
+    )
+    submit = row.get("submit_time", "")
+    if submit:
+        try:
+            dt = datetime.fromisoformat(submit)
+            out["time"] = f"{dt.strftime('%Y-%m-%d %H:%M')} / {out.get('runtime', '')}"
+        except (TypeError, ValueError):
+            out["time"] = f"{submit} / {out.get('runtime', '')}"
+    else:
+        out["time"] = f" / {out.get('runtime', '')}"
     return out
 
 
@@ -360,18 +400,26 @@ def filter_rows(rows: list[dict[str, str]], query: str) -> list[dict[str, str]]:
 def sort_rows(
     rows: list[dict[str, str]], key: str, reverse: bool
 ) -> list[dict[str, str]]:
-    if key == "submit_time":
+    if key in {"submit_time", "time"}:
         return sorted(rows, key=lambda r: r.get("submit_time", ""), reverse=reverse)
     if key == "pid":
         return sorted(rows, key=lambda r: to_int(r.get("pid", "0")), reverse=reverse)
     if key == "job_id":
         return sorted(rows, key=lambda r: to_int(r.get("job_id", "0")), reverse=reverse)
-    if key == "status":
+    if key in {"status", "s"}:
         return sorted(rows, key=lambda r: r.get("status", ""), reverse=reverse)
     if key == "rss_mb":
         return sorted(
             rows, key=lambda r: to_float(r.get("rss_mb", "0"), 0.0), reverse=reverse
         )
+    if key == "rss":
+        return sorted(
+            rows, key=lambda r: to_int(r.get("rss_kb_last", "0"), 0), reverse=reverse
+        )
+    if key == "mem":
+        return sorted(
+            rows, key=lambda r: to_int(r.get("rss_kb_last", "0"), 0), reverse=reverse
+        )
     if key == "rss_min_mb":
         return sorted(
             rows, key=lambda r: to_float(r.get("rss_min_mb", "0"), 0.0), reverse=reverse
@@ -397,15 +445,15 @@ def print_table(rows: list[dict[str, str]], columns: list[str]) -> None:
     if not rows:
         print("(no records)")
         return
-    widths = {c: len(c) for c in columns}
+    widths = {c: len(c.upper()) for c in columns}
     for row in rows:
         for c in columns:
             widths[c] = max(widths[c], len(str(row.get(c, ""))))
-    header = "  ".join(c.ljust(widths[c]) for c in columns)
+    header = " ".join(c.upper().ljust(widths[c]) for c in columns)
     print(header)
-    print("  ".join("-" * widths[c] for c in columns))
+    print(" ".join("-" * widths[c] for c in columns))
     for row in rows:
-        print("  ".join(str(row.get(c, "")).ljust(widths[c]) for c in columns))
+        print(" ".join(str(row.get(c, "")).ljust(widths[c]) for c in columns))
 
 
 def print_rows(rows: list[dict[str, str]], columns: list[str], fmt: str) -> None:
@@ -466,7 +514,7 @@ def collect_render_rows(args: Any, refresh: bool) -> list[dict[str, str]]:
     if refresh:
         rows, changed = refresh_jobs(rows)
     if changed:
-        write_jobs(rows, keep=1000)
+        write_jobs(rows)
     rows = filter_rows(rows, args.query)
     rendered = []
     for row in rows:

{jsrc-0.2.2 → jsrc-0.2.4}/src/jsrc/job/gc.py

@@ -3,7 +3,7 @@ from argparse import Namespace
 from pathlib import Path
 from typing import Any
 
-from jsrc.job.core import load_jobs, now_iso, runtime_seconds, state_dir, write_jobs
+from jsrc.job.core import DEFAULT_KEEP, load_jobs, now_iso, runtime_seconds, state_dir, write_jobs
 
 logger = logging.getLogger(__name__)
 
@@ -40,7 +40,7 @@ def register(subparsers: Any) -> None:
         "-k",
         "--keep-history",
         type=int,
-        default=1000,
+        default=DEFAULT_KEEP,
         help="Keep last N history records",
     )
     p.add_argument(

{jsrc-0.2.2 → jsrc-0.2.4}/src/jsrc/job/history.py

@@ -5,6 +5,7 @@ from jsrc.job.core import (
     filter_rows,
     load_jobs,
     print_rows,
+    refresh_jobs,
     to_row_view,
     warn_portability_limits,
 )
@@ -13,6 +14,7 @@ from jsrc.job.core import (
 def cmd(args: Namespace) -> None:
     warn_portability_limits()
     rows = load_jobs()
+    rows, _ = refresh_jobs(rows)
     rows = filter_rows(rows, args.query)
     if args.limit > 0:
         rows = rows[-args.limit :]
@@ -21,18 +23,10 @@ def cmd(args: Namespace) -> None:
         view = to_row_view(row, {})
         rendered.append(view)
     cols = [
-        "job_id",
-        "status",
         "pid",
-        "submit_time",
-        "end_time",
-        "runtime",
-        "runtime_sec",
-        "rss_mb",
-        "rss_min_mb",
-        "rss_avg_mb",
-        "rss_peak_mb",
-        "log_path",
+        "s",
+        "mem",
+        "time",
         "command",
     ]
     print_rows(rendered, cols, args.format)

{jsrc-0.2.2 → jsrc-0.2.4}/src/jsrc/job/kill.py

@@ -30,12 +30,12 @@ def cmd(args: Namespace) -> None:
             os.killpg(pgid, sig)
         else:
             os.kill(pid, sig)
-    except ProcessLookupError:
+    except (ProcessLookupError, FileNotFoundError):
         pass
     row["status"] = "killed"
     row["end_time"] = now_iso()
     row["runtime_sec"] = str(runtime_seconds(row, {}))
-    write_jobs(rows, keep=1000)
+    write_jobs(rows)
     print(f"killed\t{pid}")
     print(f"signal\t{args.signal}")