ndi-cli 0.4.0__py3-none-any.whl

ndi_cli/_login.py

@@ -0,0 +1,47 @@
+"""``ndi login`` and ``ndi version``."""
+
+from __future__ import annotations
+
+import argparse
+import sys
+
+from ndi_sdk.credentials import CredentialsError, login
+
+
+def add_parsers(sub: argparse._SubParsersAction) -> None:
+    login_p = sub.add_parser("login", help="Authorize in the browser and save the API key.")
+    login_p.add_argument(
+        "--api-key",
+        nargs="?",
+        const="",
+        default=None,
+        metavar="KEY",
+        help="Paste a key instead of opening a browser. KEY=- reads stdin. Omit KEY to type it hidden.",
+    )
+    login_p.set_defaults(run=run_login, family="standalone", needs_workspace=False, needs_client=False)
+
+    version = sub.add_parser("version", help="Print CLI and SDK versions.")
+    version.set_defaults(run=run_version, family="standalone", needs_workspace=False, needs_client=False)
+
+
+def run_login(args: argparse.Namespace) -> int:
+    prompt = args.api_key == ""
+    key = None if prompt else args.api_key
+    if key == "-":
+        key = sys.stdin.readline().strip()
+    try:
+        path = login(api_key=key, prompt=prompt, login_command="ndi login")
+    except CredentialsError as exc:
+        print(f"error: {exc}", file=sys.stderr)
+        return 2
+    print(f"saved API key to {path}", file=sys.stderr)
+    return 0
+
+
+def run_version(_args: argparse.Namespace) -> int:
+    from ndi_cli import __version__
+    from ndi_sdk import __version__ as sdk_version
+
+    print(f"ndi {__version__}")
+    print(f"ndi-sdk {sdk_version}")
+    return 0

ndi_cli/_output.py

@@ -0,0 +1,128 @@
+"""Stdout is the payload; stderr is status. ``-o`` picks the shape."""
+
+from __future__ import annotations
+
+import sys
+from collections.abc import Callable
+from pathlib import Path
+
+from ndi_sdk.models.jobs import IngestionResult, Job, ParseResult
+
+OUTPUT_CHOICES = ("auto", "md", "json", "payload", "id")
+
+
+def add_job_output_args(parser) -> None:
+    parser.add_argument(
+        "-o",
+        "--output",
+        choices=OUTPUT_CHOICES,
+        default="auto",
+        help="Result shape (default auto). --json is an alias for json.",
+    )
+    parser.add_argument("--save", default=None, metavar="PATH", help="Write one result to this file.")
+    parser.add_argument("--out-dir", default=None, metavar="DIR", help="Write one file per input.")
+    parser.add_argument("--async", dest="async_submit", action="store_true", help="Submit and print the job id.")
+
+
+def output_mode(args) -> str:
+    if getattr(args, "json", False):
+        return "json"
+    return getattr(args, "output", None) or "auto"
+
+
+def emit_text(text: str, args, *, default_stem: str, suffix: str) -> int:
+    save = getattr(args, "save", None)
+    out_dir = getattr(args, "out_dir", None)
+    if save and out_dir:
+        print("error: use --save or --out-dir, not both", file=sys.stderr)
+        return 2
+    if save:
+        return _write(Path(save), text)
+    if out_dir:
+        directory = Path(out_dir)
+        try:
+            directory.mkdir(parents=True, exist_ok=True)
+        except OSError as exc:
+            return _write_failed(directory, exc, text)
+        return _write(directory / f"{default_stem}{suffix}", text)
+    print(text)
+    return 0
+
+
+def _write(target: Path, text: str) -> int:
+    # encoding is explicit: the default follows the locale, so a C/POSIX
+    # environment would fail on any non-ASCII document the job just produced.
+    try:
+        target.write_text(text, encoding="utf-8")
+    except OSError as exc:
+        return _write_failed(target, exc, text)
+    print(f"saved {target}", file=sys.stderr)
+    return 0
+
+
+def _write_failed(target: Path, exc: OSError, text: str) -> int:
+    """Report the write failure without throwing away the result.
+
+    By the time a result is written the job has already run and been billed, so
+    the content goes to stdout rather than being lost with a traceback.
+    """
+    print(f"error: could not write {target}: {exc.strerror or exc}", file=sys.stderr)
+    print(text)
+    return 1
+
+
+def render_job(job: Job, args, *, auto: Callable[[Job], str], stem: str) -> int:
+    mode = output_mode(args)
+    if mode == "id":
+        print(job.job_id)
+        return _content_failure(job)
+    if mode == "json":
+        code = emit_text(job.model_dump_json(indent=2, exclude_none=True), args, default_stem=stem, suffix=".json")
+    elif mode == "payload":
+        if job.result is None:
+            print("error: job has no result payload", file=sys.stderr)
+            return 1
+        code = emit_text(job.result.model_dump_json(indent=2, exclude_none=True), args, default_stem=stem, suffix=".json")
+    elif mode == "md":
+        markdown = _parse_markdown(job)
+        if markdown is None:
+            print("error: this job has no markdown; use -o auto|json|payload|id", file=sys.stderr)
+            return 1
+        code = emit_text(markdown, args, default_stem=stem, suffix=".md")
+    else:
+        code = emit_text(auto(job), args, default_stem=stem, suffix=_auto_suffix(job, auto))
+    return code or _content_failure(job)
+
+
+def _content_failure(job: Job) -> int:
+    """Non-zero when the job succeeded but its payload reports failed work.
+
+    An ingestion job whose every file failed is still a ``succeeded`` job, so
+    without this ``ndi ingest … && next-step`` runs the next step on nothing.
+    """
+    result = job.result
+    if isinstance(result, IngestionResult) and result.files_failed:
+        print(
+            f"error: {result.files_failed} of {result.files_failed + result.files_ingested + result.files_skipped} "
+            "files failed to ingest",
+            file=sys.stderr,
+        )
+        return 1
+    return 0
+
+
+def _parse_markdown(job: Job) -> str | None:
+    result = job.result
+    if isinstance(result, ParseResult):
+        return result.document.markdown
+    return None
+
+
+def _auto_suffix(job: Job, auto: Callable[[Job], str]) -> str:
+    if isinstance(job.result, ParseResult):
+        document = job.result.document
+        if document.markdown is not None:
+            return ".md"
+        if document.text is None and document.blocks is not None:
+            return ".json"
+    return ".txt"