cu-cli 0.1.0b1__py3-none-any.whl

cu_cli/commands/defaults.py

@@ -0,0 +1,172 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT license.
+
+"""``cu defaults`` — read and update Content Understanding defaults.
+
+Wraps the CU SDK's ``get_defaults`` and ``update_defaults`` operations so users
+can manage resource-level model deployment mappings from the CLI.
+"""
+
+from __future__ import annotations
+
+import rich_click as click
+
+from cu_cli_core.command_spec import (
+    DEFAULTS_SET,
+    DEFAULTS_SHOW,
+    CommandBindingError,
+    build_request,
+    resolve_identifier,
+)
+from ..client import build_client, resolve
+from ..profile import Profile
+from cu_cli_core.defaults import (
+    extract_model_deployments as _extract_model_deployments,
+    parse_model_kv as _parse_model_kv,
+)
+from ..errors import CuCliError, friendly_errors
+from ..output import console, dump_json, dump_markdown_kv
+from ._help import common_commands
+from ._command_spec import with_command_arguments
+from ._options import calling_time, print_runtime_context, with_auth_options
+
+
+def _client(profile: Profile, endpoint, api_key, api_version, entra, show_runtime_context):
+    auth = resolve(
+        profile,
+        endpoint_override=endpoint,
+        api_key_override=api_key,
+        api_version_override=api_version,
+        force_entra=entra,
+    )
+    if show_runtime_context:
+        print_runtime_context(auth, profile)
+    return profile, build_client(
+        profile,
+        endpoint_override=endpoint,
+        api_key_override=api_key,
+        api_version_override=api_version,
+        force_entra=entra,
+    )
+
+
+
+
+@click.group(
+    "defaults",
+    help="Show or configure Content Understanding defaults (model-to-deployment mappings).",
+    epilog="[bold cyan]Common commands:[/bold cyan]\n\n"
+           "[bold green]cu defaults show[/bold green]\n\n"
+           "[white]\u00a0\u00a0Show Content Understanding model-to-deployment mappings.[/white]\n\n"
+           "[bold green]cu defaults set[/bold green] "
+           "[bold cyan]--from-profile[/bold cyan]\n\n"
+           "[white]\u00a0\u00a0Apply model mappings from the current profile as defaults.[/white]",
+)
+def defaults_group() -> None:
+    pass
+
+
+@defaults_group.command(
+    "show",
+    help=DEFAULTS_SHOW.help,
+    epilog=common_commands(
+        ("cu defaults show", "Print model deployment mappings as JSON."),
+        ("cu defaults show --table", "Print model mappings as a readable table."),
+    ),
+)
+@with_command_arguments(DEFAULTS_SHOW)
+@with_auth_options
+@friendly_errors
+def cmd_show(
+    table_output, endpoint, api_key, api_version, entra, profile_name, show_runtime_context,
+    show_calling_time
+) -> None:
+    try:
+        build_request(DEFAULTS_SHOW, {"table_output": table_output})
+    except CommandBindingError as exc:
+        raise CuCliError(str(exc)) from exc
+    profile = Profile.load(profile_name=profile_name)
+    _, client = _client(profile, endpoint, api_key, api_version, entra, show_runtime_context)
+    with calling_time(show_calling_time) as calling_timer:
+        defaults = resolve_identifier(DEFAULTS_SHOW.operation)(client)
+
+    if not table_output:
+        dump_json(defaults)
+        calling_timer.print()
+        return
+
+    mappings = _extract_model_deployments(defaults)
+    if mappings:
+        dump_markdown_kv(mappings, headers=("Model", "Deployment"))
+        calling_timer.print()
+        return
+    console.print("[yellow]Content Understanding defaults are not configured.[/yellow]")
+    calling_timer.print()
+
+
+@defaults_group.command(
+    "set",
+    help=DEFAULTS_SET.help,
+    epilog=common_commands(
+        ("cu defaults set --from-profile", "Push mappings from the effective profile."),
+        (
+            "cu defaults set --model MODEL=DEPLOYMENT",
+            "Add or update one model-to-deployment mapping.",
+        ),
+    ),
+)
+@with_command_arguments(DEFAULTS_SET)
+@with_auth_options
+@friendly_errors
+def cmd_set(
+    model_kv, from_profile, replace, json_output,
+    endpoint, api_key, api_version, entra, profile_name,
+    show_runtime_context, show_calling_time
+) -> None:
+    try:
+        request = build_request(
+            DEFAULTS_SET,
+            {
+                "model_kv": model_kv,
+                "from_profile": from_profile,
+                "replace": replace,
+                "json_output": json_output,
+            },
+        )
+    except CommandBindingError as exc:
+        raise CuCliError(str(exc)) from exc
+    profile = Profile.load(profile_name=profile_name)
+    desired: dict[str, str] = {}
+    if request.from_profile:
+        desired.update({str(k): str(v) for k, v in profile.model_deployments.items()})
+    desired.update(_parse_model_kv(request.models))
+
+    if not desired:
+        raise CuCliError(
+            "no model deployment mappings provided.",
+            hint="pass `--from-profile` to use the effective profile mappings "
+                 "or pass `--model MODEL=DEPLOYMENT`.",
+        )
+
+    _, client = _client(
+        profile, endpoint, api_key, api_version, entra, show_runtime_context
+    )
+
+    with calling_time(show_calling_time) as calling_timer:
+        updated, merged = resolve_identifier(DEFAULTS_SET.operation)(
+            client,
+            desired,
+            replace=request.replace,
+        )
+
+    if json_output:
+        dump_json(updated)
+        calling_timer.print()
+        return
+
+    console.print(
+        f"[green]ok[/green] updated Content Understanding defaults "
+        f"with {len(merged)} mapping(s)."
+    )
+    dump_markdown_kv(merged, headers=("Model", "Deployment"))
+    calling_timer.print()

cu_cli/commands/doctor.py

@@ -0,0 +1,166 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT license.
+
+"""``cu doctor`` — verify endpoint, auth, api-version, and model deployments.
+
+Exits non-zero when a required check fails so scripts and coding agents can gate
+on setup readiness.
+"""
+
+from __future__ import annotations
+
+import rich_click as click
+
+from ..apiversion import API_VERSION_HELP, SUPPORTED_API_VERSIONS, is_supported
+from ..client import build_client, resolve
+from cu_cli_core.defaults import with_prebuilt_default_mappings
+from ..profile import Profile
+from ..core.defaults import is_defaults_not_set as _is_defaults_not_set
+from ..core.doctor import missing_requirements as _missing_requirements
+from ..errors import CuCliError, friendly_errors
+from ..exit_codes import GENERIC_ERROR
+from ..output import console
+from ._options import CALLING_TIME_OPTION, calling_time
+from ._help import common_commands
+from ._model_setup import print_model_free_analyzers, print_model_setup_steps
+
+
+@click.command(
+    "doctor",
+    help="Verify a Microsoft Foundry resource connection and Content Understanding defaults.",
+    epilog=common_commands(
+        ("cu doctor", "Check the active CU CLI profile and resource readiness."),
+        ("cu doctor --profile NAME", "Check one profile without activating it."),
+        ("cu doctor --fix-defaults", "Check readiness and apply profile mappings as defaults."),
+    ),
+)
+@click.option("-p", "--profile", "profile_name", default=None,
+              help="Named CU CLI profile to use (from cu profile).")
+@click.option("--fix-defaults", is_flag=True,
+              help="Configure Content Understanding defaults from profile model mappings.")
+@click.option("--endpoint", default=None, help="Override configured endpoint.")
+@click.option("--auth-mode", type=click.Choice(["login", "key"]), default=None,
+              help="Authentication mode; defaults to the selected CU CLI profile.")
+@click.option("--api-key", default=None, help="Override configured API key.")
+@click.option("--api-version", "api_version", default=None,
+              help=API_VERSION_HELP)
+@CALLING_TIME_OPTION
+@friendly_errors
+def cmd_doctor(endpoint: str | None, api_key: str | None, api_version: str | None,
+               auth_mode: str | None, profile_name: str | None, fix_defaults: bool,
+               show_calling_time: bool) -> None:
+    profile = Profile.load(profile_name=profile_name)
+    failures: list[str] = []
+
+    console.print("[bold]CU CLI configuration[/bold]\n")
+
+    effective_version = api_version or profile.api_version
+    if is_supported(effective_version):
+        console.print(
+            f"[bold]API version:[/bold] {effective_version} [green](supported)[/green]"
+        )
+    else:
+        failures.append(
+            f"api-version {effective_version} is not supported by this build "
+            f"(supported: {', '.join(SUPPORTED_API_VERSIONS)})."
+        )
+        console.print(
+            f"[bold]API version:[/bold] {effective_version} [red](unsupported)[/red]"
+        )
+
+    auth = resolve(profile, endpoint_override=endpoint, api_key_override=api_key,
+                   api_version_override=api_version, auth_mode_override=auth_mode)
+    authentication = (
+        "Microsoft Entra ID" if auth.auth_mode == "entra" else "resource key"
+    )
+    console.print(f"[bold]Microsoft Foundry resource:[/bold] {auth.endpoint}")
+    console.print(f"[bold]Authentication:[/bold] {authentication}")
+    if profile.default_analyzer:
+        console.print(f"[bold]Default analyzer:[/bold] {profile.default_analyzer}")
+    else:
+        console.print("[bold]Default analyzer:[/bold] not configured")
+        console.print(
+            "  [dim]`cu analyze` requires --analyzer until you configure one:\n"
+            "  cu profile set default_analyzer <analyzer-id>[/dim]"
+        )
+
+    client = build_client(profile, endpoint_override=endpoint, api_key_override=api_key,
+                          api_version_override=api_version, auth_mode_override=auth_mode)
+
+    current: dict[str, str] = {}
+    service_reachable = False
+    with calling_time(show_calling_time) as calling_timer:
+        console.print("\n[bold]Checking Content Understanding defaults...[/bold]\n")
+        try:
+            defaults = client.get_defaults()
+            service_reachable = True
+            current = getattr(defaults, "model_deployments", None) or {}
+            console.print("Connected to the Microsoft Foundry resource.")
+            if current:
+                console.print("[bold]Content Understanding defaults:[/bold]")
+                for model, deployment in current.items():
+                    console.print(f"  - {model} -> {deployment}")
+            else:
+                console.print(
+                    "[yellow]Content Understanding defaults have no model "
+                    "deployment mappings.[/yellow]"
+                )
+        except Exception as exc:
+            if _is_defaults_not_set(exc):
+                service_reachable = True
+                console.print("Connected to the Microsoft Foundry resource.")
+                console.print(
+                    "[yellow]Content Understanding defaults are not configured.[/yellow]"
+                )
+            else:
+                failures.append(f"could not reach the service: {exc}")
+                console.print("[red]Could not connect to the service (details below).[/red]")
+
+        missing = _missing_requirements(current) if service_reachable else []
+        if fix_defaults and service_reachable:
+            merged = dict(current)
+            merged.update(profile.model_deployments)
+            merged = with_prebuilt_default_mappings(merged)
+            if not merged:
+                raise CuCliError(
+                    "cannot set defaults: no model deployment mapping is configured",
+                    hint="set model mappings first, e.g. `cu profile set "
+                         "model_deployments.gpt-5.2 <deployment-name>` then rerun "
+                         "`cu doctor --fix-defaults`.",
+                )
+            console.print("\n[bold]Applying Content Understanding defaults...[/bold]")
+            client.update_defaults(model_deployments=merged)
+            console.print("[green]Content Understanding defaults updated.[/green]")
+            missing = _missing_requirements(merged)
+
+    if missing:
+        console.print(
+            "\n[bold yellow]Setup needed for analyzers that use generative AI:"
+            "[/bold yellow]"
+        )
+        for requirement in missing:
+            console.print(f"  - {requirement}")
+        print_model_setup_steps(
+            auth.endpoint,
+            profile_name=profile_name,
+        )
+        print_model_free_analyzers()
+
+    if failures:
+        console.print()
+        for f in failures:
+            console.print(f"[bold red]x[/bold red] {f}")
+        calling_timer.print()
+        raise CuCliError("doctor found problems; see above.", exit_code=GENERIC_ERROR)
+
+    if missing:
+        console.print(
+            "\n[bold]Configuration check complete.[/bold]\n"
+            "Content extraction analyzers are ready. Analyzers that use "
+            "generative AI require the setup above."
+        )
+    else:
+        console.print(
+            "\n[bold green]Configuration check complete. CU CLI is ready.[/bold green]"
+        )
+    calling_timer.print()

cu_cli/commands/env_var.py

@@ -0,0 +1,67 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT license.
+
+"""Discover and inspect supported CU CLI environment variables."""
+
+from __future__ import annotations
+
+import rich_click as click
+from rich.table import Table
+
+from cu_cli_core.command_spec import ENV_VAR_LIST, build_request, resolve_identifier
+from cu_cli_core.environment import ENVIRONMENT_VARIABLES
+
+from ..output import dump_json, result_console
+from ._command_spec import with_command_arguments
+from ._help import common_commands
+
+
+def _environment_help() -> str:
+    blocks = ["[bold cyan]Supported environment variables:[/bold cyan]"]
+    for spec in ENVIRONMENT_VARIABLES:
+        sensitivity = " (sensitive; always redacted)" if spec.sensitive else ""
+        blocks.append(
+            f"[bold green]{spec.name}[/bold green]{sensitivity}\n"
+            f"  {spec.description}\n"
+            f"  Values: {spec.accepted_values}. Default: {spec.default}.\n"
+            f"  Scope: {spec.scope}. {spec.precedence}"
+        )
+    return "\n\n[white] [/white]\n\n".join(blocks)
+
+
+@click.group(
+    "env-var",
+    help="Show help for supported environment variables and inspect values that are set.",
+    epilog=_environment_help()
+    + "\n\n"
+    + common_commands(
+        ("cu env-var list --json", "Print the set variables as redacted JSON."),
+    ),
+)
+def env_var_group() -> None:
+    pass
+
+
+@env_var_group.command(
+    "list",
+    help=ENV_VAR_LIST.help,
+    epilog=common_commands(
+        ("cu env-var list", "List set variables as a table."),
+        ("cu env-var list --json", "Print set variables as redacted JSON."),
+    ),
+)
+@with_command_arguments(ENV_VAR_LIST)
+def cmd_list(json_output: bool) -> None:
+    build_request(ENV_VAR_LIST, {"json_output": json_output})
+    rows = resolve_identifier(ENV_VAR_LIST.operation)()
+    if json_output:
+        dump_json(rows)
+        return
+
+    table = Table(title="Set CU environment variables", show_lines=False)
+    table.add_column("Name", style="bold")
+    table.add_column("Value")
+    table.add_column("Scope")
+    for row in rows:
+        table.add_row(str(row["name"]), str(row["value"]), str(row["scope"]))
+    result_console.print(table)