langwatch 0.10.1__tar.gz → 0.10.2__tar.gz

{langwatch-0.10.1 → langwatch-0.10.2}/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## [0.10.2](https://github.com/langwatch/langwatch/compare/python-sdk@v0.10.1...python-sdk@v0.10.2) (2026-02-05)
+
+
+### Bug Fixes
+
+* tests, handle wildcard (*) in spans and metadata trace mappings and allow log_response() without explicit target context  ([#1291](https://github.com/langwatch/langwatch/issues/1291)) ([af5d77f](https://github.com/langwatch/langwatch/commit/af5d77fade37ea9ca157965e7d1ac8e4e73f2dcf))
+
 ## [1.0.0](https://github.com/langwatch/langwatch/compare/python-sdk@v0.10.0...python-sdk@v1.0.0) (2026-02-01)
 
 

{langwatch-0.10.1 → langwatch-0.10.2}/PKG-INFO

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

{langwatch-0.10.1 → langwatch-0.10.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "langwatch"
-version = "0.10.1" # remember to also update it in src/langwatch/__version__.py
+version = "0.10.2" # remember to also update it in src/langwatch/__version__.py
 description = "LangWatch Python SDK, for monitoring your LLMs"
 authors = [{ name = "Langwatch Engineers", email = "engineering@langwatch.ai" }]
 requires-python = ">=3.10,<3.14"

langwatch-0.10.2/src/langwatch/__version__.py

@@ -0,0 +1,3 @@
+"""Version information for LangWatch."""
+
+__version__ = "0.10.2" # x-release-please-version

{langwatch-0.10.1 → langwatch-0.10.2}/src/langwatch/experiment/experiment.py

@@ -302,6 +302,10 @@ class Experiment:
         iter_ctx = IterationContext(index=index, item=item)
         iter_token = _iteration_context.set(iter_ctx)
 
+        # Reset target context at the start of each iteration to prevent pollution
+        # from previous iterations (especially important for implicit Output targets)
+        _target_context.set(None)
+
         # Determine if we should create an iteration trace:
         # - Don't create if evaluation uses targets (each target creates its own trace)
         # - Don't create if we're collecting submit() calls (not in_thread yet)
@@ -340,6 +344,8 @@ class Experiment:
         finally:
             # Reset iteration context
             _iteration_context.reset(iter_token)
+            # Reset target context to prevent pollution to next iteration
+            _target_context.set(None)
 
         # Handle iteration trace cleanup
         # Note: If target() was used, it may have already closed the trace
@@ -715,9 +721,10 @@ class Experiment:
         """
         Log the model's response/output for the current target.
 
-        Must be called inside a `target()` context. The response will be stored
-        in the dataset entry's `predicted` field, which is displayed in the
-        results table.
+        Can be called inside a `target()` context, or outside of one. When called
+        outside a target context, an implicit "Output" target is created automatically.
+        The response will be stored in the dataset entry's `predicted` field, which
+        is displayed in the results table.
 
         Args:
             response: The model's output. Can be a string (will be wrapped as
@@ -725,30 +732,131 @@ class Experiment:
 
         Example:
             ```python
+            # With explicit target
             with evaluation.target("gpt-4", {"model": "openai/gpt-4"}):
                 response = call_gpt4(row["question"])
                 evaluation.log_response(response)  # Store the output
                 evaluation.log("quality", index=index, score=0.95)  # Log metrics
-            ```
 
-        Raises:
-            RuntimeError: If called outside of a target() context.
+            # Without explicit target (creates implicit "Output" target)
+            for index, row in evaluation.loop(df.iterrows()):
+                response = my_model(row["question"])
+                evaluation.log_response(response)  # Creates "Output" target
+                evaluation.log("quality", index=index, score=0.95)
+            ```
         """
         ctx = _target_context.get()
-        if ctx is None:
-            raise RuntimeError(
-                "log_response() must be called inside a target() context. "
-                "Example: with evaluation.target('my-target'): evaluation.log_response(response)"
-            )
 
         # Normalize response to dict format
         if isinstance(response, str):
-            ctx.predicted = {"output": response}
+            predicted = {"output": response}
         elif isinstance(response, dict):
-            ctx.predicted = response
+            predicted = response
         else:
             # Try to convert to string for other types
-            ctx.predicted = {"output": str(response)}
+            predicted = {"output": str(response)}
+
+        if ctx is None:
+            # Create implicit "Output" target and dataset entry immediately
+            self._create_implicit_output_target(predicted)
+        else:
+            # Inside explicit target context - just set predicted
+            ctx.predicted = predicted
+
+    def _create_implicit_output_target(self, predicted: Dict[str, Any]) -> None:
+        """
+        Create an implicit "Output" target when log_response() is called outside
+        a target() context. This enables a simpler API for single-target evaluations.
+
+        Creates the dataset entry immediately with the predicted response.
+        """
+        target_name = "Output"
+
+        # Mark that targets are being used
+        if not self._evaluation_uses_targets:
+            self._evaluation_uses_targets = True
+            # Close the active iteration trace if any
+            if self._active_iteration_trace is not None:
+                self._active_iteration_trace.__exit__(None, None, None)
+                self._active_iteration_trace = None
+
+        self._current_iteration_used_with_target = True
+
+        # Register the target
+        self._register_target(target_name, None)
+
+        # Get index and item from iteration context
+        iter_ctx = _iteration_context.get()
+        if iter_ctx is not None:
+            index = iter_ctx.index
+            current_item = iter_ctx.item
+        else:
+            index = self._current_index
+            current_item = self._current_item
+
+        # Create a trace for this implicit target
+        tracer = trace.get_tracer("langwatch-evaluation")
+        root_context = otel_context.Context()
+
+        # Start span and get trace_id
+        with tracer.start_span(
+            f"evaluation.target.{target_name}",
+            context=root_context,
+            attributes={
+                "evaluation.run_id": self.run_id,
+                "evaluation.index": index,
+                "evaluation.target": target_name,
+            },
+        ) as span:
+            span_context = span.get_span_context()
+            trace_id = format(span_context.trace_id, "032x")
+
+        # Create and set target context (for subsequent log() calls)
+        ctx = TargetContext(
+            target_id=target_name,
+            index=index,
+            trace_id=trace_id,
+            predicted=predicted,
+        )
+        _target_context.set(ctx)
+
+        # Create dataset entry immediately
+        entry_data: Any = (
+            current_item.to_dict()
+            if hasattr(current_item, "to_dict")
+            else (
+                current_item.__dict__
+                if hasattr(current_item, "__dict__")
+                else (
+                    current_item[1].to_dict()
+                    if type(current_item) == tuple
+                    and hasattr(current_item[1], "to_dict")
+                    else (
+                        current_item[1].__dict__
+                        if type(current_item) == tuple
+                        and hasattr(current_item[1], "__dict__")
+                        else {
+                            "entry": json.dumps(
+                                current_item, cls=SerializableWithStringFallback
+                            )
+                        }
+                    )
+                )
+            )
+        )
+
+        batch_entry = BatchEntry(
+            index=index,
+            entry=entry_data,
+            duration=0,  # Duration not tracked for implicit targets
+            error=None,
+            trace_id=trace_id,
+            target_id=target_name,
+            predicted=predicted,
+        )
+
+        with self.lock:
+            self.batch["dataset"].append(batch_entry)
 
     def log(
         self,

{langwatch-0.10.1 → langwatch-0.10.2}/tests/experiment/test_with_target.py

@@ -250,10 +250,47 @@ class TestLogResponse:
 
         assert evaluation.batch["dataset"][0].predicted == {"answer": "42", "confidence": 0.95}
 
-    def test_log_response_outside_target_raises(self, evaluation):
-        """log_response() outside target() raises RuntimeError."""
-        with pytest.raises(RuntimeError, match="must be called inside a target"):
-            evaluation.log_response("test")
+    def test_log_response_outside_target_creates_implicit_output_target(self, evaluation):
+        """log_response() outside target() creates an implicit 'Output' target."""
+        # Set up iteration context (normally done by loop())
+        from langwatch.experiment.experiment import _iteration_context, _target_context, IterationContext
+        iter_ctx = IterationContext(index=0, item={"question": "test"})
+        iter_token = _iteration_context.set(iter_ctx)
+
+        try:
+            evaluation.log_response("Hello, world!")
+
+            # Should create a dataset entry with target_id "Output"
+            assert len(evaluation.batch["dataset"]) == 1
+            entry = evaluation.batch["dataset"][0]
+            assert entry.target_id == "Output"
+            assert entry.predicted == {"output": "Hello, world!"}
+            assert entry.index == 0
+
+            # Should register the "Output" target
+            assert "Output" in evaluation._targets
+        finally:
+            _iteration_context.reset(iter_token)
+            # Reset target context to avoid polluting other tests
+            _target_context.set(None)
+
+    def test_log_response_outside_target_associates_log_with_output_target(self, evaluation):
+        """log() after log_response() outside target uses the implicit 'Output' target."""
+        from langwatch.experiment.experiment import _iteration_context, _target_context, IterationContext
+        iter_ctx = IterationContext(index=0, item={"question": "test"})
+        iter_token = _iteration_context.set(iter_ctx)
+
+        try:
+            evaluation.log_response("Hello, world!")
+            evaluation.log("quality", index=0, score=0.95)
+
+            # log() should use the implicit "Output" target
+            assert len(evaluation.batch["evaluations"]) == 1
+            assert evaluation.batch["evaluations"][0].target_id == "Output"
+        finally:
+            _iteration_context.reset(iter_token)
+            # Reset target context to avoid polluting other tests
+            _target_context.set(None)
 
     def test_log_response_with_multiple_metrics(self, evaluation):
         """log_response() works alongside multiple log() calls."""
@@ -269,3 +306,98 @@ class TestLogResponse:
 
         # Three evaluations
         assert len(evaluation.batch["evaluations"]) == 3
+
+
+class TestImplicitTargetContextReset:
+    """Tests to ensure implicit target context is properly reset between iterations."""
+
+    def test_implicit_target_context_reset_between_iterations(self):
+        """Context from log_response() in one iteration doesn't pollute the next."""
+        from langwatch.experiment.experiment import (
+            Experiment,
+            _iteration_context,
+            _target_context,
+            IterationContext,
+        )
+
+        ev = Experiment("test-context-reset")
+        ev.initialized = True
+        ev.last_sent = 9999999999  # Prevent sending
+
+        # First iteration with log_response (creates implicit Output target)
+        iter_ctx1 = IterationContext(index=0, item={"question": "q1"})
+        with ev._execute_item_iteration(0, {"question": "q1"}, in_thread=False):
+            ev.log_response("response 1")
+            ev.log("metric", index=0, score=0.5)
+
+        # Context should be reset after iteration
+        assert _target_context.get() is None, "Target context should be reset after iteration"
+
+        # Second iteration WITHOUT log_response - should not inherit Output target
+        with ev._execute_item_iteration(1, {"question": "q2"}, in_thread=False):
+            # log() without log_response should NOT have a target
+            ev.log("metric", index=1, score=0.6)
+
+        # Check the evaluations
+        evals = ev.batch["evaluations"]
+        assert len(evals) == 2
+        assert evals[0].target_id == "Output"  # First iteration used implicit target
+        assert evals[1].target_id is None  # Second iteration should have no target
+
+    def test_multiple_iterations_with_log_response_each_get_own_entry(self):
+        """Each iteration with log_response creates its own dataset entry."""
+        from langwatch.experiment.experiment import Experiment, _target_context
+
+        ev = Experiment("test-multi-iterations")
+        ev.initialized = True
+        ev.last_sent = 9999999999
+
+        # Run 3 iterations, each with log_response
+        for i in range(3):
+            with ev._execute_item_iteration(i, {"question": f"q{i}"}, in_thread=False):
+                ev.log_response(f"response {i}")
+                ev.log("metric", index=i, score=0.5 + i * 0.1)
+
+        # Should have 3 dataset entries
+        assert len(ev.batch["dataset"]) == 3
+        for i, entry in enumerate(ev.batch["dataset"]):
+            assert entry.target_id == "Output"
+            assert entry.predicted == {"output": f"response {i}"}
+            assert entry.index == i
+
+        # Should have 3 evaluations, all with Output target
+        assert len(ev.batch["evaluations"]) == 3
+        for i, eval_result in enumerate(ev.batch["evaluations"]):
+            assert eval_result.target_id == "Output"
+            assert eval_result.index == i
+
+    def test_run_without_log_response_after_run_with_log_response(self):
+        """A run without log_response after a run with log_response should work correctly."""
+        from langwatch.experiment.experiment import Experiment, _target_context
+
+        # Simulate first run with log_response
+        ev1 = Experiment("test-first-run")
+        ev1.initialized = True
+        ev1.last_sent = 9999999999
+
+        for i in range(2):
+            with ev1._execute_item_iteration(i, {"q": f"q{i}"}, in_thread=False):
+                ev1.log_response(f"response {i}")
+                ev1.log("metric", index=i, score=0.5)
+
+        # Context should be clean after first experiment
+        assert _target_context.get() is None
+
+        # Simulate second run WITHOUT log_response (like the user's second scenario)
+        ev2 = Experiment("test-second-run")
+        ev2.initialized = True
+        ev2.last_sent = 9999999999
+
+        for i in range(2):
+            with ev2._execute_item_iteration(i, {"q": f"q{i}"}, in_thread=False):
+                # Just log, no log_response
+                ev2.log("metric", index=i, score=0.6)
+
+        # Second run evaluations should NOT have Output target
+        for eval_result in ev2.batch["evaluations"]:
+            assert eval_result.target_id is None, "Second run should not inherit Output target"

{langwatch-0.10.1 → langwatch-0.10.2}/uv.lock

@@ -2878,7 +2878,7 @@ wheels = [
 
 [[package]]
 name = "langwatch"
-version = "0.10.1"
+version = "0.10.2"
 source = { editable = "." }
 dependencies = [
     { name = "attrs" },

langwatch-0.10.1/src/langwatch/__version__.py

@@ -1,3 +0,0 @@
-"""Version information for LangWatch."""
-
-__version__ = "0.10.1" # x-release-please-version