bugpipe 3.0.2__tar.gz → 3.1.1__tar.gz

{bugpipe-3.0.2 → bugpipe-3.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bugpipe
-Version: 3.0.2
+Version: 3.1.1
 Summary: Unofficial Python client for Buganizer; the Google Issue Tracking system
 Keywords: buganizer,google-issue-tracker,issue-tracker,bug-tracker,bug-bounty,vulnerability,security,chromium,cve,vrp,google
 Author: Ritchie Mwewa
@@ -28,7 +28,7 @@ Description-Content-Type: text/markdown
 <img alt="logo" src="https://www.gstatic.com/buganizer/img/v0/logo.svg" width="150" height="150">
 <br>
 <br>
-<strong><i>Unofficial Python client for Buganizer; the Google Issue Tracking system.</i></strong>
+Unofficial Python client for Buganizer; the Google Issue Tracking system.
 </p>
 
 ## Quick Start

{bugpipe-3.0.2 → bugpipe-3.1.1}/README.md

@@ -2,7 +2,7 @@
 <img alt="logo" src="https://www.gstatic.com/buganizer/img/v0/logo.svg" width="150" height="150">
 <br>
 <br>
-<strong><i>Unofficial Python client for Buganizer; the Google Issue Tracking system.</i></strong>
+Unofficial Python client for Buganizer; the Google Issue Tracking system.
 </p>
 
 ## Quick Start

{bugpipe-3.0.2 → bugpipe-3.1.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "bugpipe"
-version = "3.0.2"
+version = "3.1.1"
 description = "Unofficial Python client for Buganizer; the Google Issue Tracking system"
 readme = "README.md"
 license = "MIT"

{bugpipe-3.0.2 → bugpipe-3.1.1}/src/bugpipe/cli/__init__.py

@@ -1,14 +1,32 @@
+import argparse
 import logging
 import sys
 from datetime import datetime
 
 import httpx
 from rich.logging import RichHandler
+from rich.status import Status
 
-from ..api.client import TRACKERS
-from . import update_checker
-from .cmd import dispatch_client, parse_args
-from .term import FAIL, INFO, WARN, console, print_out
+from ..api.client import TRACKERS, Bugpipe
+from . import metadata, update_checker
+from .commands import parse_args
+from .output import FAIL, INFO, WARN, console, print_out
+
+
+def create_client(args: argparse.Namespace, status: Status):
+    """
+    Create a client and dispatch to the chosen subcommand.
+
+    :param args: Parsed arguments with ``.func`` set to the subcommand handler.
+    :param status: Rich status spinner for progress updates.
+    """
+
+    with Bugpipe(
+        trackers=getattr(args, "tracker", None),
+        timeout=args.timeout,
+        proxy=args.proxy,
+    ) as client:
+        args.func(client=client, args=args, status=status)
 
 
 def format_option(value) -> str:
@@ -35,7 +53,7 @@ def start():
     args = parse_args()
 
     if args.command == "trackers":
-        print_out(output=TRACKERS, as_raw=args.raw)
+        print_out(output=TRACKERS, prettified=args.raw, no_pager=args.no_pager)
         console.print(f"\n{len(TRACKERS)} trackers available")
         return
 
@@ -51,12 +69,12 @@ def start():
         )
         overrides_text: str = f" ({overrides})" if overrides else ""
         console.log(
-            f"{INFO} Started bugpipe CLI {update_checker.__version__[:3]}{overrides_text} "
+            f"{INFO} Started bugpipe CLI {metadata.version[:3]}{overrides_text} "
             f"at {datetime.now().astimezone().strftime('%x %X')}"
         )
         with console.status("[dim]Initialising…[/dim]") as status:
             update_checker.check(status=status)
-            dispatch_client(args=args, status=status)
+            create_client(args=args, status=status)
     except KeyboardInterrupt:
         console.log(f"{WARN} User interrupted ([bold yellow]CTRL+C[/bold yellow])")
         sys.exit(0)

bugpipe-3.0.2/src/bugpipe/cli/cmd.py → bugpipe-3.1.1/src/bugpipe/cli/commands.py

@@ -6,15 +6,15 @@ from datetime import datetime
 
 from ..api.client import TRACKERS, Bugpipe
 from ..api.models import Results
-from .term import FAIL, OK, console, export, print_out
-from .update_checker import __pkg__, __version__
+from . import metadata
+from .output import FAIL, OK, console, export_out, print_out
 
 if t.TYPE_CHECKING:
     from rich.status import Status
 
     from ..api.models import Issue
 
-__all__ = ["dispatch_client", "parse_args"]
+__all__ = ["parse_args"]
 
 
 def parse_args() -> argparse.Namespace:
@@ -25,9 +25,9 @@ def parse_args() -> argparse.Namespace:
     """
 
     parser = argparse.ArgumentParser(
-        prog=__pkg__,
-        description="Unofficial Python client for Buganizer; the Google Issue Tracking system.",
-        epilog=f"© {datetime.now().astimezone().year} Ritchie Mwewa",
+        prog=metadata.pkg_name,
+        description=f"{metadata.description}.",
+        epilog=f"{metadata.license} © {datetime.now().astimezone().year} {metadata.author}",
     )
     parser.add_argument(
         "-r",
@@ -35,6 +35,11 @@ def parse_args() -> argparse.Namespace:
         action="store_true",
         help="show raw output",
     )
+    parser.add_argument(
+        "--no-pager",
+        action="store_true",
+        help="print results straight to the terminal instead of paging them",
+    )
     parser.add_argument(
         "-p",
         "--proxy",
@@ -53,11 +58,11 @@ def parse_args() -> argparse.Namespace:
         "-v",
         "--version",
         action="version",
-        version=f"{__pkg__} {__version__}",
+        version=f"{metadata.pkg_name} {metadata.version}",
     )
     # Shared by commands that return issue data.
-    exportable = argparse.ArgumentParser(add_help=False)
-    exportable.add_argument(
+    export_parser = argparse.ArgumentParser(add_help=False)
+    export_parser.add_argument(
         "-e",
         "--export",
         action="append",
@@ -69,7 +74,7 @@ def parse_args() -> argparse.Namespace:
 
     # search
     search_parser = subparsers.add_parser(
-        "search", parents=[exportable], help="search for issues"
+        "search", parents=[export_parser], help="search for issues"
     )
     search_parser.add_argument("query", help="search query")
     search_parser.add_argument(
@@ -100,21 +105,21 @@ def parse_args() -> argparse.Namespace:
 
     # get
     issue_parser = subparsers.add_parser(
-        "issue", parents=[exportable], help="get a single issue"
+        "issue", parents=[export_parser], help="get a single issue"
     )
     issue_parser.add_argument("issue_id", type=int, help="issue ID")
     issue_parser.set_defaults(func=cmd_issue)
 
     # batch
     issues_parser = subparsers.add_parser(
-        "issues", parents=[exportable], help="batch get issues"
+        "issues", parents=[export_parser], help="batch get issues"
     )
     issues_parser.add_argument("issue_ids", type=int, nargs="+", help="issue IDs")
     issues_parser.set_defaults(func=cmd_issues)
 
     # comments
     comments_parser = subparsers.add_parser(
-        "comments", parents=[exportable], help="get comments on an issue"
+        "comments", parents=[export_parser], help="get comments on an issue"
     )
     comments_parser.add_argument("issue_id", type=int, help="issue ID")
     comments_parser.set_defaults(func=cmd_comments)
@@ -125,7 +130,7 @@ def parse_args() -> argparse.Namespace:
     # echo (health check)
     echo_parser = subparsers.add_parser(
         "echo",
-        help="check whether the issue tracker backend is reachable",
+        help="check whether buganizer is reachable",
         description=(
             "Ping the Buganizer backend (GET /action/yes) and print its "
             "response. 'yes' means the backend is reachable and healthy; "
@@ -145,11 +150,11 @@ def _overrides(args: argparse.Namespace, *parsers: argparse.ArgumentParser) -> d
 
     :param args: Parsed arguments.
     :param parsers: The parsers that produced them.
-    :return: Long option name (without dashes) to value.
+    :return: Option name as argparse stores it (``no_pager``) to value.
     """
 
     return {
-        action.option_strings[-1].lstrip("-"): getattr(args, action.dest)
+        action.dest: getattr(args, action.dest)
         for parser in parsers
         for action in parser._actions
         if action.option_strings
@@ -196,10 +201,10 @@ def cmd_search(client: Bugpipe, args: argparse.Namespace, status: Status):
     # Rich's Status redirects sys.stdout, which makes the pager (and the
     # TTY check) see a non-tty. Stop it first so paging can take over.
     status.stop()
-    print_out(output=issues, as_raw=args.raw)
+    print_out(output=issues, prettified=args.raw, no_pager=args.no_pager)
 
     if args.export:
-        export(output=issues, formats=args.export)
+        export_out(output=issues, formats=args.export)
 
     if result.has_more:
         print()
@@ -219,10 +224,10 @@ def cmd_issue(client: Bugpipe, args: argparse.Namespace, status: Status):
     status.update(f"[dim]Getting issue {issue_id}…[/]")
     issue = client.issue(issue_id=issue_id)
 
-    status.stop()  # restore stdout so the pager works (Status redirects it)
-    print_out(output=issue)
+    status.stop()
+    print_out(output=issue, prettified=args.raw, no_pager=args.no_pager)
     if args.export:
-        export(output=issue, formats=args.export)
+        export_out(output=issue, formats=args.export)
 
 
 def cmd_issues(client: Bugpipe, args: argparse.Namespace, status: Status):
@@ -238,10 +243,10 @@ def cmd_issues(client: Bugpipe, args: argparse.Namespace, status: Status):
     status.update(f"[dim]Getting issues {issue_ids}…[/]")
     issues = client.issues(issue_ids=issue_ids)
 
-    status.stop()  # restore stdout so the pager works (Status redirects it)
-    print_out(output=issues)
+    status.stop()
+    print_out(output=issues, prettified=args.raw, no_pager=args.no_pager)
     if args.export:
-        export(output=issues, formats=args.export)
+        export_out(output=issues, formats=args.export)
 
 
 def cmd_comments(client: Bugpipe, args: argparse.Namespace, status: Status):
@@ -258,11 +263,11 @@ def cmd_comments(client: Bugpipe, args: argparse.Namespace, status: Status):
     status.update(status=f"[dim]Getting comments for issue {issue_id}…[/]")
     result = client.comments(issue_id=issue_id)
 
-    status.stop()  # restore stdout so the pager works (Status redirects it)
+    status.stop()
     console.print(f"Issue #{issue_id} — {len(result.comments)} comments\n")
-    print_out(output=result.comments)
+    print_out(output=result.comments, prettified=args.raw, no_pager=args.no_pager)
     if args.export:
-        export(output=result.comments, formats=args.export)
+        export_out(output=result.comments, formats=args.export)
 
 
 # noinspection PyUnusedLocal
@@ -270,35 +275,18 @@ def cmd_echo(client: Bugpipe, args: argparse.Namespace, status: Status):
     """
     Handle the 'echo' subcommand: ping the backend and print its response.
 
-    Prints a green ``✔`` when the backend is reachable and healthy
-    (``echo: yes``), or a red ``✘`` when it is unreachable or returned
-    an error (``echo: no``).
+    Prints ``echo: yes`` when the backend is reachable and healthy
+    , or ``echo: no`` when it is unreachable or returned
+    an error.
 
     :param client: Shared API client instance.
     :param args: Parsed arguments (unused).
     :param status: Rich status spinner for progress updates.
     """
 
-    status.update("[dim]Pinging issue tracker backend…[/dim]")
+    status.update("[dim]Pinging buganizer…[/dim]")
     response = client.echo()
     if response == "yes":
         console.log(f"{OK} echo: {response}")
     else:
         console.log(f"{FAIL} echo: {response}")
-
-
-def dispatch_client(args: argparse.Namespace, status: Status):
-    """
-    Check for updates, then create a single client and dispatch to the
-    chosen subcommand.
-
-    :param args: Parsed arguments with ``.func`` set to the subcommand handler.
-    :param status: Rich status spinner for progress updates.
-    """
-
-    with Bugpipe(
-        trackers=getattr(args, "tracker", None),
-        timeout=args.timeout,
-        proxy=args.proxy,
-    ) as client:
-        args.func(client=client, args=args, status=status)

bugpipe-3.1.1/src/bugpipe/cli/metadata.py

@@ -0,0 +1,12 @@
+"""
+Package metadata, read from the installed distribution.
+"""
+
+from importlib.metadata import metadata
+
+pkg_name = "bugpipe"
+__metadata = metadata(pkg_name)
+author = __metadata["Author"]
+description = __metadata["Summary"]
+license = __metadata["License-Expression"]
+version = __metadata["Version"]

bugpipe-3.1.1/src/bugpipe/cli/output.py

@@ -0,0 +1,168 @@
+"""
+Console output for the CLI.
+
+Results print as their dataclasses through a pager, so bulk output scrolls
+instead of flooding the terminal. Writing them to file is left to the models'
+own ``to_json()``/``to_csv()``.
+"""
+
+import typing as t
+from contextlib import nullcontext
+from datetime import datetime
+
+from rich.box import ASCII
+from rich.console import Console, Group
+from rich.pretty import Pretty
+from rich.table import Table
+
+from ..api.models import Comment, Exportable, Issue, Results
+
+__all__ = ["FAIL", "INFO", "OK", "WARN", "export_out", "print_out"]
+
+#: Issue table columns: header -> field name. Int cells are right-aligned.
+ISSUE_COLUMNS = {
+    "ID": "id",
+    "Title": "title",
+    "Type": "issue_type",
+    "Priority": "priority",
+    "Severity": "severity",
+    "Status": "status",
+    "24h Views": "views_24h",
+    "7d Views": "views_7d",
+    "30d Views": "views_30d",
+    "Created At": "created_at",
+    "Modified At": "modified_at",
+}
+
+#: Success marker (green ✔).
+OK = "[bold green]✔[/bold green]"
+
+#: Failure/error marker (red ✘).
+FAIL = "[bold red]✘[/bold red]"
+
+#: Warning/interrupted marker (yellow ✘).
+WARN = "[bold yellow]✘[/bold yellow]"
+
+#: Informational marker (blue *).
+INFO = "[bold blue]*[/bold blue]"
+
+console = Console(log_time=False, log_path=False)
+
+
+def prettify(output: t.Any) -> Group | None:
+    """
+    Build a pretty-printed view of a result, one item per block.
+
+    :param output: A single item, or a list of them.
+    :return: The renderable, or None when there is nothing to show.
+    """
+
+    if not output:
+        return None
+    items = output if isinstance(output, list) else [output]
+    blocks = [block for item in items for block in (Pretty(item), "")]
+    return Group(*blocks[:-1], fit=False)
+
+
+def table(rows: t.Sequence[dict | Exportable] | Exportable) -> Table | None:
+    """
+    Build a table.
+
+    A sequence gets one row per item; a single item gets one
+    row per dataclass field, as field name and value.
+
+    :param rows: The items to show, or one item.
+    :return: The table, or None when there is nothing to show.
+    """
+
+    is_single_item: bool = isinstance(rows, Exportable)
+    if is_single_item:
+        dicts = [
+            {"field": key, "value": value} for key, value in rows.to_dict().items()
+        ]
+    elif not rows:
+        return None
+    else:
+        dicts = [
+            (
+                {header: row.to_dict()[name] for header, name in ISSUE_COLUMNS.items()}
+                if isinstance(row, Issue)
+                else row.to_dict() if isinstance(row, Exportable) else row
+            )
+            for row in rows
+        ]
+
+    table = Table(
+        box=ASCII, highlight=True, expand=not is_single_item, header_style="bold"
+    )
+    for header, value in dicts[0].items():
+        table.add_column(
+            str(header).title(),
+            justify="right" if isinstance(value, int) else "left",
+            overflow="fold",
+        )
+    for row in dicts:
+        table.add_row(
+            *("[dim]-[/dim]" if cell is None else str(cell) for cell in row.values())
+        )
+
+    return table
+
+
+def print_out(
+    output: list[dict] | Results[Issue] | Results[Comment] | Issue | Comment,
+    no_pager: bool = False,
+    prettified: bool = False,
+):
+    """
+    Show a result, paging it in a terminal.
+
+    :param output: A single issue or comment, a list of issues or comments,
+        or a list of dicts.
+    :param no_pager: Print straight to the terminal instead of paging.
+    :param prettified: Print results as prettified dataclasses instead of a table.
+    """
+
+    if not (
+        isinstance(output, (Issue, Comment))
+        or isinstance(output, Results)
+        and all(isinstance(item, (Issue, Comment)) for item in output)
+        or isinstance(output, list)
+        and all(isinstance(item, dict) for item in output)
+    ):
+        raise ValueError(f"Unexpected value type for param `output`: {type(output)}")
+
+    render = prettify(output=output) if prettified else table(rows=output)
+    if render is None:
+        console.log(f"{WARN} Nothing to print.")
+        return
+
+    if not no_pager and not console.is_terminal:
+        console.print(f"{WARN} Not a TTY — output won't be paged.")
+    with (
+        console.pager(styles=True)
+        if not no_pager and console.is_terminal
+        else nullcontext()
+    ):
+        console.print(render)
+
+
+def export_out(output: Exportable | Results[t.Any], formats: list[str]):
+    """
+    Write a result to timestamped files, one per format.
+
+    :param output: A single item, or a list of them.
+    :param formats: Format strings, each one of ``"csv"`` or ``"json"``.
+    """
+
+    if not output:
+        return
+
+    base = f"bugpipe-{datetime.now().astimezone().strftime('%Y%m%d_%H%M%S')}"
+    for fmt in formats:
+        if fmt == "json":
+            console.print(f"{OK} JSON exported to {output.to_json(f'{base}.json')}")
+        elif fmt == "csv":
+            console.print(f"{OK} CSV exported to {output.to_csv(f'{base}.csv')}")
+        else:
+            continue

{bugpipe-3.0.2 → bugpipe-3.1.1}/src/bugpipe/cli/update_checker.py

@@ -4,15 +4,13 @@ import json
 import re
 import time
 import typing as t
-from importlib.metadata import version
 from pathlib import Path
 from tempfile import gettempdir
 
 import httpx
 from rich.status import Status
 
-__pkg__ = "bugpipe"
-__version__ = version(__pkg__)
+from . import metadata
 
 CACHE_FILE = Path(gettempdir()) / "bugpipe_update_check.json"
 CACHE_TTL = 3600
@@ -93,8 +91,8 @@ def standard_release(version: str) -> bool:
 
 
 def check(
-    package_name: str = __pkg__,
-    package_version: str = __version__,
+    package_name: str = metadata.pkg_name,
+    package_version: str = metadata.version,
     status: Status | None = None,
 ):
     """Print a notice when PyPI has a newer version.
@@ -118,15 +116,14 @@ def check(
 
     available = data["data"]["version"]
     message = (
-        f"Version {package_version} of {package_name} is outdated. "
-        f"Version {available} "
+        f"Version {package_version} of {package_name} is outdated. Version {available} "
     )
     release_date = data["data"]["upload_time"]
     message += (
         f"was released on {release_date[:10]}." if release_date else "is available."
     )
 
-    from .term import console
+    from .output import console
 
     console.log(f"[bold blue]⬆[/bold blue] {message}")
 

bugpipe-3.0.2/src/bugpipe/cli/term.py

@@ -1,234 +0,0 @@
-"""
-Console output for the CLI.
-
-Results print as their dataclasses through a pager, so bulk output scrolls
-instead of flooding the terminal. Writing them to file is left to the models'
-own ``to_json()``/``to_csv()``.
-"""
-
-import enum
-import typing as t
-from contextlib import nullcontext
-from datetime import datetime
-
-from rich.box import ASCII
-from rich.console import Console
-from rich.pretty import Pretty
-from rich.table import Table
-from rich.text import Text
-
-from ..api.models import (
-    Comment,
-    Exportable,
-    Issue,
-    IssueType,
-    Priority,
-    Results,
-    Severity,
-    Status,
-)
-
-__all__ = ["FAIL", "INFO", "OK", "WARN", "export", "print_out"]
-
-#: Style for values the API sent that the enum doesn't define (e.g. ``TYPE_7``).
-UNKNOWN_STYLE = "magenta"
-
-#: Priority cell styles. Other known values (P3, P4) are plain yellow.
-PRIORITY_STYLES = {
-    Priority.P0: "bold red",
-    Priority.P1: "red",
-    Priority.P2: "bold yellow",
-}
-
-#: Severity cell styles. Other known values (S3, S4) are plain yellow.
-SEVERITY_STYLES = {
-    Severity.S0: "bold red",
-    Severity.S1: "red",
-    Severity.S2: "bold yellow",
-}
-
-#: Issue type cell styles. Other known values (INTERNAL_CLEANUP, PROCESS) are unstyled.
-ISSUE_TYPE_STYLES = {
-    IssueType.VULNERABILITY: "bold red",
-    IssueType.BUG: "red",
-    IssueType.CUSTOMER_ISSUE: "bold yellow",
-    IssueType.FEATURE_REQUEST: "bold green",
-}
-
-#: Status cell styles. Open statuses are blue, fixed ones green. Other closed
-#: statuses (NOT_REPRODUCIBLE, INTENDED_BEHAVIOR, OBSOLETE, INFEASIBLE, DUPLICATE)
-#: are dim.
-STATUS_STYLES = {
-    Status.NEW: "bold blue",
-    Status.ASSIGNED: "cyan",
-    Status.ACCEPTED: "bold cyan",
-    Status.FIXED: "green",
-    Status.VERIFIED: "bold green",
-}
-
-#: Issue table columns: header -> cell builder. Int cells are right-aligned.
-ISSUE_COLUMNS: dict[str, t.Callable[[Issue], t.Any]] = {
-    "ID": lambda issue: issue.id,
-    "Title": lambda issue: issue.title,
-    "Type": lambda issue: _style_cell(
-        value=issue.issue_type, styles=ISSUE_TYPE_STYLES, default="dim"
-    ),
-    "Priority": lambda issue: _style_cell(
-        value=issue.priority, styles=PRIORITY_STYLES, default="yellow"
-    ),
-    "Severity": lambda issue: _style_cell(
-        value=issue.severity, styles=SEVERITY_STYLES, default="green"
-    ),
-    "Status": lambda issue: _style_cell(
-        value=issue.status, styles=STATUS_STYLES, default="dim"
-    ),
-    "24h Views": lambda issue: issue.views_24h,
-    "7d Views": lambda issue: issue.views_7d,
-    "30d Views": lambda issue: issue.views_30d,
-    "Created At": lambda issue: issue.created_at,
-    "Modified At": lambda issue: issue.modified_at,
-}
-
-#: Success marker (green ✔).
-OK = "[bold green]✔[/bold green]"
-
-#: Failure/error marker (red ✘).
-FAIL = "[bold red]✘[/bold red]"
-
-#: Warning/interrupted marker (yellow ✘).
-WARN = "[bold yellow]✘[/bold yellow]"
-
-#: Informational marker (blue *).
-INFO = "[bold blue]*[/bold blue]"
-
-console = Console(log_time=False, log_path=False)
-
-
-def _style_cell(value: enum.Enum | None, styles: dict, default: str = "") -> Text | str:
-    """
-    Build a table cell for an enum value, styled by its member.
-
-    :param value: The enum value, or None when the issue has none.
-    :param styles: Style per known member.
-    :param default: Style for known members missing from ``styles``.
-    :return: The styled name, or an empty string for None.
-    """
-
-    if value is None:
-        return ""
-    if value.name not in type(value).__members__:
-        return Text(value.name, style=UNKNOWN_STYLE)
-    return Text(value.name, style=styles.get(value, default))
-
-
-def _pretty_print(output: t.Any):
-    """
-    Show a result, paging it.
-
-    :param output: A single item, or a list of them.
-    """
-
-    if not output:
-        console.log("No results.")
-        return
-
-    context = console.pager(styles=True) if console.is_terminal else nullcontext()
-    if not console.is_terminal:
-        console.print(f"{WARN} Not a TTY — output won't be paged.")
-
-    with context:
-        if isinstance(output, list):
-            for index, item in enumerate(output):
-                if index:
-                    console.print()
-                console.print(Pretty(item))
-        else:
-            console.print(Pretty(output))
-
-
-def _print_table(rows: t.Sequence[dict | Exportable]):
-    """
-    Print and page rows in a table. Headers come from the first row.
-
-    :param rows: Dicts (headers are the keys), issues (headers from
-        ``ISSUE_COLUMNS``), or other exportables (headers from ``to_dict``).
-    """
-
-    if not rows:
-        return
-    dicts = [
-        (
-            {header: cell(row) for header, cell in ISSUE_COLUMNS.items()}
-            if isinstance(row, Issue)
-            else row.to_dict() if isinstance(row, Exportable) else row
-        )
-        for row in rows
-    ]
-
-    table = Table(box=ASCII, highlight=True, expand=True, header_style="bold")
-    for header, value in dicts[0].items():
-        table.add_column(
-            str(header).title(),
-            justify="right" if isinstance(value, int) else "left",
-            overflow="fold",
-        )
-    for row in dicts:
-        table.add_row(
-            *(cell if isinstance(cell, Text) else str(cell) for cell in row.values())
-        )
-
-    if not console.is_terminal:
-        console.print(f"{WARN} Not a TTY — output won't be paged.")
-    with console.pager(styles=True) if console.is_terminal else nullcontext():
-        console.print(table)
-
-
-def print_out(
-    output: list[dict] | Results[Issue] | Results[Comment] | Issue, as_raw: bool = False
-):
-    """
-    Show a result, paging it. Issues and dicts go in a table; a single issue
-    and comments print as their dataclasses.
-
-    :param output: A single issue, a list of issues or comments, or a list of dicts.
-    :param as_raw: Print tabular results as dataclasses instead of a table.
-    """
-
-    if (
-        isinstance(output, Issue)
-        or isinstance(output, Results)
-        and all(isinstance(item, Comment) for item in output)
-    ):
-        _pretty_print(output=output)
-
-    elif (
-        isinstance(output, Results)
-        and all(isinstance(item, Issue) for item in output)
-        or isinstance(output, list)
-        and all(isinstance(item, dict) for item in output)
-    ):
-        if as_raw:
-            _pretty_print(output=output)
-        else:
-            _print_table(rows=output)
-
-
-def export(output: Exportable | Results[t.Any], formats: list[str]):
-    """
-    Write a result to timestamped files, one per format.
-
-    :param output: A single item, or a list of them.
-    :param formats: Format strings, each one of ``"csv"`` or ``"json"``.
-    """
-
-    if not output:
-        return
-
-    base = f"bugpipe-{datetime.now().astimezone().strftime('%Y%m%d_%H%M%S')}"
-    for fmt in formats:
-        if fmt == "json":
-            console.print(f"\n{OK} JSON exported to {output.to_json(f'{base}.json')}")
-        elif fmt == "csv":
-            console.print(f"\n{OK} CSV exported to {output.to_csv(f'{base}.csv')}")
-        else:
-            continue