ipmg 2.1.1__tar.gz → 2.2.0__tar.gz

{ipmg-2.1.1/src/ipmg.egg-info → ipmg-2.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ipmg
-Version: 2.1.1
+Version: 2.2.0
 Summary: IP Management & Ping Monitoring CLI Tool
 Author: Sameer Alam
 Maintainer-email: Sameer Alam <sameeralam3127@gmail.com>
@@ -542,6 +542,21 @@ default). A finished scan overwrites those files with the complete report, so
 the file names and contents are the same as they always were. Use
 `--no-incremental` to go back to writing only at the end.
 
+**Pick up where an interrupted scan stopped.** `--resume` reads the hosts the
+partial report already holds, scans only the rest, and finishes that same
+report — same file names, same batch timestamp:
+
+```bash
+ipmg --input 10.0.0.0/16 --formats jsonl xlsx     # Ctrl+C partway through
+ipmg --input 10.0.0.0/16 --formats jsonl xlsx --resume
+ipmg --input 10.0.0.0/16 --resume results_20260917_120000.csv
+```
+
+Without a path, `--resume` takes the newest report named after `--output`,
+preferring `jsonl` or `csv` (current to the last host) over `json` or `xlsx`
+(current to the last autosave). Hosts dropped from the target list since are
+left out of the finished report.
+
 **Open ports.** `Open Ports` is only populated when `--scan-ports` is set: for
 each host that answers, IPMG probes a list of common TCP ports (SSH, HTTP,
 HTTPS, RDP, SMB, FTP, SMTP, DNS, MSSQL, MySQL, PostgreSQL by default)
@@ -572,6 +587,7 @@ them — so piping IPMG into a file or a log gives you clean text.
 | `--formats` | `xlsx` | One or more of `xlsx`, `csv`, `json`, `jsonl`, `md` |
 | `--no-incremental` | off | Only write the report once the scan has finished |
 | `--autosave` | `30` | How often a running scan re-saves `xlsx`, `json`, and `md` |
+| `--resume` | off | Finish an interrupted scan from its partial report (newest one, or the path given) |
 
 **Speed and accuracy**
 

{ipmg-2.1.1 → ipmg-2.2.0}/README.md

@@ -495,6 +495,21 @@ default). A finished scan overwrites those files with the complete report, so
 the file names and contents are the same as they always were. Use
 `--no-incremental` to go back to writing only at the end.
 
+**Pick up where an interrupted scan stopped.** `--resume` reads the hosts the
+partial report already holds, scans only the rest, and finishes that same
+report — same file names, same batch timestamp:
+
+```bash
+ipmg --input 10.0.0.0/16 --formats jsonl xlsx     # Ctrl+C partway through
+ipmg --input 10.0.0.0/16 --formats jsonl xlsx --resume
+ipmg --input 10.0.0.0/16 --resume results_20260917_120000.csv
+```
+
+Without a path, `--resume` takes the newest report named after `--output`,
+preferring `jsonl` or `csv` (current to the last host) over `json` or `xlsx`
+(current to the last autosave). Hosts dropped from the target list since are
+left out of the finished report.
+
 **Open ports.** `Open Ports` is only populated when `--scan-ports` is set: for
 each host that answers, IPMG probes a list of common TCP ports (SSH, HTTP,
 HTTPS, RDP, SMB, FTP, SMTP, DNS, MSSQL, MySQL, PostgreSQL by default)
@@ -525,6 +540,7 @@ them — so piping IPMG into a file or a log gives you clean text.
 | `--formats` | `xlsx` | One or more of `xlsx`, `csv`, `json`, `jsonl`, `md` |
 | `--no-incremental` | off | Only write the report once the scan has finished |
 | `--autosave` | `30` | How often a running scan re-saves `xlsx`, `json`, and `md` |
+| `--resume` | off | Finish an interrupted scan from its partial report (newest one, or the path given) |
 
 **Speed and accuracy**
 

{ipmg-2.1.1 → ipmg-2.2.0}/pyproject.toml

@@ -13,7 +13,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ipmg"
-version = "2.1.1"  # Managed automatically by semantic-release
+version = "2.2.0"  # Managed automatically by semantic-release
 description = "IP Management & Ping Monitoring CLI Tool"
 readme = "README.md"
 requires-python = ">=3.9"

{ipmg-2.1.1 → ipmg-2.2.0}/src/ipmg/__init__.py

@@ -2,4 +2,4 @@
 ipmg - IP Management & Ping Monitoring Tool
 """
 
-__version__ = "2.1.1"
+__version__ = "2.2.0"

{ipmg-2.1.1 → ipmg-2.2.0}/src/ipmg/cli/parser.py

@@ -219,6 +219,18 @@ def build_parser() -> argparse.ArgumentParser:
             "csv and jsonl are written per host regardless."
         ),
     )
+    reports.add_argument(
+        "--resume",
+        nargs="?",
+        const="",
+        default=None,
+        metavar="REPORT",
+        help=(
+            "Finish an interrupted scan: skip the hosts its report already holds and "
+            "complete that report. REPORT is its jsonl, csv, json, or xlsx file "
+            "(default: the newest report named after --output)."
+        ),
+    )
 
     live = parser.add_argument_group("live output")
     live.add_argument(

{ipmg-2.1.1 → ipmg-2.2.0}/src/ipmg/infrastructure/incremental.py

@@ -17,23 +17,32 @@ writes at the end of the pass, which is why the scan shares its timestamp with
 the writer. A completed scan overwrites every snapshot with the canonical
 report, so incremental writing changes what survives an interruption without
 changing what a finished scan produces.
+
+That partial report is also where an interrupted scan picks up again:
+:func:`load_partial_report` reads the hosts it already holds, and ``--resume``
+scans only the rest, writing to the same files under the same timestamp.
 """
 
 from __future__ import annotations
 
+import io
 import json
 import logging
+import math
 import os
+import re
 import time
 from dataclasses import dataclass
+from datetime import datetime
 from pathlib import Path
-from typing import IO, Dict, List, Optional, Sequence
+from typing import IO, Dict, List, Optional, Sequence, Set, Tuple
 
 import pandas as pd
 
 from ipmg.core.engine import HostResult
+from ipmg.exceptions import FileIOError
 from ipmg.reporting.frames import RESULT_COLUMNS, format_open_ports
-from ipmg.utils.helpers import spreadsheet_escape
+from ipmg.utils.helpers import FORMULA_PREFIXES, spreadsheet_escape
 
 log = logging.getLogger(__name__)
 
@@ -48,6 +57,12 @@ REPORT_FORMATS = ("xlsx", "csv", "json", "jsonl", "md")
 STREAMING_FORMATS = ("csv", "jsonl")
 #: Formats that only exist as a whole file, so they are re-snapshotted.
 SNAPSHOT_FORMATS = ("xlsx", "json", "md")
+#: Formats a scan can be resumed from, most faithful first. ``md`` only
+#: previews the first 25 hosts, so it cannot stand in for the whole report.
+RESUMABLE_FORMATS = ("jsonl", "csv", "json", "xlsx")
+
+#: ``<base>_<YYYYMMDD_HHMMSS>.<format>``, the name every report is saved under.
+_REPORT_NAME = re.compile(r"^(?P<prefix>.+)_(?P<timestamp>\d{8}_\d{6})\.(?P<fmt>[a-z]+)$")
 
 
 @dataclass(frozen=True)
@@ -120,6 +135,7 @@ class IncrementalReport:
         batch_timestamp: object,
         options: IncrementalOptions = IncrementalOptions(),
         previous: Optional[Sequence[HostResult]] = None,
+        previous_elapsed_s: float = 0.0,
     ) -> None:
         self.options = options.clamped()
         self._base = base
@@ -127,13 +143,17 @@ class IncrementalReport:
         self._batch_timestamp = batch_timestamp
         self._formats = [fmt for fmt in dict.fromkeys(formats)]
         self._results: List[HostResult] = list(previous or ())
+        # Resumed rows keep the time the earlier run had reached, and new rows
+        # count on from it, so a report interrupted twice still knows how long
+        # the whole scan has taken.
         self._rows: List[Dict[str, object]] = [
-            result_row(result, batch_timestamp, None) for result in self._results
+            result_row(result, batch_timestamp, previous_elapsed_s if previous else None)
+            for result in self._results
         ]
         self._handles: Dict[str, IO[str]] = {}
         self._written: Dict[str, None] = {}
-        self._started_at = time.monotonic()
-        self._last_snapshot = self._started_at
+        self._started_at = time.monotonic() - previous_elapsed_s
+        self._last_snapshot = time.monotonic()
         self._closed = False
 
     # -- lifecycle ---------------------------------------------------------
@@ -259,6 +279,194 @@ class IncrementalReport:
         self._handles.clear()
 
 
+@dataclass(frozen=True)
+class PartialReport:
+    """The hosts an interrupted scan left in its report, ready to resume."""
+
+    path: str
+    #: The ``--output`` prefix and timestamp the report was saved under, so a
+    #: resumed scan writes back to the same files.
+    base: str
+    timestamp: str
+    results: Tuple[HostResult, ...]
+    batch_timestamp: Optional[datetime]
+    #: How long the earlier run had been scanning when it stopped.
+    elapsed_s: float
+
+    @property
+    def scanned(self) -> Set[str]:
+        return {result.ip for result in self.results}
+
+
+def find_partial_report(base: str) -> Optional[str]:
+    """The newest report saved under ``base`` that a scan can resume from.
+
+    When one scan left several formats behind, the most faithful one wins:
+    ``jsonl`` and ``csv`` hold every host up to the moment of interruption,
+    while ``json`` and ``xlsx`` are only as recent as their last autosave.
+    """
+    directory = Path(base).parent
+    prefix = Path(base).name
+    candidates = []
+    try:
+        entries = list(directory.iterdir())
+    except OSError:
+        return None
+    for entry in entries:
+        match = _REPORT_NAME.match(entry.name)
+        if not match or match["prefix"] != prefix or match["fmt"] not in RESUMABLE_FORMATS:
+            continue
+        rank = RESUMABLE_FORMATS.index(match["fmt"])
+        candidates.append((match["timestamp"], -rank, str(entry)))
+    return max(candidates)[2] if candidates else None
+
+
+def load_partial_report(path: str) -> PartialReport:
+    """Read the hosts a report already holds, including one cut off mid-write."""
+    name = _REPORT_NAME.match(Path(path).name)
+    if name is None:
+        raise FileIOError(
+            f"Cannot resume from {path}: expected a report named like "
+            "results_20260917_120000.jsonl, as IPMG saves them."
+        )
+    fmt = name["fmt"]
+    if fmt not in RESUMABLE_FORMATS:
+        raise FileIOError(
+            f"Cannot resume from a .{fmt} report; use the "
+            f"{', '.join(RESUMABLE_FORMATS)} report from the same scan instead."
+        )
+
+    try:
+        frame = _read_report(path, fmt)
+    except FileNotFoundError:
+        raise FileIOError(f"Report to resume not found: {path}") from None
+    except (OSError, ValueError) as exc:
+        raise FileIOError(f"Cannot read report {path}: {exc}") from exc
+
+    missing = [column for column in ("IP Address", "Status") if column not in frame.columns]
+    if missing:
+        raise FileIOError(f"{path} is not an IPMG report: missing {', '.join(missing)}.")
+
+    # A spreadsheet format stores cells escaped against formula injection;
+    # the scan itself needs the text the host actually reported.
+    unescape = fmt in ("csv", "xlsx")
+    by_ip: Dict[str, HostResult] = {}
+    for row in frame.to_dict(orient="records"):
+        result = _row_result(row, unescape)
+        if result is not None:
+            by_ip[result.ip] = result
+
+    base = str(Path(path).parent / name["prefix"])
+    return PartialReport(
+        path=path,
+        base=base,
+        timestamp=name["timestamp"],
+        results=tuple(by_ip.values()),
+        batch_timestamp=_batch_timestamp(frame),
+        elapsed_s=_elapsed(frame),
+    )
+
+
+def _read_report(path: str, fmt: str) -> pd.DataFrame:
+    if fmt == "xlsx":
+        return pd.read_excel(path, dtype=object)
+    if fmt == "json":
+        with open(path, encoding="utf-8") as handle:
+            return pd.DataFrame(json.load(handle))
+
+    with open(path, encoding="utf-8", newline="") as handle:
+        text = handle.read()
+    # Rows are flushed whole, so a last line without its newline is one the
+    # previous run was killed while writing. It is dropped, and that host is
+    # simply scanned again.
+    if text and not text.endswith("\n"):
+        text = text[: text.rfind("\n") + 1]
+
+    if fmt == "csv":
+        if not text.strip():
+            return pd.DataFrame(columns=RESULT_COLUMNS)
+        return pd.read_csv(io.StringIO(text), dtype=str, keep_default_na=False)
+
+    records = []
+    for number, line in enumerate(text.splitlines(), start=1):
+        if not line.strip():
+            continue
+        try:
+            records.append(json.loads(line))
+        except json.JSONDecodeError as exc:
+            raise ValueError(f"line {number} is not valid JSON ({exc.msg})") from None
+    return pd.DataFrame(records)
+
+
+def _is_blank(value: object) -> bool:
+    return value is None or (isinstance(value, float) and math.isnan(value)) or value == ""
+
+
+def _text(value: object, unescape: bool = False) -> str:
+    if _is_blank(value):
+        return ""
+    text = str(value).strip()
+    if unescape and text.startswith("'") and text[1:].startswith(FORMULA_PREFIXES):
+        return text[1:]
+    return text
+
+
+def _latency(value: object) -> Optional[float]:
+    if _is_blank(value):
+        return None
+    try:
+        return float(value)  # type: ignore[arg-type]
+    except (TypeError, ValueError):
+        return None
+
+
+def _open_ports(value: object) -> Tuple[int, ...]:
+    ports = []
+    for piece in _text(value).split(","):
+        try:
+            ports.append(int(float(piece)))
+        except ValueError:
+            continue
+    return tuple(ports)
+
+
+def _row_result(row: Dict[str, object], unescape: bool) -> Optional[HostResult]:
+    ip = _text(row.get("IP Address"))
+    status = _text(row.get("Status"))
+    if not ip or not status:
+        return None
+    return HostResult(
+        ip=ip,
+        status=status,
+        latency=_latency(row.get("Latency")),
+        hostname=_text(row.get("Hostname"), unescape),
+        open_ports=_open_ports(row.get("Open Ports")),
+    )
+
+
+def _batch_timestamp(frame: pd.DataFrame) -> Optional[datetime]:
+    """The resumed scan's start time, so both runs report as one batch."""
+    if "Batch Timestamp" not in frame.columns:
+        return None
+    for value in frame["Batch Timestamp"]:
+        if _is_blank(value):
+            continue
+        try:
+            # A finished json report stores it as epoch milliseconds.
+            unit = "ms" if isinstance(value, (int, float)) else None
+            return pd.to_datetime(value, unit=unit).to_pydatetime()
+        except (TypeError, ValueError, OverflowError):
+            return None
+    return None
+
+
+def _elapsed(frame: pd.DataFrame) -> float:
+    if "Scan Duration (s)" not in frame.columns:
+        return 0.0
+    durations = pd.to_numeric(frame["Scan Duration (s)"], errors="coerce").dropna()
+    return float(durations.max()) if not durations.empty else 0.0
+
+
 def atomic_write_bytes(path: str, data: bytes) -> None:
     """Replace ``path`` with ``data`` in one step, or leave it untouched.
 

{ipmg-2.1.1 → ipmg-2.2.0}/src/ipmg/reporting/ui.py

@@ -111,7 +111,8 @@ def heading(title: str) -> None:
 def field(label: str, value: object, value_style: str = "ipmg.value") -> None:
     """One aligned ``label   value`` line."""
     text = Text(INDENT)
-    text.append(f"{label:<{LABEL_WIDTH}}", style="ipmg.label")
+    # A label as long as the column still gets one space before its value.
+    text.append(f"{label:<{LABEL_WIDTH - 1}} ", style="ipmg.label")
     text.append(str(value), style=value_style)
     console.print(text)
 

{ipmg-2.1.1 → ipmg-2.2.0}/src/ipmg/services/scan_service.py

@@ -15,7 +15,7 @@ from ipmg.core.diff import DiffOptions
 from ipmg.core.discovery import discover_local_subnet
 from ipmg.core.engine import HostResult, ScanConfig, execute_scan
 from ipmg.core.portscan import DEFAULT_PORTS
-from ipmg.exceptions import HistoryError
+from ipmg.exceptions import FileIOError, HistoryError
 from ipmg.infrastructure.file_io import (
     DEFAULT_INPUT_FILE,
     create_sample_file,
@@ -26,6 +26,9 @@ from ipmg.infrastructure.incremental import (
     DEFAULT_AUTOSAVE_S,
     IncrementalOptions,
     IncrementalReport,
+    PartialReport,
+    find_partial_report,
+    load_partial_report,
 )
 from ipmg.reporting import ui
 from ipmg.reporting.diff_report import export_diff, print_diff
@@ -49,6 +52,8 @@ class ScanOutcome:
     source: str
     #: File-name stamp shared by the incremental writes and the final report.
     timestamp: str
+    #: Report file name prefix; a resumed scan keeps the one it started with.
+    output: str
 
 
 @dataclass(frozen=True)
@@ -88,6 +93,20 @@ def _incremental_options(args) -> IncrementalOptions:
     ).clamped()
 
 
+def _load_resume(args) -> Optional[PartialReport]:
+    """The partial report ``--resume`` points at, or the newest one for ``--output``."""
+    target = getattr(args, "resume", None)
+    if target is None:
+        return None
+    path = target or find_partial_report(args.output)
+    if path is None:
+        raise FileIOError(
+            f"No report to resume: nothing named {args.output}_<timestamp>.<format> "
+            "was found. Pass the report's path, as in --resume results_20260917_120000.jsonl."
+        )
+    return load_partial_report(path)
+
+
 def _stream_options(args) -> StreamOptions:
     """Read live-output settings off the parsed arguments."""
     all_hosts = bool(getattr(args, "stream_all", False))
@@ -175,18 +194,32 @@ def _scan_with_progress(
 def _open_report(
     args,
     incremental: IncrementalOptions,
+    output: str,
     timestamp: str,
     batch_timestamp: datetime,
+    previous: List[HostResult],
+    previous_elapsed_s: float,
 ) -> Optional[IncrementalReport]:
     """Start writing this pass's report, unless incremental writing is off."""
     if not incremental.enabled or not args.formats:
         return None
     return IncrementalReport(
-        base=args.output,
+        base=output,
         formats=args.formats,
         timestamp=timestamp,
         batch_timestamp=batch_timestamp,
         options=incremental,
+        previous=previous,
+        previous_elapsed_s=previous_elapsed_s,
+    )
+
+
+def _announce_resume(resume: PartialReport, done: int, total: int) -> None:
+    ui.fields(
+        [
+            ("Resuming", resume.path),
+            ("Left", f"{ui.plural(total - done, 'host')} of {total} still to scan"),
+        ]
     )
 
 
@@ -224,18 +257,32 @@ def _run_single_pass(
     config: ScanConfig,
     stream: StreamOptions,
     incremental: IncrementalOptions,
+    resume: Optional[PartialReport] = None,
 ) -> ScanOutcome:
-    batch_timestamp = current_timestamp()
-    timestamp = timestamp_str()
+    batch_timestamp = (resume and resume.batch_timestamp) or current_timestamp()
+    timestamp = resume.timestamp if resume else timestamp_str()
+    output = resume.base if resume else args.output
     started_at = time.perf_counter()
 
     ip_list = discover_local_subnet() if args.discover else load_targets(args.input)
     source = "auto-discovery" if args.discover else args.input
 
+    # Hosts the earlier run finished are kept only if they are still targets,
+    # so resuming against an edited list never reports hosts it no longer has.
+    targets = set(ip_list)
+    previous = [result for result in resume.results if result.ip in targets] if resume else []
+    previous_elapsed_s = resume.elapsed_s if resume else 0.0
+    scanned = {result.ip for result in previous}
+    remaining = [ip for ip in ip_list if ip not in scanned]
+
     _print_configuration(source, len(ip_list), config)
-    report = _open_report(args, incremental, timestamp, batch_timestamp)
-    results = _run_pass(ip_list, config, stream, report)
-    duration = time.perf_counter() - started_at
+    if resume:
+        _announce_resume(resume, len(previous), len(ip_list))
+    report = _open_report(
+        args, incremental, output, timestamp, batch_timestamp, previous, previous_elapsed_s
+    )
+    results = previous + _run_pass(remaining, config, stream, report)
+    duration = previous_elapsed_s + time.perf_counter() - started_at
 
     return ScanOutcome(
         results=results,
@@ -244,6 +291,7 @@ def _run_single_pass(
         duration_s=duration,
         source=source,
         timestamp=timestamp,
+        output=output,
     )
 
 
@@ -306,14 +354,18 @@ def run_scan(args) -> None:
     stream = _stream_options(args)
     incremental = _incremental_options(args)
     _ensure_input_file(args)
+    resume = _load_resume(args)
 
     while True:
-        outcome = _run_single_pass(args, config, stream, incremental)
+        outcome = _run_single_pass(args, config, stream, incremental, resume)
+        # Only the first pass picks up where an earlier run stopped; every
+        # --interval pass after it is a fresh scan.
+        resume = None
 
         print_summary(outcome.frame, outcome.batch_timestamp, outcome.duration_s)
         # Overwrites whatever the incremental writer left on those same paths,
         # so a finished scan produces exactly the report it always did.
-        save_results(outcome.frame, args.output, args.formats, timestamp=outcome.timestamp)
+        save_results(outcome.frame, outcome.output, args.formats, timestamp=outcome.timestamp)
         _store_and_compare(history_options, config, outcome)
 
         if not args.interval:

{ipmg-2.1.1 → ipmg-2.2.0/src/ipmg.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ipmg
-Version: 2.1.1
+Version: 2.2.0
 Summary: IP Management & Ping Monitoring CLI Tool
 Author: Sameer Alam
 Maintainer-email: Sameer Alam <sameeralam3127@gmail.com>
@@ -542,6 +542,21 @@ default). A finished scan overwrites those files with the complete report, so
 the file names and contents are the same as they always were. Use
 `--no-incremental` to go back to writing only at the end.
 
+**Pick up where an interrupted scan stopped.** `--resume` reads the hosts the
+partial report already holds, scans only the rest, and finishes that same
+report — same file names, same batch timestamp:
+
+```bash
+ipmg --input 10.0.0.0/16 --formats jsonl xlsx     # Ctrl+C partway through
+ipmg --input 10.0.0.0/16 --formats jsonl xlsx --resume
+ipmg --input 10.0.0.0/16 --resume results_20260917_120000.csv
+```
+
+Without a path, `--resume` takes the newest report named after `--output`,
+preferring `jsonl` or `csv` (current to the last host) over `json` or `xlsx`
+(current to the last autosave). Hosts dropped from the target list since are
+left out of the finished report.
+
 **Open ports.** `Open Ports` is only populated when `--scan-ports` is set: for
 each host that answers, IPMG probes a list of common TCP ports (SSH, HTTP,
 HTTPS, RDP, SMB, FTP, SMTP, DNS, MSSQL, MySQL, PostgreSQL by default)
@@ -572,6 +587,7 @@ them — so piping IPMG into a file or a log gives you clean text.
 | `--formats` | `xlsx` | One or more of `xlsx`, `csv`, `json`, `jsonl`, `md` |
 | `--no-incremental` | off | Only write the report once the scan has finished |
 | `--autosave` | `30` | How often a running scan re-saves `xlsx`, `json`, and `md` |
+| `--resume` | off | Finish an interrupted scan from its partial report (newest one, or the path given) |
 
 **Speed and accuracy**
 

{ipmg-2.1.1 → ipmg-2.2.0}/tests/test_incremental.py

@@ -7,11 +7,14 @@ import pandas as pd
 import pytest
 
 from ipmg.core.engine import HostResult
+from ipmg.exceptions import FileIOError
 from ipmg.infrastructure.file_io import save_results, write_report
 from ipmg.infrastructure.incremental import (
     IncrementalOptions,
     IncrementalReport,
     atomic_write_bytes,
+    find_partial_report,
+    load_partial_report,
 )
 from ipmg.services.scan_service import run_scan
 from ipmg.utils.helpers import console
@@ -225,3 +228,163 @@ def test_finished_scan_writes_one_set_of_reports(tmp_path, monkeypatch):
     assert sorted(row["IP Address"] for row in rows) == ["1.1.1.1", "8.8.8.8"]
     # Every row carries the duration of the whole pass, as it did before.
     assert len({row["Scan Duration (s)"] for row in rows}) == 1
+
+
+# -- resuming an interrupted scan ---------------------------------------------
+
+
+def _pinged(calls):
+    def ping_ip(ip, _timeout, _count):
+        calls.append(ip)
+        return "Active", 2.0
+
+    return ping_ip
+
+
+def _interrupt_first_run(tmp_path, monkeypatch, targets, stop_at, **overrides):
+    monkeypatch.setattr("ipmg.services.scan_service.load_targets", lambda _source: targets)
+    monkeypatch.setattr("ipmg.core.engine.ping_ip", _interrupted_ping(stop_at))
+    with pytest.raises(KeyboardInterrupt):
+        run_scan(_scan_args(tmp_path, **overrides))
+
+
+def test_resume_scans_only_the_hosts_left(tmp_path, monkeypatch):
+    targets = ["8.8.8.8", "1.1.1.1", "9.9.9.9"]
+    _interrupt_first_run(tmp_path, monkeypatch, targets, "1.1.1.1")
+    (partial,) = tmp_path.glob("scan_*.csv")
+
+    calls = []
+    monkeypatch.setattr("ipmg.core.engine.ping_ip", _pinged(calls))
+    run_scan(_scan_args(tmp_path, resume=str(partial)))
+
+    assert sorted(calls) == ["1.1.1.1", "9.9.9.9"]
+    # The finished report lands on the file the interrupted run started.
+    assert list(tmp_path.glob("scan_*.csv")) == [partial]
+    rows = list(csv.DictReader(open(partial, encoding="utf-8")))
+    assert sorted(row["IP Address"] for row in rows) == sorted(targets)
+    assert len({row["Batch Timestamp"] for row in rows}) == 1
+    assert len({row["Scan Duration (s)"] for row in rows}) == 1
+
+
+def test_resume_without_a_path_picks_the_newest_report(tmp_path, monkeypatch):
+    (tmp_path / "scan_20200101_000000.jsonl").write_text(
+        json.dumps({"IP Address": "1.1.1.1", "Status": "Active"}) + "\n", encoding="utf-8"
+    )
+    _interrupt_first_run(
+        tmp_path, monkeypatch, ["8.8.8.8", "1.1.1.1"], "1.1.1.1", formats=["jsonl", "xlsx"]
+    )
+
+    calls = []
+    monkeypatch.setattr("ipmg.core.engine.ping_ip", _pinged(calls))
+    run_scan(_scan_args(tmp_path, formats=["jsonl", "xlsx"], resume=""))
+
+    # The older report lists 1.1.1.1 as done; the newer one, which wins, does not.
+    assert calls == ["1.1.1.1"]
+
+
+def test_resume_with_no_report_to_find_is_an_error(tmp_path):
+    with pytest.raises(FileIOError, match="No report to resume"):
+        run_scan(_scan_args(tmp_path, resume=""))
+
+
+def test_interrupting_a_resumed_scan_keeps_both_runs(tmp_path, monkeypatch):
+    targets = ["8.8.8.8", "1.1.1.1", "9.9.9.9"]
+    _interrupt_first_run(tmp_path, monkeypatch, targets, "1.1.1.1", formats=["jsonl"])
+    (partial,) = tmp_path.glob("scan_*.jsonl")
+
+    monkeypatch.setattr(
+        "ipmg.services.scan_service.load_targets", lambda _source: ["8.8.8.8", "9.9.9.9", "1.1.1.1"]
+    )
+    with pytest.raises(KeyboardInterrupt):
+        run_scan(_scan_args(tmp_path, formats=["jsonl"], resume=str(partial)))
+
+    resumed = load_partial_report(str(partial))
+    assert sorted(resumed.scanned) == ["8.8.8.8", "9.9.9.9"]
+
+
+def test_resume_drops_hosts_no_longer_targeted(tmp_path, monkeypatch):
+    partial = tmp_path / "scan_20260917_120000.jsonl"
+    partial.write_text(
+        "".join(
+            json.dumps({"IP Address": ip, "Status": "Active", "Batch Timestamp": BATCH}) + "\n"
+            for ip in ("8.8.8.8", "10.0.0.1")
+        ),
+        encoding="utf-8",
+    )
+    monkeypatch.setattr(
+        "ipmg.services.scan_service.load_targets", lambda _source: ["8.8.8.8", "1.1.1.1"]
+    )
+    monkeypatch.setattr("ipmg.core.engine.ping_ip", _pinged([]))
+
+    run_scan(_scan_args(tmp_path, formats=["jsonl"], resume=str(partial)))
+
+    rows = [json.loads(line) for line in partial.read_text(encoding="utf-8").splitlines()]
+    assert sorted(row["IP Address"] for row in rows) == ["1.1.1.1", "8.8.8.8"]
+    assert {row["Batch Timestamp"] for row in rows} == {BATCH}
+
+
+def test_load_drops_a_line_cut_off_mid_write(tmp_path):
+    partial = tmp_path / "scan_20260917_120000.jsonl"
+    partial.write_text(
+        json.dumps({"IP Address": "8.8.8.8", "Status": "Active", "Scan Duration (s)": 4.5})
+        + '\n{"IP Address": "1.1.1.1", "Sta',
+        encoding="utf-8",
+    )
+
+    loaded = load_partial_report(str(partial))
+
+    assert [result.ip for result in loaded.results] == ["8.8.8.8"]
+    assert loaded.elapsed_s == 4.5
+    assert loaded.base == str(tmp_path / "scan")
+    assert loaded.timestamp == "20260917_120000"
+
+
+@pytest.mark.parametrize("fmt", ["csv", "xlsx", "json"])
+def test_load_round_trips_every_field(tmp_path, fmt):
+    original = HostResult(
+        ip="8.8.8.8",
+        status="Active",
+        latency=12.5,
+        hostname="=evil.example",
+        open_ports=(22, 443),
+    )
+    with _report(tmp_path, [fmt]) as report:
+        report.record(original)
+        report.record(_result("1.1.1.1", "Timeout", None))
+        report.snapshot()
+
+    loaded = load_partial_report(report.path_for(fmt))
+
+    # Spreadsheet formats store the hostname escaped; the scan gets it back as-is.
+    assert loaded.results[0] == original
+    assert loaded.results[1].latency is None
+    assert str(loaded.batch_timestamp) == BATCH
+
+
+@pytest.mark.parametrize(
+    "name, message",
+    [
+        ("scan_20260917_120000.md", "Cannot resume from a .md report"),
+        ("notes.jsonl", "expected a report named like"),
+        ("scan_20260917_999999.csv", "not found"),
+    ],
+)
+def test_load_rejects_what_it_cannot_resume(tmp_path, name, message):
+    if not name.endswith(".csv"):
+        (tmp_path / name).write_text("", encoding="utf-8")
+
+    with pytest.raises(FileIOError, match=message):
+        load_partial_report(str(tmp_path / name))
+
+
+def test_find_prefers_the_most_complete_format(tmp_path):
+    for name in (
+        "scan_20260917_120000.xlsx",
+        "scan_20260917_120000.jsonl",
+        "other_20990101_000000.csv",
+    ):
+        (tmp_path / name).write_text("", encoding="utf-8")
+
+    assert find_partial_report(str(tmp_path / "scan")) == str(
+        tmp_path / "scan_20260917_120000.jsonl"
+    )

{ipmg-2.1.1 → ipmg-2.2.0}/tests/test_parser.py

@@ -55,3 +55,13 @@ def test_parser_accepts_streaming_flags():
 
     assert args.stream_all is True
     assert args.stream_refresh == 1.0
+
+
+def test_parser_resume_takes_an_optional_report():
+    parser = build_parser()
+
+    assert parser.parse_args([]).resume is None
+    assert parser.parse_args(["--resume"]).resume == ""
+    assert parser.parse_args(["--resume", "scan_20260917_120000.csv"]).resume == (
+        "scan_20260917_120000.csv"
+    )