ap-client 0.1.4.dev0__tar.gz → 0.1.5__tar.gz

ap_client-0.1.5/PKG-INFO

@@ -0,0 +1,12 @@
+Metadata-Version: 2.4
+Name: ap-client
+Version: 0.1.5
+Summary: Agent Platform API Client & CLI
+Requires-Python: >=3.10
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: requests>=2.28.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: typer>=0.9.0
+Description-Content-Type: text/markdown
+
+A lightweight Python SDK and command line interface for Agent Platform. It provides helpers for configuring API access and managing templates, datasets, jobs, and groups.

ap_client-0.1.5/ap_client/__init__.py

@@ -0,0 +1,21 @@
+"""Agent Platform API Client"""
+
+from importlib.metadata import PackageNotFoundError, version
+
+from .api import APIClient, APIError, get_client
+from .config import Config, ConfigurationError, get_config
+
+try:
+    __version__ = version("ap-client")
+except PackageNotFoundError:
+    __version__ = "0+unknown"
+
+__all__ = [
+    "APIClient",
+    "APIError",
+    "Config",
+    "ConfigurationError",
+    "__version__",
+    "get_client",
+    "get_config",
+]

{ap_client-0.1.4.dev0 → ap_client-0.1.5}/ap_client/api.py

@@ -10,7 +10,7 @@ from urllib.parse import quote
 
 import requests
 
-from .config import Config, get_config
+from .config import Config, ConfigurationError, get_config, has_cluster_header
 
 _GROUP_ARTIFACTS_PAGE_SIZE = 500
 _VERBOSE_SAMPLE_KEYS = 5
@@ -18,6 +18,28 @@ _VERBOSE_SAMPLE_ITEMS = 3
 _VERBOSE_VALUE_PREVIEW = 120
 
 
+class APIError(Exception):
+    """Raised when an API request fails."""
+
+    def __init__(
+        self,
+        status_code: Optional[int],
+        detail: Any,
+        request_id: str,
+        response: Optional[requests.Response],
+    ):
+        self.status_code = status_code
+        self.detail = detail
+        self.request_id = request_id
+        self.response = response
+        super().__init__(self._build_message())
+
+    def _build_message(self) -> str:
+        if self.status_code is None:
+            return f"API Network Error: {self.detail} (request_id={self.request_id})"
+        return f"API Error {self.status_code}: {self.detail} (request_id={self.request_id})"
+
+
 class APIClient:
     """Agent Platform API client."""
 
@@ -55,6 +77,7 @@ class APIClient:
         timeout: float = 30,
     ) -> Any:
         """Send an HTTP request with X-Request-ID and optional verbose logging."""
+        self._require_cluster_config()
         url = self._url(path)
         request_id = str(uuid.uuid4())
         headers = {"X-Request-ID": request_id}
@@ -71,27 +94,29 @@ class APIClient:
                 headers=headers,
                 timeout=timeout,
             )
-        except Exception as exc:
+        except requests.RequestException as exc:
             if verbose:
                 duration_ms = (time.perf_counter() - start) * 1000
                 self._log_exception(method, url, request_id, duration_ms, exc)
-            raise
+            raise APIError(None, str(exc), request_id, None) from exc
         duration_ms = (time.perf_counter() - start) * 1000
         if verbose:
             self._log_response(method, url, request_id, resp, duration_ms)
         if not resp.ok:
-            try:
-                err_data = resp.json()
-                detail = err_data.get("detail", resp.text)
-            except Exception:
-                detail = resp.text
-            raise Exception(
-                f"API Error {resp.status_code}: {detail} (request_id={request_id})"
-            )
+            detail = _response_error_detail(resp)
+            raise APIError(resp.status_code, detail, request_id, resp)
         if not resp.content:
             return None
         return resp.json()
 
+    def _require_cluster_config(self) -> None:
+        if has_cluster_header(self.config.headers):
+            return
+        raise ConfigurationError(
+            "Missing cluster configuration. Set AP_CLUSTER (e.g. export AP_CLUSTER=test) "
+            "or include a non-empty X-Cluster in AP_HEADERS (e.g. export AP_HEADERS='X-Cluster: test')."
+        )
+
     def _get(self, path: str, params: Optional[dict] = None) -> Any:
         """Send a GET request."""
         return self._request("GET", path, params=params)
@@ -476,6 +501,16 @@ def _safe_json(value: Any) -> str:
         return str(value)
 
 
+def _response_error_detail(resp: requests.Response) -> Any:
+    try:
+        err_data = resp.json()
+    except Exception:
+        return resp.text
+    if isinstance(err_data, dict):
+        return err_data.get("detail", resp.text)
+    return err_data
+
+
 def _safe_decode(raw: bytes) -> str:
     try:
         return raw.decode("utf-8", errors="replace")

{ap_client-0.1.4.dev0 → ap_client-0.1.5}/ap_client/cli.py

@@ -11,14 +11,21 @@ from rich.console import Console
 
 from ap_client import __version__, get_client, get_config
 from ap_client.api import set_verbose_override
+from ap_client.config import _parse_bool
 from ap_client.exporter import export_group, export_job
-from ap_client.waiter import wait_for_group, wait_for_job
+from ap_client.waiter import WaitTimeoutError, wait_for_group, wait_for_job
+
+# Verbose mode (AP_VERBOSE / --verbose) also controls whether Typer's pretty
+# traceback dumps local variables on unhandled exceptions. Default is off to
+# avoid leaking large payloads (URLs, events, job dicts) to end users.
+_INITIAL_VERBOSE = _parse_bool(os.environ.get("AP_VERBOSE"))
 
 app = typer.Typer(
     name="ap",
     help="Agent Platform CLI - minimal job submission tool",
     add_completion=False,
     no_args_is_help=True,
+    pretty_exceptions_show_locals=_INITIAL_VERBOSE,
 )
 console = Console()
 
@@ -48,6 +55,8 @@ def _global_options(
     del version
     if verbose:
         set_verbose_override(True)
+        # Keep traceback-locals behavior in sync with the HTTP verbose switch.
+        app.pretty_exceptions_show_locals = True
 
 # Resource sub-command groups
 template_app = typer.Typer(help="Template operations")
@@ -79,6 +88,14 @@ def _emit_info(message: str, output_format: str = "plain") -> None:
     typer.echo(message, err=output_format != "plain")
 
 
+def _format_wait_timeout(timeout: Optional[float]) -> str:
+    if timeout is None:
+        return "none"
+    if timeout == int(timeout):
+        return f"{int(timeout)}s"
+    return f"{timeout:g}s"
+
+
 def _normalize_output_format(output_format: str) -> str:
     value = output_format.lower()
     if value == "text":
@@ -158,8 +175,12 @@ def _runtime_job_tags() -> list[str]:
 
 
 def _print_job_list_plain(result: dict) -> None:
+    jobs = result.get("jobs", [])
+    for row in jobs:
+        if "tags" in row and isinstance(row["tags"], list):
+            row["tags"] = ",".join(row["tags"])
     _print_plain_table(
-        result.get("jobs", []),
+        jobs,
         [
             ("job_id", "job_id"),
             ("template", "template"),
@@ -167,6 +188,7 @@ def _print_job_list_plain(result: dict) -> None:
             ("group_id", "group_id"),
             ("status", "status"),
             ("failed_reason", "failed_reason"),
+            ("tags", "tags"),
             ("created_at", "created_at"),
         ],
     )
@@ -284,11 +306,29 @@ def _mask_config_headers(headers: dict) -> dict:
     return masked
 
 
+def _extract_cluster(headers: dict) -> str | None:
+    for key, value in headers.items():
+        if key.lower() == "x-cluster":
+            return value
+    return None
+
+
 def _config_payload() -> dict:
-    config = get_config()
+    from ap_client import api as _api
+
+    config = get_config(verbose=_api._verbose_override)
+    ap_cluster = (
+        os.environ.get("AP_CLUSTER", "").strip()
+        or _extract_cluster(config.headers)
+        or None
+    )
     return {
         "base_url": config.base_url,
+        "ap_cluster": ap_cluster,
         "agenthub_ref": config.agenthub_ref,
+        "ap_verbose": config.verbose,
+        "ap_verbose_body_limit": config.verbose_body_limit,
+        "ap_verbose_full_body": config.verbose_full_body,
         "headers": _mask_config_headers(config.headers),
     }
 
@@ -303,7 +343,11 @@ def show_config(
     if output_format == "plain":
         rows = [
             {"key": "base_url", "value": payload["base_url"]},
+            {"key": "ap_cluster", "value": payload["ap_cluster"]},
             {"key": "agenthub_ref", "value": payload["agenthub_ref"]},
+            {"key": "ap_verbose", "value": str(payload["ap_verbose"]).lower()},
+            {"key": "ap_verbose_body_limit", "value": payload["ap_verbose_body_limit"]},
+            {"key": "ap_verbose_full_body", "value": str(payload["ap_verbose_full_body"]).lower()},
             {"key": "headers", "value": json.dumps(payload["headers"], ensure_ascii=False)},
         ]
         _print_plain_table(rows, [("key", "key"), ("value", "value")])
@@ -468,6 +512,12 @@ def job_create(
     wait_interval: float = typer.Option(
         5.0, "--wait-interval", min=0.1, help="Polling interval in seconds when used with --wait"
     ),
+    wait_timeout: Optional[float] = typer.Option(
+        None,
+        "--wait-timeout",
+        min=0.0,
+        help="Maximum seconds to wait when used with --wait; omit to wait indefinitely",
+    ),
     output_format: str = typer.Option("plain", "--format", help="Output format: plain/json/yaml"),
     enable_otel_tracing: Optional[bool] = typer.Option(
         None,
@@ -675,35 +725,63 @@ def job_create(
                 print(f"  group_id: {result.get('group_id')}")
 
     if wait:
-        group_id = result.get("group_id")
-        if group_id:
-            _emit_info(
-                f"Waiting for group to finish: {group_id} (interval={wait_interval}s)",
-                output_format,
-            )
-            final_group = wait_for_group(client, group_id, wait_interval, printer=wait_printer)
-            wait_result = {"type": "group", "interval": wait_interval, "result": final_group}
-            if output_format == "plain":
-                stats = final_group.get("stats") or {}
-                print(f"[green]Group finished:[/] {group_id}")
-                print(f"  total: {stats.get('total', 0)}")
-                print(f"  succeeded: {stats.get('succeeded', 0)}")
-                print(f"  failed: {stats.get('failed', 0)}")
-                print(f"  cancelled: {stats.get('cancelled', 0)}")
-        else:
-            job = result.get("jobs", [{}])[0]
-            job_id = job.get("job_id")
-            _emit_info(
-                f"Waiting for job to finish: {job_id} (interval={wait_interval}s)",
-                output_format,
-            )
-            final_job = wait_for_job(client, job_id, wait_interval, printer=wait_printer)
-            wait_result = {"type": "job", "interval": wait_interval, "result": final_job}
-            if output_format == "plain":
-                print(f"[green]Job finished:[/] {job_id}")
-                print(f"  status: {final_job.get('status')}")
-                if final_job.get("failed_reason"):
-                    print(f"  failed_reason: {final_job.get('failed_reason')}")
+        try:
+            group_id = result.get("group_id")
+            if group_id:
+                _emit_info(
+                    f"Waiting for group to finish: {group_id} "
+                    f"(interval={wait_interval}s, timeout={_format_wait_timeout(wait_timeout)})",
+                    output_format,
+                )
+                final_group = wait_for_group(
+                    client,
+                    group_id,
+                    wait_interval,
+                    timeout=wait_timeout,
+                    printer=wait_printer,
+                )
+                wait_result = {
+                    "type": "group",
+                    "interval": wait_interval,
+                    "timeout": wait_timeout,
+                    "result": final_group,
+                }
+                if output_format == "plain":
+                    stats = final_group.get("stats") or {}
+                    print(f"[green]Group finished:[/] {group_id}")
+                    print(f"  total: {stats.get('total', 0)}")
+                    print(f"  succeeded: {stats.get('succeeded', 0)}")
+                    print(f"  failed: {stats.get('failed', 0)}")
+                    print(f"  cancelled: {stats.get('cancelled', 0)}")
+            else:
+                job = result.get("jobs", [{}])[0]
+                job_id = job.get("job_id")
+                _emit_info(
+                    f"Waiting for job to finish: {job_id} "
+                    f"(interval={wait_interval}s, timeout={_format_wait_timeout(wait_timeout)})",
+                    output_format,
+                )
+                final_job = wait_for_job(
+                    client,
+                    job_id,
+                    wait_interval,
+                    timeout=wait_timeout,
+                    printer=wait_printer,
+                )
+                wait_result = {
+                    "type": "job",
+                    "interval": wait_interval,
+                    "timeout": wait_timeout,
+                    "result": final_job,
+                }
+                if output_format == "plain":
+                    print(f"[green]Job finished:[/] {job_id}")
+                    print(f"  status: {final_job.get('status')}")
+                    if final_job.get("failed_reason"):
+                        print(f"  failed_reason: {final_job.get('failed_reason')}")
+        except WaitTimeoutError as exc:
+            typer.echo(f"error: {exc}", err=True)
+            raise typer.Exit(1)
 
     if output_format != "plain":
         payload = {"submission": result}
@@ -808,10 +886,21 @@ def job_wait(
     interval: float = typer.Option(
         5.0, "--interval", "-i", min=0.1, help="Polling interval (seconds)"
     ),
+    timeout: Optional[float] = typer.Option(
+        None,
+        "--timeout",
+        "--wait-timeout",
+        min=0.0,
+        help="Maximum seconds to wait; omit to wait indefinitely",
+    ),
 ):
     """Poll until the job finishes."""
     client = get_client()
-    result = wait_for_job(client, job_id, interval)
+    try:
+        result = wait_for_job(client, job_id, interval, timeout=timeout)
+    except WaitTimeoutError as exc:
+        typer.echo(f"error: {exc}", err=True)
+        raise typer.Exit(1)
     print(f"[green]Job finished:[/] {job_id}")
     print(f"  status: {result.get('status')}")
     if result.get("failed_reason"):
@@ -1000,10 +1089,21 @@ def group_wait(
     interval: float = typer.Option(
         5.0, "--interval", "-i", min=0.1, help="Polling interval (seconds)"
     ),
+    timeout: Optional[float] = typer.Option(
+        None,
+        "--timeout",
+        "--wait-timeout",
+        min=0.0,
+        help="Maximum seconds to wait; omit to wait indefinitely",
+    ),
 ):
     """Poll until all jobs under a Group finish."""
     client = get_client()
-    result = wait_for_group(client, group_id, interval)
+    try:
+        result = wait_for_group(client, group_id, interval, timeout=timeout)
+    except WaitTimeoutError as exc:
+        typer.echo(f"error: {exc}", err=True)
+        raise typer.Exit(1)
     stats = result.get("stats") or {}
     print(f"[green]Group finished:[/] {group_id}")
     print(f"  total: {stats.get('total', 0)}")

{ap_client-0.1.4.dev0 → ap_client-0.1.5}/ap_client/config.py

@@ -3,6 +3,13 @@
 import os
 from dataclasses import dataclass
 
+DEFAULT_BASE_URL = "http://agentplatform.aliyun-inc.com"
+CLUSTER_HEADER = "X-Cluster"
+
+
+class ConfigurationError(Exception):
+    """Raised when required client configuration is missing or invalid."""
+
 
 def _parse_bool(value: str | None) -> bool:
     """Parse a boolean environment variable."""
@@ -21,6 +28,17 @@ def _parse_positive_int(value: str | None, default: int) -> int:
     return parsed
 
 
+def has_cluster_header(headers: dict[str, str]) -> bool:
+    return any(key.lower() == "x-cluster" and value.strip() for key, value in headers.items())
+
+
+def _set_cluster_header(headers: dict[str, str], cluster: str) -> None:
+    for key in list(headers):
+        if key.lower() == "x-cluster":
+            del headers[key]
+    headers[CLUSTER_HEADER] = cluster
+
+
 @dataclass
 class Config:
     """CLI configuration."""
@@ -35,11 +53,9 @@ class Config:
     @classmethod
     def from_env(cls) -> "Config":
         """Load configuration from environment variables."""
-        base_url = os.environ.get("AP_BASE_URL")
-        if not base_url:
-            raise ValueError("AP_BASE_URL environment variable must be set")
+        base_url = os.environ.get("AP_BASE_URL") or DEFAULT_BASE_URL
 
-        headers = {}
+        headers: dict[str, str] = {}
         headers_str = os.environ.get("AP_HEADERS", "")
         if headers_str:
             for h in headers_str.split(","):
@@ -47,6 +63,10 @@ class Config:
                     k, v = h.split(":", 1)
                     headers[k.strip()] = v.strip()
 
+        cluster = os.environ.get("AP_CLUSTER", "").strip()
+        if cluster:
+            _set_cluster_header(headers, cluster)
+
         return cls(
             base_url=base_url.rstrip("/"),
             headers=headers,

{ap_client-0.1.4.dev0 → ap_client-0.1.5}/ap_client/exporter.py

@@ -1,21 +1,23 @@
 """Export job/group data from Agent Platform to local directories."""
 
 from __future__ import annotations
+
 import concurrent.futures
-from functools import lru_cache
 import json
 import os
+import shutil
 import socket
 import sys
 import tarfile
 import threading
+from functools import lru_cache
 from pathlib import Path
 from typing import Callable, Optional
 from urllib.parse import urlparse, urlunparse
 
 import requests
 
-from .api import APIClient
+from .api import APIClient, APIError
 
 DEFAULT_CACHE_DIR = "~/.cache/agentplatform"
 _DOWNLOAD_TIMEOUT = (10, 300)
@@ -215,7 +217,9 @@ def _export_job_into_dir(
                 else:
                     raise
     except Exception as exc:
-        raise RuntimeError(f"Failed to export job {job_id} at stage '{current_stage}': {exc}") from exc
+        raise RuntimeError(
+            f"Failed to export job {job_id} at stage '{current_stage}': {exc}"
+        ) from exc
 
 
 def _get_job_artifact(client: APIClient, job_id: str) -> dict:
@@ -336,6 +340,10 @@ def can_connect(endpoint: str, port: int = 80, timeout: int = 1) -> bool:
 
 
 def _is_missing_artifact_error(exc: Exception) -> bool:
+    if isinstance(exc, APIError):
+        if exc.status_code == 404:
+            return True
+        return "NoSuchKey" in str(exc.detail)
     if isinstance(exc, requests.HTTPError):
         response = exc.response
         if response is not None:
@@ -352,16 +360,28 @@ def _is_missing_artifact_error(exc: Exception) -> bool:
 
 def _warn_missing_artifact(job_id: str) -> None:
     print(
-        f"[ap export] warning: artifact missing for job {job_id}; "
-        "skipping result.tgz download",
+        f"[ap export] warning: artifact missing for job {job_id}; skipping result.tgz download",
         file=sys.stderr,
     )
 
 
 def _extract_tgz(archive_path: Path, dest_dir: Path) -> None:
+    # Wipe the destination first so that a previous extraction cannot leave
+    # behind a symlink that a re-extraction would follow outside ``dest_dir``.
+    if dest_dir.exists():
+        shutil.rmtree(dest_dir, ignore_errors=True)
     dest_dir.mkdir(parents=True, exist_ok=True)
     with tarfile.open(archive_path, "r:gz") as tar:
-        tar.extractall(dest_dir)
+        _safe_extractall(tar, dest_dir)
+
+
+def _safe_extractall(tar: tarfile.TarFile, dest_dir: Path) -> None:
+    root = dest_dir.resolve()
+    for member in tar.getmembers():
+        member_path = (root / member.name).resolve()
+        if os.path.commonpath([str(root), str(member_path)]) != str(root):
+            raise ValueError(f"Unsafe artifact archive path: {member.name} {member_path}")
+    tar.extractall(dest_dir)
 
 
 def _sanitize_name(name: str) -> str:

{ap_client-0.1.4.dev0 → ap_client-0.1.5}/ap_client/waiter.py

@@ -9,30 +9,52 @@ from typing import Callable
 from .api import APIClient
 
 
+class WaitTimeoutError(TimeoutError):
+    """Raised when waiting for a job or group exceeds the configured timeout."""
+
+    def __init__(self, resource_type: str, resource_id: str, timeout: float):
+        self.resource_type = resource_type
+        self.resource_id = resource_id
+        self.timeout = timeout
+        super().__init__(
+            f"timed out waiting for {resource_type} {resource_id} after {_format_seconds(timeout)}"
+        )
+
+
 def wait_for_job(
     client: APIClient,
     job_id: str,
     interval: float = 5.0,
+    timeout: float | None = None,
     printer: Callable[[str], None] = print,
 ) -> dict:
     """Poll until a job reaches a terminal status."""
     _TERMINAL = {"Succeeded", "Failed", "Cancelled", "Unknown"}
+    deadline = _deadline(timeout)
+    first_poll = True
     while True:
+        _raise_if_timed_out(deadline, first_poll, "job", job_id, timeout)
+        first_poll = False
         job = client.get_job(job_id)
         _print_job_status(job, printer)
         if job.get("status") in _TERMINAL:
             return job
-        time.sleep(interval)
+        _sleep_until_next_poll(interval, deadline, "job", job_id, timeout)
 
 
 def wait_for_group(
     client: APIClient,
     group_id: str,
     interval: float = 5.0,
+    timeout: float | None = None,
     printer: Callable[[str], None] = print,
 ) -> dict:
     """Poll until all jobs in a group are finished."""
+    deadline = _deadline(timeout)
+    first_poll = True
     while True:
+        _raise_if_timed_out(deadline, first_poll, "group", group_id, timeout)
+        first_poll = False
         group = client.get_group_stats(group_id)
         _print_group_status(group, printer)
         stats = group.get("stats") or {}
@@ -40,7 +62,42 @@ def wait_for_group(
         finished = int(stats.get("finished", 0) or 0)
         if total == 0 or finished >= total:
             return group
+        _sleep_until_next_poll(interval, deadline, "group", group_id, timeout)
+
+
+def _deadline(timeout: float | None) -> float | None:
+    if timeout is None:
+        return None
+    return time.monotonic() + timeout
+
+
+def _raise_if_timed_out(
+    deadline: float | None,
+    first_poll: bool,
+    resource_type: str,
+    resource_id: str,
+    timeout: float | None,
+) -> None:
+    if deadline is None or first_poll:
+        return
+    if time.monotonic() >= deadline:
+        raise WaitTimeoutError(resource_type, resource_id, timeout or 0.0)
+
+
+def _sleep_until_next_poll(
+    interval: float,
+    deadline: float | None,
+    resource_type: str,
+    resource_id: str,
+    timeout: float | None,
+) -> None:
+    if deadline is None:
         time.sleep(interval)
+        return
+    remaining = deadline - time.monotonic()
+    if remaining <= 0:
+        raise WaitTimeoutError(resource_type, resource_id, timeout or 0.0)
+    time.sleep(min(interval, remaining))
 
 
 def _print_job_status(job: dict, printer: Callable[[str], None]) -> None:
@@ -68,3 +125,9 @@ def _print_group_status(group: dict, printer: Callable[[str], None]) -> None:
 
 def _now_str() -> str:
     return datetime.now().astimezone().strftime("%Y-%m-%d %H:%M:%S")
+
+
+def _format_seconds(value: float) -> str:
+    if value == int(value):
+        return f"{int(value)}s"
+    return f"{value:g}s"

{ap_client-0.1.4.dev0 → ap_client-0.1.5}/pyproject.toml

@@ -4,8 +4,9 @@ build-backend = "hatchling.build"
 
 [project]
 name = "ap-client"
-version = "0.1.4.dev0"
+version = "0.1.5"
 description = "Agent Platform API Client & CLI"
+readme = { text = "A lightweight Python SDK and command line interface for Agent Platform. It provides helpers for configuring API access and managing templates, datasets, jobs, and groups.", content-type = "text/markdown" }
 requires-python = ">=3.10"
 dependencies = [
     "typer>=0.9.0",
@@ -35,3 +36,8 @@ only-include = [
 
 [tool.hatch.build.targets.wheel]
 packages = ["ap_client"]
+
+[tool.pytest.ini_options]
+pythonpath = ["."]
+testpaths = ["tests"]
+markers = ["e2e: end-to-end tests that require external services"]

ap_client-0.1.4.dev0/.gitignore

@@ -1,235 +0,0 @@
-
-# Local config (never commit — copy from .env.example)
-.env
-tests/integration/.env
-
-# Byte-compiled / optimized / DLL files
-__pycache__/
-*.py[codz]
-*$py.class
-
-# C extensions
-*.so
-
-# Distribution / packaging
-.Python
-build/
-develop-eggs/
-dist/
-downloads/
-eggs/
-.eggs/
-lib/
-lib64/
-parts/
-sdist/
-var/
-wheels/
-share/python-wheels/
-*.egg-info/
-.installed.cfg
-*.egg
-MANIFEST
-
-# PyInstaller
-#   Usually these files are written by a python script from a template
-#   before PyInstaller builds the exe, so as to inject date/other infos into it.
-*.manifest
-*.spec
-
-# Installer logs
-pip-log.txt
-pip-delete-this-directory.txt
-
-# Unit test / coverage reports
-htmlcov/
-.tox/
-.nox/
-.coverage
-.coverage.*
-.cache
-nosetests.xml
-coverage.xml
-*.cover
-*.py.cover
-.hypothesis/
-.pytest_cache/
-cover/
-
-# Translations
-*.mo
-*.pot
-
-# Django stuff:
-*.log
-local_settings.py
-db.sqlite3
-db.sqlite3-journal
-
-# Flask stuff:
-instance/
-.webassets-cache
-
-# Scrapy stuff:
-.scrapy
-
-# Sphinx documentation
-docs/_build/
-
-# PyBuilder
-.pybuilder/
-target/
-
-# Jupyter Notebook
-.ipynb_checkpoints
-
-# IPython
-profile_default/
-ipython_config.py
-
-# pyenv
-#   For a library or package, you might want to ignore these files since the code is
-#   intended to run in multiple environments; otherwise, check them in:
-# .python-version
-
-# pipenv
-#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
-#   However, in case of collaboration, if having platform-specific dependencies or dependencies
-#   having no cross-platform support, pipenv may install dependencies that don't work, or not
-#   install all needed dependencies.
-# Pipfile.lock
-
-# UV
-#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
-#   This is especially recommended for binary packages to ensure reproducibility, and is more
-#   commonly ignored for libraries.
-# uv.lock
-
-# poetry
-#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
-#   This is especially recommended for binary packages to ensure reproducibility, and is more
-#   commonly ignored for libraries.
-#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
-# poetry.lock
-# poetry.toml
-
-# pdm
-#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
-#   pdm recommends including project-wide configuration in pdm.toml, but excluding .pdm-python.
-#   https://pdm-project.org/en/latest/usage/project/#working-with-version-control
-# pdm.lock
-# pdm.toml
-.pdm-python
-.pdm-build/
-
-# pixi
-#   Similar to Pipfile.lock, it is generally recommended to include pixi.lock in version control.
-# pixi.lock
-#   Pixi creates a virtual environment in the .pixi directory, just like venv module creates one
-#   in the .venv directory. It is recommended not to include this directory in version control.
-.pixi
-
-# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
-__pypackages__/
-
-# Celery stuff
-celerybeat-schedule
-celerybeat.pid
-
-# Redis
-*.rdb
-*.aof
-*.pid
-
-# RabbitMQ
-mnesia/
-rabbitmq/
-rabbitmq-data/
-
-# ActiveMQ
-activemq-data/
-
-# SageMath parsed files
-*.sage.py
-
-# Environments
-.envrc
-.venv
-env/
-venv/
-ENV/
-env.bak/
-venv.bak/
-
-# Spyder project settings
-.spyderproject
-.spyproject
-
-# Rope project settings
-.ropeproject
-
-# mkdocs documentation
-/site
-
-# mypy
-.mypy_cache/
-.dmypy.json
-dmypy.json
-
-# Pyre type checker
-.pyre/
-
-# pytype static type analyzer
-.pytype/
-
-# Cython debug symbols
-cython_debug/
-
-# PyCharm
-#   JetBrains specific template is maintained in a separate JetBrains.gitignore that can
-#   be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
-#   and can be added to the global gitignore or merged into this file.  For a more nuclear
-#   option (not recommended) you can uncomment the following to ignore the entire idea folder.
-# .idea/
-
-# Abstra
-#   Abstra is an AI-powered process automation framework.
-#   Ignore directories containing user credentials, local state, and settings.
-#   Learn more at https://abstra.io/docs
-.abstra/
-
-# Visual Studio Code
-#   Visual Studio Code specific template is maintained in a separate VisualStudioCode.gitignore 
-#   that can be found at https://github.com/github/gitignore/blob/main/Global/VisualStudioCode.gitignore
-#   and can be added to the global gitignore or merged into this file. However, if you prefer, 
-#   you could uncomment the following to ignore the entire vscode folder
-.vscode/
-
-# Ruff stuff:
-.ruff_cache/
-
-# PyPI configuration file
-.pypirc
-
-# Marimo
-marimo/_static/
-marimo/_lsp/
-__marimo__/
-
-# Streamlit
-.streamlit/secrets.toml
-
-
-results/
-ix-run*/
-CLAUDE.md
-.claude/*
-!.claude/skills/
-DESIGN.md
-deploy/k8s/secret.yaml
-.idea/
-web/
-
-# Stress test output files
-stress-test/results.txt
-stress-test/stress_report*.md

ap_client-0.1.4.dev0/PKG-INFO

@@ -1,9 +0,0 @@
-Metadata-Version: 2.4
-Name: ap-client
-Version: 0.1.4.dev0
-Summary: Agent Platform API Client & CLI
-Requires-Python: >=3.10
-Requires-Dist: pyyaml>=6.0
-Requires-Dist: requests>=2.28.0
-Requires-Dist: rich>=13.0.0
-Requires-Dist: typer>=0.9.0

ap_client-0.1.4.dev0/ap_client/__init__.py

@@ -1,13 +0,0 @@
-"""Agent Platform API Client"""
-
-from importlib.metadata import PackageNotFoundError, version
-
-from .api import APIClient, get_client
-from .config import Config, get_config
-
-try:
-    __version__ = version("ap-client")
-except PackageNotFoundError:
-    __version__ = "0.1.4"
-
-__all__ = ["APIClient", "Config", "__version__", "get_client", "get_config"]