charisma-cli 0.1.2__tar.gz → 0.1.4__tar.gz

{charisma_cli-0.1.2 → charisma_cli-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: charisma-cli
-Version: 0.1.2
+Version: 0.1.4
 Summary: CLI tool that watches allure-results and streams test results + attachments to Charisma.
 Author: Charisma Team
 License-Expression: MIT
@@ -41,18 +41,6 @@ For local development from a checkout of the repo:
 pip install -e packages/charisma-cli
 ```
 
-<details>
-<summary>Alternative: install from the GitHub Packages registry (PyOCI)</summary>
-
-Also published to GitHub Packages via [PyOCI](https://pyoci.com) (requires a GitHub token with `read:packages`) — useful for a build not yet on PyPI:
-
-```bash
-pip install charisma-cli \
-  --index-url "https://__token__:$GITHUB_TOKEN@pyoci.com/ghcr.io/align-QCOE/"
-```
-
-</details>
-
 ## Publishing (maintainers)
 
 Releases publish to public PyPI automatically from the merge-queue workflow using a **PyPI API token**.
@@ -96,3 +84,22 @@ charismactl watch --results allure-results -- uv run pytest -n 4 tests/
 | `--project ID`   | Project alias (overrides env var)            |
 | `--silent`       | Don't fail pipeline if upload errors occur   |
 | `--skip-too-big` | Skip result files larger than 2MB            |
+
+## Launch URL in CI
+
+`charismactl` prints the Charisma launch URL (`Charisma launch: <url>`) and, when running
+in GitHub Actions, writes it as a step output named `launch_url`. Attach it to the job
+summary or a Teams message:
+
+```yaml
+- name: Run tests and stream to Charisma
+  id: charisma
+  run: charismactl watch --project my-project -- pytest tests/
+
+- name: Add Charisma link to summary
+  if: always()
+  run: echo "[View Charisma launch](${{ steps.charisma.outputs.launch_url }})" >> "$GITHUB_STEP_SUMMARY"
+
+# The same value can feed a Teams-notification step:
+#   text: "Results: ${{ steps.charisma.outputs.launch_url }}"
+```

{charisma_cli-0.1.2 → charisma_cli-0.1.4}/README.md

@@ -16,18 +16,6 @@ For local development from a checkout of the repo:
 pip install -e packages/charisma-cli
 ```
 
-<details>
-<summary>Alternative: install from the GitHub Packages registry (PyOCI)</summary>
-
-Also published to GitHub Packages via [PyOCI](https://pyoci.com) (requires a GitHub token with `read:packages`) — useful for a build not yet on PyPI:
-
-```bash
-pip install charisma-cli \
-  --index-url "https://__token__:$GITHUB_TOKEN@pyoci.com/ghcr.io/align-QCOE/"
-```
-
-</details>
-
 ## Publishing (maintainers)
 
 Releases publish to public PyPI automatically from the merge-queue workflow using a **PyPI API token**.
@@ -71,3 +59,22 @@ charismactl watch --results allure-results -- uv run pytest -n 4 tests/
 | `--project ID`   | Project alias (overrides env var)            |
 | `--silent`       | Don't fail pipeline if upload errors occur   |
 | `--skip-too-big` | Skip result files larger than 2MB            |
+
+## Launch URL in CI
+
+`charismactl` prints the Charisma launch URL (`Charisma launch: <url>`) and, when running
+in GitHub Actions, writes it as a step output named `launch_url`. Attach it to the job
+summary or a Teams message:
+
+```yaml
+- name: Run tests and stream to Charisma
+  id: charisma
+  run: charismactl watch --project my-project -- pytest tests/
+
+- name: Add Charisma link to summary
+  if: always()
+  run: echo "[View Charisma launch](${{ steps.charisma.outputs.launch_url }})" >> "$GITHUB_STEP_SUMMARY"
+
+# The same value can feed a Teams-notification step:
+#   text: "Results: ${{ steps.charisma.outputs.launch_url }}"
+```

{charisma_cli-0.1.2 → charisma_cli-0.1.4}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "charisma-cli"
-version = "0.1.2"
+version = "0.1.4"
 description = "CLI tool that watches allure-results and streams test results + attachments to Charisma."
 readme = "README.md"
 license = "MIT"

charisma_cli-0.1.4/src/charisma_cli/launch_url.py

@@ -0,0 +1,45 @@
+"""Construct and surface the Charisma launch URL for CI consumption."""
+
+import logging
+import os
+
+logger = logging.getLogger(__name__)
+
+# The Charisma web UI base is always the same, unlike the region-dependent API
+# ingestion endpoint. Hardcoded here rather than exposed as user config.
+WEB_BASE_URL = "https://charisma.aligntech.com"
+
+
+def build_launch_url(project_id: str, launch_id: str) -> str:
+    """Build the Charisma web URL for a launch.
+
+    Mirrors the frontend route ``/project/{projectId}/launches/{launchId}``.
+
+    Args:
+        project_id: Project UUID (from the open-launch API response).
+        launch_id: Launch UUID.
+
+    Returns:
+        The fully-qualified launch URL.
+    """
+    return f"{WEB_BASE_URL}/project/{project_id}/launches/{launch_id}"
+
+
+def emit_github_output(launch_url: str) -> None:
+    """Append ``launch_url=<url>`` to the GitHub Actions step output file.
+
+    No-op when not running under GitHub Actions (``GITHUB_OUTPUT`` unset).
+    Failures are logged and swallowed — surfacing the URL must never affect
+    the exit code or upload outcome.
+
+    Args:
+        launch_url: The launch URL to expose as the ``launch_url`` step output.
+    """
+    github_output = os.getenv("GITHUB_OUTPUT")
+    if not github_output:
+        return
+    try:
+        with open(github_output, "a", encoding="utf-8") as fh:
+            fh.write(f"launch_url={launch_url}\n")
+    except OSError as e:
+        logger.warning("Could not write launch_url to GITHUB_OUTPUT: %s", e)

{charisma_cli-0.1.2 → charisma_cli-0.1.4}/src/charisma_cli/main.py

@@ -9,6 +9,7 @@ import click
 
 from charisma_cli import __version__
 from charisma_cli.config import Config
+from charisma_cli.launch_url import build_launch_url, emit_github_output
 from charisma_cli.models import FileEvent
 from charisma_cli.subprocess_mgr import SubprocessManager
 from charisma_cli.uploader import Uploader
@@ -59,6 +60,45 @@ def _open_launch_or_exit(uploader: Uploader, config: Config) -> str:
     return launch_id
 
 
+def _surface_launch_url(uploader: Uploader) -> None:
+    """Print the Charisma launch URL and expose it to GitHub Actions.
+
+    Constructs the URL from the project UUID returned by the open-launch
+    response and the launch ID. Prints it to stdout and, when running under
+    GitHub Actions, appends ``launch_url=<url>`` to $GITHUB_OUTPUT.
+    Does nothing if no launch was opened or the project UUID is unavailable.
+    """
+    launch_id = uploader.launch_id
+    project_id = uploader.project_id
+    if not launch_id or not project_id:
+        return
+    url = build_launch_url(project_id, launch_id)
+    click.echo(f"Charisma launch: {url}")
+    emit_github_output(url)
+
+
+def _warn_if_results_unsent(uploader: Uploader, config: Config) -> None:
+    """Warn loudly when result files exist on disk but none were sent.
+
+    Turns the previously-silent ``results_sent=0`` failure into a visible
+    warning naming the absolute watched path and the on-disk result count, so
+    a broken run is not mistaken for success.
+    """
+    if uploader.summary.results_sent > 0:
+        return
+    results_path = Path(config.results_dir).resolve()
+    if not results_path.exists():
+        return
+    result_files = [p for p in results_path.iterdir() if p.name.endswith("-result.json")]
+    if result_files:
+        click.echo(
+            f"Warning: {len(result_files)} result file(s) present in "
+            f"{results_path} but results_sent=0 — nothing was uploaded. "
+            "Check connectivity/auth or file another issue.",
+            err=True,
+        )
+
+
 def _print_summary(uploader: Uploader) -> None:
     """Print the upload summary to stdout."""
     summary = uploader.summary
@@ -106,6 +146,9 @@ def watch(
         mgr.spawn(command)
         sys.exit(mgr.wait())
 
+    # Surface the launch URL (stdout + $GITHUB_OUTPUT) now that the launch is open
+    _surface_launch_url(uploader)
+
     # Start watcher + uploader consumer
     watcher = ResultsWatcher(config.results_dir, queue, config)
     watcher.start()
@@ -146,6 +189,7 @@ def watch(
         uploader._client.close()
         uploader._client = None
 
+    _warn_if_results_unsent(uploader, config)
     _print_summary(uploader)
     sys.exit(exit_code)
 
@@ -181,6 +225,9 @@ def upload(
         click.echo("Warning: Failed to open launch. No results uploaded.", err=True)
         sys.exit(0)
 
+    # Surface the launch URL (stdout + $GITHUB_OUTPUT) now that the launch is open
+    _surface_launch_url(uploader)
+
     # Scan existing results directory
     results_path = Path(config.results_dir)
     if not results_path.exists():

{charisma_cli-0.1.2 → charisma_cli-0.1.4}/src/charisma_cli/uploader.py

@@ -51,10 +51,12 @@ class Uploader:
         self._queue = queue
         self._summary = UploadSummary()
         self._launch_id: str | None = None
+        self._project_id: str | None = None
         self._disabled = False
         self._auth_failed = False
         self._stop_event = threading.Event()
         self._drain_event = threading.Event()
+        self._batch_lock = threading.Lock()
         self._thread: threading.Thread | None = None
         self._client: httpx.Client | None = None
         self._batch: list[dict[str, Any]] = []
@@ -69,6 +71,16 @@ class Uploader:
         """Return current upload statistics."""
         return self._summary
 
+    @property
+    def launch_id(self) -> str | None:
+        """Return the opened launch ID, or None if no launch was opened."""
+        return self._launch_id
+
+    @property
+    def project_id(self) -> str | None:
+        """Return the project UUID from the open-launch response, if available."""
+        return self._project_id
+
     def configure_logging(self) -> None:
         """Configure logging based on silent mode.
 
@@ -113,17 +125,45 @@ class Uploader:
             self._client = None
 
     def drain(self, timeout: float) -> None:
-        """Signal drain and wait for queue to empty or timeout to expire.
+        """Signal drain and wait until all consumed items are flushed/sent.
+
+        Waits for BOTH the queue to empty AND the in-memory batch to be flushed.
+        Waiting on queue emptiness alone is insufficient: the consumer moves a
+        result from the queue into ``self._batch`` (queue becomes empty) but only
+        flushes at 50 items or the 2s batch timeout. For short runs (e.g. a single
+        result enqueued by final_scan after the subprocess exits), that left the
+        result unsent — the ``watch results_sent=0`` bug. Once the queue is empty,
+        this forces a final batch flush so pending results are sent before return.
 
         Args:
-            timeout: Maximum seconds to wait for the queue to drain.
+            timeout: Maximum seconds to wait for the queue+batch to drain.
         """
         self._drain_event.set()
         deadline = time.monotonic() + timeout
-        while not self._queue.empty() and time.monotonic() < deadline:
-            time.sleep(0.1)
-        if not self._queue.empty():
-            logger.warning("Drain timeout expired with %d items remaining in queue", self._queue.qsize())
+
+        # Phase 1: wait for the queue to empty AND for the consumer to finish
+        # processing every dequeued item. Checking queue.empty() alone is racy:
+        # an item that has been dequeued but not yet appended to the batch is in
+        # neither the queue nor the batch. unfinished_tasks (decremented by the
+        # consumer's task_done()) closes that window.
+        while (
+            (not self._queue.empty() or self._queue.unfinished_tasks > 0)
+            and time.monotonic() < deadline
+        ):
+            time.sleep(0.05)
+
+        # Phase 2: the consumer is idle and everything is now in the batch (or
+        # already sent). Force out any partial batch that hasn't hit the 50-item
+        # or 2s trigger, so drain() honors its contract: everything consumed has
+        # been sent when it returns.
+        self._flush_batch()
+
+        if not self._queue.empty() or self._queue.unfinished_tasks > 0 or self._batch:
+            logger.warning(
+                "Drain timeout expired with %d queued and %d batched items remaining",
+                self._queue.qsize(),
+                len(self._batch),
+            )
 
     def open_launch(self) -> str | None:
         """Open a streaming launch via the API.
@@ -150,6 +190,7 @@ class Uploader:
                 if response.status_code == 201:
                     data = response.json()
                     self._launch_id = data["launchId"]
+                    self._project_id = data.get("projectId")
                     return self._launch_id
                 if response.status_code in RETRYABLE_STATUS_CODES and attempt < MAX_RETRIES:
                     time.sleep(exponential_backoff(attempt))
@@ -411,13 +452,18 @@ class Uploader:
                 self._flush_batch()
 
     def _flush_batch(self) -> None:
-        """Send the current batch to the API."""
-        if not self._batch or not self._launch_id:
-            return
+        """Send the current batch to the API.
 
-        batch = self._batch[:]
-        self._batch = []
-        self._batch_start = 0.0
+        Thread-safe: the batch may be flushed by the consumer thread (on 50-item
+        or 2s-timeout triggers) or by drain() on the main thread. The lock ensures
+        the swap-and-clear is atomic so a batch is never sent twice or lost.
+        """
+        with self._batch_lock:
+            if not self._batch or not self._launch_id:
+                return
+            batch = self._batch[:]
+            self._batch = []
+            self._batch_start = 0.0
 
         success = self._send_batch(batch)
         if success:

charisma_cli-0.1.4/tests/test_launch_url.py

@@ -0,0 +1,37 @@
+"""Unit tests for charisma_cli.launch_url: URL construction + GitHub output emission."""
+
+from pathlib import Path
+
+from charisma_cli.launch_url import build_launch_url, emit_github_output
+
+
+class TestBuildLaunchUrl:
+    """build_launch_url mirrors the frontend /project/{id}/launches/{id} route."""
+
+    def test_basic_url(self) -> None:
+        url = build_launch_url("proj-uuid", "launch-uuid")
+        assert url == "https://charisma.aligntech.com/project/proj-uuid/launches/launch-uuid"
+
+
+class TestEmitGithubOutput:
+    """emit_github_output appends launch_url only when GITHUB_OUTPUT is set."""
+
+    def test_writes_when_github_output_set(self, tmp_path: Path, monkeypatch) -> None:
+        out = tmp_path / "gh_output"
+        out.write_text("")  # simulate existing GITHUB_OUTPUT file
+        monkeypatch.setenv("GITHUB_OUTPUT", str(out))
+
+        emit_github_output("https://charisma.aligntech.com/project/p/launches/l")
+
+        content = out.read_text()
+        assert "launch_url=https://charisma.aligntech.com/project/p/launches/l\n" in content
+
+    def test_noop_when_github_output_unset(self, monkeypatch) -> None:
+        monkeypatch.delenv("GITHUB_OUTPUT", raising=False)
+        # Should simply return without raising
+        emit_github_output("https://charisma.aligntech.com/project/p/launches/l")
+
+    def test_bad_path_does_not_raise(self, monkeypatch) -> None:
+        # Point at an unwritable/nonexistent directory — must be swallowed
+        monkeypatch.setenv("GITHUB_OUTPUT", "/nonexistent-dir-xyz/output")
+        emit_github_output("https://charisma.aligntech.com/project/p/launches/l")

{charisma_cli-0.1.2 → charisma_cli-0.1.4}/tests/test_uploader.py

@@ -282,3 +282,52 @@ class TestUploaderSummary:
         assert summary.attachments_sent == 0
         assert summary.attachments_skipped == 0
         assert summary.containers_sent == 0
+
+
+class TestUploaderDrainFlushesBatch:
+    """Regression: drain() must flush the pending sub-batch, not just empty the queue.
+
+    Reproduces the `charismactl watch --> results_sent=0` bug: a short run enqueues
+    a single result after the subprocess exits (via final_scan). The consumer moves
+    it from the queue into the in-memory batch, which empties the queue immediately.
+    drain() only waits on queue emptiness, so it returns before the 2s batch-timeout
+    flush fires — leaving the result unsent. This mirrors the real CI failure where
+    `upload` (which flushes on stop) sent the result but `watch` reported 0.
+    """
+
+    @respx.mock
+    def test_drain_flushes_single_pending_result(self, tmp_path: Path) -> None:
+        """A single result enqueued just before drain must be SENT by drain().
+
+        Fails on the buggy implementation (result stuck in batch, results_sent=0);
+        passes once drain() forces a batch flush and waits for it.
+        """
+        config = _make_config()
+        queue: PriorityQueue = PriorityQueue()
+
+        results_route = respx.post(
+            "https://charisma.test/api/v1/launches/launch-1/results"
+        ).mock(return_value=httpx.Response(200, json={"accepted": 1}))
+
+        uploader = Uploader(config, queue)
+        uploader._launch_id = "launch-1"
+
+        uploader.start()
+
+        # Simulate final_scan enqueueing one result AFTER the subprocess exits,
+        # then draining — the real watch-mode sequence.
+        filepath = _make_result_file(tmp_path, "late-result.json")
+        queue.put(FileEvent(path=filepath, category=FileCategory.RESULT))
+
+        uploader.drain(timeout=5.0)
+
+        # Contract: after drain returns, the result must already be sent —
+        # not left sitting in the batch waiting on stop().
+        assert uploader.summary.results_sent == 1, (
+            "drain() returned but the pending result was not flushed/sent "
+            f"(results_sent={uploader.summary.results_sent}); "
+            "batch still held the result — this is the watch results_sent=0 bug"
+        )
+        assert results_route.called
+
+        uploader.stop()