cometapi-cli 0.3.0__py3-none-any.whl → 0.3.2__py3-none-any.whl

cometapi_cli/__init__.py

@@ -1,3 +1,3 @@
 """CometAPI CLI — professional terminal interface for CometAPI."""
 
-__version__ = "0.3.0"
+__version__ = "0.3.2"

cometapi_cli/client.py

@@ -9,6 +9,8 @@ import openai
 
 COMETAPI_BASE_URL = "https://api.cometapi.com/v1"
 COMETAPI_DASHBOARD_BASE = "https://api.cometapi.com"
+ACCOUNT_REQUEST_TIMEOUT = 30.0
+ACCOUNT_EXPORT_TIMEOUT = 120.0
 
 
 class CometClient(openai.OpenAI):
@@ -44,7 +46,14 @@ class CometClient(openai.OpenAI):
 
     # -- Account management (access-token auth) --------------------------------
 
-    def _account_request(self, method: str, path: str, *, params: dict | None = None) -> dict:
+    def _account_request(
+        self,
+        method: str,
+        path: str,
+        *,
+        params: dict | None = None,
+        timeout: float = ACCOUNT_REQUEST_TIMEOUT,
+    ) -> dict:
         """Make an authenticated request to a CometAPI account endpoint."""
         if not self._access_token:
             raise openai.OpenAIError(
@@ -56,6 +65,7 @@ class CometClient(openai.OpenAI):
             f"{COMETAPI_DASHBOARD_BASE}{path}",
             headers={"Authorization": f"Bearer {self._access_token}"},
             params=params,
+            timeout=timeout,
         )
         response.raise_for_status()
         return response.json()
@@ -151,6 +161,7 @@ class CometClient(openai.OpenAI):
         start_timestamp: int | None = None,
         end_timestamp: int | None = None,
         group: str | None = None,
+        request_id: str | None = None,
     ) -> dict:
         """List the user's usage logs (requires access token)."""
         params: dict[str, Any] = {"p": page, "page_size": page_size}
@@ -166,6 +177,8 @@ class CometClient(openai.OpenAI):
             params["end_timestamp"] = end_timestamp
         if group:
             params["group"] = group
+        if request_id:
+            params["request_id"] = request_id
         return self._account_request("GET", "/api/log/self", params=params)
 
     def search_logs(self, keyword: str) -> dict:
@@ -235,6 +248,7 @@ class CometClient(openai.OpenAI):
             f"{COMETAPI_DASHBOARD_BASE}/api/log/self/export",
             headers={"Authorization": f"Bearer {self._access_token}"},
             params=params,
+            timeout=ACCOUNT_EXPORT_TIMEOUT,
         )
         response.raise_for_status()
         return response.content

cometapi_cli/commands/logs.py

@@ -4,12 +4,20 @@ from __future__ import annotations
 
 import json as _json
 import sys
+from datetime import datetime, time, timedelta, timezone
 from typing import Annotated
 
 import typer
 
 from ..config import get_client
-from ..constants import extract_items, format_ts, parse_date, quota_to_usd
+from ..constants import (
+    QUOTA_PER_UNIT,
+    extract_items,
+    format_iso,
+    format_ts,
+    parse_date,
+    quota_to_usd,
+)
 from ..errors import handle_errors
 from ..formatters import OutputFormat, output, resolve_format
 
@@ -24,6 +32,9 @@ LOG_TYPE_MAP = {
 }
 
 _LOG_TYPE_NAMES = {v: k for k, v in LOG_TYPE_MAP.items()}
+REQUEST_ID_PAGE_SIZE = 100
+REQUEST_ID_DEFAULT_MAX_PAGES = 10
+REQUEST_ID_LOCAL_TZ = timezone(timedelta(hours=8))
 
 
 def _parse_other(other_raw: str | None) -> dict:
@@ -37,7 +48,29 @@ def _parse_other(other_raw: str | None) -> dict:
         return {}
 
 
-def _find_log_by_id(
+def _request_id_date_window(request_id: str) -> tuple[int, int] | None:
+    """Infer the local request day from a CometAPI request ID prefix."""
+    prefix = request_id[:14]
+    if len(prefix) != 14 or not prefix.isdigit():
+        return None
+    try:
+        local_dt = datetime.strptime(prefix, "%Y%m%d%H%M%S").replace(tzinfo=REQUEST_ID_LOCAL_TZ)
+    except ValueError:
+        return None
+
+    local_day_start = datetime.combine(local_dt.date(), time.min, tzinfo=REQUEST_ID_LOCAL_TZ)
+    local_day_end = local_day_start + timedelta(days=1) - timedelta(seconds=1)
+    return int(local_day_start.timestamp()), int(local_day_end.timestamp())
+
+
+def _exact_request_id_match(items: list, request_id: str) -> dict | None:
+    for item in items:
+        if isinstance(item, dict) and item.get("request_id") == request_id:
+            return item
+    return None
+
+
+def _lookup_log_by_id(
     client: object,
     *,
     request_id: str,
@@ -47,84 +80,166 @@ def _find_log_by_id(
     start_timestamp: int | None = None,
     end_timestamp: int | None = None,
     group: str | None = None,
-    max_pages: int = 10,
-) -> dict | None:
-    """Search through paginated logs to find the entry matching a request ID."""
+    max_pages: int = REQUEST_ID_DEFAULT_MAX_PAGES,
+) -> tuple[dict | None, dict]:
+    """Look up a log entry by request ID, using server filtering before fallback scans."""
+    meta = {
+        "used_server_filter": False,
+        "used_inferred_window": False,
+        "scanned_pages": 0,
+        "max_pages": max_pages,
+    }
+
+    # Older backends may ignore request_id, so verify the returned item matches
+    # before trusting this direct lookup.
+    resp = client.list_logs(  # type: ignore[union-attr]
+        page=1,
+        page_size=REQUEST_ID_PAGE_SIZE,
+        log_type=log_type,
+        model_name=model_name,
+        token_name=token_name,
+        start_timestamp=start_timestamp,
+        end_timestamp=end_timestamp,
+        group=group,
+        request_id=request_id,
+    )
+    meta["used_server_filter"] = True
+    if match := _exact_request_id_match(extract_items(resp), request_id):
+        return match, meta
+
+    scan_start = start_timestamp
+    scan_end = end_timestamp
+    if scan_start is None and scan_end is None:
+        inferred = _request_id_date_window(request_id)
+        if inferred:
+            scan_start, scan_end = inferred
+            meta["used_inferred_window"] = True
+
     for pg in range(1, max_pages + 1):
         resp = client.list_logs(  # type: ignore[union-attr]
             page=pg,
-            page_size=100,
+            page_size=REQUEST_ID_PAGE_SIZE,
             log_type=log_type,
             model_name=model_name,
             token_name=token_name,
-            start_timestamp=start_timestamp,
-            end_timestamp=end_timestamp,
+            start_timestamp=scan_start,
+            end_timestamp=scan_end,
             group=group,
         )
+        meta["scanned_pages"] = pg
         items = extract_items(resp)
         if not items:
             break
-        for item in items:
-            if item.get("request_id") == request_id:
-                return item
-    return None
+        if match := _exact_request_id_match(items, request_id):
+            return match, meta
+    return None, meta
+
 
+def _build_log_record(log: dict) -> dict:
+    """Build the canonical, machine-friendly record for a single log entry.
 
-def _format_log_detail(log: dict) -> dict:
-    """Build a rich key-value detail card from a single log entry."""
+    Returns a stable schema with raw, typed values (numbers, booleans, ISO 8601
+    time). The same field set drives every output format; human-facing formats
+    layer display formatting on top via :func:`_record_to_detail_display`.
+    Missing values are ``None`` so the schema stays consistent across entries.
+    """
     other = _parse_other(log.get("other"))
-    prompt_tokens = log.get("prompt_tokens", 0)
-    completion_tokens = log.get("completion_tokens", 0)
-    quota = log.get("quota", 0)
+    quota = log.get("quota", 0) or 0
+
+    # model_price == -1 is the backend sentinel for "use ratio-based pricing"
+    # (i.e. no fixed per-call price); expose it as null in the canonical record.
+    raw_model_price = other.get("model_price")
+    model_price = None if raw_model_price == -1 else raw_model_price
+
+    # Prefer total_ms (true end-to-end latency) over use_time, which the backend
+    # records in seconds and is too coarse to be useful as a duration.
+    total_ms = other.get("total_ms")
+    use_time = log.get("use_time", 0) or 0
+    duration_ms = total_ms if total_ms else (use_time or None)
+
+    frt = other.get("frt")
+    user_id = log.get("user_id")
 
+    return {
+        "request_id": log.get("request_id") or None,
+        "response_id": log.get("response_id") or None,
+        "time": format_iso(log.get("created_at", 0)),
+        "type": _LOG_TYPE_NAMES.get(log.get("type", 0), "unknown"),
+        "model": log.get("model_name") or None,
+        "token_name": log.get("token_name") or None,
+        "username": log.get("username") or None,
+        "user_id": user_id if user_id else None,
+        "ip": log.get("ip") or None,
+        "stream": bool(log.get("is_stream")),
+        "prompt_tokens": log.get("prompt_tokens", 0) or 0,
+        "completion_tokens": log.get("completion_tokens", 0) or 0,
+        "cache_tokens": other.get("cache_tokens", 0) or 0,
+        "cost_usd": round(quota / QUOTA_PER_UNIT, 6),
+        "quota": quota,
+        "model_ratio": other.get("model_ratio"),
+        "completion_ratio": other.get("completion_ratio"),
+        "group_ratio": other.get("group_ratio"),
+        "model_price": model_price,
+        "cache_ratio": other.get("cache_ratio"),
+        "duration_ms": duration_ms,
+        "first_token_ms": frt if frt and frt > 0 else None,
+        "endpoint": other.get("request_path") or None,
+    }
+
+
+def _record_to_detail_display(rec: dict) -> dict:
+    """Render a canonical log record as a formatted key-value detail card.
+
+    Mirrors the field set of :func:`_build_log_record` but uses human-friendly
+    labels and formatted strings (USD, ``Yes``/``No``, ``ms``). Optional fields
+    are omitted when absent to keep the card readable.
+    """
+    em_dash = "—"
     info: dict[str, str | int | float] = {}
-    info["Request ID"] = log.get("request_id", "") or "—"
-    info["Response ID"] = log.get("response_id", "") or "—"
-    info["Time"] = format_ts(log.get("created_at", 0))
-    info["Model"] = log.get("model_name", "") or "—"
-    info["Token Name"] = log.get("token_name", "") or "—"
-    info["Group"] = log.get("group", "") or "—"
-    info["Stream"] = "Yes" if log.get("is_stream") else "No"
+    info["Request ID"] = rec["request_id"] or em_dash
+    info["Response ID"] = rec["response_id"] or em_dash
+    iso = rec["time"]
+    info["Time"] = iso[:19].replace("T", " ") if iso else em_dash
+    info["Model"] = rec["model"] or em_dash
+    info["Token Name"] = rec["token_name"] or em_dash
+    if rec["username"]:
+        info["Username"] = rec["username"]
+    if rec["user_id"] is not None:
+        info["User ID"] = rec["user_id"]
+    if rec["ip"]:
+        info["IP"] = rec["ip"]
+    info["Type"] = rec["type"]
+    info["Stream"] = "Yes" if rec["stream"] else "No"
 
     # Tokens
-    info["Prompt Tokens"] = f"{prompt_tokens:,}"
-    info["Completion Tokens"] = f"{completion_tokens:,}"
-    cache_tokens = other.get("cache_tokens", 0)
-    if cache_tokens:
-        info["Cache Tokens"] = f"{cache_tokens:,}"
-
-    # Cost
-    info["Cost (USD)"] = quota_to_usd(quota)
-    info["Quota (raw)"] = f"{quota:,}"
-
-    # Pricing breakdown from 'other'
-    model_ratio = other.get("model_ratio")
-    if model_ratio is not None:
-        info["Model Ratio"] = model_ratio
-    completion_ratio = other.get("completion_ratio")
-    if completion_ratio is not None:
-        info["Completion Ratio"] = f"{completion_ratio}x"
-    group_ratio = other.get("group_ratio")
-    if group_ratio is not None:
-        info["Group Ratio"] = group_ratio
-    model_price = other.get("model_price")
-    if model_price is not None:
-        info["Model Price"] = "default" if model_price == -1 else model_price
-    cache_ratio = other.get("cache_ratio")
-    if cache_ratio is not None:
-        info["Cache Ratio"] = cache_ratio
+    info["Prompt Tokens"] = f"{rec['prompt_tokens']:,}"
+    info["Completion Tokens"] = f"{rec['completion_tokens']:,}"
+    if rec["cache_tokens"]:
+        info["Cache Tokens"] = f"{rec['cache_tokens']:,}"
+
+    # Cost (6 decimals so sub-cent calls are not rounded away)
+    info["Cost (USD)"] = f"${rec['cost_usd']:,.6f}"
+    info["Quota (raw)"] = f"{rec['quota']:,}"
+
+    # Pricing breakdown
+    if rec["model_ratio"] is not None:
+        info["Model Ratio"] = rec["model_ratio"]
+    if rec["completion_ratio"] is not None:
+        info["Completion Ratio"] = f"{rec['completion_ratio']}x"
+    if rec["group_ratio"] is not None:
+        info["Group Ratio"] = rec["group_ratio"]
+    info["Model Price"] = "default" if rec["model_price"] is None else rec["model_price"]
+    if rec["cache_ratio"] is not None:
+        info["Cache Ratio"] = rec["cache_ratio"]
 
     # Timing
-    use_time = log.get("use_time", 0)
-    info["Duration"] = f"{use_time:,} ms" if use_time else "—"
-    frt = other.get("frt")
-    if frt and frt > 0:
-        info["First Token"] = f"{frt:,} ms"
+    info["Duration"] = f"{rec['duration_ms']:,} ms" if rec["duration_ms"] else em_dash
+    if rec["first_token_ms"]:
+        info["First Token"] = f"{rec['first_token_ms']:,} ms"
 
     # Path
-    request_path = other.get("request_path")
-    if request_path:
-        info["Endpoint"] = request_path
+    if rec["endpoint"]:
+        info["Endpoint"] = rec["endpoint"]
 
     return info
 
@@ -169,6 +284,14 @@ def logs(
         str | None,
         typer.Option("--request-id", help="Look up cost by request ID (X-Cometapi-Request-Id header)."),
     ] = None,
+    request_id_max_pages: Annotated[
+        int,
+        typer.Option(
+            "--request-id-max-pages",
+            min=1,
+            help="Fallback pages to scan when direct request-ID lookup is unavailable.",
+        ),
+    ] = REQUEST_ID_DEFAULT_MAX_PAGES,
     detail: Annotated[
         bool,
         typer.Option("--detail", help="Show extended columns (request ID, pricing ratios)."),
@@ -202,7 +325,7 @@ def logs(
         if log_type:
             type_int = LOG_TYPE_MAP.get(log_type.lower())
 
-        log_entry = _find_log_by_id(
+        log_entry, lookup_meta = _lookup_log_by_id(
             client,
             request_id=request_id,
             log_type=type_int,
@@ -211,22 +334,32 @@ def logs(
             start_timestamp=start_ts,
             end_timestamp=end_ts,
             group=group,
+            max_pages=request_id_max_pages,
         )
 
         if log_entry is None:
+            if lookup_meta["used_inferred_window"]:
+                scan_note = (
+                    f"Then scanned {lookup_meta['scanned_pages']} page(s) in the request ID's "
+                    "inferred local date window."
+                )
+            else:
+                scan_note = f"Then scanned {lookup_meta['scanned_pages']} fallback page(s)."
             err_console.print(
                 f"[red]No log found for request_id=[/]{request_id}\n"
-                "[dim]The entry may be older than the search window. "
-                "Try narrowing with --start/--end or --model.[/]"
+                "[dim]Tried direct request-id lookup first. "
+                f"{scan_note} Increase --request-id-max-pages or narrow with --start/--end "
+                "if the backend does not support direct request-id filtering.[/]"
             )
             raise typer.Exit(code=1)
 
-        if fmt == OutputFormat.JSON:
-            output(log_entry, fmt)
+        record = _build_log_record(log_entry)
+        # Machine formats get raw typed values; human formats get the formatted card.
+        if fmt in (OutputFormat.JSON, OutputFormat.YAML, OutputFormat.CSV):
+            output(record, fmt)
             return
 
-        info = _format_log_detail(log_entry)
-        output(info, fmt, title="Request Detail")
+        output(_record_to_detail_display(record), fmt, title="Request Detail")
         return
 
     # Server-side CSV export — write raw bytes to stdout and return early
@@ -266,12 +399,15 @@ def logs(
         start_timestamp=start_ts,
         end_timestamp=end_ts,
         group=group,
+        request_id=None,
     )
 
     data = extract_items(resp)
 
-    if fmt == OutputFormat.JSON:
-        output(data, fmt)
+    # Machine formats emit the full canonical record per entry (typed values,
+    # incl. cost_usd); table/markdown/csv keep the compact summary rows.
+    if fmt in (OutputFormat.JSON, OutputFormat.YAML):
+        output([_build_log_record(log) for log in data], fmt)
         return
 
     if not data:

cometapi_cli/constants.py

@@ -24,6 +24,13 @@ def format_ts(ts: int, fmt: str = "%Y-%m-%d %H:%M:%S") -> str:
     return datetime.fromtimestamp(ts, tz=timezone.utc).strftime(fmt)
 
 
+def format_iso(ts: int) -> str | None:
+    """Format a Unix timestamp as an ISO 8601 UTC string, or None when absent."""
+    if not ts:
+        return None
+    return datetime.fromtimestamp(ts, tz=timezone.utc).isoformat()
+
+
 def parse_date(value: str, label: str) -> int:
     """Parse a date string into a Unix timestamp (UTC).
 

{cometapi_cli-0.3.0.dist-info → cometapi_cli-0.3.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cometapi-cli
-Version: 0.3.0
+Version: 0.3.2
 Summary: CometAPI CLI — official command-line interface for the CometAPI AI gateway
 Project-URL: Homepage, https://pypi.org/project/cometapi-cli/
 Project-URL: Documentation, https://apidoc.cometapi.com/libraries/cli/overview
@@ -21,6 +21,7 @@ Classifier: Topic :: Internet
 Classifier: Topic :: Software Development :: Libraries
 Classifier: Typing :: Typed
 Requires-Python: >=3.10
+Requires-Dist: click>=8.0
 Requires-Dist: openai>=1.0.0
 Requires-Dist: prompt-toolkit>=3.0
 Requires-Dist: pyyaml>=6.0
@@ -144,6 +145,21 @@ cometapi run -h
 | `repl` | Start an interactive command shell | Depends on command used |
 | `config` | Show, set, unset, or locate local configuration | None |
 
+## Logs
+
+Use `cometapi logs` to inspect recent usage, export CSV, or look up one request by the
+`X-Cometapi-Request-Id` response header.
+
+```bash
+cometapi logs --limit 20
+cometapi logs --type consume --start 2026-06-01 --json
+cometapi logs --request-id 20260617165550885561292gJBlzjtp
+```
+
+`logs --request-id` first asks the backend for that exact request ID. If the installed
+backend does not support direct request-ID filtering yet, the CLI falls back to scanning
+a bounded number of log pages. Use `--request-id-max-pages` to widen that fallback scan.
+
 ## Models
 
 `cometapi models` uses the public model catalog by default and displays richer metadata than `/v1/models`.

{cometapi_cli-0.3.0.dist-info → cometapi_cli-0.3.2.dist-info}/RECORD

@@ -1,10 +1,10 @@
-cometapi_cli/__init__.py,sha256=QEpNqXBo4pYsnFqEmU3Twm9RJoOaTlwmkKDAb1xt7iA,92
+cometapi_cli/__init__.py,sha256=I37ML-zws7ZAjDJSAw87LxYgHMsTcaVOz67of_juqiI,92
 cometapi_cli/app.py,sha256=d2IZJabWmdZtPtFNOB4YiuSJ1GYvO0hgIOkjm4gQjxA,2948
 cometapi_cli/catalog.py,sha256=Pc0XGoskMEKIzfbU2H_0Yi8zecLzKl1ss8fd2mV7778,4929
-cometapi_cli/client.py,sha256=4JkMSrjWwAQV8tmlwplZQ75gzt3zHno8ASKLgMCpYkU,9658
+cometapi_cli/client.py,sha256=QBtQ1cvmwvwjpIYpzupC3BMNqxREhMoRnzgCZOeJnEE,9998
 cometapi_cli/config.py,sha256=oJXQidKCOsKNYPnE8OfLLoOfsv0MSZEDICB6VShJRSA,3307
 cometapi_cli/console.py,sha256=HFSU1gL9SDmwjBvgVgDraoaU50oTwCRpsAwYXYlVP9o,163
-cometapi_cli/constants.py,sha256=EV2i-ag4ss1xGrU1CLiF9iPz8ggzNm4-U3wpYCC2pys,1601
+cometapi_cli/constants.py,sha256=UPfU36fnRTl4JdcyjySQ0UEVign3i_UTNH9mQ-Gb4ls,1826
 cometapi_cli/errors.py,sha256=MQ3VXefVhdIFa4uUmoLf_O5d1EFuu9PfGYrBGuq-mSA,3703
 cometapi_cli/formatters.py,sha256=PvIGp-O9UtSFuQWKJGp3OEeDnd9L6vbHL91V5VYrqLo,4559
 cometapi_cli/main.py,sha256=4NmO8MAAc_H30hahT6VNrdGdlaFlQ99AixKcRV5iDXE,168
@@ -16,7 +16,7 @@ cometapi_cli/commands/chat.py,sha256=xQgsjFQ33kVRfSnU5t3fbahjZE8nmVSa_w8qUTPeacE
 cometapi_cli/commands/chat_repl.py,sha256=b9lkYnbbaOb0AlSpRcq3wWHmnhtTXvaqeJiUImsMEBY,8176
 cometapi_cli/commands/config_cmd.py,sha256=OqR0TuAq6gQXw8nJIt5AAv_Fk4zdfbg-KhNLuUsrEsU,8619
 cometapi_cli/commands/doctor.py,sha256=s9XzRIkF9FIMAWSc7b3c6v3g8Px9kb0k6WDucOrdXY8,5360
-cometapi_cli/commands/logs.py,sha256=0mD9PviMitJl77gm3U9PJ2UYV8XKRkWqGGYY9aVUqvM,10333
+cometapi_cli/commands/logs.py,sha256=__6Ft5TpBwVtRPTkFbmCjnriGfb1CBNGgGH_CWFmOeY,16082
 cometapi_cli/commands/model.py,sha256=YyMRt6enCAZfxW_dVcNvdNgYSl-J4iOqPlSsv14nfJs,2654
 cometapi_cli/commands/models.py,sha256=1TQC8LJ6JASErkLG5XtaZyRrq4vr4sVWH7eo426FeNs,8824
 cometapi_cli/commands/repl.py,sha256=b5z1jmEXOsCrb6fwEUyv-IKot929NIPQQAbA1uas1D4,4283
@@ -24,8 +24,8 @@ cometapi_cli/commands/run.py,sha256=JQQ1DFSyJoD4pByLmhMht1-XhDDZpV94F0hshXL7hKY,
 cometapi_cli/commands/stats.py,sha256=bEVywsom7bm8AGKGWlgAWTFjOp4NTJxDk6YEEvECM6U,1411
 cometapi_cli/commands/tasks.py,sha256=NBKOKrDow52sVjoM0ezwS9IhVRltlqYLmpamoEUbAWA,4718
 cometapi_cli/commands/tokens.py,sha256=U0AI8T690NJxAKFBwrWrsr3izXIiB_PZ9avmwpdgM9A,3042
-cometapi_cli-0.3.0.dist-info/METADATA,sha256=ychTHSOEc5NIaVi6QjBsTLWSie8f4p80ZgOZQfP5kds,10064
-cometapi_cli-0.3.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
-cometapi_cli-0.3.0.dist-info/entry_points.txt,sha256=xoiE2ZVNNWXTq0JRBtzC8hJ2JkdKuaBNz_fEd8OJpLs,50
-cometapi_cli-0.3.0.dist-info/licenses/LICENSE,sha256=-rBwHQzkmLbty07abmGvQvsRrvDeEQUkPDhNJfTcjdE,1065
-cometapi_cli-0.3.0.dist-info/RECORD,,
+cometapi_cli-0.3.2.dist-info/METADATA,sha256=WJ4GHqBwefcOBQJ4A5jF3vLTcqotUOUmd4pAy0dld_s,10646
+cometapi_cli-0.3.2.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+cometapi_cli-0.3.2.dist-info/entry_points.txt,sha256=xoiE2ZVNNWXTq0JRBtzC8hJ2JkdKuaBNz_fEd8OJpLs,50
+cometapi_cli-0.3.2.dist-info/licenses/LICENSE,sha256=-rBwHQzkmLbty07abmGvQvsRrvDeEQUkPDhNJfTcjdE,1065
+cometapi_cli-0.3.2.dist-info/RECORD,,

{cometapi_cli-0.3.0.dist-info → cometapi_cli-0.3.2.dist-info}/WHEEL

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