charisma-cli 0.2.2__tar.gz → 0.3.0__tar.gz

{charisma_cli-0.2.2 → charisma_cli-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: charisma-cli
-Version: 0.2.2
+Version: 0.3.0
 Summary: CLI tool that watches allure-results and streams test results + attachments to Charisma.
 Author: Charisma Team
 License-Expression: MIT

{charisma_cli-0.2.2 → charisma_cli-0.3.0}/pyproject.toml

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

{charisma_cli-0.2.2 → charisma_cli-0.3.0}/src/charisma_cli/config.py

@@ -24,6 +24,7 @@ class Config:
     build_id: str | None
     commit_sha: str | None
     branch: str | None
+    run_key: str | None = None
 
     @classmethod
     def from_env(
@@ -36,6 +37,7 @@ class Config:
         silent: bool = False,
         skip_too_big: bool = False,
         drain_timeout: int = 30,
+        run_key: str | None = None,
     ) -> "Config":
         """Build Config by resolving CLI flags over environment variables.
 
@@ -49,6 +51,11 @@ class Config:
             silent: --silent flag
             skip_too_big: --skip-too-big flag
             drain_timeout: drain timeout in seconds
+            run_key: --run-key flag override. Client-supplied merge key: the
+                backend derives the launch id as uuid5(project/run_key) and
+                get-or-creates, so reruns and parallel producers sharing a key
+                land in one launch. Empty/whitespace resolves to None (a new
+                random launch, unchanged behavior).
 
         Returns:
             Fully resolved Config instance.
@@ -60,17 +67,14 @@ class Config:
         resolved_token = (token or os.getenv("CHARISMA_TOKEN", "")).strip()
         resolved_project = (project or os.getenv("CHARISMA_PROJECT_ID", "")).strip()
         resolved_results = results or os.getenv("CHARISMA_RESULTS", "allure-results")
+        resolved_run_key = (run_key or os.getenv("CHARISMA_RUN_KEY", "")).strip() or None
 
         if not resolved_endpoint:
             raise click.UsageError(
-                "Missing required configuration: endpoint. "
-                "Set CHARISMA_ENDPOINT or pass --endpoint."
+                "Missing required configuration: endpoint. Set CHARISMA_ENDPOINT or pass --endpoint."
             )
         if not resolved_token:
-            raise click.UsageError(
-                "Missing required configuration: token. "
-                "Set CHARISMA_TOKEN or pass --token."
-            )
+            raise click.UsageError("Missing required configuration: token. Set CHARISMA_TOKEN or pass --token.")
 
         return cls(
             endpoint=resolved_endpoint,
@@ -83,4 +87,5 @@ class Config:
             build_id=os.getenv("BUILD_ID"),
             commit_sha=os.getenv("COMMIT_SHA"),
             branch=os.getenv("BRANCH"),
+            run_key=resolved_run_key,
         )

{charisma_cli-0.2.2 → charisma_cli-0.3.0}/src/charisma_cli/main.py

@@ -39,6 +39,7 @@ def _resolve_config(
     results: str,
     silent: bool,
     skip_too_big: bool,
+    run_key: str | None = None,
 ) -> Config:
     """Resolve CLI config from flags + env vars. Re-raises UsageError on failure."""
     return Config.from_env(
@@ -48,6 +49,7 @@ def _resolve_config(
         results=results,
         silent=silent,
         skip_too_big=skip_too_big,
+        run_key=run_key,
     )
 
 
@@ -140,6 +142,16 @@ def _print_summary(uploader: Uploader) -> None:
 @click.option("--project", envvar="CHARISMA_PROJECT_ID", required=True, help="Project alias.")
 @click.option("--silent", is_flag=True, default=False, help="Don't fail if upload errors occur.")
 @click.option("--skip-too-big", is_flag=True, default=False, help="Skip result files larger than 2MB.")
+@click.option(
+    "--run-key",
+    envvar="CHARISMA_RUN_KEY",
+    default=None,
+    help="Run identity / merge key (NOT the build id). Producers sharing this key "
+    "stream into one launch (launch id = uuid5(project/run-key)) — powers "
+    "rerun-in-place and parallel workers; reruns record retry attempts. Use your "
+    "CI run/pipeline id (e.g. GITHUB_RUN_ID) so retries merge but separate runs "
+    "stay separate. Omit for a new launch.",
+)
 @click.argument("command", nargs=-1, required=True)
 def watch(
     endpoint: str | None,
@@ -148,13 +160,14 @@ def watch(
     project: str,
     silent: bool,
     skip_too_big: bool,
+    run_key: str | None,
     command: tuple[str, ...],
 ) -> None:
     """Watch allure-results and stream to Charisma while running COMMAND.
 
     Usage: charismactl watch --project my-project -- pytest -n 4 tests/
     """
-    config = _resolve_config(endpoint, token, project, results, silent, skip_too_big)
+    config = _resolve_config(endpoint, token, project, results, silent, skip_too_big, run_key)
 
     queue: PriorityQueue[FileEvent] = PriorityQueue()
     uploader = Uploader(config, queue)
@@ -229,6 +242,16 @@ def watch(
 @click.option("--project", envvar="CHARISMA_PROJECT_ID", required=True, help="Project alias.")
 @click.option("--silent", is_flag=True, default=False, help="Don't fail if upload errors occur.")
 @click.option("--skip-too-big", is_flag=True, default=False, help="Skip result files larger than 2MB.")
+@click.option(
+    "--run-key",
+    envvar="CHARISMA_RUN_KEY",
+    default=None,
+    help="Run identity / merge key (NOT the build id). Producers sharing this key "
+    "stream into one launch (launch id = uuid5(project/run-key)) — powers "
+    "rerun-in-place and parallel workers; reruns record retry attempts. Use your "
+    "CI run/pipeline id (e.g. GITHUB_RUN_ID) so retries merge but separate runs "
+    "stay separate. Omit for a new launch.",
+)
 def upload(
     endpoint: str | None,
     token: str | None,
@@ -236,12 +259,13 @@ def upload(
     project: str,
     silent: bool,
     skip_too_big: bool,
+    run_key: str | None,
 ) -> None:
     """Upload completed allure-results to Charisma (post-execution).
 
     Usage: charismactl upload --project my-project --results allure-results
     """
-    config = _resolve_config(endpoint, token, project, results, silent, skip_too_big)
+    config = _resolve_config(endpoint, token, project, results, silent, skip_too_big, run_key)
 
     queue: PriorityQueue[FileEvent] = PriorityQueue()
     uploader = Uploader(config, queue)

{charisma_cli-0.2.2 → charisma_cli-0.3.0}/src/charisma_cli/models.py

@@ -4,32 +4,69 @@ from dataclasses import dataclass, field
 from enum import IntEnum
 from pathlib import Path
 from typing import Any
-from uuid import NAMESPACE_URL, uuid5
 
+# Backend field-size contract (mirror of backend
+# models/testresults.py::MAX_ERROR_MESSAGE_BYTES / MAX_STACK_TRACE_BYTES).
+# The streaming ingestion API rejects the WHOLE batch (400 INVALID_INPUT) if any
+# result's error_message > 10KB or stack_trace > 100KB (UTF-8 bytes). Keep these
+# byte-identical to the backend; oversized fields spill to an attachment rather
+# than truncate (see uploader._spill_oversized_field).
+MAX_ERROR_MESSAGE_BYTES = 10 * 1024  # 10KB
+MAX_STACK_TRACE_BYTES = 100 * 1024  # 100KB
 
-def backend_result_id(launch_id: str, test_id: str) -> str:
-    """Derive the result identity the Charisma backend stores and validates against.
 
-    The backend computes ``test_results.id`` as
-    ``uuid5(NAMESPACE_URL, f"{launch_id}/{test_id}")`` (see backend
-    ``models/testresults.py`` ``to_canonical``). Attachment uploads are validated
-    against that stored id, so the CLI MUST send the same value as ``resultId`` —
-    not the raw Allure ``uuid``, which the backend discards. This function is the
-    single CLI-side mirror of that contract; keep the namespace, separator, and
-    field order byte-identical to the backend.
+# Cap for a synthesized attachment filename derived from a test's historyId,
+# which is arbitrary client-supplied text (Allure historyId, or fullName
+# fallback) that may contain path separators or be very long.
+MAX_ATTACHMENT_FILENAME_LENGTH = 200
+
+
+def safe_attachment_filename(history_id: str, suffix: str) -> str:
+    """Build a safe ``text/plain`` attachment filename from a test identity.
+
+    ``history_id`` is arbitrary client-supplied text (Allure ``historyId``, or
+    the ``fullName`` fallback) and can contain path separators (``/``, ``\\``),
+    ``..``, control characters, or be very long. This strips it to a basename,
+    replaces any remaining unsafe characters, and length-caps the stem so the
+    multipart filename sent to the backend is well-formed and bounded.
+
+    Args:
+        history_id: The owning result's test identity.
+        suffix: A short descriptor appended to the stem (e.g. ``error-message``).
+
+    Returns:
+        A sanitized ``{stem}-{suffix}.txt`` filename.
+    """
+    # Drop any path structure, then keep only filename-safe characters.
+    base = history_id.replace("\\", "/").rsplit("/", 1)[-1]
+    safe = "".join(c if (c.isalnum() or c in "-_.") else "_" for c in base)
+    stem = safe[:MAX_ATTACHMENT_FILENAME_LENGTH] or "result"
+    return f"{stem}-{suffix}.txt"
+
+
+def head_snippet(text: str, max_bytes: int) -> str:
+    """Return the longest UTF-8 prefix of ``text`` that fits in ``max_bytes``.
+
+    Cuts on a character boundary — never splits a multibyte code point — by
+    encoding, slicing the byte string, and decoding with ``errors="ignore"`` to
+    drop a trailing partial character. Used to keep an inline head of an
+    oversized field (the full value goes to an attachment).
 
     Args:
-        launch_id: The open launch UUID returned by the backend.
-        test_id: The result's test identity — the SAME value the CLI sends as
-            ``test_id`` in the results batch. This is the Allure ``historyId``,
-            falling back to ``fullName`` when ``historyId`` is absent (see
-            ``parser.parse_result_file``). Matching the backend requires only
-            that both sides key off this same value, whichever it is.
+        text: The source string.
+        max_bytes: Maximum size of the returned prefix in UTF-8 bytes.
 
     Returns:
-        The deterministic result id string matching the backend's stored id.
+        A prefix of ``text`` whose UTF-8 encoding is ``<= max_bytes`` bytes.
     """
-    return str(uuid5(NAMESPACE_URL, f"{launch_id}/{test_id}"))
+    encoded = text.encode("utf-8")
+    # Clamp: a non-positive budget must yield an empty prefix, never a Python
+    # negative slice (encoded[:-n]) which would return almost the whole string.
+    if max_bytes <= 0:
+        return ""
+    if len(encoded) <= max_bytes:
+        return text
+    return encoded[:max_bytes].decode("utf-8", errors="ignore")
 
 
 class FileCategory(IntEnum):