langwatch 0.8.0__py3-none-any.whl → 0.9.0__py3-none-any.whl

langwatch/evaluation/platform_run.py

@@ -0,0 +1,462 @@
+"""
+Runner for platform-configured evaluations (Evaluations V3).
+
+This module provides the `run()` function to execute evaluations that are
+configured in the LangWatch platform from CI/CD pipelines or scripts.
+"""
+
+from dataclasses import dataclass, field
+from typing import Callable, List, Literal, Optional
+from urllib.parse import urlparse, urlunparse
+import sys
+import time
+import httpx
+
+import langwatch
+from langwatch.state import get_api_key, get_endpoint
+
+
+def _replace_url_domain(url: str, new_base: str) -> str:
+    """Replace the domain/scheme of a URL with a new base URL, preserving the path."""
+    if not url:
+        return url
+
+    parsed_url = urlparse(url)
+    parsed_new_base = urlparse(new_base)
+
+    # Replace scheme and netloc with new base, keep path/query/fragment
+    return urlunparse((
+        parsed_new_base.scheme,
+        parsed_new_base.netloc,
+        parsed_url.path,
+        parsed_url.params,
+        parsed_url.query,
+        parsed_url.fragment,
+    ))
+
+
+class EvaluationNotFoundError(Exception):
+    """Raised when evaluation slug doesn't exist."""
+
+    def __init__(self, slug: str):
+        self.slug = slug
+        super().__init__(f"Evaluation not found: {slug}")
+
+
+class EvaluationTimeoutError(Exception):
+    """Raised when evaluation run times out."""
+
+    def __init__(self, run_id: str, progress: int, total: int):
+        self.run_id = run_id
+        self.progress = progress
+        self.total = total
+        super().__init__(
+            f"Evaluation run timed out: {run_id} ({progress}/{total} completed)"
+        )
+
+
+class EvaluationRunFailedError(Exception):
+    """Raised when evaluation run fails."""
+
+    def __init__(self, run_id: str, error: str):
+        self.run_id = run_id
+        self.error_message = error
+        super().__init__(f"Evaluation run failed: {error}")
+
+
+class EvaluationsApiError(Exception):
+    """Raised for other API errors."""
+
+    def __init__(self, message: str, status_code: int):
+        self.status_code = status_code
+        super().__init__(message)
+
+
+@dataclass
+class TargetStats:
+    """Statistics for a single target."""
+
+    target_id: str
+    name: str
+    passed: int
+    failed: int
+    avg_latency: float
+    total_cost: float
+
+
+@dataclass
+class EvaluatorStats:
+    """Statistics for a single evaluator."""
+
+    evaluator_id: str
+    name: str
+    passed: int
+    failed: int
+    pass_rate: float
+    avg_score: Optional[float] = None
+
+
+@dataclass
+class EvaluationRunSummary:
+    """Summary of a completed evaluation run."""
+
+    run_id: str
+    total_cells: int
+    completed_cells: int
+    failed_cells: int
+    duration: int
+    run_url: str = ""
+    targets: List[TargetStats] = field(default_factory=list)
+    evaluators: List[EvaluatorStats] = field(default_factory=list)
+    total_passed: int = 0
+    total_failed: int = 0
+    pass_rate: float = 0.0
+    total_cost: float = 0.0
+
+
+@dataclass
+class EvaluationRunResult:
+    """Result of running a platform evaluation."""
+
+    run_id: str
+    status: Literal["completed", "failed", "stopped"]
+    passed: int
+    failed: int
+    pass_rate: float
+    duration: int
+    run_url: str
+    summary: EvaluationRunSummary
+
+    def print_summary(self, exit_on_failure: Optional[bool] = None) -> None:
+        """
+        Print a CI-friendly summary and optionally exit with code 1 on failure.
+
+        Args:
+            exit_on_failure: If True, calls sys.exit(1) when there are failures.
+                           If False, never exits.
+                           If None (default), auto-detects: exits in scripts/CI, doesn't exit in notebooks.
+        """
+        _print_summary(self)
+
+        # Auto-detect: don't exit in notebooks, exit in scripts/CI
+        should_exit = exit_on_failure if exit_on_failure is not None else not _is_notebook()
+
+        if should_exit and self.failed > 0:
+            sys.exit(1)
+
+
+def _is_notebook() -> bool:
+    """Detect if running in a Jupyter notebook."""
+    try:
+        from IPython import get_ipython  # type: ignore
+
+        shell = get_ipython().__class__.__name__
+        if shell == "ZMQInteractiveShell":
+            return True  # Jupyter notebook or qtconsole
+        elif shell == "TerminalInteractiveShell":
+            return False  # Terminal running IPython
+        else:
+            return False
+    except (ImportError, AttributeError, NameError):
+        return False
+
+
+def evaluate(
+    slug: str,
+    *,
+    poll_interval: float = 2.0,
+    timeout: float = 600.0,
+    on_progress: Optional[Callable[[int, int], None]] = None,
+    api_key: Optional[str] = None,
+) -> EvaluationRunResult:
+    """
+    Run a platform-configured evaluation and wait for completion.
+
+    This runs an Evaluation that you have configured in the LangWatch platform.
+    The evaluation will execute all targets and evaluators defined in the configuration.
+
+    Args:
+        slug: The slug of the evaluation to run (found in the evaluation URL)
+        poll_interval: Seconds between status checks (default: 2.0)
+        timeout: Maximum seconds to wait for completion (default: 600.0 = 10 minutes)
+        on_progress: Optional callback for progress updates (completed, total)
+        api_key: Optional API key override (uses LANGWATCH_API_KEY env var by default)
+
+    Returns:
+        EvaluationRunResult with pass rate and summary. Call result.print_summary()
+        to display results and exit with code 1 on failure.
+
+    Raises:
+        EvaluationNotFoundError: If the evaluation slug doesn't exist
+        EvaluationTimeoutError: If the evaluation doesn't complete within timeout
+        EvaluationRunFailedError: If the evaluation fails
+        EvaluationsApiError: For other API errors
+
+    Example:
+        ```python
+        import langwatch
+
+        result = langwatch.evaluation.evaluate("my-evaluation-slug")
+        result.print_summary()
+        ```
+    """
+    langwatch.ensure_setup()
+
+    effective_api_key = api_key or get_api_key()
+    endpoint = get_endpoint()
+
+    if not effective_api_key:
+        raise ValueError(
+            "API key not set. Set LANGWATCH_API_KEY environment variable or pass api_key parameter."
+        )
+
+    # Start the run
+    start_response = _start_run(slug, endpoint, effective_api_key)
+    run_id = start_response["runId"]
+    total = start_response.get("total", 0)
+
+    # Use the run URL from API but replace domain with configured endpoint
+    api_run_url = start_response.get("runUrl", "")
+    run_url = _replace_url_domain(api_run_url, endpoint) if api_run_url else ""
+
+    print(f"Started evaluation run: {run_id}")
+    if run_url:
+        print(f"Follow live: {run_url}")
+
+    # Track last progress for change detection
+    last_progress = 0
+
+    # Print initial progress
+    if total > 0:
+        print(f"Progress: 0/{total} (0%)", end="", flush=True)
+    if on_progress:
+        on_progress(0, total)
+
+    # Poll until complete
+    start_time = time.time()
+    while True:
+        if time.time() - start_time > timeout:
+            print()  # Newline after progress
+            status = _get_run_status(run_id, endpoint, effective_api_key)
+            raise EvaluationTimeoutError(
+                run_id, status.get("progress", 0), status.get("total", 0)
+            )
+
+        time.sleep(poll_interval)
+
+        status = _get_run_status(run_id, endpoint, effective_api_key)
+        progress = status.get("progress", 0)
+        total = status.get("total", total)
+
+        # Update progress display if changed
+        if progress != last_progress and total > 0:
+            percentage = (progress / total) * 100
+            # Use carriage return to overwrite the line
+            print(f"\rProgress: {progress}/{total} ({percentage:.0f}%)", end="", flush=True)
+            last_progress = progress
+
+        if on_progress:
+            on_progress(progress, total)
+
+        run_status = status.get("status")
+
+        if run_status == "completed":
+            print()  # Newline after progress
+            summary_data = status.get("summary", {})
+            return _build_result(run_id, "completed", summary_data, run_url)
+
+        if run_status == "failed":
+            print()  # Newline after progress
+            raise EvaluationRunFailedError(
+                run_id, status.get("error", "Unknown error")
+            )
+
+        if run_status == "stopped":
+            print()  # Newline after progress
+            summary_data = status.get("summary", {})
+            return _build_result(run_id, "stopped", summary_data, run_url)
+
+
+def _start_run(slug: str, endpoint: str, api_key: str) -> dict:
+    """Start an evaluation run."""
+    with httpx.Client(timeout=60) as client:
+        response = client.post(
+            f"{endpoint}/api/evaluations/v3/{slug}/run",
+            headers={"X-Auth-Token": api_key},
+        )
+
+    if response.status_code == 404:
+        raise EvaluationNotFoundError(slug)
+    if response.status_code == 401:
+        raise EvaluationsApiError("Unauthorized - check your API key", 401)
+    if not response.is_success:
+        error_body = response.json() if response.content else {}
+        raise EvaluationsApiError(
+            error_body.get("error", f"Failed to start evaluation: {response.status_code}"),
+            response.status_code,
+        )
+
+    return response.json()
+
+
+def _get_run_status(run_id: str, endpoint: str, api_key: str) -> dict:
+    """Get the status of a run."""
+    with httpx.Client(timeout=60) as client:
+        response = client.get(
+            f"{endpoint}/api/evaluations/v3/runs/{run_id}",
+            headers={"X-Auth-Token": api_key},
+        )
+
+    if response.status_code == 404:
+        raise EvaluationsApiError(f"Run not found: {run_id}", 404)
+    if response.status_code == 401:
+        raise EvaluationsApiError("Unauthorized - check your API key", 401)
+    if not response.is_success:
+        error_body = response.json() if response.content else {}
+        raise EvaluationsApiError(
+            error_body.get("error", f"Failed to get run status: {response.status_code}"),
+            response.status_code,
+        )
+
+    return response.json()
+
+
+def _build_result(
+    run_id: str,
+    status: Literal["completed", "failed", "stopped"],
+    summary_data: dict,
+    run_url: str,
+) -> EvaluationRunResult:
+    """Build the result object from API response."""
+    total_cells = summary_data.get("totalCells", 0)
+    completed_cells = summary_data.get("completedCells", 0)
+    failed_cells = summary_data.get("failedCells", 0)
+    duration = summary_data.get("duration", 0)
+
+    total_passed = summary_data.get("totalPassed", completed_cells - failed_cells)
+    total_failed = summary_data.get("totalFailed", failed_cells)
+    pass_rate = summary_data.get(
+        "passRate",
+        (total_passed / completed_cells * 100) if completed_cells > 0 else 0.0,
+    )
+
+    # Parse targets
+    targets: List[TargetStats] = []
+    for t in summary_data.get("targets", []):
+        targets.append(
+            TargetStats(
+                target_id=t.get("targetId", ""),
+                name=t.get("name", ""),
+                passed=t.get("passed", 0),
+                failed=t.get("failed", 0),
+                avg_latency=t.get("avgLatency", 0),
+                total_cost=t.get("totalCost", 0),
+            )
+        )
+
+    # Parse evaluators
+    evaluators: List[EvaluatorStats] = []
+    for e in summary_data.get("evaluators", []):
+        evaluators.append(
+            EvaluatorStats(
+                evaluator_id=e.get("evaluatorId", ""),
+                name=e.get("name", ""),
+                passed=e.get("passed", 0),
+                failed=e.get("failed", 0),
+                pass_rate=e.get("passRate", 0),
+                avg_score=e.get("avgScore"),
+            )
+        )
+
+    summary = EvaluationRunSummary(
+        run_id=run_id,
+        total_cells=total_cells,
+        completed_cells=completed_cells,
+        failed_cells=failed_cells,
+        duration=duration,
+        run_url=run_url,  # Always use the endpoint-based URL we constructed
+        targets=targets,
+        evaluators=evaluators,
+        total_passed=total_passed,
+        total_failed=total_failed,
+        pass_rate=pass_rate,
+        total_cost=summary_data.get("totalCost", 0),
+    )
+
+    return EvaluationRunResult(
+        run_id=run_id,
+        status=status,
+        passed=total_passed,
+        failed=total_failed,
+        pass_rate=pass_rate,
+        duration=duration,
+        run_url=summary.run_url,
+        summary=summary,
+    )
+
+
+def _print_summary(result: EvaluationRunResult) -> None:
+    """Print a CI-friendly summary of the evaluation results."""
+    summary = result.summary
+
+    print("\n" + "═" * 60)
+    print("  EVALUATION RESULTS")
+    print("═" * 60)
+    print(f"  Run ID:     {result.run_id}")
+    print(f"  Status:     {result.status.upper()}")
+    print(f"  Duration:   {result.duration / 1000:.1f}s")
+    print("─" * 60)
+    print(f"  Passed:     {result.passed}")
+    print(f"  Failed:     {result.failed}")
+    print(f"  Pass Rate:  {result.pass_rate:.1f}%")
+
+    if summary.targets:
+        print("─" * 60)
+        print("  TARGETS:")
+        for target in summary.targets:
+            print(f"    {target.name}: {target.passed} passed, {target.failed} failed")
+            if target.avg_latency:
+                print(f"      Avg latency: {target.avg_latency:.0f}ms")
+            if target.total_cost:
+                print(f"      Total cost: ${target.total_cost:.4f}")
+
+    if summary.evaluators:
+        print("─" * 60)
+        print("  EVALUATORS:")
+        for evaluator in summary.evaluators:
+            print(f"    {evaluator.name}: {evaluator.pass_rate:.1f}% pass rate")
+            if evaluator.avg_score is not None:
+                print(f"      Avg score: {evaluator.avg_score:.2f}")
+
+    print("─" * 60)
+    print(f"  View details: {result.run_url}")
+    print("═" * 60 + "\n")
+
+
+def run(
+    slug: str,
+    *,
+    poll_interval: float = 2.0,
+    timeout: float = 600.0,
+    on_progress: Optional[Callable[[int, int], None]] = None,
+    api_key: Optional[str] = None,
+) -> EvaluationRunResult:
+    """
+    Deprecated: Use `evaluate()` instead.
+
+    Run a platform-configured evaluation and wait for completion.
+    """
+    import warnings
+
+    warnings.warn(
+        "langwatch.evaluation.run() is deprecated, use langwatch.evaluation.evaluate() instead",
+        DeprecationWarning,
+        stacklevel=2,
+    )
+    return evaluate(
+        slug,
+        poll_interval=poll_interval,
+        timeout=timeout,
+        on_progress=on_progress,
+        api_key=api_key,
+    )

langwatch/evaluations.py

@@ -12,6 +12,7 @@ from langwatch.telemetry.span import LangWatchSpan
 from langwatch.telemetry.context import get_current_span
 from langwatch.state import get_api_key, get_endpoint, get_instance
 from langwatch.attributes import AttributeKey
+from langwatch.utils.exceptions import EvaluatorException, better_raise_for_status
 from pydantic import BaseModel
 
 from langwatch.types import (
@@ -101,7 +102,7 @@ def evaluate(
         try:
             with httpx.Client(timeout=900) as client:
                 response = client.post(**request_params)
-                response.raise_for_status()
+                better_raise_for_status(response, cls=EvaluatorException)
         except Exception as e:
             return _handle_exception(e, span, as_guardrail)
 
@@ -156,7 +157,7 @@ async def async_evaluate(
         try:
             async with httpx.AsyncClient(timeout=900) as client:
                 response = await client.post(**request_params)
-                response.raise_for_status()
+                better_raise_for_status(response)
         except Exception as e:
             return _handle_exception(e, span, as_guardrail)
 

langwatch/login.py

@@ -1,6 +1,7 @@
 import httpx
 
 import langwatch
+from langwatch.utils.exceptions import better_raise_for_status
 from .state import get_api_key, get_endpoint
 from getpass import getpass
 
@@ -25,7 +26,7 @@ def login(relogin=False):
     )
     if response.status_code == 401:
         raise ValueError("API key is not valid, please try to login again")
-    response.raise_for_status()
+    better_raise_for_status(response)
 
     langwatch.setup(api_key=api_key)
     print("LangWatch API key set")

langwatch/telemetry/tracing.py

@@ -6,6 +6,7 @@ import httpx
 import threading
 from deprecated import deprecated
 from langwatch.attributes import AttributeKey
+from langwatch.utils.exceptions import better_raise_for_status
 from langwatch.utils.transformation import (
     SerializableWithStringFallback,
     convert_typed_values,
@@ -300,7 +301,7 @@ class LangWatchTrace:
                 headers={"X-Auth-Token": get_api_key()},
                 timeout=15,
             )
-            response.raise_for_status()
+            better_raise_for_status(response)
             path = response.json()["path"]
             return f"{endpoint}{path}"
 
@@ -317,7 +318,7 @@ class LangWatchTrace:
                 headers={"X-Auth-Token": get_api_key()},
                 timeout=15,
             )
-            response.raise_for_status()
+            better_raise_for_status(response)
 
     def update(
         self,

langwatch/utils/exceptions.py

@@ -1,7 +1,8 @@
 import traceback
-from typing import List, cast
+from typing import List, cast, Type
 
 from langwatch.domain import ErrorCapture
+import httpx
 
 
 def capture_exception(err: BaseException):
@@ -12,3 +13,23 @@ def capture_exception(err: BaseException):
     except:  # python 3.10+
         string_stacktrace = traceback.format_exception(err)  # type: ignore
     return ErrorCapture(message=repr(err), stacktrace=string_stacktrace)
+
+
+class EvaluatorException(Exception):
+    pass
+
+
+def better_raise_for_status(response: httpx.Response, cls: Type[BaseException] = httpx.HTTPStatusError) -> None:
+    try:
+        response.raise_for_status()
+    except httpx.HTTPStatusError as http_err:
+        try:
+            json = response.json()
+        except Exception:
+            raise http_err
+
+        if "error" in json:
+            error = json["error"]
+            raise cls(f"{response.status_code} {error}") from http_err
+        else:
+            raise http_err

{langwatch-0.8.0.dist-info → langwatch-0.9.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langwatch
-Version: 0.8.0
+Version: 0.9.0
 Summary: LangWatch Python SDK, for monitoring your LLMs
 Author-email: Langwatch Engineers <engineering@langwatch.ai>
 License: MIT

{langwatch-0.8.0.dist-info → langwatch-0.9.0.dist-info}/RECORD

@@ -1,13 +1,13 @@
 langwatch/__init__.py,sha256=GMq4SV2Tz2i0JD05shqnw2lBW5cgMx4Zzo141hp106k,4266
-langwatch/__version__.py,sha256=vwG-FkKYsGya3EzNIEIMvFwGCI2K-gXNyKE3Y88jHc4,91
+langwatch/__version__.py,sha256=sympc_lD0EH1ffjgsP80P8i4Sqm2XBcIgblEeQTq6bs,91
 langwatch/attributes.py,sha256=nXdI_G85wQQCAdAcwjCiLYdEYj3wATmfgCmhlf6dVIk,3910
-langwatch/batch_evaluation.py,sha256=piez7TYqUZPb9NlIShTuTPmSzrZqX-vm2Grz_NGXe04,16078
+langwatch/batch_evaluation.py,sha256=Y_S3teXpHV07U-vvJYyV1PB6d0CgyFM_rTzPp6GnEBo,16165
 langwatch/client.py,sha256=WTNcYSik7kZ2kH-qGDnhbMTosc8e_Xhab_lZlfh5TC8,25559
-langwatch/evaluations.py,sha256=6JYaChMoG2oVvHRtZEVzn2xNxQIZr1nUFfHffm6Rfp0,16832
+langwatch/evaluations.py,sha256=W-nxhcbQ4Niyx949LjHjTehw74pj31dUVs5rjkQUBLo,16951
 langwatch/guardrails.py,sha256=4d320HyklXPUVszF34aWsDKGzuvPggcDM_f45_eJTnc,1352
 langwatch/langchain.py,sha256=HjbBBIDwwt688g0W4K0EsZGuGBbo1Mv5LQ-7Mkn56iQ,18726
 langwatch/litellm.py,sha256=mPcw5cLykt0SQf9bTNSoT7elMx4gj-wZ_K2PC14Bw50,11998
-langwatch/login.py,sha256=Wm8Vs7zxJNeGEPO7s_wSQN2DYObteDg56HcyluhTobw,896
+langwatch/login.py,sha256=o0DxYVMhMCRHeopyF0qlj_U4o6yD1rL8QjfKvKnHv0s,965
 langwatch/openai.py,sha256=h_NCIwJ0qs57PS-R7gQZsnf2_EBAahlYQMuqS9-Cj3Q,25139
 langwatch/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 langwatch/state.py,sha256=qXvPAjO90jdokCU6tPSwjHIac4QU_5N0pSd9dfmc9kY,1204
@@ -15,9 +15,10 @@ langwatch/tracer.py,sha256=t5FOdP1es9H_pPGqGUBLXCyEln0tTi4m4M9b6WxCrPU,975
 langwatch/types.py,sha256=h6r3tNTzWqENx-9j_JPmOMZfFoKq9SNpEtxpAACk2G0,3114
 langwatch/dataset/__init__.py,sha256=hZBcbjXuBO2qE5osJtd9wIE9f45F6-jpNTrne5nk4eE,2606
 langwatch/domain/__init__.py,sha256=gSCOV3WkRhp_--9D1vxw7BYpnMRbpGh-2NbsXd4KZC0,6074
-langwatch/dspy/__init__.py,sha256=gv8jOH_oh-dSQlVXCSz90Pa0f2zdk330DEZBCRhYSsw,33979
-langwatch/evaluation/__init__.py,sha256=Jy7PW5VQbMoDGdOLRlQmDEvo_9TDkBLmrLrfocxddLM,281
-langwatch/evaluation/evaluation.py,sha256=AF3VXCcTGB3F8ChsjwBxqjUXkLzvTbkWbiWYxRzVWik,16037
+langwatch/dspy/__init__.py,sha256=wp8AmobV8XGVWOI8MQFmXPHu-8Wq3wvjB6YiHQm9Fdg,33007
+langwatch/evaluation/__init__.py,sha256=dctG-Ec0N_Or2Ta0XW6liYtdpMZN3ZtRXqUoeG5ksnk,870
+langwatch/evaluation/evaluation.py,sha256=MqMiGlsPIS5zqN1wKfhEs6mIGLRwB452iqDTSQFbtYo,31735
+langwatch/evaluation/platform_run.py,sha256=cwuRNtG99nhvqGL-YoOwdvEH3x-hDaVUzl7Vx9orjPo,14546
 langwatch/exporters/filterable_batch_span_exporter.py,sha256=MlhZjui56XD6p2sa8kEGyr-Hb3wqudknngmemnB4Twg,2142
 langwatch/generated/langwatch_rest_api_client/__init__.py,sha256=8r-9pAj7fK7vnVX3mT0y_zS4B9ZRqD6RZiBo5fPra60,156
 langwatch/generated/langwatch_rest_api_client/client.py,sha256=o_mdLqyBCQstu5tS1WZFwqIEbGwkvWQ7eQjuCJw_5VY,12419
@@ -405,16 +406,16 @@ langwatch/prompts/types/structures.py,sha256=cB94bn-qhFgHHYXcrmJV6Bk9idk5ZmyfXhF
 langwatch/telemetry/context.py,sha256=q0hUG9PM3aifIr6ZRuuNNbsGtcAImu9Pv2XTKUp3CGc,4029
 langwatch/telemetry/sampling.py,sha256=XDf6ZoXiwpHaHDYd_dDszSqH8_9-CHFNsGAZWOW1VYk,1327
 langwatch/telemetry/span.py,sha256=g-RGWfQk4Q3b2TpipiHqjEV7rwmidaUHp54q51UxQ6s,32801
-langwatch/telemetry/tracing.py,sha256=oyCAqW-9sFFRYPWy9epZVN0aNvqToRY4_PGxQAtS-dI,27622
+langwatch/telemetry/tracing.py,sha256=R5e0F5Gea72Otusxj5ceafs_-KuFFylNRjcGNkLAhTQ,27697
 langwatch/telemetry/types.py,sha256=Q9H7nT3GMK1aluRB7CCX8BR7VFKrQY_vdFdyF4Yc98U,501
 langwatch/telemetry/__tests__/test_tracing.py,sha256=Px2vcpbRWBgwwaXzw3MgRfkcL-If2LmPAwaFN1sLyvY,3350
 langwatch/utils/__init__.py,sha256=3rqQTgzEtmICJW_KSPuLa5q8p5udxt5SRi28Z2vZB10,138
 langwatch/utils/capture.py,sha256=uVKPqHCm-o8CpabsUfhqbNFr5sgUHzcKnBadvL2oIwI,1172
-langwatch/utils/exceptions.py,sha256=J2_0EZ_GMRTJvCQ-ULX4LOG63r1R-0TCbKg9sskgl5A,498
+langwatch/utils/exceptions.py,sha256=b-dorrnQ9XBJcijLLNJP9LRQzdOZGEiyQ3f8GcA1kgk,1046
 langwatch/utils/initialization.py,sha256=1KoZmkHOvGEVF0j-4t4xRQdA_2C_SPiF7qFXqEG4Nkw,4553
 langwatch/utils/module.py,sha256=KLBNOK3mA9gCSifCcQX_lOtU48BJQDWvFKtF6NMvwVA,688
 langwatch/utils/transformation.py,sha256=76MGXyrYTxM0Yri36NJqLK-XxL4BBYdmKWAXXlw3D4Q,7690
 langwatch/utils/utils.py,sha256=ZCOSie4o9LdJ7odshNfCNjmgwgQ27ojc5ENqt1rXuSs,596
-langwatch-0.8.0.dist-info/METADATA,sha256=RVtrzq4jjZAzk9s80xxjXz4Wd_grAzp0vRJ73oN7WNs,13192
-langwatch-0.8.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-langwatch-0.8.0.dist-info/RECORD,,
+langwatch-0.9.0.dist-info/METADATA,sha256=JtLLtVbyy0iau3ySelLpMO4RpjrQAEyhd72J9NkxHl8,13192
+langwatch-0.9.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+langwatch-0.9.0.dist-info/RECORD,,