trustarc-cli 1.0.0__py3-none-any.whl

ta/lib/config.py

@@ -0,0 +1,65 @@
+import json
+from pathlib import Path
+
+from ta.lib.catalog_cache import load_catalog
+from ta.lib.services import ENVS, services_for
+
+CONFIG_DIR = Path.home() / ".ta"
+CONFIG_FILE = CONFIG_DIR / "config.json"
+
+DEFAULT_CONFIG = {
+    "env": "prod-us",
+}
+
+
+def _deep_merge(base: dict, override: dict) -> dict:
+    result = base.copy()
+    for key, value in override.items():
+        if key in result and isinstance(result[key], dict) and isinstance(value, dict):
+            result[key] = _deep_merge(result[key], value)
+        else:
+            result[key] = value
+    return result
+
+
+class UnknownEnvError(ValueError):
+    def __init__(self, env: str):
+        self.env = env
+        super().__init__(
+            f"Saved env '{env}' is not supported. Run `ta config setup` to pick one of: {', '.join(ENVS)}."
+        )
+
+
+def _read_config() -> dict:
+    if CONFIG_FILE.exists():
+        with open(CONFIG_FILE) as f:
+            return _deep_merge(DEFAULT_CONFIG, json.load(f))
+    return dict(DEFAULT_CONFIG)
+
+
+def saved_env() -> str:
+    env = _read_config()["env"]
+    if env not in ENVS:
+        raise UnknownEnvError(env)
+    return env
+
+
+def load_config(refresh_catalog: bool = False) -> dict:
+    cfg = _read_config()
+    if cfg["env"] not in ENVS:
+        raise UnknownEnvError(cfg["env"])
+
+    try:
+        catalog = load_catalog(cfg["env"], force=refresh_catalog)
+    except RuntimeError:
+        catalog = {}
+    cfg["catalog"] = catalog
+    cfg["services"] = services_for(catalog)
+    return cfg
+
+
+def save_config(config: dict) -> Path:
+    CONFIG_DIR.mkdir(exist_ok=True)
+    with open(CONFIG_FILE, "w") as f:
+        json.dump(config, f, indent=2)
+    return CONFIG_FILE

ta/lib/dynamic.py

@@ -0,0 +1,259 @@
+import json
+import keyword
+import platform
+import sys
+import time
+
+import httpx
+import typer
+from rich.console import Console
+from trustarc_sdk.openapi import (
+    Entrypoint,
+    build_schema_snapshot,
+    call,
+    fetch_spec,
+    group_operations_by_resource,
+    resolve_base_url,
+)
+
+from ta import __version__
+from ta.lib.analytics import report_tool_call
+from ta.lib.auth import get_access_token
+from ta.lib.auth_servers import FEATURE_MANAGER_API_URLS
+from ta.lib.config import UnknownEnvError, load_config
+from ta.lib.spec_cache import SPEC_CACHE_TTL_SECONDS, load_spec, save_spec, spec_cache_path
+from ta.lib.urls import to_public_url
+
+console = Console()
+
+_USER_AGENT = " ".join(
+    (
+        f"python/{sys.version.split()[0]}",
+        f"{platform.system()}/{platform.release()}",
+        f"trustarc-cli/{__version__}",
+    )
+)
+_SOURCE = "cli"
+_WRITE_EPILOG = "Changes data in TrustArc. Confirm the change before running it."
+_WRITE_EPILOG_WITH_BODY = (
+    "Changes data in TrustArc. Check the request body with --schema and confirm the change before running it."
+)
+
+
+def register_dynamic_commands(app: typer.Typer) -> None:
+    try:
+        cfg = load_config()
+    except UnknownEnvError:
+        return
+    env = cfg["env"]
+    token = get_access_token(env) or ""
+    active_service = sys.argv[1] if len(sys.argv) > 1 else None
+
+    catalog = cfg["catalog"]
+    for service, spec_url in sorted(cfg["services"].items()):
+        entry = catalog[service]
+        prefix = entry["prefix"]
+        include_tags = entry["include_tags"]
+        description = entry["description"]
+        full_name = entry["name"] or service
+        service_app = typer.Typer(help=f"{full_name} — {description}", no_args_is_help=True)
+        _register_refresh(service_app, service, env, spec_url)
+
+        if service == active_service and _is_stale(service, env):
+            try:
+                save_spec(service, env, fetch_spec(spec_url))
+            except httpx.HTTPError:
+                pass
+
+        spec = load_spec(service, env)
+        if spec:
+            base_url = to_public_url(resolve_base_url(spec, spec_url))
+            grouped = group_operations_by_resource(
+                spec,
+                prefix,
+                include_tags=include_tags,
+                feature_manager_url=FEATURE_MANAGER_API_URLS.get(env),
+                access_token=token,
+            )
+            for resource in sorted(grouped):
+                resource_app = typer.Typer(help=f"{resource} operations", no_args_is_help=True)
+                for action, op in grouped[resource]:
+                    _register_operation(resource_app, service, resource, action, op, base_url, spec)
+                service_app.add_typer(resource_app, name=resource)
+
+        app.add_typer(service_app, name=service)
+
+
+def _is_stale(service: str, env: str) -> bool:
+    path = spec_cache_path(service, env)
+    if not path.exists():
+        return True
+    return (time.time() - path.stat().st_mtime) > SPEC_CACHE_TTL_SECONDS
+
+
+def _register_refresh(service_app: typer.Typer, service: str, env: str, spec_url: str) -> None:
+    @service_app.command("refresh", help=f"Fetch and cache the {service} OpenAPI spec.")
+    def refresh():
+        console.print(f"[bold]{service}[/bold] {spec_url}")
+        try:
+            spec = fetch_spec(spec_url)
+        except httpx.HTTPError as e:
+            console.print(f"  [red]failed:[/red] {e}")
+            raise typer.Exit(1) from e
+        path = save_spec(service, env, spec)
+        grouped = group_operations_by_resource(spec)
+        total = sum(len(ops) for ops in grouped.values())
+        console.print(f"  [green]cached[/green] {path} [dim]({len(grouped)} resources, {total} ops)[/dim]")
+
+
+def _register_operation(
+    sub: typer.Typer, service: str, resource: str, action: str, op: dict, base_url: str, spec: dict
+) -> None:
+    help_text = op.get("summary") or op.get("description") or f"{op['method']} {op['path']}"
+
+    path_params = [p for p in op["parameters"] if p.get("in") == "path"]
+    query_params = [p for p in op["parameters"] if p.get("in") == "query"]
+    has_body = op["request_body"] is not None
+    schema_snapshot = build_schema_snapshot(op, spec)
+
+    seen_py_names: set[str] = set()
+    path_py = [(_py_name(p["name"], seen_py_names), p["name"]) for p in path_params]
+    query_py = [(_py_name(p["name"], seen_py_names), p["name"]) for p in query_params]
+
+    def make_runner(
+        op=op,
+        base_url=base_url,
+        path_py=path_py,
+        query_py=query_py,
+        has_body=has_body,
+    ):
+        def runner(**kwargs):
+            kwargs.pop("schema", None)
+            cfg = load_config()
+            path_values, query_values, body = split_request(path_py, query_py, has_body, kwargs)
+
+            token = get_access_token(cfg["env"]) or ""
+            try:
+                resp = call(
+                    op,
+                    base_url,
+                    token,
+                    None,
+                    path_params=path_values,
+                    query_params=query_values,
+                    body=body,
+                    user_agent=_USER_AGENT,
+                    entrypoint=Entrypoint.CLI,
+                    source=_SOURCE,
+                    feature_manager_url=FEATURE_MANAGER_API_URLS.get(cfg["env"]),
+                )
+            except Exception:
+                report_tool_call(cfg["env"], token, service, resource, action, op["method"], None, "request_failed")
+                raise
+            report_tool_call(cfg["env"], token, service, resource, action, op["method"], resp.status_code)
+
+            try:
+                console.print_json(data=resp.json())
+            except ValueError:
+                console.print(resp.text)
+            if resp.status_code >= 400:
+                raise typer.Exit(1)
+
+        return runner
+
+    runner = make_runner()
+    params: list[tuple[str, object, object]] = []
+    for (py_name, _), p in zip(path_py, path_params):
+        params.append((py_name, typer.Argument(..., help=p.get("description", "")), str))
+    for (py_name, api_name), p in zip(query_py, query_params):
+        default = ... if p.get("required") else None
+        flag = f"--{api_name.replace('_', '-')}"
+        params.append((py_name, typer.Option(default, flag, help=p.get("description", "")), str))
+    if has_body:
+        params.append(
+            ("body", typer.Option(None, "--body", help="JSON request body. Run with --schema to see its fields."), str)
+        )
+    params.append(
+        (
+            "schema",
+            typer.Option(
+                False,
+                "--schema",
+                is_eager=True,
+                callback=_schema_printer(schema_snapshot),
+                help="Print request/response schema and exit",
+            ),
+            bool,
+        )
+    )
+
+    runner.__name__ = action.replace("-", "_")
+    runner.__doc__ = help_text
+    runner.__signature__ = _build_signature(params)  # type: ignore[attr-defined]
+    epilog = None
+    if op["method"].upper() != "GET":
+        epilog = _WRITE_EPILOG_WITH_BODY if has_body else _WRITE_EPILOG
+    sub.command(name=action, help=help_text, epilog=epilog)(runner)
+
+
+def _schema_printer(schema_snapshot: dict):
+    def print_schema(value: bool) -> None:
+        if value:
+            console.print_json(data=schema_snapshot)
+            raise typer.Exit()
+
+    return print_schema
+
+
+def split_request(
+    path_py: list[tuple[str, str]],
+    query_py: list[tuple[str, str]],
+    has_body: bool,
+    kwargs: dict,
+) -> tuple[dict, dict, dict | list | None]:
+    """Keep path, query and body apart so a body field can never change the request target."""
+    path_values = {api_name: kwargs[py_name] for py_name, api_name in path_py}
+    query_values = {api_name: kwargs[py_name] for py_name, api_name in query_py if kwargs.get(py_name) is not None}
+    body: dict | list | None = None
+    if has_body and kwargs.get("body"):
+        try:
+            body = json.loads(kwargs["body"])
+        except ValueError as e:
+            raise typer.BadParameter(f"--body must be valid JSON: {e}", param_hint="--body") from e
+        if isinstance(body, dict):
+            given = {**path_values, **query_values}
+            conflicting = sorted(key for key in body if key in given and str(body[key]) != str(given[key]))
+            if conflicting:
+                raise typer.BadParameter(
+                    f"--body fields {', '.join(conflicting)} disagree with the argument or option of the same "
+                    "name; the arguments and options decide the target, so make the body match them or leave "
+                    "those fields out",
+                    param_hint="--body",
+                )
+    return path_values, query_values, body
+
+
+def _py_name(api_name: str, seen: set[str]) -> str:
+    name = api_name.replace("-", "_")
+    if not name.isidentifier() or keyword.iskeyword(name):
+        name = f"_{name}"
+    if not name.isidentifier():
+        name = "arg_" + "".join(c if c.isalnum() or c == "_" else "_" for c in name)
+    base = name
+    i = 2
+    while name in seen:
+        name = f"{base}_{i}"
+        i += 1
+    seen.add(name)
+    return name
+
+
+def _build_signature(params: list[tuple[str, object, object]]):
+    import inspect
+
+    return inspect.Signature(
+        parameters=[
+            inspect.Parameter(name, kind=inspect.Parameter.KEYWORD_ONLY, default=default, annotation=annotation)
+            for name, default, annotation in params
+        ]
+    )

ta/lib/services.py

@@ -0,0 +1,13 @@
+ENVS = ("dev", "qa", "prod-us", "prod-eu", "prod-india")
+
+
+def spec_url(service: str, catalog: dict) -> str:
+    entry = catalog[service]
+    return f"{entry['base_url'].rstrip('/')}{entry['spec_path']}"
+
+
+def services_for(catalog: dict) -> dict[str, str]:
+    return {service: spec_url(service, catalog) for service in catalog if catalog[service].get("base_url")}
+
+
+__all__ = ["ENVS", "services_for", "spec_url"]

ta/lib/spec_cache.py

@@ -0,0 +1,25 @@
+import json
+from pathlib import Path
+
+SPEC_DIR = Path.home() / ".ta" / "openapi"
+SPEC_CACHE_TTL_SECONDS = 600
+
+
+def spec_cache_path(service: str, env: str) -> Path:
+    return SPEC_DIR / env / f"{service}.json"
+
+
+def save_spec(service: str, env: str, spec: dict) -> Path:
+    path = spec_cache_path(service, env)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with open(path, "w") as f:
+        json.dump(spec, f)
+    return path
+
+
+def load_spec(service: str, env: str) -> dict | None:
+    path = spec_cache_path(service, env)
+    if not path.exists():
+        return None
+    with open(path) as f:
+        return json.load(f)

ta/lib/update_check.py

@@ -0,0 +1,66 @@
+import contextlib
+import json
+import os
+import sys
+import time
+from pathlib import Path
+
+import httpx
+from packaging.version import InvalidVersion, Version
+
+from ta import __version__
+
+PACKAGE_NAME = "trustarc-cli"
+PYPI_URL = f"https://pypi.org/pypi/{PACKAGE_NAME}/json"
+CACHE_FILE = Path.home() / ".ta" / "update_check.json"
+CHECK_INTERVAL_SECONDS = 24 * 60 * 60
+_TIMEOUT_S = 2.0
+
+
+def fetch_latest_version() -> str | None:
+    with contextlib.suppress(httpx.HTTPError, ValueError, KeyError, TypeError):
+        resp = httpx.get(PYPI_URL, timeout=_TIMEOUT_S)
+        resp.raise_for_status()
+        return resp.json()["info"]["version"]
+    return None
+
+
+def _read_cache() -> dict:
+    with contextlib.suppress(OSError, ValueError):
+        return json.loads(CACHE_FILE.read_text())
+    return {}
+
+
+def _write_cache(latest: str | None) -> None:
+    with contextlib.suppress(OSError):
+        CACHE_FILE.parent.mkdir(parents=True, exist_ok=True)
+        CACHE_FILE.write_text(json.dumps({"checked_at": time.time(), "latest": latest}))
+
+
+def latest_version(*, force: bool = False) -> str | None:
+    cache = _read_cache()
+    if not force and time.time() - cache.get("checked_at", 0) < CHECK_INTERVAL_SECONDS:
+        return cache.get("latest")
+    latest = fetch_latest_version() or cache.get("latest")
+    _write_cache(latest)
+    return latest
+
+
+def is_newer(latest: str | None, current: str = __version__) -> bool:
+    if not latest:
+        return False
+    try:
+        return Version(latest) > Version(current)
+    except InvalidVersion:
+        return False
+
+
+def notify_if_outdated() -> None:
+    if os.getenv("TA_NO_UPDATE_CHECK"):
+        return
+    latest = latest_version()
+    if is_newer(latest):
+        print(
+            f"A new version of trustarc-cli is available: {__version__} → {latest}. Run: ta self-update",
+            file=sys.stderr,
+        )

ta/lib/urls.py

@@ -0,0 +1,18 @@
+from urllib.parse import urlsplit, urlunsplit
+
+INTERNAL_SUFFIX = ".prod.internal"
+_API_SUFFIX = "-api"
+
+
+def to_public_url(url: str | None) -> str | None:
+    if not url or INTERNAL_SUFFIX not in url:
+        return url
+
+    parts = urlsplit(url)
+    host = parts.netloc.replace(INTERNAL_SUFFIX, "", 1)
+
+    first, dot, rest = host.partition(".")
+    if first.endswith(_API_SUFFIX):
+        host = f"{first[: -len(_API_SUFFIX)]}{dot}{rest}"
+
+    return urlunsplit(parts._replace(netloc=host))

ta/main.py

@@ -0,0 +1,69 @@
+import typer
+
+from ta import __version__
+from ta.commands import auth as auth_mod
+from ta.commands import config as config_mod
+from ta.commands.self_update import self_update
+from ta.commands.services import services as services_cmd
+from ta.lib.config import UnknownEnvError, saved_env
+from ta.lib.dynamic import register_dynamic_commands
+from ta.lib.update_check import is_newer, latest_version, notify_if_outdated
+
+_RECOVERY_COMMANDS = ("config", "self-update")
+
+app = typer.Typer(
+    name="ta",
+    help="Command-line interface for the TrustArc platform APIs.",
+    no_args_is_help=True,
+    invoke_without_command=True,
+    epilog=(
+        "Start with `ta auth login` (and `ta config show` to check the env), then `ta services` and "
+        "`ta <service> <resource> --help` to find the command. Responses are JSON on stdout. "
+        "Before a create, update, patch or delete, run it with --schema to see the request body "
+        "and confirm the change first."
+    ),
+)
+
+
+def version_callback(value: bool):
+    if value:
+        msg = f"trustarc-cli {__version__}"
+        latest = latest_version(force=True)
+        if is_newer(latest):
+            msg += f" (latest: {latest} — run: ta self-update)"
+        elif latest:
+            msg += " (up to date)"
+        typer.echo(msg)
+        raise typer.Exit()
+
+
+@app.callback()
+def main(
+    ctx: typer.Context,
+    version: bool = typer.Option(
+        False,
+        "--version",
+        "-v",
+        callback=version_callback,
+        is_eager=True,
+        help="Show the version and check for updates.",
+    ),
+):
+    if ctx.invoked_subcommand not in _RECOVERY_COMMANDS:
+        try:
+            saved_env()
+        except UnknownEnvError as e:
+            typer.echo(str(e), err=True)
+            raise typer.Exit(1) from e
+    if ctx.invoked_subcommand != "self-update":
+        notify_if_outdated()
+
+
+app.command("self-update")(self_update)
+app.command("services")(services_cmd)
+app.add_typer(auth_mod.app, name="auth")
+app.add_typer(config_mod.app, name="config")
+register_dynamic_commands(app)
+
+if __name__ == "__main__":
+    app()

trustarc_cli-1.0.0.dist-info/METADATA

@@ -0,0 +1,114 @@
+Metadata-Version: 2.5
+Name: trustarc-cli
+Version: 1.0.0
+Summary: Command-line interface for the TrustArc platform APIs
+Project-URL: Homepage, https://trustarc.com
+Author: TrustArc
+Keywords: cli,compliance,privacy,trustarc
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.13
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: inflection>=0.5.1
+Requires-Dist: packaging>=24
+Requires-Dist: rich>=13.0
+Requires-Dist: typer>=0.12
+Description-Content-Type: text/markdown
+
+# trustarc-cli
+
+`ta` is the command-line interface for the TrustArc platform APIs. Commands are built from each product's live API spec, so new endpoints show up without upgrading the CLI.
+
+Use it directly from your terminal, in scripts, or as a tool for AI agents such as Claude Code, Codex and Cursor.
+
+## Install
+
+With [uv](https://docs.astral.sh/uv/getting-started/installation/) (installs Python 3.13 for you if needed):
+
+```bash
+uv tool install trustarc-cli
+```
+
+Or with [pipx](https://pipx.pypa.io) (requires Python 3.13+):
+
+```bash
+pipx install trustarc-cli
+```
+
+## Update
+
+```bash
+ta self-update
+```
+
+`ta` checks for a new release once a day and prints a notice to stderr when one is available. Set `TA_NO_UPDATE_CHECK=1` to turn the check off (e.g. in CI).
+
+## Quick start
+
+```bash
+ta config setup       # pick your region (prod-us/prod-eu/prod-india)
+ta auth login         # OAuth login via browser (PKCE)
+ta services           # list configured services for this env
+ta dmrm business-process list   # example call
+```
+
+## Use with AI agents
+
+`ta` is built to be driven by an AI agent as well as by a person:
+
+- API responses are printed as JSON on stdout, and the update notice goes to stderr, so output can be parsed as-is.
+- `--help` and `--schema` let the agent discover operations and their request/response shapes without calling the API.
+- Log in once with `ta auth login`; the agent reuses the saved token.
+
+Then ask your agent something like:
+
+> Use the `ta` CLI to list my business processes in TrustArc. Run `ta services` and `--help` first to find the right command.
+
+## Command tree
+
+```
+ta
+├── auth
+│   ├── login                       # OAuth login (browser + PKCE)
+│   ├── logout                      # revoke + clear local tokens
+│   └── status                      # current token expiry / user
+├── config
+│   ├── show                        # current env + login state
+│   ├── setup                       # pick region
+│   └── reset                       # delete ~/.ta/config.json
+├── services                        # list all services for the current env
+├── self-update                     # upgrade to the latest release
+└── <service>                       # e.g. dmrm, tc, am, cpm, ccm, irm, pc, cst, evidence, org
+    ├── refresh                     # re-fetch this service's OpenAPI spec
+    └── <resource>                  # e.g. business-process, trust-center
+        └── <action> [args]         # e.g. list, get-by-internal-id, upsert
+```
+
+### Inspecting operations
+
+```bash
+ta <service> --help                     # list resources
+ta <service> <resource> --help          # list actions
+ta <service> <resource> <action> --help # show args/options
+ta <service> <resource> <action> --schema   # request/response schema (no API call)
+```
+
+### Passing arguments
+
+- **Path params** → positional: `ta dmrm business-process get-by-internal-id <id>`
+- **Query params** → `--flag`: `ta tc subscription list --since 2026-01-01`
+- **Body** → `--body '<json>'`: `ta dmrm business-process upsert --body '{"internalId":"...","name":"..."}'`
+
+### Regions and auth
+
+Tokens are stored per env at `~/.ta/auth/<env>.json`. Spec caches at `~/.ta/openapi/<env>/<service>.json` (10-minute TTL; auto-refreshed when stale).
+
+Switch region:
+
+```bash
+ta config setup                # change default region
+ta auth login --env prod-eu    # log into a specific region without changing default
+```

trustarc_cli-1.0.0.dist-info/RECORD

@@ -0,0 +1,31 @@
+ta/__init__.py,sha256=J-j-u0itpEFT6irdmWmixQqYMadNl1X91TxUmoiLHMI,22
+ta/main.py,sha256=gv-vu4yH87QNCGal31gr44IC3gUPjizJBk8qPYceTj8,2106
+ta/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ta/commands/auth/__init__.py,sha256=5MIEqVZ5cGgG8mCOV71lthtO6olpVAZBOaKCcN9U-3U,48
+ta/commands/auth/command.py,sha256=agebaFnR7HoYVBlM1HCtIZlu2ORjGtFIT65uBLcpe-g,3019
+ta/commands/config/__init__.py,sha256=0aWe-DWx7aoYZDLEsWbuL05pRxxfDg1OgrjU3-PCMkQ,50
+ta/commands/config/command.py,sha256=wzzfJkY2TnAfdIfnPujZh6xSdUuT7G-65OKcXoX7UXc,1906
+ta/commands/self_update/__init__.py,sha256=A9mBjfV37eOEmhIjPHELvzFnZvBQD1vwTQj2qgTrPpk,150
+ta/commands/self_update/command.py,sha256=uyhGH-dQ7ZA17hw8op6bmFG1FGmDQlJE6Z3Nckk1Zhw,1105
+ta/commands/services/__init__.py,sha256=EEIrAK25APADsml7ye959peakp2-GibuazzzA580Gr8,62
+ta/commands/services/command.py,sha256=FTWwQXkd6jpfkV-fa7ne6rC1uWUDdTv5ekWbGZ9H2s0,1360
+ta/lib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ta/lib/analytics.py,sha256=lQaJZdq_whg1A-DSTSBtS3S53VLmX6Adk42yxtLQrvM,1524
+ta/lib/auth.py,sha256=PIp-uAuyx2Zx6qnhukY4PQtS9AiIflOBD5fNndeiVLU,6794
+ta/lib/auth_servers.py,sha256=DQk-1Cqiot6l4izy3fKKEpNx0oMTxM8wUQcsLhsndyE,1931
+ta/lib/catalog_cache.py,sha256=rhx2CZdOHMcyJluPOZvA8UdKQFnqmhOqKrXszsaWHtU,2151
+ta/lib/config.py,sha256=QQTlRPEeWRpSIsNMWJO3ybFq6R-nZ5Xr6VhpSFfKrZI,1682
+ta/lib/dynamic.py,sha256=wDkClvMGUo05bKProBaE9RMtRv2vyEN1Egjak9lLaIE,9497
+ta/lib/services.py,sha256=uIZOwkJfwGEASfvEpW1szQpsTeXk92knWtOxbjHvCqI,414
+ta/lib/spec_cache.py,sha256=l3xlHb6DIisnpELAwBYru3sof-2-NEtIKOb5QCmxU-w,635
+ta/lib/update_check.py,sha256=W9wQJxMMtqyjyTNgSuQ-gkE8SPwl6SZomFwNI5QVEKU,1873
+ta/lib/urls.py,sha256=8qrQEh06e8460c2BLfzx1aC_DvIQ4Fto85DO2yv-C6Q,493
+trustarc_sdk/openapi/__init__.py,sha256=qiMYPXPtP5pB0nGEyzMI1GmL6sh1XQ6YK6HegmOwoTY,981
+trustarc_sdk/openapi/call.py,sha256=RdUWtLqfvgcDZLhhT-Fqgx5MhsxtLzwAfYak6Pfr_NM,6460
+trustarc_sdk/openapi/feature_manager.py,sha256=2-uurrK0ZBNzwA1sjyGJjHVaPstGZbU0wyrWSiHbknY,3327
+trustarc_sdk/openapi/parse.py,sha256=JqmTKL-86SIZLWElQODOaENQvhEekCxZh59FCa8esFw,5933
+trustarc_sdk/openapi/schema.py,sha256=2s95Y_dX9-z7xPNcxEx2a7pd9qgqMjIlh-lhesjuIHU,3440
+trustarc_cli-1.0.0.dist-info/METADATA,sha256=NSeZl5zNsbJUUMkBoj8N6qE15S3ZcopuRpJuq_o5pyA,4167
+trustarc_cli-1.0.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+trustarc_cli-1.0.0.dist-info/entry_points.txt,sha256=Cs_ki__IkcU8u-22kgTRG5ujLtDIOXLwNDJeC0Idwk4,35
+trustarc_cli-1.0.0.dist-info/RECORD,,

trustarc_cli-1.0.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any

trustarc_cli-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+ta = ta.main:app