cu-cli-core 0.1.0b1__py3-none-any.whl

cu_cli_core/schema_validation.py

@@ -0,0 +1,312 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT license.
+
+"""Local, structural schema validation against the bundled rules for an
+api-version.
+
+Deterministic and offline — **no service call**. ``validate`` produces detailed,
+actionable messages: on a bad field ``type`` it names the field and lists the
+accepted types, and returns exit code ``2`` on any error (so agents can branch).
+
+The accepted types/methods are shared by both MVP api-versions; the
+``api_version`` argument is threaded through so future versions can diverge
+without changing call sites.
+"""
+
+from __future__ import annotations
+
+import json
+import re
+from dataclasses import dataclass, field
+from importlib import resources as ir
+from typing import Any, List, Optional, Tuple
+
+from .service_options import DEFAULT_API_VERSION
+
+# Accepted field types/methods come from the bundled CU OpenAPI spec (the service
+# contract) so they never drift from the API. A hardcoded fallback keeps the
+# validator working if the bundled spec is unavailable.
+_FALLBACK_TYPES = ["array", "boolean", "date", "integer", "json", "number",
+                   "object", "string", "time"]
+_FALLBACK_METHODS = ["classify", "extract", "generate"]
+
+
+def _spec_enums(api_version: str) -> Tuple[List[str], List[str]]:
+    try:
+        text = (ir.files("cu_cli_core")
+                .joinpath(f"resources/openapi/{api_version}/ContentUnderstanding.json")
+                .read_text(encoding="utf-8"))
+        defs = json.loads(text).get("definitions", {})
+        types = defs.get("ContentFieldType", {}).get("enum")
+        methods = defs.get("GenerationMethod", {}).get("enum")
+        return (sorted(types) if isinstance(types, list) and types else _FALLBACK_TYPES,
+                sorted(methods) if isinstance(methods, list) and methods else _FALLBACK_METHODS)
+    except Exception:
+        return _FALLBACK_TYPES, _FALLBACK_METHODS
+
+
+ALLOWED_TYPES, ALLOWED_METHODS = _spec_enums(DEFAULT_API_VERSION)
+
+_CUSTOM_ANALYZER_ID_RE = re.compile(r"^[a-zA-Z0-9_]{1,64}$")
+_BASE_ANALYZER_ID_RE = re.compile(r"^[a-zA-Z0-9._-]{1,64}$")
+_MAX_NESTING = 4
+_MIN_DESCRIPTION_LEN = 15
+
+
+@dataclass
+class Finding:
+    path: str
+    msg: str
+
+
+@dataclass
+class ValidationResult:
+    ok: bool
+    errors: List[Finding] = field(default_factory=list)
+    warnings: List[Finding] = field(default_factory=list)
+
+    def as_dict(self) -> dict:
+        return {
+            "ok": self.ok,
+            "errors": [{"path": e.path, "msg": e.msg} for e in self.errors],
+            "warnings": [{"path": w.path, "msg": w.msg} for w in self.warnings],
+        }
+
+
+def _types_list() -> str:
+    return "[" + ", ".join(ALLOWED_TYPES) + "]"
+
+
+def custom_analyzer_id_error(value: Any) -> str | None:
+    """Return the user-facing validation error for a custom analyzer ID."""
+    if isinstance(value, str) and _CUSTOM_ANALYZER_ID_RE.fullmatch(value):
+        return None
+    return (
+        "must contain 1-64 ASCII letters, numbers, or underscores. "
+        "Hyphens are reserved for service-provided prebuilt analyzer IDs "
+        "(for example, 'prebuilt-invoice')."
+    )
+
+
+def _validate_field(name: str, defn: Any, path: str, depth: int,
+                    errors: List[Finding], warnings: List[Finding]) -> None:
+    if not isinstance(defn, dict):
+        errors.append(Finding(path, f"field '{name}' must be an object."))
+        return
+
+    if "$ref" in defn:
+        errors.append(Finding(
+            f"{path}.$ref",
+            "`$ref` is not currently supported in analyzer field schemas; "
+            "inline the field definition.",
+        ))
+        return
+
+    ftype = defn.get("type")
+
+    if ftype is None:
+        errors.append(Finding(
+            f"{path}.type",
+            "missing `type`; every field definition requires an explicit type.",
+        ))
+    elif ftype is not None and ftype not in ALLOWED_TYPES:
+        errors.append(Finding(
+            f"{path}.type",
+            f"must be one of {_types_list()}, got '{ftype}'.",
+        ))
+
+    desc = defn.get("description")
+    if desc is None or (isinstance(desc, str) and not desc.strip()):
+        warnings.append(Finding(f"{path}.description",
+                                "no `description` — the model uses this as a per-field prompt."))
+    elif not isinstance(desc, str):
+        errors.append(Finding(f"{path}.description", "must be a string."))
+    elif len(desc.strip()) < _MIN_DESCRIPTION_LEN:
+        warnings.append(Finding(f"{path}.description",
+                                f"description is very short ({len(desc.strip())} chars); be specific."))
+
+    method = defn.get("method")
+    if method is not None and method not in ALLOWED_METHODS:
+        errors.append(Finding(f"{path}.method",
+                              f"must be one of [{', '.join(ALLOWED_METHODS)}], got '{method}'."))
+    if method == "classify":
+        enum = defn.get("enum")
+        if not isinstance(enum, list) or len({str(e) for e in enum}) < 2:
+            errors.append(Finding(f"{path}.enum",
+                                  "`classify` fields require `enum` with >=2 distinct values."))
+
+    if ftype == "array":
+        items = defn.get("items")
+        if not isinstance(items, dict):
+            errors.append(Finding(f"{path}.items", "`array` fields require an `items` object."))
+        else:
+            _depth_check(depth + 1, f"{path}.items", errors, warnings)
+            _validate_field(f"{name}[]", items, f"{path}.items", depth + 1, errors, warnings)
+
+    if ftype == "object":
+        props = defn.get("properties")
+        if not isinstance(props, dict) or not props:
+            errors.append(Finding(
+                f"{path}.properties",
+                "`object` fields require a non-empty `properties` map.",
+            ))
+        else:
+            _depth_check(depth + 1, f"{path}.properties", errors, warnings)
+            for sub_name, sub_def in props.items():
+                _validate_field(sub_name, sub_def, f"{path}.properties.{sub_name}",
+                                depth + 1, errors, warnings)
+
+    esc = defn.get("estimateSourceAndConfidence")
+    if esc is not None and not isinstance(esc, bool):
+        errors.append(Finding(f"{path}.estimateSourceAndConfidence", "must be a boolean."))
+
+
+def _depth_check(depth: int, path: str, errors: List[Finding], warnings: List[Finding]) -> None:
+    if depth > _MAX_NESTING:
+        warnings.append(Finding(path,
+                                f"nesting depth {depth}; accuracy drops past depth "
+                                f"{_MAX_NESTING}. Consider flattening."))
+
+
+def validate_schema(body: Any, *, api_version: Optional[str] = None) -> ValidationResult:
+    errors: List[Finding] = []
+    warnings: List[Finding] = []
+
+    if not isinstance(body, dict):
+        errors.append(Finding("$", "schema root must be a JSON object."))
+        return ValidationResult(ok=False, errors=errors, warnings=warnings)
+
+    aid = body.get("analyzerId") or body.get("analyzer_id")
+    if aid is not None:
+        aid_error = custom_analyzer_id_error(aid)
+        if aid_error:
+            errors.append(Finding("analyzerId", aid_error))
+
+    base = body.get("baseAnalyzerId") or body.get("base_analyzer_id")
+    if base is not None and (not isinstance(base, str) or not _BASE_ANALYZER_ID_RE.match(base)):
+        errors.append(Finding("baseAnalyzerId", "must match ^[a-zA-Z0-9._-]{1,64}$."))
+    elif base is None:
+        warnings.append(Finding("baseAnalyzerId",
+                                "no `baseAnalyzerId`; recommend `prebuilt-document`."))
+
+    pinned = body.get("apiVersion")
+    if pinned is not None and api_version is not None and pinned != api_version:
+        # Callers pass the already-reconciled api_version; a residual mismatch
+        # here is surfaced so the schema and resolved version never diverge.
+        errors.append(Finding("apiVersion",
+                              f"schema pins '{pinned}' but resolved api-version is '{api_version}'."))
+
+    models = body.get("models")
+    if models is not None and not isinstance(models, dict):
+        errors.append(Finding("models", "must be an object mapping role -> model name."))
+
+    has_content_categories = False
+    cfg = body.get("config")
+    if cfg is not None:
+        if not isinstance(cfg, dict):
+            errors.append(Finding("config", "must be an object."))
+        else:
+            for bool_key in ("enableSegment", "segmentPerPage", "estimateFieldSourceAndConfidence"):
+                val = cfg.get(bool_key)
+                if val is not None and not isinstance(val, bool):
+                    errors.append(Finding(f"config.{bool_key}", "must be a boolean."))
+
+            cats = cfg.get("contentCategories")
+            if cats is not None:
+                if not isinstance(cats, dict) or not cats:
+                    errors.append(Finding("config.contentCategories",
+                                          "must be a non-empty object when provided."))
+                else:
+                    has_content_categories = True
+                    for cat_name, cat_def in cats.items():
+                        if not isinstance(cat_def, dict):
+                            errors.append(Finding(
+                                f"config.contentCategories.{cat_name}",
+                                "must be an object with category definition fields.",
+                            ))
+                            continue
+
+                        desc = cat_def.get("description")
+                        if desc is None or (isinstance(desc, str) and not desc.strip()):
+                            warnings.append(Finding(
+                                f"config.contentCategories.{cat_name}.description",
+                                "no `description` — classification quality improves with clear category intent.",
+                            ))
+                        elif not isinstance(desc, str):
+                            errors.append(Finding(
+                                f"config.contentCategories.{cat_name}.description",
+                                "must be a string.",
+                            ))
+
+                        analyzer_id = cat_def.get("analyzerId")
+                        if analyzer_id is not None:
+                            if not isinstance(analyzer_id, str) or not _BASE_ANALYZER_ID_RE.match(analyzer_id):
+                                errors.append(Finding(
+                                    f"config.contentCategories.{cat_name}.analyzerId",
+                                    "must match ^[a-zA-Z0-9._-]{1,64}$.",
+                                ))
+
+    fs = body.get("fieldSchema") or body.get("field_schema")
+    if fs is None:
+        if not has_content_categories:
+            warnings.append(Finding("fieldSchema", "no `fieldSchema`; layout/markdown only."))
+    elif not isinstance(fs, dict):
+        errors.append(Finding("fieldSchema", "must be an object."))
+    else:
+        fields = fs.get("fields")
+        if fields is None:
+            warnings.append(Finding("fieldSchema.fields", "no `fields`; layout only."))
+        elif not isinstance(fields, dict):
+            errors.append(Finding("fieldSchema.fields", "must be an object."))
+        elif fields:
+            models_map = models if isinstance(models, dict) else {}
+            if not models_map.get("completion"):
+                warnings.append(Finding("models.completion",
+                                        "field extraction needs a completion model, e.g. "
+                                        "`\"models\": {\"completion\": \"gpt-5.2\"}`."))
+            for name, defn in fields.items():
+                _validate_field(name, defn, f"fieldSchema.fields.{name}", 1, errors, warnings)
+
+        defs = fs.get("definitions")
+        if defs is not None:
+            if not isinstance(defs, dict):
+                errors.append(Finding("fieldSchema.definitions", "must be an object."))
+            else:
+                for name, defn in defs.items():
+                    _validate_field(name, defn, f"fieldSchema.definitions.{name}", 1,
+                                    errors, warnings)
+
+    return ValidationResult(ok=not errors, errors=errors, warnings=warnings)
+
+
+def schema_pinned_version(body: Any) -> Optional[str]:
+    if isinstance(body, dict):
+        v = body.get("apiVersion")
+        return v if isinstance(v, str) else None
+    return None
+
+
+def first_error_line(result: ValidationResult, schema_path: str) -> str:
+    """The design-doc 'Invalid schema (structural)' one-liner for the first error."""
+    e = result.errors[0]
+    return (
+        f"Schema invalid: {schema_path} — {e.path}: {e.msg} "
+        "Run `cu analyzer validate --help` for validation guidance."
+    )
+
+
+def parse_and_validate(text: str, *, api_version: Optional[str] = None
+                       ) -> Tuple[ValidationResult, Optional[dict]]:
+    """Parse JSON text, then validate. JSON errors are returned as a validation
+    error (exit-2 territory) rather than raised."""
+    try:
+        body = json.loads(text)
+    except json.JSONDecodeError as exc:
+        res = ValidationResult(
+            ok=False,
+            errors=[Finding("$", f"file is not valid JSON: {exc.msg} "
+                                 f"at line {exc.lineno} col {exc.colno}.")],
+        )
+        return res, None
+    result = validate_schema(body, api_version=api_version)
+    return result, body if isinstance(body, dict) else None

cu_cli_core/serialization.py

@@ -0,0 +1,75 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT license.
+
+"""Convert CU and Azure SDK values into frontend-neutral plain values."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping, Sequence
+from dataclasses import asdict, is_dataclass
+from datetime import date, datetime, time
+from enum import Enum
+from pathlib import Path
+from typing import Any
+
+from .errors import ValidationError
+
+
+def to_plain_value(value: Any) -> Any:
+    """Recursively convert supported values to dictionaries, lists, and scalars."""
+
+    return _to_plain_value(value, seen=set())
+
+
+def _to_plain_value(value: Any, *, seen: set[int]) -> Any:
+    if value is None or isinstance(value, (str, int, float, bool)):
+        return value
+    if isinstance(value, Enum):
+        return _to_plain_value(value.value, seen=seen)
+    if isinstance(value, (date, datetime, time)):
+        return value.isoformat()
+    if isinstance(value, Path):
+        return str(value)
+
+    identity = id(value)
+    if identity in seen:
+        raise ValidationError("cannot serialize a cyclic result value")
+
+    if hasattr(value, "as_dict"):
+        seen.add(identity)
+        try:
+            converted = value.as_dict()
+        except Exception as exc:
+            raise ValidationError(
+                f"failed to serialize {type(value).__name__} through as_dict()"
+            ) from exc
+        finally:
+            seen.remove(identity)
+        return _to_plain_value(converted, seen=seen)
+
+    if is_dataclass(value) and not isinstance(value, type):
+        seen.add(identity)
+        try:
+            converted = asdict(value)
+        finally:
+            seen.remove(identity)
+        return _to_plain_value(converted, seen=seen)
+
+    if isinstance(value, Mapping):
+        seen.add(identity)
+        try:
+            return {
+                str(key): _to_plain_value(item, seen=seen)
+                for key, item in value.items()
+            }
+        finally:
+            seen.remove(identity)
+
+    if isinstance(value, Sequence) and not isinstance(value, (str, bytes, bytearray)):
+        seen.add(identity)
+        try:
+            return [_to_plain_value(item, seen=seen) for item in value]
+        finally:
+            seen.remove(identity)
+
+    raise ValidationError(f"unsupported result value: {type(value).__name__}")

cu_cli_core/service_options.py

@@ -0,0 +1,71 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT license.
+
+"""Static service-option metadata shared by command frontends."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from .command_spec import ArgumentValueType, SurfaceClassification
+
+DEFAULT_API_VERSION = "2025-11-01"
+
+
+@dataclass(frozen=True)
+class ServiceOptionSpec:
+    key: str
+    name: str
+    parser_name: str
+    help: str
+    value_type: ArgumentValueType = ArgumentValueType.STRING
+    aliases: tuple[str, ...] = ()
+    required: bool = False
+    default: object = None
+    choices: tuple[str, ...] = ()
+    sensitive: bool = False
+    classification: SurfaceClassification = SurfaceClassification.COMMON
+
+
+ENDPOINT = ServiceOptionSpec(
+    key="endpoint",
+    name="--endpoint",
+    parser_name="endpoint",
+    help="Microsoft Foundry resource endpoint for Content Understanding.",
+)
+API_VERSION = ServiceOptionSpec(
+    key="api-version",
+    name="--api-version",
+    parser_name="api_version",
+    help="Content Understanding service API version.",
+    default=DEFAULT_API_VERSION,
+)
+AUTH_MODE = ServiceOptionSpec(
+    key="auth-mode",
+    name="--auth-mode",
+    parser_name="auth_mode",
+    help="Authentication mode.",
+    default="login",
+    choices=("login", "key"),
+)
+API_KEY = ServiceOptionSpec(
+    key="api-key",
+    name="--api-key",
+    parser_name="api_key",
+    help="Microsoft Foundry resource API key.",
+    sensitive=True,
+)
+
+SERVICE_OPTIONS = (ENDPOINT, API_VERSION, AUTH_MODE, API_KEY)
+_SERVICE_OPTIONS_BY_KEY = {option.key: option for option in SERVICE_OPTIONS}
+
+if len(_SERVICE_OPTIONS_BY_KEY) != len(SERVICE_OPTIONS):
+    raise RuntimeError("duplicate service option key")
+
+
+def get_service_option(key: str) -> ServiceOptionSpec:
+    return _SERVICE_OPTIONS_BY_KEY[key]
+
+
+def service_options_for(keys: tuple[str, ...]) -> tuple[ServiceOptionSpec, ...]:
+    return tuple(get_service_option(key) for key in keys)

cu_cli_core/spec_validation.py

@@ -0,0 +1,141 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT license.
+
+"""Spec-backed structural validation against the bundled CU OpenAPI (Swagger 2.0).
+
+The CU service contract is published as ``ContentUnderstanding.json`` (Swagger
+2.0, whose ``definitions`` are JSON Schema Draft 4). We bundle that JSON per
+api-version and validate an analyzer body against the ``ContentAnalyzer``
+definition with ``jsonschema`` — so the structural rules come straight from the
+service contract instead of a hand-maintained list.
+
+Two adaptations are applied:
+
+* **Create-view** — the ``ContentAnalyzer`` model marks server-generated fields
+  (``status``, ``createdAt``, ``lastModifiedAt``, ``analyzerId``) as ``readOnly``
+  yet lists them in ``required``. Those don't exist in an authoring/create body,
+  so we drop ``readOnly`` properties from every object's ``required`` list.
+* **Graceful degradation** — if the bundled spec or ``jsonschema`` is
+  unavailable, ``validate_against_spec`` returns an OK result with no findings so
+  the primary (rule-based) validator is never blocked.
+
+This module is an *additional* structural gate (opt-in via ``cu analyzer
+validate --spec``); the curated, message-friendly checks in ``schema_validate``
+remain the default.
+"""
+
+from __future__ import annotations
+
+import copy
+import json
+from functools import lru_cache
+from importlib import resources as ir
+from typing import Any, List
+
+from .schema_validation import Finding, ValidationResult
+from .service_options import DEFAULT_API_VERSION
+
+_ANALYZER_DEF = "ContentAnalyzer"
+_SPEC_URI = "urn:cu-spec"
+
+
+def _spec_resource(api_version: str) -> str:
+    return f"openapi/{api_version}/ContentUnderstanding.json"
+
+
+@lru_cache(maxsize=None)
+def _load_spec(api_version: str) -> dict | None:
+    try:
+        text = (ir.files("cu_cli_core")
+                .joinpath(f"resources/{_spec_resource(api_version)}")
+                .read_text(encoding="utf-8"))
+        data = json.loads(text)
+        return data if isinstance(data, dict) else None
+    except Exception:
+        return None
+
+
+def spec_available(api_version: str = DEFAULT_API_VERSION) -> bool:
+    """True when the bundled OpenAPI spec exists and has the analyzer definition."""
+    spec = _load_spec(api_version)
+    return bool(spec and isinstance(spec.get("definitions"), dict)
+                and _ANALYZER_DEF in spec["definitions"])
+
+
+def spec_allowed_types(api_version: str = DEFAULT_API_VERSION) -> List[str]:
+    spec = _load_spec(api_version) or {}
+    enum = (spec.get("definitions", {}).get("ContentFieldType", {}) or {}).get("enum") or []
+    return sorted(str(v) for v in enum)
+
+
+def spec_allowed_methods(api_version: str = DEFAULT_API_VERSION) -> List[str]:
+    spec = _load_spec(api_version) or {}
+    enum = (spec.get("definitions", {}).get("GenerationMethod", {}) or {}).get("enum") or []
+    return sorted(str(v) for v in enum)
+
+
+def _create_view_defs(defs: dict) -> dict:
+    """Return a copy of *defs* with ``readOnly`` props removed from ``required``."""
+    out = copy.deepcopy(defs)
+    for d in out.values():
+        if isinstance(d, dict) and d.get("type") == "object" and isinstance(d.get("required"), list):
+            props = d.get("properties") or {}
+            d["required"] = [
+                r for r in d["required"]
+                if not (isinstance(props.get(r), dict) and props[r].get("readOnly"))
+            ]
+    return out
+
+
+@lru_cache(maxsize=None)
+def _build_validator(api_version: str):
+    spec = _load_spec(api_version)
+    if not spec:
+        return None
+    defs = spec.get("definitions")
+    if not isinstance(defs, dict) or _ANALYZER_DEF not in defs:
+        return None
+    try:
+        from jsonschema import Draft4Validator
+        from referencing import Registry, Resource
+        from referencing.jsonschema import DRAFT4
+    except Exception:  # pragma: no cover - deps are declared, defensive only
+        return None
+
+    create_view = {"definitions": _create_view_defs(defs)}
+    resource = Resource.from_contents(create_view, default_specification=DRAFT4)
+    registry = Registry().with_resource(uri=_SPEC_URI, resource=resource)
+    return Draft4Validator(
+        {"$ref": f"{_SPEC_URI}#/definitions/{_ANALYZER_DEF}"},
+        registry=registry,
+    )
+
+
+def _dotted(parts: list) -> str:
+    out = ""
+    for p in parts:
+        if isinstance(p, int):
+            out += f"[{p}]"
+        else:
+            out += f".{p}" if out else str(p)
+    return out or "$"
+
+
+def validate_against_spec(body: Any, *, api_version: str = DEFAULT_API_VERSION) -> ValidationResult:
+    """Validate *body* against the bundled CU ``ContentAnalyzer`` (create-view).
+
+    Returns an OK result with no findings when the spec or ``jsonschema`` are
+    unavailable, so it never blocks the primary validator.
+    """
+    validator = _build_validator(api_version)
+    if validator is None:
+        return ValidationResult(ok=True)
+    if not isinstance(body, dict):
+        return ValidationResult(
+            ok=False, errors=[Finding("$", "schema root must be a JSON object.")]
+        )
+    errors: List[Finding] = []
+    for err in sorted(validator.iter_errors(body), key=lambda e: list(e.absolute_path)):
+        path = _dotted(list(err.absolute_path))
+        errors.append(Finding(path, f"{err.message} (per CU {api_version} spec)"))
+    return ValidationResult(ok=not errors, errors=errors)

cu_cli_core-0.1.0b1.dist-info/METADATA

@@ -0,0 +1,26 @@
+Metadata-Version: 2.4
+Name: cu-cli-core
+Version: 0.1.0b1
+Summary: Framework-neutral command contracts and operations for Azure Content Understanding CLIs.
+Author: Microsoft Corporation
+License: MIT
+Classifier: Development Status :: 4 - Beta
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: azure-ai-contentunderstanding>=1.2.0b3
+Requires-Dist: jsonschema>=4.18
+Requires-Dist: referencing>=0.30
+Provides-Extra: dev
+Requires-Dist: pytest>=7.4; extra == "dev"
+Requires-Dist: pytest-cov>=4.1; extra == "dev"
+Requires-Dist: mypy<2,>=1.8; extra == "dev"
+Requires-Dist: ruff<0.16,>=0.5; extra == "dev"
+
+# CU CLI Core
+
+`cu-cli-core` is an implementation dependency shared by official Azure Content
+Understanding command-line frontends. Install
+[`cu-cli`](https://pypi.org/project/cu-cli/) instead.
+
+Direct use of this package is unsupported. Its contracts may change between
+compatible CU CLI releases.

cu_cli_core-0.1.0b1.dist-info/RECORD

@@ -0,0 +1,29 @@
+cu_cli_core/__init__.py,sha256=DHWkIHgv3xPo9hd_P15Q0CjynCcSCWi57qlqGCgLy1k,290
+cu_cli_core/analysis.py,sha256=pePCCKLsVZnzTc6tnZqky7BFB_-XU6WYH63evcmBxV0,12500
+cu_cli_core/client.py,sha256=8x1RT_taZeCRdo2mWNjaMWXMZF0K6MitZ2ldEKatDOQ,1177
+cu_cli_core/command_spec.py,sha256=0i3OSa6hwJt325hj4cuSO6xmnnu9vipNFMyV7GfniIs,36043
+cu_cli_core/contracts.py,sha256=OZCQsA4e6hrj747nbKT8-NRx_1diFNQ3f27Vlp87nx4,11016
+cu_cli_core/defaults.py,sha256=EBzIocHnK8Q3L3rYJanBrug0qTD9aMAiORo6izKftD0,4854
+cu_cli_core/environment.py,sha256=ThvebulIgf_kKSyKncxQ_Mw1z4_8PGHYwLIfDmu08XY,3258
+cu_cli_core/errors.py,sha256=wDCZZghsoUarc47k2drvbTaxYQAUUdz7sc_WdxC1GMQ,1728
+cu_cli_core/input_planning.py,sha256=xrlHZ_8H25VEOu0waMICcCOgueYI4EZ9_WpGPp9Q3eQ,11147
+cu_cli_core/profiles.py,sha256=4z6H1hy2QLwZIcp6e5rV71-bX4ur3H4rmBRtxjouYSU,22800
+cu_cli_core/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cu_cli_core/schema.py,sha256=uJj4PlNi920m6jWoj0VF3vC6vsr8dbhpoJbEYkko2Y8,14137
+cu_cli_core/schema_validation.py,sha256=GR2z4SG7CDbNMbOgSaI72A8BVG9KYjh7mQIrpGDdfY8,13442
+cu_cli_core/serialization.py,sha256=NPNlZQesjsPuJB2nbfalcRrQQ72sSICkK4W_Rbki0B4,2330
+cu_cli_core/service_options.py,sha256=hXQJ8kfQlgWROxY3RGkHOowd292KYxu9OWF9xnJBoy8,1944
+cu_cli_core/spec_validation.py,sha256=De-YAVxfqeEmzR_HKLqVy01vdNLfq7U4RCgdMFDppbM,5385
+cu_cli_core/operations/__init__.py,sha256=a9Po_SPpPzPCFtAF8RNG5FwsFz7gDYir6-vmTydCMww,130
+cu_cli_core/operations/analysis.py,sha256=yCaWq7vimXI-V2ClXnC3mf4445LnZNu-6TMpFsOzHck,9376
+cu_cli_core/operations/analyzer_copy.py,sha256=uvTgVb3Lf5TpvhoPXvVzQj_8rry1EF3JHKgqJJhMk0Q,13751
+cu_cli_core/operations/analyzers.py,sha256=HGICe9b91kFVRRVYltObRRr5M_4mtmAGisvLVhm1OCI,2715
+cu_cli_core/operations/profiles.py,sha256=VPZppZ0blbFBKamZvBnhwbtfgO8rW3NXEQJokLDD-So,3708
+cu_cli_core/operations/schema.py,sha256=3ILQTqlzvS14wzWGhBELkRPeUKQNZ5FkHKiGiPYUu0M,1315
+cu_cli_core/operations/validation.py,sha256=WbfSvO9hPdc5uZnyYzH0jNZSub0eFHTwtjUQthrAQv8,1383
+cu_cli_core/resources/openapi/2025-11-01/ContentUnderstanding.json,sha256=_lEnj8-0aEn7mSQUPtZsHHffSKFlciZUgNKw4__CFhQ,111923
+cu_cli_core/resources/openapi/2026-06-01-preview/ContentUnderstanding.json,sha256=xb8oVxyD0q_j7bmvr1LUEwXUWO7aaR3mL73PUPucXhQ,127937
+cu_cli_core-0.1.0b1.dist-info/METADATA,sha256=lpiAjBT_QbuOvEhSqGuzr5OpDzVjGg1HHwoXcYDniwA,925
+cu_cli_core-0.1.0b1.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+cu_cli_core-0.1.0b1.dist-info/top_level.txt,sha256=bvblrW7CaZDgJVrnNCtKh5AACehffTYE3-xTNIEIpFw,12
+cu_cli_core-0.1.0b1.dist-info/RECORD,,

cu_cli_core-0.1.0b1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

cu_cli_core-0.1.0b1.dist-info/top_level.txt

@@ -0,0 +1 @@
+cu_cli_core