bmsdna-devtools 0.2.0__py3-none-any.whl

bmsdna/devtools/gh_pr.py

@@ -0,0 +1,140 @@
+"""GitHub PR merge/check status and creation via the `gh` CLI.
+
+Deliberately avoids `gh pr checks --json` — that flag was only added in a
+later `gh` release than some machines still run (confirmed missing on gh
+2.45.0). Everything here is built on `gh pr view --json ...`, whose --json
+support has been stable for a long time, plus statusCheckRollup entries
+categorized ourselves using GitHub's documented GraphQL enums.
+"""
+
+from __future__ import annotations
+
+import json
+import subprocess
+import sys
+import time
+
+PR_VIEW_FIELDS = "number,title,baseRefName,mergeable,statusCheckRollup"
+
+# PullRequest.mergeable (GraphQL MergeableState).
+CONFLICTING = "CONFLICTING"
+UNKNOWN_MERGEABLE = "UNKNOWN"
+
+# statusCheckRollup entries are a union of CheckRun | StatusContext.
+# CheckRun.conclusion (GraphQL CheckConclusionState) -> bucket.
+_CHECK_RUN_BUCKET = {
+    "SUCCESS": "pass",
+    "NEUTRAL": "pass",
+    "SKIPPED": "skipping",
+    "CANCELLED": "cancel",
+    "FAILURE": "fail",
+    "TIMED_OUT": "fail",
+    "ACTION_REQUIRED": "fail",
+    "STALE": "fail",
+}
+# Legacy commit Status.state (GraphQL StatusState) -> bucket.
+_STATUS_CONTEXT_BUCKET = {
+    "SUCCESS": "pass",
+    "PENDING": "pending",
+    "EXPECTED": "pending",
+    "ERROR": "fail",
+    "FAILURE": "fail",
+}
+
+
+def _run_gh_json(gh: str, args: list[str]) -> dict:
+    r = subprocess.run([gh, *args], capture_output=True, encoding="utf-8")
+    if r.returncode != 0:
+        sys.exit((r.stderr or r.stdout).strip() or f"`gh {' '.join(args)}` failed")
+    return json.loads(r.stdout)
+
+
+def get_pr(gh: str) -> dict:
+    """The PR for the current branch, however `gh` resolves it — there's no
+    target-branch filter on `gh pr view` the way ADO's search API has one.
+    """
+    return _run_gh_json(gh, ["pr", "view", "--json", PR_VIEW_FIELDS])
+
+
+def check_bucket(check: dict) -> str:
+    if check.get("__typename") == "StatusContext":
+        return _STATUS_CONTEXT_BUCKET.get(check.get("state"), "pending")
+    if check.get("status") != "COMPLETED":
+        return "pending"
+    return _CHECK_RUN_BUCKET.get(check.get("conclusion"), "fail")
+
+
+def check_label(check: dict) -> str:
+    name = check.get("name", "?")
+    workflow = check.get("workflowName")
+    return f"{workflow} / {name}" if workflow and workflow not in name else name
+
+
+def merge_conflict_message(pr: dict) -> str | None:
+    if pr.get("mergeable") != CONFLICTING:
+        return None
+    return f"PR #{pr.get('number')} ({pr.get('title', '?')!r}) has merge conflicts with '{pr.get('baseRefName', '?')}' (mergeable=CONFLICTING)"
+
+
+def print_check(check: dict) -> None:
+    bucket = check_bucket(check)
+    icon = {"pass": "✓", "fail": "✗", "cancel": "⊘"}.get(bucket, "…")
+    print(f"  [{icon} {bucket.upper()}] {check_label(check)}")
+
+
+def run(gh: str, wait: bool) -> None:
+    last_line = ""
+    while True:
+        pr = get_pr(gh)
+
+        # GitHub hasn't finished computing mergeability yet (usually resolves
+        # within a couple seconds); worth a short wait even outside --wait mode
+        # isn't safe (could spin forever if it never resolves) — only retry
+        # when the caller already opted into waiting.
+        if pr.get("mergeable") == UNKNOWN_MERGEABLE and wait:
+            time.sleep(3)
+            continue
+
+        conflict = merge_conflict_message(pr)
+        if conflict:
+            sys.exit(conflict)
+
+        pr_number = pr.get("number")
+        title = pr.get("title", "?")
+        base = pr.get("baseRefName", "?")
+        msg = f"\rPR #{pr_number}: {title} (base={base})"
+
+        checks = pr.get("statusCheckRollup") or []
+        if not checks:
+            print(msg + " | no checks found.")
+            return
+
+        buckets = [check_bucket(c) for c in checks]
+        msg += " | " + ", ".join(f"{check_label(c)}: {check_bucket(c)}" for c in checks)
+
+        if "pending" in buckets and wait:
+            if msg != last_line:
+                print(msg, end="", flush=True)
+                last_line = msg
+            time.sleep(30)
+            continue
+
+        print(msg)
+        print("\nDetails:")
+        for c in checks:
+            print_check(c)
+
+        if "fail" in buckets:
+            sys.exit(1)
+        return
+
+
+def create(gh: str, target: str, extra_args: list[str]) -> int:
+    """Create a GitHub PR from the current branch into `target`.
+
+    --fill autofills title/body from commit info so this never blocks on an
+    interactive prompt; pass --title/--body in extra_args to override (gh
+    lets explicit values take precedence over --fill).
+    """
+    cmd = [gh, "pr", "create", "--base", target, "--fill", *extra_args]
+    return subprocess.run(cmd).returncode

bmsdna/devtools/gitrepo.py

@@ -0,0 +1,123 @@
+"""Git-remote inspection: figure out which host (Azure DevOps or GitHub) the
+current repo's `origin` points at, and parse out its org/project/repo (ADO)
+or owner/repo (GitHub) so callers don't have to.
+"""
+
+from __future__ import annotations
+
+import re
+import subprocess
+import sys
+from dataclasses import dataclass
+from urllib.parse import unquote
+
+
+class NotAzureDevOpsRemoteError(Exception):
+    pass
+
+
+class NotGitHubRemoteError(Exception):
+    pass
+
+
+class UnknownRemoteError(Exception):
+    pass
+
+
+@dataclass(frozen=True)
+class AdoRemote:
+    org: str
+    project: str
+    repo: str
+
+
+@dataclass(frozen=True)
+class GitHubRemote:
+    owner: str
+    repo: str
+
+
+def _run_git(args: list[str], cwd: str | None = None) -> str:
+    try:
+        return subprocess.check_output(["git", *args], encoding="utf-8", cwd=cwd).strip()
+    except FileNotFoundError:
+        sys.exit("'git' is required for this command but wasn't found on PATH.")
+    except subprocess.CalledProcessError as e:
+        sys.exit((e.stderr or e.stdout or str(e)).strip() if isinstance(e.stderr, str) else str(e))
+
+
+def current_branch(cwd: str | None = None) -> str:
+    return _run_git(["rev-parse", "--abbrev-ref", "HEAD"], cwd=cwd)
+
+
+def origin_url(cwd: str | None = None) -> str:
+    return _run_git(["remote", "get-url", "origin"], cwd=cwd)
+
+
+def parse_ado_remote(url: str) -> AdoRemote:
+    """Parse an Azure DevOps org/project/repo out of a git remote URL.
+
+    Handles SSH (git@ssh.dev.azure.com:v3/org/project/repo), dev.azure.com
+    HTTPS, and the older *.visualstudio.com HTTPS form. Project/repo names
+    are unquoted since ADO allows spaces and punctuation (e.g. "BMS - Data").
+    """
+    if url.startswith("git@ssh.dev.azure.com"):
+        path = url.split(":", 1)[1]
+        parts = path.strip("/").split("/")
+        if parts[0] == "v3":
+            parts = parts[1:]
+        return AdoRemote(parts[0], unquote(parts[1]), unquote(parts[2]))
+
+    parts = url.rstrip("/").split("/")
+    if "dev.azure.com" in url:
+        for i, part in enumerate(parts):
+            if "dev.azure.com" in part:
+                org = parts[i + 1]
+                project = unquote(parts[i + 2])
+                if i + 4 < len(parts) and parts[i + 3] == "_git":
+                    repo = unquote(parts[i + 4])
+                else:
+                    repo = unquote(parts[i + 3])
+                return AdoRemote(org, project, repo)
+    elif "visualstudio.com" in url:
+        org = parts[2].split(".")[0]
+        project = unquote(parts[3])
+        if len(parts) > 5 and parts[4] == "_git":
+            repo = unquote(parts[5])
+        else:
+            repo = unquote(parts[4])
+        return AdoRemote(org, project, repo)
+
+    raise NotAzureDevOpsRemoteError(f"Could not parse Azure DevOps info from remote URL: {url}")
+
+
+# Matches git@github.com:owner/repo(.git), ssh://git@github.com/owner/repo(.git),
+# and https://[user@]github.com/owner/repo(.git).
+_GITHUB_RE = re.compile(r"github\.com[:/]([^/]+)/(.+?)(?:\.git)?/?$")
+
+
+def parse_github_remote(url: str) -> GitHubRemote:
+    match = _GITHUB_RE.search(url)
+    if not match:
+        raise NotGitHubRemoteError(f"Could not parse GitHub owner/repo from remote URL: {url}")
+    return GitHubRemote(match.group(1), match.group(2))
+
+
+def parse_remote(url: str) -> AdoRemote | GitHubRemote:
+    """Parse whichever of GitHub or Azure DevOps `url` points at."""
+    if "github.com" in url:
+        return parse_github_remote(url)
+    try:
+        return parse_ado_remote(url)
+    except NotAzureDevOpsRemoteError:
+        raise UnknownRemoteError(
+            f"'{url}' doesn't look like a GitHub or Azure DevOps remote — only those two are supported."
+        ) from None
+
+
+def current_remote(cwd: str | None = None) -> AdoRemote | GitHubRemote:
+    return parse_remote(origin_url(cwd))
+
+
+def current_ado_remote(cwd: str | None = None) -> AdoRemote:
+    return parse_ado_remote(origin_url(cwd))

bmsdna/devtools/logs.py

@@ -0,0 +1,170 @@
+"""Fetch recent Application Insights / Log Analytics logs via `az monitor app-insights query`.
+
+Unlike the other commands, this one takes no repo-specific defaults: pass
+--resource-group/--app-insights explicitly (or set AZURE_RESOURCE_GROUP /
+AZURE_APP_INSIGHTS), since which Azure resource "this repo" maps to isn't
+derivable from the git remote the way Azure DevOps org/project/repo is.
+"""
+
+from __future__ import annotations
+
+import json
+import subprocess
+import sys
+from datetime import datetime, timezone
+
+from .cli_tools import require_az
+
+SEVERITY_MAP = {"verbose": 0, "information": 1, "warning": 2, "error": 3, "critical": 4}
+
+COLORS = {
+    "CRITICAL": "\033[95m",
+    "ERROR   ": "\033[91m",
+    "WARNING ": "\033[93m",
+    "INFO    ": "\033[97m",
+    "VERBOSE ": "\033[90m",
+    "RESET": "\033[0m",
+}
+
+
+def run_az(*args: str) -> tuple[int, str]:
+    az = require_az()
+    # Never shell=True here: KQL queries contain `|`, which a Windows cmd.exe
+    # shell would reinterpret as a pipe instead of passing through literally.
+    result = subprocess.run([az, *args], capture_output=True, encoding="utf-8")
+    return result.returncode, result.stdout + result.stderr
+
+
+def find_app_insights(resource_group: str) -> str | None:
+    code, out = run_az(
+        "resource", "list",
+        "--resource-group", resource_group,
+        "--resource-type", "Microsoft.Insights/components",
+        "--query", "[0].name",
+        "--output", "tsv",
+    )
+    name = out.strip()
+    return name if code == 0 and name else None
+
+
+def query_roles(app_insights: str, resource_group: str, minutes: int) -> tuple[dict[str, int] | None, str | None]:
+    kql = f"""
+union traces, exceptions
+| where timestamp > ago({minutes}m)
+| summarize count() by cloud_RoleName
+| order by count_ desc
+""".strip()
+    code, out = run_az(
+        "monitor", "app-insights", "query",
+        "--app", app_insights,
+        "--resource-group", resource_group,
+        "--analytics-query", kql,
+        "--output", "json",
+    )
+    if code != 0:
+        return None, out
+    try:
+        table = json.loads(out)["tables"][0]
+    except json.JSONDecodeError:
+        table = json.loads(out.split("\n")[0])["tables"][0]
+    col_names = [c["name"] for c in table["columns"]]
+    role_col = next((i for i, n in enumerate(col_names) if n == "cloud_RoleName"), None)
+    count_col = next((i for i, n in enumerate(col_names) if n == "count_"), None)
+    if role_col is None:
+        return None, f"cloud_RoleName column not found; got: {col_names}"
+    counts: dict[str, int] = {}
+    for row in table["rows"]:
+        role = row[role_col] or "(unknown)"
+        counts[role] = int(row[count_col]) if count_col is not None and row[count_col] else 1
+    return dict(sorted(counts.items(), key=lambda x: x[1], reverse=True)), None
+
+
+def query_logs(
+    app_insights: str, resource_group: str, minutes: int, min_severity: int, role: str
+) -> tuple[list | None, str | None]:
+    role_filter = "" if role == "all" else f'| where cloud_RoleName == "{role}"'
+    kql = f"""
+union traces, exceptions
+| where timestamp > ago({minutes}m)
+| where severityLevel >= {min_severity}
+{role_filter}
+| order by timestamp asc
+| take 500
+""".strip()
+    code, out = run_az(
+        "monitor", "app-insights", "query",
+        "--app", app_insights,
+        "--resource-group", resource_group,
+        "--analytics-query", kql,
+        "--output", "json",
+    )
+    if code != 0:
+        return None, out
+    try:
+        table = json.loads(out)["tables"][0]
+    except json.JSONDecodeError:
+        table = json.JSONDecoder().raw_decode(out)[0]["tables"][0]
+    col_index = {col["name"]: i for i, col in enumerate(table["columns"])}
+
+    def col(row: list, *names: str) -> str:
+        for name in names:
+            if name in col_index:
+                return row[col_index[name]] or ""
+        return ""
+
+    results = []
+    for row in table["rows"]:
+        sev: int | None = row[col_index["severityLevel"]] if "severityLevel" in col_index else None
+        lvl = (
+            {0: "VERBOSE ", 1: "INFO    ", 2: "WARNING ", 3: "ERROR   ", 4: "CRITICAL"}.get(sev, "UNKNOWN ")
+            if sev is not None else "UNKNOWN "
+        )
+        msg = col(row, "message", "outerMessage", "innermostMessage")
+        item_type = col(row, "itemType")
+        exc = f" | {col(row, 'type')}: {col(row, 'outerMessage')}" if item_type == "exception" else ""
+        results.append({"timestamp": row[col_index["timestamp"]], "lvl": lvl, "msg": msg, "exc": exc})
+    return results, None
+
+
+def print_roles(app_insights: str, resource_group: str, minutes: int) -> None:
+    print(f"Querying roles for last {minutes} min from {app_insights}...", flush=True)
+    roles, err = query_roles(app_insights, resource_group, minutes)
+    if roles is None:
+        found = find_app_insights(resource_group)
+        if not found:
+            sys.exit(f"ERROR: No App Insights in {resource_group}.")
+        roles, err = query_roles(found, resource_group, minutes)
+    if roles is None:
+        sys.exit(f"ERROR: {err}")
+    print(f"\n{'Role':<50} {'Messages':>10}\n" + "-" * 62)
+    for role, count in roles.items():
+        print(f"{role:<50} {count:>10}")
+    print("\nPass --role <name> to fetch logs for a specific role.")
+
+
+def print_logs(
+    app_insights: str, resource_group: str, minutes: int, level: str, role: str, no_color: bool
+) -> None:
+    min_severity = SEVERITY_MAP[level]
+    print(f"Querying last {minutes} min | role={role} | severity>={level}...", flush=True)
+    rows, err = query_logs(app_insights, resource_group, minutes, min_severity, role)
+    if rows is None:
+        found = find_app_insights(resource_group)
+        if not found:
+            sys.exit(f"ERROR: No App Insights in {resource_group}.")
+        rows, err = query_logs(found, resource_group, minutes, min_severity, role)
+    if rows is None:
+        sys.exit(f"ERROR:\n{err}")
+    if not rows:
+        print(f"No entries in the last {minutes} minutes.")
+        return
+
+    print(f"--- {len(rows)} entries ---")
+    for row in rows:
+        ts = datetime.fromisoformat(row["timestamp"].rstrip("Z")).replace(tzinfo=timezone.utc).strftime("%H:%M:%S")
+        line = f"{ts} [{row['lvl']}] {row['msg']}{row['exc']}"
+        if no_color:
+            print(line)
+        else:
+            color = COLORS.get(row["lvl"], "")
+            print(f"{color}{line}{COLORS['RESET']}")

bmsdna/devtools/pr_build.py

@@ -0,0 +1,206 @@
+"""Azure DevOps PR build status: find the PR for the current branch and report its builds."""
+
+from __future__ import annotations
+
+import re
+import sys
+import time
+from urllib.parse import quote
+
+import requests
+
+from .ado_auth import auth_header
+from .gitrepo import AdoRemote, current_branch
+
+# Matches an ISO 8601 timestamp at the start of a log line, e.g. 2024-03-21T15:01:23.1234567Z
+TIMESTAMP_RE = re.compile(r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z\s*")
+
+# GitPullRequest.mergeStatus values (PullRequestAsyncStatus) that mean the PR
+# can't be merged as-is — build status is moot until this is resolved.
+BAD_MERGE_STATUSES = {
+    "conflicts": "has merge conflicts with the target branch",
+    "failure": "merge failed",
+    "rejectedByPolicy": "merge was rejected by branch policy",
+}
+
+
+def _base_url(remote: AdoRemote) -> str:
+    return f"https://dev.azure.com/{remote.org}/{quote(remote.project, safe='')}"
+
+
+def merge_conflict_message(pr: dict) -> str | None:
+    """None if the PR's mergeStatus is fine; else a human-readable description of the problem."""
+    merge_status = pr.get("mergeStatus")
+    if merge_status not in BAD_MERGE_STATUSES:
+        return None
+    pr_id = pr.get("pullRequestId")
+    title = pr.get("title", "?")
+    detail = pr.get("mergeFailureMessage") or BAD_MERGE_STATUSES[merge_status]
+    return f"PR #{pr_id} ({title!r}) {detail} (mergeStatus={merge_status})"
+
+
+def get_pr(session: requests.Session, remote: AdoRemote, source_branch: str, target_branch: str) -> dict:
+    url = f"{_base_url(remote)}/_apis/git/repositories/{remote.repo}/pullrequests"
+    for status in ["active", "completed"]:
+        r = session.get(
+            url,
+            params={
+                "searchCriteria.sourceRefName": f"refs/heads/{source_branch}",
+                "searchCriteria.targetRefName": f"refs/heads/{target_branch}",
+                "searchCriteria.status": status,
+                "$top": 1,
+                "api-version": "7.1",
+            },
+        )
+        r.raise_for_status()
+        items = r.json().get("value", [])
+        if items:
+            pr = items[0]
+            conflict = merge_conflict_message(pr)
+            if conflict:
+                sys.exit(conflict)
+            return pr
+
+    print(f"No PR found from '{source_branch}' → '{target_branch}'")
+    sys.exit(1)
+
+
+def get_builds_for_pr(session: requests.Session, remote: AdoRemote, source_branch: str, pr_id: int) -> list:
+    builds = []
+    for ref in [f"refs/pull/{pr_id}/merge", f"refs/heads/{source_branch}"]:
+        url = f"{_base_url(remote)}/_apis/build/builds"
+        r = session.get(url, params={"branchName": ref, "$top": 5, "api-version": "7.1"})
+        r.raise_for_status()
+        builds.extend(r.json().get("value", []))
+
+    if builds:
+        builds.sort(key=lambda b: b["id"], reverse=True)
+    return builds
+
+
+def latest_per_pipeline(builds: list) -> list:
+    """Reduce a build list to the single latest build per pipeline (definition)."""
+    latest: dict = {}
+    for b in builds:
+        def_id = b.get("definition", {}).get("id")
+        if def_id not in latest or b["id"] > latest[def_id]["id"]:
+            latest[def_id] = b
+    return sorted(latest.values(), key=lambda b: b["id"], reverse=True)
+
+
+def get_failed_step_logs(session: requests.Session, remote: AdoRemote, build_id: int) -> None:
+    r = session.get(f"{_base_url(remote)}/_apis/build/builds/{build_id}/timeline", params={"api-version": "7.1"})
+    r.raise_for_status()
+    records = r.json().get("records", [])
+
+    failed = [rec for rec in records if rec.get("result") == "failed" and rec.get("type") == "Task" and rec.get("log")]
+
+    if not failed:
+        print("  (no failed steps with logs)")
+        return
+
+    print(f"\n--- Failed steps (build {build_id}) ---")
+    for rec in failed:
+        name = rec.get("name", "?")
+        log_url = rec["log"]["url"]
+        print(f"\n  [FAILED] {name}")
+        r2 = session.get(log_url, params={"api-version": "7.1"})
+        r2.raise_for_status()
+        for line in r2.text.splitlines():
+            print(f"    {TIMESTAMP_RE.sub('', line)}")
+
+
+def print_build(session: requests.Session, remote: AdoRemote, build: dict) -> None:
+    build_id = build["id"]
+    status = build.get("status", "unknown")
+    result = build.get("result", "—")
+    name = build.get("definition", {}).get("name", "?")
+    number = build.get("buildNumber", "?")
+    start = build.get("startTime", "?")
+    finish = build.get("finishTime", "?")
+    source_version = build.get("sourceVersion", "?")[:8]
+
+    icon = {"succeeded": "✓", "failed": "✗", "canceled": "⊘"}.get(result, "…")
+
+    print(f"\n{'-' * 60}")
+    print(f"Build #{build_id}  [{icon} {result.upper()}]")
+    print(f"  Commit   : {source_version}")
+    print(f"  Pipeline : {name}")
+    print(f"  Number   : {number}")
+    print(f"  Status   : {status}")
+    print(f"  Started  : {start}")
+    print(f"  Finished : {finish}")
+
+    if status == "completed" and result == "failed":
+        get_failed_step_logs(session, remote, build_id)
+
+
+def run(remote: AdoRemote, pat: str | None, target_branch: str, wait: bool, source_branch: str | None = None) -> None:
+    source_branch = source_branch or current_branch()
+    session = requests.Session()
+    session.headers.update(auth_header(pat))
+
+    # When waiting, a pipeline's "latest" build may already be a completed run
+    # from before this invocation. Only accept builds newer than whatever was
+    # already there when we started, so --wait actually waits for the build(s)
+    # triggered by the current HEAD instead of immediately reporting a stale result.
+    baseline_ids: dict[int, int] = {}
+    if wait:
+        pr = get_pr(session, remote, source_branch, target_branch)
+        for b in get_builds_for_pr(session, remote, source_branch, pr["pullRequestId"]):
+            def_id = b.get("definition", {}).get("id")
+            baseline_ids[def_id] = max(baseline_ids.get(def_id, 0), b["id"])
+
+    last_line = ""
+    while True:
+        pr = get_pr(session, remote, source_branch, target_branch)
+        pr_id = pr["pullRequestId"]
+        pr_title = pr.get("title", "?")
+        pr_status = pr.get("status", "?")
+
+        msg = f"\rPR #{pr_id}: {pr_title} ({pr_status})"
+
+        builds = get_builds_for_pr(session, remote, source_branch, pr_id)
+        if builds:
+            pipeline_builds = latest_per_pipeline(builds)
+            if wait:
+                stale = [b for b in pipeline_builds if b["id"] <= baseline_ids.get(b.get("definition", {}).get("id"), 0)]
+                if stale:
+                    msg += " | waiting for new build(s) to start: " + ", ".join(
+                        b.get("definition", {}).get("name", "?") for b in stale
+                    )
+                    if msg != last_line:
+                        print(msg, end="", flush=True)
+                        last_line = msg
+                    time.sleep(30)
+                    continue
+            msg += " | " + ", ".join(
+                f"{b.get('definition', {}).get('name', '?')} #{b['id']} {b.get('status')} ({b.get('result', '—')})"
+                for b in pipeline_builds
+            )
+
+            all_done = all(b.get("status") == "completed" for b in pipeline_builds)
+            if all_done or not wait:
+                print(msg)
+                print("\nDetails:")
+                for b in pipeline_builds:
+                    print_build(session, remote, b)
+
+                if not all_done and not wait:
+                    print("\nTip: Use --wait to poll until all pipelines are completed.")
+
+                if any(b.get("result") == "failed" for b in pipeline_builds):
+                    sys.exit(1)
+                return
+        else:
+            msg += " | No builds found."
+            if not wait:
+                print(msg)
+                return
+
+        if msg != last_line:
+            print(msg, end="", flush=True)
+            last_line = msg
+
+        if wait:
+            time.sleep(30)