HTTP: prefer pip-system-certs/certifi_win32 bundle; use init-time verify in retries; add tests

cmdlet/provider_table.py

@@ -0,0 +1,157 @@
+from __future__ import annotations
+
+from typing import Any, Dict, Iterable, Optional, Sequence
+from pathlib import Path
+
+from . import _shared as sh
+from SYS.logger import log, debug
+from SYS import pipeline as ctx
+
+from SYS.result_table_adapters import get_provider
+from SYS.result_table_renderers import RichRenderer
+
+Cmdlet = sh.Cmdlet
+CmdletArg = sh.CmdletArg
+parse_cmdlet_args = sh.parse_cmdlet_args
+
+
+CMDLET = Cmdlet(
+    name="provider-table",
+    summary="Render a provider's result set and optionally run a follow-up cmdlet using the selected row.",
+    usage="provider-table -provider <name> [-sample] [-select <n>] [-run-cmd <name>]",
+    arg=[
+        CmdletArg("provider", type="string", description="Provider name to render (default: example)"),
+        CmdletArg("sample", type="flag", description="Use provider sample/demo items when available."),
+        CmdletArg("select", type="int", description="1-based row index to select and use for follow-up command."),
+        CmdletArg("run-cmd", type="string", description="Cmdlet to invoke with the selected row's selector args."),
+    ],
+    detail=[
+        "Use a registered provider to build a table and optionally run another cmdlet with selection args.",
+        "Emits pipeline-friendly dicts enriched with `_selection_args` so you can pipe into `select` and other cmdlets.",
+        "Example: provider-table -provider example -sample | select -select 1 | add-file -store default",
+    ],
+)
+
+
+def _run(result: Any, args: Sequence[str], config: Dict[str, Any]) -> int:
+    parsed = parse_cmdlet_args(args, CMDLET)
+
+    provider_name = parsed.get("provider") or "example"
+    use_sample = bool(parsed.get("sample", False))
+    run_cmd = parsed.get("run-cmd")
+    select_raw = parsed.get("select")
+
+    try:
+        provider = get_provider(provider_name)
+    except Exception as exc:
+        log(f"Unknown provider: {provider_name}", file=sys.stderr)
+        return 1
+
+    # Obtain items to feed to the adapter
+    items = None
+    if use_sample:
+        # Try to locate SAMPLE_ITEMS in the adapter's module (convention only)
+        try:
+            mod = __import__(provider.adapter.__module__, fromlist=["*"])
+            items = getattr(mod, "SAMPLE_ITEMS", None)
+            if items is None:
+                log("Provider does not expose SAMPLE_ITEMS; no sample available", file=sys.stderr)
+                return 1
+        except Exception:
+            log("Failed to load provider sample", file=sys.stderr)
+            return 1
+    else:
+        # Require input for non-sample runs
+        inputs = list(result) if isinstance(result, Iterable) else []
+        if not inputs:
+            log("No input provided. Use -sample for demo or pipe provider items in.", file=sys.stderr)
+            return 1
+        items = inputs
+
+    # Build rows
+    try:
+        rows = list(provider.adapter(items))
+    except Exception as exc:
+        log(f"Provider adapter failed: {exc}", file=sys.stderr)
+        return 1
+
+    cols = provider.get_columns(rows)
+
+    # Emit rows for downstream pipeline consumption (pipable behavior).
+    try:
+        for r in rows:
+            try:
+                item = {
+                    "title": getattr(r, "title", None) or None,
+                    "path": getattr(r, "path", None) or None,
+                    "ext": getattr(r, "ext", None) or None,
+                    "size_bytes": getattr(r, "size_bytes", None) or None,
+                    "metadata": getattr(r, "metadata", None) or {},
+                    "source": getattr(r, "source", None) or provider.name,
+                    "_selection_args": provider.selection_args(r),
+                }
+                ctx.emit(item)
+            except Exception:
+                # Best-effort: continue emitting other rows
+                continue
+    except Exception:
+        # Non-fatal: continue to rendering even if emission fails
+        pass
+
+    # Render using RichRenderer
+    try:
+        table = RichRenderer().render(rows, cols, provider.metadata)
+        try:
+            from rich.console import Console
+
+            Console().print(table)
+        except Exception:
+            # Fallback to simple printing
+            for r in rows:
+                print(" ".join(str((c.extractor(r) or "")) for c in cols))
+    except Exception as exc:
+        log(f"Rendering failed: {exc}", file=sys.stderr)
+        return 1
+
+    # If no selection requested, we're done
+    if not select_raw:
+        return 0
+
+    try:
+        select_idx = int(select_raw) - 1
+    except Exception:
+        log("Invalid -select value; must be an integer", file=sys.stderr)
+        return 1
+
+    if select_idx < 0 or select_idx >= len(rows):
+        log("-select out of range", file=sys.stderr)
+        return 1
+
+    selected = rows[select_idx]
+    sel_args = provider.selection_args(selected)
+
+    if not run_cmd:
+        # Print selection args for caller
+        log(f"Selection args: {sel_args}", file=sys.stderr)
+        return 0
+
+    # Run follow-up cmdlet
+    try:
+        from cmdlet import ensure_cmdlet_modules_loaded, get as get_cmdlet
+
+        ensure_cmdlet_modules_loaded()
+        cmd_fn = get_cmdlet(run_cmd)
+        if not cmd_fn:
+            log(f"Follow-up cmdlet not found: {run_cmd}", file=sys.stderr)
+            return 1
+
+        # Call the cmdlet with no upstream result, but with selection args
+        ret = cmd_fn(None, sel_args, config or {})
+        return ret
+    except Exception as exc:
+        log(f"Failed to invoke follow-up cmdlet: {exc}", file=sys.stderr)
+        return 1
+
+
+CMDLET.exec = _run
+CMDLET.register()