feat!: deprecate trace updates

Author: hassiebp

langfuse/_client/client.py

@@ -45,7 +45,7 @@
     ObservationTypeSpanLike,
     get_observation_types_list,
 )
-from langfuse._client.datasets import DatasetClient, DatasetItemClient
+from langfuse._client.datasets import DatasetClient
 from langfuse._client.environment_variables import (
     LANGFUSE_BASE_URL,
     LANGFUSE_DEBUG,
@@ -1633,67 +1633,6 @@ def update_current_span(
                 status_message=status_message,
             )
 
-    def update_current_trace(
-        self,
-        *,
-        name: Optional[str] = None,
-        user_id: Optional[str] = None,
-        session_id: Optional[str] = None,
-        version: Optional[str] = None,
-        input: Optional[Any] = None,
-        output: Optional[Any] = None,
-        metadata: Optional[Any] = None,
-        tags: Optional[List[str]] = None,
-        public: Optional[bool] = None,
-    ) -> None:
-        """Update the current trace with additional information.
-
-        Args:
-            name: Updated name for the Langfuse trace
-            user_id: ID of the user who initiated the Langfuse trace
-            session_id: Session identifier for grouping related Langfuse traces
-            version: Version identifier for the application or service
-            input: Input data for the overall Langfuse trace
-            output: Output data from the overall Langfuse trace
-            metadata: Additional metadata to associate with the Langfuse trace
-            tags: List of tags to categorize the Langfuse trace
-            public: Whether the Langfuse trace should be publicly accessible
-
-        See Also:
-            :func:`langfuse.propagate_attributes`: Recommended replacement
-        """
-        if not self._tracing_enabled:
-            langfuse_logger.debug(
-                "Operation skipped: update_current_trace - Tracing is disabled or client is in no-op mode."
-            )
-            return
-
-        current_otel_span = self._get_current_otel_span()
-
-        if current_otel_span is not None and current_otel_span.is_recording():
-            existing_observation_type = current_otel_span.attributes.get(  # type: ignore[attr-defined]
-                LangfuseOtelSpanAttributes.OBSERVATION_TYPE, "span"
-            )
-            # We need to preserve the class to keep the correct observation type
-            span_class = self._get_span_class(existing_observation_type)
-            span = span_class(
-                otel_span=current_otel_span,
-                langfuse_client=self,
-                environment=self._environment,
-            )
-
-            span.update_trace(
-                name=name,
-                user_id=user_id,
-                session_id=session_id,
-                version=version,
-                input=input,
-                output=output,
-                metadata=metadata,
-                tags=tags,
-                public=public,
-            )
-
     def create_event(
         self,
         *,
@@ -2466,9 +2405,9 @@ def get_dataset(
 
                 page += 1
 
-            items = [DatasetItemClient(i, langfuse=self) for i in dataset_items]
-
-            return DatasetClient(dataset, items=items)
+            return DatasetClient(
+                dataset=dataset, items=dataset_items, langfuse_client=self
+            )
 
         except Error as e:
             handle_fern_exception(e)

langfuse/_client/datasets.py

@@ -1,13 +1,9 @@
 import datetime as dt
-import logging
-from typing import TYPE_CHECKING, Any, Dict, Generator, List, Optional
-
-from opentelemetry.util._decorator import _agnosticcontextmanager
+from typing import TYPE_CHECKING, Any, Dict, List, Optional
 
 from langfuse.api import (
     Dataset,
     DatasetItem,
-    DatasetStatus,
 )
 from langfuse.batch_evaluation import CompositeEvaluatorFunction
 from langfuse.experiment import (
@@ -17,129 +13,10 @@
     TaskFunction,
 )
 
-from .span import LangfuseSpan
-
 if TYPE_CHECKING:
     from langfuse._client.client import Langfuse
 
 
-class DatasetItemClient:
-    """Class for managing dataset items in Langfuse.
-
-    Args:
-        id (str): Unique identifier of the dataset item.
-        status (DatasetStatus): The status of the dataset item. Can be either 'ACTIVE' or 'ARCHIVED'.
-        input (Any): Input data of the dataset item.
-        expected_output (Optional[Any]): Expected output of the dataset item.
-        metadata (Optional[Any]): Additional metadata of the dataset item.
-        source_trace_id (Optional[str]): Identifier of the source trace.
-        source_observation_id (Optional[str]): Identifier of the source observation.
-        dataset_id (str): Identifier of the dataset to which this item belongs.
-        dataset_name (str): Name of the dataset to which this item belongs.
-        created_at (datetime): Timestamp of dataset item creation.
-        updated_at (datetime): Timestamp of the last update to the dataset item.
-        langfuse (Langfuse): Instance of Langfuse client for API interactions.
-
-    Example:
-        ```python
-        from langfuse import Langfuse
-
-        langfuse = Langfuse()
-
-        dataset = langfuse.get_dataset("<dataset_name>")
-
-        for item in dataset.items:
-            # Generate a completion using the input of every item
-            completion, generation = llm_app.run(item.input)
-
-            # Evaluate the completion
-            generation.score(
-                name="example-score",
-                value=1
-            )
-        ```
-    """
-
-    log = logging.getLogger("langfuse")
-
-    id: str
-    status: DatasetStatus
-    input: Any
-    expected_output: Optional[Any]
-    metadata: Optional[Any]
-    source_trace_id: Optional[str]
-    source_observation_id: Optional[str]
-    dataset_id: str
-    dataset_name: str
-    created_at: dt.datetime
-    updated_at: dt.datetime
-
-    langfuse: "Langfuse"
-
-    def __init__(self, dataset_item: DatasetItem, langfuse: "Langfuse"):
-        """Initialize the DatasetItemClient."""
-        self.id = dataset_item.id
-        self.status = dataset_item.status
-        self.input = dataset_item.input
-        self.expected_output = dataset_item.expected_output
-        self.metadata = dataset_item.metadata
-        self.source_trace_id = dataset_item.source_trace_id
-        self.source_observation_id = dataset_item.source_observation_id
-        self.dataset_id = dataset_item.dataset_id
-        self.dataset_name = dataset_item.dataset_name
-        self.created_at = dataset_item.created_at
-        self.updated_at = dataset_item.updated_at
-
-        self.langfuse = langfuse
-
-    @_agnosticcontextmanager
-    def run(
-        self,
-        *,
-        run_name: str,
-        run_metadata: Optional[Any] = None,
-        run_description: Optional[str] = None,
-    ) -> Generator[LangfuseSpan, None, None]:
-        """Create a context manager for the dataset item run that links the execution to a Langfuse trace.
-
-        This method is a context manager that creates a trace for the dataset run and yields a span
-        that can be used to track the execution of the run.
-
-        Args:
-            run_name (str): The name of the dataset run.
-            run_metadata (Optional[Any]): Additional metadata to include in dataset run.
-            run_description (Optional[str]): Description of the dataset run.
-
-        Yields:
-            span: A LangfuseSpan that can be used to trace the execution of the run.
-        """
-        trace_name = f"Dataset run: {run_name}"
-
-        with self.langfuse.start_as_current_span(name=trace_name) as span:
-            span.update_trace(
-                name=trace_name,
-                metadata={
-                    "dataset_item_id": self.id,
-                    "run_name": run_name,
-                    "dataset_id": self.dataset_id,
-                },
-            )
-
-            self.log.debug(
-                f"Creating dataset run item: run_name={run_name} id={self.id} trace_id={span.trace_id}"
-            )
-
-            self.langfuse.api.dataset_run_items.create(
-                run_name=run_name,
-                dataset_item_id=self.id,
-                trace_id=span.trace_id,
-                metadata=run_metadata,
-                run_description=run_description,
-            )
-
-            yield span
-
-
 class DatasetClient:
     """Class for managing datasets in Langfuse.
 
@@ -151,7 +28,7 @@ class DatasetClient:
         project_id (str): Identifier of the project to which the dataset belongs.
         created_at (datetime): Timestamp of dataset creation.
         updated_at (datetime): Timestamp of the last update to the dataset.
-        items (List[DatasetItemClient]): List of dataset items associated with the dataset.
+        items (List[DatasetItem]): List of dataset items associated with the dataset.
 
     Example:
         Print the input of each dataset item in a dataset.
@@ -174,9 +51,13 @@ class DatasetClient:
     metadata: Optional[Any]
     created_at: dt.datetime
     updated_at: dt.datetime
-    items: List[DatasetItemClient]
+    input_schema: Optional[Any]
+    expected_output_schema: Optional[Any]
+    items: List[DatasetItem]
 
-    def __init__(self, dataset: Dataset, items: List[DatasetItemClient]):
+    def __init__(
+        self, *, dataset: Dataset, items: List[DatasetItem], langfuse_client: "Langfuse"
+    ):
         """Initialize the DatasetClient."""
         self.id = dataset.id
         self.name = dataset.name
@@ -185,14 +66,10 @@ def __init__(self, dataset: Dataset, items: List[DatasetItemClient]):
         self.metadata = dataset.metadata
         self.created_at = dataset.created_at
         self.updated_at = dataset.updated_at
+        self.input_schema = dataset.input_schema
+        self.expected_output_schema = dataset.expected_output_schema
         self.items = items
-        self._langfuse: Optional["Langfuse"] = None
-
-    def _get_langfuse_client(self) -> Optional["Langfuse"]:
-        """Get the Langfuse client from the first item."""
-        if self._langfuse is None and self.items:
-            self._langfuse = self.items[0].langfuse
-        return self._langfuse
+        self._langfuse_client: "Langfuse" = langfuse_client
 
     def run_experiment(
         self,
@@ -403,11 +280,7 @@ def content_diversity(*, item_results, **kwargs):
             - This method works in both sync and async contexts (Jupyter notebooks, web apps, etc.)
             - Async execution is handled automatically with smart event loop detection
         """
-        langfuse_client = self._get_langfuse_client()
-        if not langfuse_client:
-            raise ValueError("No Langfuse client available. Dataset items are empty.")
-
-        return langfuse_client.run_experiment(
+        return self._langfuse_client.run_experiment(
             name=name,
             run_name=run_name,
             description=description,

langfuse/_client/span.py

@@ -20,7 +20,6 @@
     TYPE_CHECKING,
     Any,
     Dict,
-    List,
     Literal,
     Optional,
     Type,
@@ -42,7 +41,6 @@
     LangfuseOtelSpanAttributes,
     create_generation_attributes,
     create_span_attributes,
-    create_trace_attributes,
 )
 from langfuse._client.constants import (
     ObservationTypeGenerationLike,
@@ -209,64 +207,6 @@ def end(self, *, end_time: Optional[int] = None) -> "LangfuseObservationWrapper"
 
         return self
 
-    def update_trace(
-        self,
-        *,
-        name: Optional[str] = None,
-        user_id: Optional[str] = None,
-        session_id: Optional[str] = None,
-        version: Optional[str] = None,
-        input: Optional[Any] = None,
-        output: Optional[Any] = None,
-        metadata: Optional[Any] = None,
-        tags: Optional[List[str]] = None,
-        public: Optional[bool] = None,
-    ) -> "LangfuseObservationWrapper":
-        """Update the trace that this span belongs to.
-
-        Args:
-            name: Updated name for the trace
-            user_id: ID of the user who initiated the trace
-            session_id: Session identifier for grouping related traces
-            version: Version identifier for the application or service
-            input: Input data for the overall trace
-            output: Output data from the overall trace
-            metadata: Additional metadata to associate with the trace
-            tags: List of tags to categorize the trace
-            public: Whether the trace should be publicly accessible
-
-        See Also:
-            :func:`langfuse.propagate_attributes`: Recommended replacement
-        """
-        if not self._otel_span.is_recording():
-            return self
-
-        media_processed_input = self._process_media_and_apply_mask(
-            data=input, field="input", span=self._otel_span
-        )
-        media_processed_output = self._process_media_and_apply_mask(
-            data=output, field="output", span=self._otel_span
-        )
-        media_processed_metadata = self._process_media_and_apply_mask(
-            data=metadata, field="metadata", span=self._otel_span
-        )
-
-        attributes = create_trace_attributes(
-            name=name,
-            user_id=user_id,
-            session_id=session_id,
-            version=version,
-            input=media_processed_input,
-            output=media_processed_output,
-            metadata=media_processed_metadata,
-            tags=tags,
-            public=public,
-        )
-
-        self._otel_span.set_attributes(attributes)
-
-        return self
-
     @overload
     def score(
         self,