cu-cli 0.1.0b1__py3-none-any.whl

cu_cli/windows_self_upgrade.py

@@ -0,0 +1,245 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT license.
+
+"""Windows-only detached self-upgrade helper.
+
+On Windows, a running ``cu.exe`` holds an exclusive file lock on its own
+executable image. ``pip install --upgrade`` is non-atomic (uninstall, then
+install); if the install step cannot replace the locked ``cu.exe``, the
+uninstall has already completed and the environment is left with no
+importable ``cu_cli`` module at all.
+
+POSIX allows unlinking/replacing a file that is currently executing, so this
+failure mode is Windows-specific — the fix below is only exercised there.
+
+The fix: don't run pip synchronously from inside ``cu.exe``. Instead, write a
+small, dependency-free helper script to disk and launch it as a fully
+detached process, then let ``cu.exe`` return control to the shell (and exit)
+immediately. The helper:
+
+1. waits for the original ``cu.exe`` process to actually exit, releasing the
+   file lock;
+2. runs ``pip install --upgrade`` for the target version, retrying a few
+   times in case another handle (AV scanning, indexing) still holds the file
+   briefly;
+3. rolls back to the previously installed, known-good ``cu-cli`` (and
+   ``cu-cli-core``) version if the upgrade fails, so the environment is never
+   left without an importable CLI;
+4. logs progress/outcome to a log file for later inspection.
+
+The helper script intentionally does not import ``cu_cli`` (or any of its
+dependencies) — it must keep working even while the ``cu-cli`` package itself
+is mid-uninstall/reinstall.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+import sys
+import tempfile
+import textwrap
+import uuid
+from pathlib import Path
+from typing import Callable, Mapping, Sequence
+
+_LOG_DIR = Path.home() / ".cu"
+
+
+def is_windows() -> bool:
+    """Return whether the current platform needs the detached-helper path."""
+    return sys.platform.startswith("win")
+
+
+def default_log_path() -> Path:
+    return _LOG_DIR / "upgrade.log"
+
+
+def _rollback_args(python_exe: str, current_version: str, core_version: str | None) -> list[str]:
+    args = [
+        python_exe,
+        "-m",
+        "pip",
+        "install",
+        "--force-reinstall",
+        f"cu-cli=={current_version}",
+    ]
+    if core_version:
+        args.append(f"cu-cli-core=={core_version}")
+    return args
+
+
+_HELPER_SOURCE = textwrap.dedent(
+    '''\
+    """Detached helper for `cu upgrade` on Windows (auto-generated, no cu_cli import).
+
+    Do not edit: regenerated on every `cu upgrade`. Safe to delete once the
+    logged outcome shows "upgrade succeeded" or "rollback".
+    """
+    import json
+    import os
+    import subprocess
+    import sys
+    import time
+
+    with open(__file__.rsplit(".", 1)[0] + ".json", "r", encoding="utf-8") as _f:
+        _CONFIG = json.load(_f)
+
+    PARENT_PID = _CONFIG["parent_pid"]
+    UPGRADE_ARGS = _CONFIG["upgrade_args"]
+    ROLLBACK_ARGS = _CONFIG["rollback_args"]
+    ENV_OVERRIDES = _CONFIG["env_overrides"]
+    LOG_PATH = _CONFIG["log_path"]
+    WAIT_TIMEOUT_SECONDS = _CONFIG["wait_timeout_seconds"]
+    RETRY_ATTEMPTS = _CONFIG["retry_attempts"]
+    RETRY_DELAY_SECONDS = _CONFIG["retry_delay_seconds"]
+
+
+    def _log(message):
+        try:
+            with open(LOG_PATH, "a", encoding="utf-8") as handle:
+                handle.write(f"{time.strftime('%Y-%m-%d %H:%M:%S')} {message}\\n")
+        except OSError:
+            pass
+
+
+    def _wait_for_parent_exit(pid, timeout_seconds):
+        try:
+            import ctypes
+
+            synchronize = 0x00100000
+            query_limited = 0x1000
+            handle = ctypes.windll.kernel32.OpenProcess(
+                synchronize | query_limited, False, pid
+            )
+            if not handle:
+                return  # already exited, or we can't see it: proceed anyway
+            try:
+                ctypes.windll.kernel32.WaitForSingleObject(
+                    handle, int(timeout_seconds * 1000)
+                )
+            finally:
+                ctypes.windll.kernel32.CloseHandle(handle)
+        except Exception:
+            # Best effort only: if the wait itself fails, fall through and
+            # rely on the pip retry loop below.
+            time.sleep(2)
+
+
+    def _run_pip(args, attempts, delay_seconds):
+        env = {**os.environ, **ENV_OVERRIDES}
+        result = None
+        for attempt in range(attempts):
+            result = subprocess.run(args, env=env)
+            if result.returncode == 0:
+                return True
+            _log(f"attempt {attempt + 1}/{attempts} failed (exit {result.returncode})")
+            time.sleep(delay_seconds)
+        return False
+
+
+    def main():
+        _log(f"waiting for parent pid {PARENT_PID} to exit")
+        _wait_for_parent_exit(PARENT_PID, WAIT_TIMEOUT_SECONDS)
+        _log(f"running: {' '.join(UPGRADE_ARGS)}")
+        if _run_pip(UPGRADE_ARGS, RETRY_ATTEMPTS, RETRY_DELAY_SECONDS):
+            _log("upgrade succeeded")
+            return
+        _log("upgrade failed; rolling back to previous version")
+        if _run_pip(ROLLBACK_ARGS, RETRY_ATTEMPTS, RETRY_DELAY_SECONDS):
+            _log("rollback succeeded; previous cu-cli remains usable")
+        else:
+            _log(
+                "rollback FAILED - manual recovery required: "
+                + " ".join(ROLLBACK_ARGS)
+            )
+
+
+    if __name__ == "__main__":
+        main()
+    '''
+)
+
+
+def write_helper_files(
+    *,
+    parent_pid: int,
+    upgrade_args: Sequence[str],
+    rollback_args: Sequence[str],
+    env_overrides: Mapping[str, str],
+    log_path: Path,
+    wait_timeout_seconds: float = 30.0,
+    retry_attempts: int = 5,
+    retry_delay_seconds: float = 2.0,
+) -> Path:
+    """Write the helper script + its config to a temp dir; return the script path."""
+    run_dir = Path(tempfile.gettempdir()) / f"cu-upgrade-{uuid.uuid4().hex}"
+    run_dir.mkdir(parents=True, exist_ok=True)
+    script_path = run_dir / "cu_upgrade_helper.py"
+    config_path = run_dir / "cu_upgrade_helper.json"
+
+    config = {
+        "parent_pid": parent_pid,
+        "upgrade_args": list(upgrade_args),
+        "rollback_args": list(rollback_args),
+        "env_overrides": dict(env_overrides),
+        "log_path": str(log_path),
+        "wait_timeout_seconds": wait_timeout_seconds,
+        "retry_attempts": retry_attempts,
+        "retry_delay_seconds": retry_delay_seconds,
+    }
+    config_path.write_text(json.dumps(config), encoding="utf-8")
+    script_path.write_text(_HELPER_SOURCE, encoding="utf-8")
+    return script_path
+
+
+def launch_detached(python_exe: str, script_path: Path) -> subprocess.Popen:
+    """Launch the helper fully detached so it outlives the current process."""
+    creationflags = getattr(subprocess, "DETACHED_PROCESS", 0) | getattr(
+        subprocess, "CREATE_NEW_PROCESS_GROUP", 0
+    )
+    return subprocess.Popen(
+        [python_exe, str(script_path)],
+        creationflags=creationflags,
+        close_fds=True,
+        stdin=subprocess.DEVNULL,
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.DEVNULL,
+    )
+
+
+def run_windows_upgrade(
+    *,
+    current_version: str,
+    core_version: str | None,
+    pip_args: Sequence[str],
+    pip_env: Mapping[str, str],
+    python_exe: str | None = None,
+    parent_pid: int | None = None,
+    write_helper: Callable[..., Path] = write_helper_files,
+    launch: Callable[[str, Path], subprocess.Popen] = launch_detached,
+    log_path: Path | None = None,
+) -> tuple[int, Path]:
+    """Start the detached Windows upgrade helper. Returns (exit_code, log_path).
+
+    ``cu upgrade`` cannot synchronously guarantee the final outcome, because
+    that would require pip to replace the file backing the process still
+    running it. Spawning succeeds, so this returns exit code 0; the actual
+    upgrade/rollback result is written to ``log_path``.
+    """
+    python_exe = python_exe or sys.executable
+    parent_pid = parent_pid if parent_pid is not None else os.getpid()
+    resolved_log_path = log_path or default_log_path()
+    resolved_log_path.parent.mkdir(parents=True, exist_ok=True)
+
+    rollback_args = _rollback_args(python_exe, current_version, core_version)
+    script_path = write_helper(
+        parent_pid=parent_pid,
+        upgrade_args=list(pip_args),
+        rollback_args=rollback_args,
+        env_overrides=pip_env,
+        log_path=resolved_log_path,
+    )
+    launch(python_exe, script_path)
+    return 0, resolved_log_path

cu_cli-0.1.0b1.dist-info/METADATA

@@ -0,0 +1,345 @@
+Metadata-Version: 2.4
+Name: cu-cli
+Version: 0.1.0b1
+Summary: Author, validate, and run Azure Content Understanding custom analyzers from the terminal — advanced document layout, industry-leading OCR, and grounded field extraction with confidence, all backed by Azure Content Understanding.
+Author: Microsoft Corporation
+License: MIT
+Project-URL: Homepage, https://github.com/Azure/content-understanding-toolkit/tree/main/cu-cli
+Project-URL: Repository, https://github.com/Azure/content-understanding-toolkit
+Project-URL: Issues, https://github.com/Azure/content-understanding-toolkit/issues
+Project-URL: Documentation, https://aka.ms/cu-doc
+Keywords: azure,content-understanding,document-intelligence,ocr,pdf,extract,field-extraction,analyzer,cli,markdown
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Text Processing
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: cu-cli-core<0.2.0,>=0.1.0b1
+Requires-Dist: azure-ai-contentunderstanding>=1.2.0b3
+Requires-Dist: azure-identity>=1.19
+Requires-Dist: azure-mgmt-cognitiveservices>=13.5
+Requires-Dist: click>=8.1
+Requires-Dist: packaging>=23.2
+Requires-Dist: requests>=2.31
+Requires-Dist: rich>=13.7
+Requires-Dist: rich-click>=1.7
+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"
+Requires-Dist: tomli>=2.0; python_version < "3.11" and extra == "dev"
+Requires-Dist: vcrpy>=6.0; extra == "dev"
+
+# CU CLI
+
+`cu` is the preview command-line interface for Azure Content Understanding in
+Foundry Tools. Use it to provision the required Microsoft Foundry resource,
+optionally deploy selected supported large language models (LLMs) and embeddings
+models, configure Content Understanding defaults, analyze local files, manage
+analyzers, and manage local configuration.
+
+> [!IMPORTANT]
+> CU CLI is in preview. Commands and package contracts may change before general
+> availability.
+
+## Content Understanding concepts
+
+Content Understanding processes unstructured content, including documents,
+images, audio, and video, into structured output for automation, analytics, and
+search workflows. It is a Foundry Tool that you access through a Microsoft
+Foundry resource in Azure.
+
+The Content Understanding documentation uses these terms:
+
+- A **file** is the input. It can be a document, image, audio file, video, or
+  other [supported file type](https://learn.microsoft.com/azure/ai-services/content-understanding/service-limits#input-file-limits).
+- An **analyzer** defines how Content Understanding processes a file and
+  extracts content and structured fields.
+- An **analyzer result** is the output from processing a file. It can include
+  extracted Markdown content, structured fields, and modality-specific details.
+- A **prebuilt analyzer** is a ready-to-use analyzer supplied by Content
+  Understanding for common content extraction, search, and domain scenarios.
+- A **custom analyzer** is an analyzer you define for your scenario. It uses a
+  base analyzer for a content type and a field schema that describes the
+  structured fields to extract.
+
+CU CLI lets you configure a Microsoft Foundry resource, select an analyzer,
+submit local files, and save analyzer results without calling the REST API
+directly.
+
+Further reading:
+
+- [What is Content Understanding?](https://learn.microsoft.com/azure/ai-services/content-understanding/overview)
+- [Content Understanding terminology](https://learn.microsoft.com/azure/ai-services/content-understanding/glossary)
+
+## Install
+
+Requirements:
+
+- Python 3.10 or later
+- [Azure CLI](https://aka.ms/azcli) for login and resource discovery
+- [Azure Developer CLI](https://aka.ms/azd) only when using `cu infra generate`
+
+```bash
+python -m pip install cu-cli
+cu --version
+cu --help
+```
+
+macOS includes an unrelated system command named `cu`. Use the equivalent
+`cu-cli` executable on macOS:
+
+```bash
+cu-cli --help
+```
+
+## Connect to Microsoft Foundry and check setup
+
+You need a Microsoft Foundry resource endpoint. LLM-based prebuilt analyzers and
+custom analyzers also need supported LLM and embeddings deployments plus Content
+Understanding defaults. If any of these are missing, follow the complete
+[Microsoft Foundry provisioning guide](https://github.com/Azure/content-understanding-toolkit/blob/main/cu-cli/docs/provisioning.md).
+
+A CU CLI profile is local configuration for one Microsoft Foundry resource. It
+stores the endpoint, authentication method, API version, and optional model
+deployment mappings; it is not an Azure resource. For a ready resource,
+configure the automatically available `default` profile. With Microsoft Entra
+ID authentication:
+
+```bash
+cu profile set endpoint https://<resource-name>.services.ai.azure.com/
+cu profile set auth_mode login
+az login
+cu doctor
+```
+
+Alternatively, use a resource key:
+
+```bash
+cu profile set endpoint https://<resource-name>.services.ai.azure.com/
+cu profile set api_key <key>
+cu doctor
+```
+
+The API key is redacted by `cu profile get` and `cu profile show`. `cu doctor`
+checks the API version, endpoint, authentication, service connectivity, and
+Content Understanding defaults. It exits nonzero when a required check fails,
+so it can serve as a readiness gate.
+
+## Supported Content Understanding API versions
+
+Content Understanding API version. Known versions: 2025-11-01 (GA) and
+2026-06-01-preview (preview); any YYYY-MM-DD-preview version is also accepted.
+
+CU CLI defaults to `2025-11-01`. Override the version with `cu profile set
+api_version <version>`, the `--api-version` flag, or the `CU_API_VERSION`
+environment variable; run `cu profile show` to see the active profile's
+configured version.
+
+The preview API adds capabilities beyond the GA version. CU CLI returns
+result-based capabilities, such as document metadata and signatures, through
+the normal analysis result without dedicated CLI options. Inline analysis is
+the only preview capability that requires a new CU CLI option:
+`cu analyze --inline` runs supported analysis synchronously and returns the
+result directly instead of using the default long-running-operation (LRO)
+polling flow.
+
+```bash
+cu analyze --inline --api-version 2026-06-01-preview document.pdf --analyzer prebuilt-layout
+```
+
+Save the preview version to a profile to avoid passing `--api-version` on every
+call: `cu profile set api_version 2026-06-01-preview`. Pin to `2025-11-01` for
+production workloads that don't need preview capabilities.
+
+Further reading:
+
+- [What's new in the `2026-06-01-preview` API](https://learn.microsoft.com/azure/ai-services/content-understanding/whats-new#july-2026)
+- Run `cu analyze --help` for all analyze options.
+
+## Use prebuilt analyzers
+
+List the prebuilt analyzers available to the configured resource:
+
+```bash
+cu analyzer list
+```
+
+Start with the `prebuilt-layout` content extraction analyzer. It extracts text,
+paragraphs, tables, figures, and document structure without requiring a language
+model or embeddings model. `-a` is the short form of `--analyzer`:
+
+```bash
+# Generate Markdown from the analyzer result with the CU SDK's to_llm_input().
+cu analyze ./document.pdf -a prebuilt-layout
+```
+
+Markdown generated by the Content Understanding SDK's `to_llm_input()` helper is
+the default output format. The helper formats field extraction results as
+Markdown with YAML frontmatter so they can be used as generative AI model input.
+Use `--llm-input` to select this default view explicitly, or use `--json` to
+return the complete analyzer result as JSON. See the
+[Content Understanding SDK `to_llm_input()` helper](https://learn.microsoft.com/azure/ai-services/content-understanding/whats-new#april-2026).
+
+Domain-specific prebuilt analyzers, such as `prebuilt-invoice`, extract a
+defined set of structured fields. They require the model setup described in
+[Deploy models and configure defaults](https://github.com/Azure/content-understanding-toolkit/blob/main/cu-cli/docs/provisioning.md#deploy-models-and-configure-defaults):
+
+```bash
+cu analyze ./invoice.pdf --analyzer prebuilt-invoice --json
+```
+
+The command returns an analyzer result. Use `--json` when you want the
+structured result as JSON.
+
+Analyze several files into one output directory. `--pattern` requires
+`--source`, because a positional path can be either a file or a directory and
+`--pattern` only makes sense once a directory is named explicitly:
+
+```bash
+cu analyze --source ./documents --pattern "*.pdf" --output-dir ./results
+```
+
+Each result is written under `./results` and keeps the input path relative to
+`./documents`. For example, `./documents/invoice-01.pdf` produces
+`./results/invoice-01.pdf.result.md`. Markdown results use the
+`.result.md` suffix; adding `--json` produces `.result.json` files instead.
+
+Further reading:
+
+- [Prebuilt analyzers](https://learn.microsoft.com/azure/ai-services/content-understanding/concepts/prebuilt-analyzers)
+- [Supported input files and service limits](https://learn.microsoft.com/azure/ai-services/content-understanding/service-limits#input-file-limits)
+- Run `cu analyze --help` for input, output, overwrite, concurrency, and reporting options.
+
+## Create a custom analyzer
+
+A custom analyzer lets you define the structured fields needed by your
+application. Its analyzer schema identifies a base analyzer for the content type
+and includes a field schema that describes the field names, value types, and
+generation methods.
+
+Custom analyzers require supported model deployments and configured Content
+Understanding defaults. Confirm the model-to-deployment mappings before creating
+the analyzer:
+
+```bash
+# Show the Content Understanding defaults configured on the resource.
+cu defaults show
+```
+
+If the required mappings are missing, follow
+[Configure defaults manually](https://github.com/Azure/content-understanding-toolkit/blob/main/cu-cli/docs/provisioning.md#configure-defaults-manually)
+to configure them. Then generate a starter analyzer schema from a representative
+file:
+
+```bash
+# Generate a schema from a representative document.
+cu analyzer schema create \
+  --from-sample ./invoice.pdf \
+  --output-file ./invoice-schema.json
+
+# Review and update the generated schema for your extraction requirements,
+# then create the analyzer.
+cu analyzer create --name invoice_v1 --schema ./invoice-schema.json
+
+# Run the analyzer against the sample and summarize whether fields were returned
+# and any confidence values supplied by the service. This is not an accuracy
+# benchmark and does not compare the result with labeled ground truth.
+cu analyzer test invoice_v1 ./invoice.pdf
+
+cu analyze ./invoice.pdf --analyzer invoice_v1 --json
+```
+
+Schema generation preserves existing files by default. Pass `--force` only when
+you intentionally want to replace the selected `--output-file`.
+
+Further reading:
+
+- [Create a custom analyzer](https://learn.microsoft.com/azure/ai-services/content-understanding/tutorial/create-custom-analyzer)
+- [Supported generative models](https://learn.microsoft.com/azure/ai-services/content-understanding/service-limits#supported-generative-models)
+- Run `cu analyzer --help` for analyzer management and testing commands.
+
+## Command overview
+
+| Command | Purpose |
+| --- | --- |
+| `cu analyze` | Analyze local files and return analyzer results. |
+| `cu analyzer` | List, show, create, copy, delete, and test analyzers; create and validate local analyzer schemas. |
+| `cu defaults` | Read or configure Content Understanding defaults that map models to deployments. |
+| `cu profile` | Manage local CU CLI endpoint, authentication, API, and model settings. |
+| `cu infra generate` | Generate an azd/Bicep project used to provision a Microsoft Foundry resource and configure Content Understanding. Run `azd up` to provision it. |
+| `cu doctor` | Verify the active CU CLI profile, authentication, and model readiness. |
+| `cu env-var` | Inspect supported environment-variable overrides. |
+
+Every command provides examples:
+
+```bash
+cu profile --help
+cu analyzer copy --help
+cu infra generate --help
+```
+
+## CU CLI usage guide
+
+Use this README for installation, resource connection, and the first successful
+analysis. For Azure provisioning, see the
+[Microsoft Foundry provisioning guide](https://github.com/Azure/content-understanding-toolkit/blob/main/cu-cli/docs/provisioning.md). For detailed
+operational guidance, see the
+[CU CLI usage guide](https://github.com/Azure/content-understanding-toolkit/blob/main/cu-cli/docs/usage-guide.md). It explains:
+
+- CU CLI profile resolution and environment-variable overrides
+- safe batch previews, output handling, and machine-readable reports
+- analyzer schema, lifecycle, testing, and cross-resource copy workflows
+- Content Understanding defaults and troubleshooting
+
+## More information
+
+- [Azure Content Understanding documentation](https://aka.ms/cu-doc)
+- [Support](https://github.com/Azure/content-understanding-toolkit/blob/main/cu-cli/SUPPORT.md)
+- [Contributing](https://github.com/Azure/content-understanding-toolkit/blob/main/cu-cli/CONTRIBUTING.md)
+
+The standalone distribution is `cu-cli`. It depends on the separately built
+`cu-cli-core` implementation package in this same product tree. `cu-cli-core`
+is an internal implementation boundary for official CU command-line frontends;
+install and use `cu-cli` rather than importing the core package directly.
+
+## Telemetry
+
+CU CLI adds `cu-cli/<version>` to the standard Azure SDK `User-Agent` header on
+requests to the Azure Content Understanding service. Microsoft uses this
+identifier to understand CU CLI adoption. CU CLI does not add customer content
+or separate usage and analytics events to this telemetry.
+
+To remove the `cu-cli/<version>` identifier, set `CU_TELEMETRY=off` (also
+accepts `0`, `false`, or `no`) before running CU CLI. The Azure SDK continues to
+send its standard `User-Agent` as part of service requests. See the repository
+[data collection notice](https://github.com/Azure/content-understanding-toolkit#data-collection)
+for more information.
+
+## Use multiple profiles
+
+If you work with multiple resources, create named profiles and either activate
+one or select it per command:
+
+```bash
+cu profile create dev
+cu profile set endpoint https://<dev-resource>.services.ai.azure.com/ --name dev
+cu profile create prod
+cu profile set endpoint https://<prod-resource>.services.ai.azure.com/ --name prod
+
+cu profile set-active dev
+cu analyzer list
+cu analyzer list --profile prod
+cu doctor --profile prod
+```
+
+See the [CU CLI profile usage guide](https://github.com/Azure/content-understanding-toolkit/blob/main/cu-cli/docs/usage-guide.md#cu-cli-profiles) for
+profile resolution and environment-variable overrides.

cu_cli-0.1.0b1.dist-info/RECORD

@@ -0,0 +1,56 @@
+cu_cli/__init__.py,sha256=fNEG_VsQlqBY7pcBFmxqW11GgSnmfyiReuP76IoqGag,478
+cu_cli/__main__.py,sha256=w_pUFk4iLDoh1Kh5BXRoTuSw4AXHQSgfhmcy_mtILmo,205
+cu_cli/apiversion.py,sha256=khC7v1HioXoXPOBoqAGIS-rRu_WK5VqooKMhUGnehDQ,4088
+cu_cli/cli.py,sha256=rA3GAk0ZpuPFYleHe5WpooCkRuXxyu68IWzCDZ2YDYw,4884
+cu_cli/client.py,sha256=GyfEp2-orgvmw-5pHGc0YrIQQtKouPxiV_CY_kx0YVI,5097
+cu_cli/errors.py,sha256=upmEupCkxgkrYySwuvYn8ltpAz_AZcYKLRc0wX-fLlE,6993
+cu_cli/exit_codes.py,sha256=o2sq68adhmtTk-GGna7G5yDlCdNEeZIagrA_sV4sDcs,506
+cu_cli/modality.py,sha256=nUtuGxX64YIgSCXQ9hVKkL4UjwZMwnK48eGlqrXhKQk,945
+cu_cli/output.py,sha256=CUYvlc7eBrLo72CO52JGJiJNgVezMMDO9_hRN3vcGz8,5935
+cu_cli/profile.py,sha256=QudPVd9fOh_hwo-nZYmupnN0mt4V6FJDBmPrfY828Ug,692
+cu_cli/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cu_cli/schema_validate.py,sha256=KbRYZAMO00GGULPmhkrqTGcdE8W5zkt4g9LuIGJTnyQ,632
+cu_cli/spec_validate.py,sha256=PdKOKpUMSYj_jXGB85_ZE1W4J4_r-_GFzKPboiprkiY,414
+cu_cli/telemetry.py,sha256=aQ8_T72l2yX-kcxv-LgpxCNdGdePOtHrfGItIBafY-w,1586
+cu_cli/update_check.py,sha256=fH5pw0bvKuJ1x6gEo3adlwuMOimdjKuZabeeN_Mut4k,4806
+cu_cli/update_provider.py,sha256=vQP-AMALk-LnU6HQ08hhVTbyCRYdO1EbbEOd35x2WX4,2952
+cu_cli/windows_self_upgrade.py,sha256=-BmdBe-o4ZZcjuBhq73Jte-0eQboOri1FqVd4tAVcvk,8412
+cu_cli/commands/__init__.py,sha256=B1-toem4whTXdehhZ_s_FjdE1Tjd-2brjluf2Qj4CZc,101
+cu_cli/commands/_command_spec.py,sha256=TdGiGS6wFldTb9fghICf1LKwqGeIfaCKmaGu8KK7-VU,3037
+cu_cli/commands/_help.py,sha256=DFwZj7Qr_7jVN1oqYGk9zgFojinBvYGE0akCaN5SSCE,1191
+cu_cli/commands/_infra_models.py,sha256=MQbKJ-9L63-8lzBvmOSeKUq0FP7lIz6Ah-9P2hOP63M,6266
+cu_cli/commands/_infra_wizard.py,sha256=773yaRfhLeMgvqhOgSkdAyThqK-O_qANAC6twlhnPCU,22724
+cu_cli/commands/_model_setup.py,sha256=wHyDMdEa1UMx7yZPi-GYw1Fk7niinVvlOwjvYg7Yeas,1668
+cu_cli/commands/_options.py,sha256=iOBPk0HK1OexAaHM8VfsvD_XFrIh-ZBV2v5gr4drjsI,3796
+cu_cli/commands/analyze.py,sha256=n1jyhojWwOB2g_e7cpQEWj9yBPkLsEsKRp1Sm9pKBYo,25209
+cu_cli/commands/analyzer.py,sha256=ZGEnGeT0cIPeBPfKzCD5JKy_CHWNsVSGHimLRFb0eB8,56444
+cu_cli/commands/defaults.py,sha256=NDdE3r3Ew60glWC1U51LSwtxNwN_2UhjyPl_NMz4NEE,5521
+cu_cli/commands/doctor.py,sha256=m9epNBjAAqkloqTfL8uQ338XHfed9yePJFDLQTkJXL8,7342
+cu_cli/commands/env_var.py,sha256=jP8k5tbZ5v-L3fwMmOYCY8VSEr4z7jIv2Ne3OoAt7m4,2183
+cu_cli/commands/infra.py,sha256=aFrrnNUTWGvVXv-Lmv1G1J1eCr2QL8App1s8ldPY7b4,10834
+cu_cli/commands/profile_cmd.py,sha256=ucoPeMiHkaSyX2YeVgwFW7erKNcyfCGIsaoY0b-T8-o,17263
+cu_cli/commands/upgrade.py,sha256=Fqc2IGcD0Y_7gesJz-AtUZGX-_PjfmKksX-BjCdC7C8,5125
+cu_cli/core/__init__.py,sha256=wdd_xMCNyN_rBm3hCGcedo-ZJPZ4qOKwQ1Rnlox98g4,784
+cu_cli/core/analyze.py,sha256=NNcgmyKCANamWW0tIBlrRLadPFpYvZAfChy2EFSoy3I,1036
+cu_cli/core/analyzers.py,sha256=Z9vgNCxKwTaYh9aA7DS2UiH0_30Cs3iyaT4mrKcPcck,729
+cu_cli/core/azure_resources.py,sha256=9vFbBtyC66E8Q3RqGqiSGEK4lIxVT9cOfHOIODwPagg,20000
+cu_cli/core/defaults.py,sha256=tPLWda1zDhQauyyjv0xX2j-oGqg3ZPvVB2o0vQ2g-aI,408
+cu_cli/core/doctor.py,sha256=JjIO0jIuEZRA5ePt8TKDQf7AW_f1M3dF7xX8DSoCLX8,1673
+cu_cli/core/foundry.py,sha256=_MZR3YN1vtiLW5Hhx5PwGUCbZR76U6jb6gvBJNgoczU,2574
+cu_cli/core/infra_models.py,sha256=frF-xCetihSkeQjcO2pRARL9VPHTqlRQN1SaNn-yzGM,12994
+cu_cli/core/inputs.py,sha256=sx7mPjabKPpg_ZFDVHvyqwRPsAqQZ9sYxIZ-N_q2wCE,8593
+cu_cli/core/schema.py,sha256=fhUeHlenZQhnj50HrE-srOv2ILsaNB8bWkgpTKWu11E,626
+cu_cli/resources/__init__.py,sha256=m1srM72w5rc2dYn8wXIkDYQ8TBPIIXMax2Q0I2vVysM,142
+cu_cli/resources/azd_template/README.md,sha256=Cqwb0bg29DwIy6CHyhFakq3CN2h3kvmKtK-sLG38UIM,8373
+cu_cli/resources/azd_template/azure.yaml,sha256=e9vG-M9C_BSFulLATX7Qw6t4zVF9SJKxJ1p7gGrDFmc,742
+cu_cli/resources/azd_template/hooks/postprovision.ps1,sha256=8lZW8VvzAHlco9KOrrYykyFn8dKHx0Kqc2BFQNGGoUg,14422
+cu_cli/resources/azd_template/hooks/postprovision.sh,sha256=cx6FpAcILRTi2UL7_prI6CcAzHuzdgbMpvj7j6E6HKg,12414
+cu_cli/resources/azd_template/infra/main.bicep,sha256=rN2OsHfYpMTamutZdv1u1yvxLppfuIWnRwGzyIldkqU,5185
+cu_cli/resources/azd_template/infra/main.parameters.json,sha256=m9ptgHue5J5GinAvif3uo-Vg7kxqlhZ5tel7Mai0_cQ,773
+cu_cli/resources/azd_template/infra/models.json,sha256=N1F-Xz3GaBn2H1p7uKzhkhKCQV8QVR0t76XD6wmFtXA,3
+cu_cli/resources/azd_template/infra/modules/foundry.bicep,sha256=YTKRran5peWzOJUmoNKgGGxLlBhVJDHLLDHCRE-awB8,3683
+cu_cli-0.1.0b1.dist-info/METADATA,sha256=sI_uT5jbZH23FlPAPlGH6s83q2WTgi4mPYFQobHKZRE,15116
+cu_cli-0.1.0b1.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+cu_cli-0.1.0b1.dist-info/entry_points.txt,sha256=kLZwQxUM-rTAzoAR_ti8P-R8NB561gEh-pN1lQgiQsU,64
+cu_cli-0.1.0b1.dist-info/top_level.txt,sha256=AxwNJjvjn81SAkSkB21ljPbi25_KLdKuLfKlVg8ep44,7
+cu_cli-0.1.0b1.dist-info/RECORD,,

cu_cli-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-0.1.0b1.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+cu = cu_cli.cli:main
+cu-cli = cu_cli.cli:main

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

@@ -0,0 +1 @@
+cu_cli