lmnr 0.6.9__py3-none-any.whl → 0.6.11__py3-none-any.whl

lmnr/cli.py

@@ -100,9 +100,14 @@ async def run_evaluation(args):
             sys.modules[name] = mod
 
             spec.loader.exec_module(mod)
-            evaluations: list[Evaluation] | None = EVALUATION_INSTANCES.get()
-            if evaluations is None:
-                LOG.warning("Evaluation instance not found")
+            evaluations = []
+            try:
+                evaluations: list[Evaluation] | None = EVALUATION_INSTANCES.get()
+                if evaluations is None:
+                    raise LookupError()
+            # may be raised by `get()` or manually by us above
+            except LookupError:
+                log_evaluation_instance_not_found()
                 if args.continue_on_error:
                     continue
                 return
@@ -130,6 +135,14 @@ async def run_evaluation(args):
         PREPARE_ONLY.reset(prep_token)
 
 
+def log_evaluation_instance_not_found():
+    LOG.warning(
+        "Evaluation instance not found. "
+        "`evaluate` must be called at the top level of the file, "
+        "not inside a function when running evaluations from the CLI."
+    )
+
+
 def cli():
     parser = ArgumentParser(
         prog="lmnr",

lmnr/opentelemetry_lib/__init__.py

@@ -54,6 +54,8 @@ class TracerManager:
 
     @staticmethod
     def flush() -> bool:
+        if not hasattr(TracerManager, "_TracerManager__tracer_wrapper"):
+            return False
         return TracerManager.__tracer_wrapper.flush()
 
     @staticmethod

lmnr/opentelemetry_lib/opentelemetry/instrumentation/langgraph/__init__.py

@@ -11,7 +11,7 @@ from .utils import (
 from langchain_core.runnables.graph import Graph
 from opentelemetry.trace import Tracer
 from wrapt import wrap_function_wrapper
-from opentelemetry.trace import get_tracer, get_current_span
+from opentelemetry.trace import get_tracer
 
 from lmnr.opentelemetry_lib.tracing.context_properties import (
     update_association_properties,
@@ -81,7 +81,9 @@ async def async_wrap_pregel_stream(
             "langgraph.nodes": json.dumps(nodes),
         },
     )
-    return await wrapped(*args, **kwargs)
+
+    async for item in wrapped(*args, **kwargs):
+        yield item
 
 
 class LanggraphInstrumentor(BaseInstrumentor):

lmnr/opentelemetry_lib/tracing/__init__.py

@@ -1,5 +1,6 @@
 import atexit
 import logging
+import threading
 
 from lmnr.opentelemetry_lib.tracing.processor import LaminarSpanProcessor
 from lmnr.sdk.client.asynchronous.async_client import AsyncLaminarClient
@@ -16,12 +17,6 @@ from opentelemetry.sdk.resources import Resource
 from opentelemetry.sdk.trace import TracerProvider, SpanProcessor
 from opentelemetry.sdk.trace.export import SpanExporter
 
-module_logger = logging.getLogger(__name__)
-console_log_handler = logging.StreamHandler()
-console_log_handler.setFormatter(VerboseColorfulFormatter())
-module_logger.addHandler(console_log_handler)
-
-
 TRACER_NAME = "lmnr.tracer"
 
 MAX_EVENTS_OR_ATTRIBUTES_PER_SPAN = 5000
@@ -30,12 +25,13 @@ MAX_EVENTS_OR_ATTRIBUTES_PER_SPAN = 5000
 class TracerWrapper(object):
     resource_attributes: dict = {}
     enable_content_tracing: bool = True
-    __tracer_provider: TracerProvider | None = None
-    __logger: logging.Logger
-    __client: LaminarClient
-    __async_client: AsyncLaminarClient
-    __resource: Resource
-    __span_processor: SpanProcessor
+    _lock = threading.Lock()
+    _tracer_provider: TracerProvider | None = None
+    _logger: logging.Logger
+    _client: LaminarClient
+    _async_client: AsyncLaminarClient
+    _resource: Resource
+    _span_processor: SpanProcessor
 
     def __new__(
         cls,
@@ -57,73 +53,76 @@ class TracerWrapper(object):
         logging.getLogger("opentelemetry.trace").setLevel(otel_logger_level)
 
         base_http_url = f"{base_url}:{http_port}"
-        cls._initialize_logger(cls)
-        if not hasattr(cls, "instance"):
-            obj = cls.instance = super(TracerWrapper, cls).__new__(cls)
-
-            obj.__client = LaminarClient(
-                base_url=base_http_url,
-                project_api_key=project_api_key,
-            )
-            obj.__async_client = AsyncLaminarClient(
-                base_url=base_http_url,
-                project_api_key=project_api_key,
-            )
-
-            obj.__resource = Resource(attributes=TracerWrapper.resource_attributes)
-
-            obj.__span_processor = LaminarSpanProcessor(
-                base_url=base_url,
-                api_key=project_api_key,
-                port=http_port if force_http else port,
-                exporter=exporter,
-                max_export_batch_size=max_export_batch_size,
-                timeout_seconds=timeout_seconds,
-                force_http=force_http,
-                disable_batch=disable_batch,
-            )
-
-            lmnr_provider = TracerProvider(resource=obj.__resource)
-            global_provider = trace.get_tracer_provider()
-            if set_global_tracer_provider and isinstance(
-                global_provider, trace.ProxyTracerProvider
-            ):
-                trace.set_tracer_provider(lmnr_provider)
-
-            obj.__tracer_provider = lmnr_provider
-
-            obj.__tracer_provider.add_span_processor(obj.__span_processor)
-
-            # This is not a real instrumentation and does not generate telemetry
-            # data, but it is required to ensure that OpenTelemetry context
-            # propagation is enabled.
-            # See the README at:
-            # https://pypi.org/project/opentelemetry-instrumentation-threading/
-            ThreadingInstrumentor().instrument()
-
-            init_instrumentations(
-                tracer_provider=obj.__tracer_provider,
-                instruments=instruments,
-                block_instruments=block_instruments,
-                client=obj.__client,
-                async_client=obj.__async_client,
-            )
-
-            # Force flushes for debug environments (e.g. local development)
-            atexit.register(obj.exit_handler)
-
-        return cls.instance
+        with cls._lock:
+            if not hasattr(cls, "instance"):
+                cls._initialize_logger(cls)
+                obj = super(TracerWrapper, cls).__new__(cls)
+
+                obj._client = LaminarClient(
+                    base_url=base_http_url,
+                    project_api_key=project_api_key,
+                )
+                obj._async_client = AsyncLaminarClient(
+                    base_url=base_http_url,
+                    project_api_key=project_api_key,
+                )
+
+                obj._resource = Resource(attributes=TracerWrapper.resource_attributes)
+
+                obj._span_processor = LaminarSpanProcessor(
+                    base_url=base_url,
+                    api_key=project_api_key,
+                    port=http_port if force_http else port,
+                    exporter=exporter,
+                    max_export_batch_size=max_export_batch_size,
+                    timeout_seconds=timeout_seconds,
+                    force_http=force_http,
+                    disable_batch=disable_batch,
+                )
+
+                lmnr_provider = TracerProvider(resource=obj._resource)
+                global_provider = trace.get_tracer_provider()
+                if set_global_tracer_provider and isinstance(
+                    global_provider, trace.ProxyTracerProvider
+                ):
+                    trace.set_tracer_provider(lmnr_provider)
+
+                obj._tracer_provider = lmnr_provider
+
+                obj._tracer_provider.add_span_processor(obj._span_processor)
+
+                # This is not a real instrumentation and does not generate telemetry
+                # data, but it is required to ensure that OpenTelemetry context
+                # propagation is enabled.
+                # See the README at:
+                # https://pypi.org/project/opentelemetry-instrumentation-threading/
+                ThreadingInstrumentor().instrument()
+
+                init_instrumentations(
+                    tracer_provider=obj._tracer_provider,
+                    instruments=instruments,
+                    block_instruments=block_instruments,
+                    client=obj._client,
+                    async_client=obj._async_client,
+                )
+
+                cls.instance = obj
+
+                # Force flushes for debug environments (e.g. local development)
+                atexit.register(obj.exit_handler)
+
+            return cls.instance
 
     def exit_handler(self):
-        if isinstance(self.__span_processor, LaminarSpanProcessor):
-            self.__span_processor.clear()
+        if isinstance(self._span_processor, LaminarSpanProcessor):
+            self._span_processor.clear()
         self.flush()
 
     def _initialize_logger(self):
-        self.__logger = logging.getLogger(__name__)
+        self._logger = logging.getLogger(__name__)
         console_log_handler = logging.StreamHandler()
         console_log_handler.setFormatter(VerboseColorfulFormatter())
-        self.__logger.addHandler(console_log_handler)
+        self._logger.addHandler(console_log_handler)
 
     @staticmethod
     def set_static_params(
@@ -135,23 +134,29 @@ class TracerWrapper(object):
 
     @classmethod
     def verify_initialized(cls) -> bool:
-        return hasattr(cls, "instance")
+        with cls._lock:
+            return hasattr(cls, "instance") and hasattr(cls.instance, "_span_processor")
 
     @classmethod
     def clear(cls):
+        if not cls.verify_initialized():
+            return
         # Any state cleanup. Now used in between tests
-        if isinstance(cls.instance.__span_processor, LaminarSpanProcessor):
-            cls.instance.__span_processor.clear()
+        if isinstance(cls.instance._span_processor, LaminarSpanProcessor):
+            cls.instance._span_processor.clear()
 
     def shutdown(self):
-        if self.__tracer_provider is None:
+        if self._tracer_provider is None:
             return
-        self.__tracer_provider.shutdown()
+        self._tracer_provider.shutdown()
 
     def flush(self):
-        return self.__span_processor.force_flush()
+        if not hasattr(self, "_span_processor"):
+            self._logger.warning("TracerWrapper not fully initialized, cannot flush")
+            return False
+        return self._span_processor.force_flush()
 
     def get_tracer(self):
-        if self.__tracer_provider is None:
+        if self._tracer_provider is None:
             return trace.get_tracer_provider().get_tracer(TRACER_NAME)
-        return self.__tracer_provider.get_tracer(TRACER_NAME)
+        return self._tracer_provider.get_tracer(TRACER_NAME)

lmnr/sdk/client/asynchronous/async_client.py

@@ -89,11 +89,11 @@ class AsyncLaminarClient:
         return self.__agent
 
     @property
-    def _evals(self) -> AsyncEvals:
+    def evals(self) -> AsyncEvals:
         """Get the Evals resource.
 
         Returns:
-            Evals: The Evals resource instance.
+            AsyncEvals: The Evals resource instance.
         """
         return self.__evals
 
@@ -144,3 +144,5 @@ class AsyncLaminarClient:
             "Content-Type": "application/json",
             "Accept": "application/json",
         }
+
+

lmnr/sdk/client/asynchronous/resources/evals.py

@@ -1,5 +1,6 @@
 """Evals resource for interacting with Laminar evaluations API."""
 
+from typing import Any
 import uuid
 
 from lmnr.sdk.client.asynchronous.resources.base import BaseAsyncResource
@@ -33,9 +34,71 @@ class AsyncEvals(BaseAsyncResource):
             },
             headers=self._headers(),
         )
+        if response.status_code != 200:
+            if response.status_code == 401:
+                raise ValueError("Unauthorized. Please check your project API key.")
+            raise ValueError(f"Error initializing evaluation: {response.text}")
         resp_json = response.json()
         return InitEvaluationResponse.model_validate(resp_json)
 
+    async def create_evaluation(
+        self,
+        name: str | None = None,
+        group_name: str | None = None,
+    ) -> uuid.UUID:
+        """
+        Create a new evaluation and return its ID.
+        
+        Parameters:
+            name (str | None, optional): Optional name of the evaluation.
+            group_name (str | None, optional): An identifier to group evaluations.
+        
+        Returns:
+            uuid.UUID: The evaluation ID.
+        """
+        evaluation = await self.init(name=name, group_name=group_name)
+        return evaluation.id
+
+    async def create_datapoint(
+        self,
+        eval_id: uuid.UUID,
+        data: Any,
+        target: Any = None,
+        metadata: dict[str, Any] | None = None,
+        index: int | None = None,
+        trace_id: uuid.UUID | None = None,
+    ) -> uuid.UUID:
+        """
+        Create a datapoint for an evaluation.
+        
+        Parameters:
+            eval_id (uuid.UUID): The evaluation ID.
+            data: The input data for the executor.
+            target: The target/expected output for evaluators.
+            metadata (dict[str, Any] | None, optional): Optional metadata.
+            index (int | None, optional): Optional index of the datapoint.
+            trace_id (uuid.UUID | None, optional): Optional trace ID.
+        
+        Returns:
+            uuid.UUID: The datapoint ID.
+        """
+        
+        datapoint_id = uuid.uuid4()
+        
+        # Create a minimal datapoint first
+        partial_datapoint = PartialEvaluationDatapoint(
+            id=datapoint_id,
+            data=data,
+            target=target,
+            index=index or 0,
+            trace_id=trace_id or uuid.uuid4(),
+            executor_span_id=uuid.uuid4(),  # Will be updated when executor runs
+            metadata=metadata,
+        )
+        
+        await self.save_datapoints(eval_id, [partial_datapoint])
+        return datapoint_id
+
     async def save_datapoints(
         self,
         eval_id: uuid.UUID,
@@ -62,3 +125,34 @@ class AsyncEvals(BaseAsyncResource):
         )
         if response.status_code != 200:
             raise ValueError(f"Error saving evaluation datapoints: {response.text}")
+        
+    
+    async def update_datapoint(
+        self,
+        eval_id: uuid.UUID,
+        datapoint_id: uuid.UUID,
+        scores: dict[str, float | int],
+        executor_output: Any | None = None,
+    ) -> None:
+        """Update a datapoint with evaluation results.
+
+        Args:
+            eval_id (uuid.UUID): The evaluation ID.
+            datapoint_id (uuid.UUID): The datapoint ID.
+            executor_output (Any): The executor output.
+            scores (dict[str, float | int] | None, optional): The scores. Defaults to None.
+        """
+        
+        response = await self._client.post(
+            self._base_url + f"/v1/evals/{eval_id}/datapoints/{datapoint_id}",
+            json={
+                "executorOutput": executor_output,
+                "scores": scores,
+            },
+            headers=self._headers(),
+        )
+
+        if response.status_code != 200:
+            raise ValueError(f"Error updating evaluation datapoint: {response.text}")
+        
+    

lmnr/sdk/client/synchronous/resources/evals.py

@@ -2,6 +2,7 @@
 
 import uuid
 import urllib.parse
+from typing import Any
 
 from lmnr.sdk.client.synchronous.resources.base import BaseResource
 from lmnr.sdk.types import (
@@ -35,9 +36,71 @@ class Evals(BaseResource):
             },
             headers=self._headers(),
         )
+        if response.status_code != 200:
+            if response.status_code == 401:
+                raise ValueError("Unauthorized. Please check your project API key.")
+            raise ValueError(f"Error initializing evaluation: {response.text}")
         resp_json = response.json()
         return InitEvaluationResponse.model_validate(resp_json)
 
+    def create_evaluation(
+        self,
+        name: str | None = None,
+        group_name: str | None = None,
+    ) -> uuid.UUID:
+        """
+        Create a new evaluation and return its ID.
+        
+        Parameters:
+            name (str | None, optional): Optional name of the evaluation.
+            group_name (str | None, optional): An identifier to group evaluations.
+        
+        Returns:
+            uuid.UUID: The evaluation ID.
+        """
+        evaluation = self.init(name=name, group_name=group_name)
+        return evaluation.id
+
+    def create_datapoint(
+        self,
+        eval_id: uuid.UUID,
+        data: Any,
+        target: Any = None,
+        metadata: dict[str, Any] | None = None,
+        index: int | None = None,
+        trace_id: uuid.UUID | None = None,
+    ) -> uuid.UUID:
+        """
+        Create a datapoint for an evaluation.
+        
+        Parameters:
+            eval_id (uuid.UUID): The evaluation ID.
+            data: The input data for the executor.
+            target: The target/expected output for evaluators.
+            metadata (dict[str, Any] | None, optional): Optional metadata.
+            index (int | None, optional): Optional index of the datapoint.
+            trace_id (uuid.UUID | None, optional): Optional trace ID.
+        
+        Returns:
+            uuid.UUID: The datapoint ID.
+        """
+        
+        datapoint_id = uuid.uuid4()
+        
+        # Create a minimal datapoint first
+        partial_datapoint = PartialEvaluationDatapoint(
+            id=datapoint_id,
+            data=data,
+            target=target,
+            index=index or 0,
+            trace_id=trace_id or uuid.uuid4(),
+            executor_span_id=uuid.uuid4(),  # Will be updated when executor runs
+            metadata=metadata,
+        )
+        
+        self.save_datapoints(eval_id, [partial_datapoint])
+        return datapoint_id
+
     def save_datapoints(
         self,
         eval_id: uuid.UUID,
@@ -65,6 +128,34 @@ class Evals(BaseResource):
         if response.status_code != 200:
             raise ValueError(f"Error saving evaluation datapoints: {response.text}")
 
+    def update_datapoint(
+        self,
+        eval_id: uuid.UUID,
+        datapoint_id: uuid.UUID,
+        scores: dict[str, float | int],
+        executor_output: Any | None = None,
+    ) -> None:
+        """Update a datapoint with evaluation results.
+
+        Args:
+            eval_id (uuid.UUID): The evaluation ID.
+            datapoint_id (uuid.UUID): The datapoint ID.
+            executor_output (Any): The executor output.
+            scores (dict[str, float | int] | None, optional): The scores. Defaults to None.
+        """
+        
+        response = self._client.post(
+            self._base_url + f"/v1/evals/{eval_id}/datapoints/{datapoint_id}",
+            json={
+                "executorOutput": executor_output,
+                "scores": scores,
+            },
+            headers=self._headers(),
+        )
+
+        if response.status_code != 200:
+            raise ValueError(f"Error updating evaluation datapoint: {response.text}")
+
     def get_datapoints(
         self,
         dataset_name: str,

lmnr/sdk/client/synchronous/sync_client.py

@@ -89,7 +89,7 @@ class LaminarClient:
         return self.__agent
 
     @property
-    def _evals(self) -> Evals:
+    def evals(self) -> Evals:
         """Get the Evals resource.
 
         Returns:
@@ -155,3 +155,5 @@ class LaminarClient:
             "Content-Type": "application/json",
             "Accept": "application/json",
         }
+
+

lmnr/sdk/datasets.py

@@ -38,7 +38,7 @@ class LaminarDataset(EvaluationDataset):
             f"dataset {self.name}. Fetching batch from {self._offset} to "
             + f"{self._offset + self._fetch_size}"
         )
-        resp = self.client._evals.get_datapoints(
+        resp = self.client.evals.get_datapoints(
             self.name, self._offset, self._fetch_size
         )
         self._fetched_items += resp.items

lmnr/sdk/evaluations.py

@@ -199,11 +199,11 @@ class Evaluation:
         self.base_http_url = f"{base_url}:{http_port or 443}"
 
         api_key = project_api_key or from_env("LMNR_PROJECT_API_KEY")
-        if not api_key:
+        if not api_key and not L.is_initialized():
             raise ValueError(
-                "Please initialize the Laminar object with"
-                " your project API key or set the LMNR_PROJECT_API_KEY"
-                " environment variable in your environment or .env file"
+                "Please pass the project API key to `evaluate`"
+                " or set the LMNR_PROJECT_API_KEY environment variable"
+                " in your environment or .env file"
             )
         self.project_api_key = api_key
 
@@ -212,17 +212,12 @@ class Evaluation:
                 base_url=L.get_base_http_url(),
                 project_api_key=L.get_project_api_key(),
             )
-            if project_api_key and project_api_key != L.get_project_api_key():
-                self._logger.warning(
-                    "Project API key is different from the one used to initialize"
-                    " Laminar. Ignoring the project API key passed to the evaluation."
-                )
-            return
+        else:
+            self.client = AsyncLaminarClient(
+                base_url=self.base_http_url,
+                project_api_key=self.project_api_key,
+            )
 
-        self.client = AsyncLaminarClient(
-            base_url=self.base_http_url,
-            project_api_key=self.project_api_key,
-        )
         L.initialize(
             project_api_key=project_api_key,
             base_url=base_url,
@@ -246,7 +241,7 @@ class Evaluation:
             )
         self.reporter.start(len(self.data))
         try:
-            evaluation = await self.client._evals.init(
+            evaluation = await self.client.evals.init(
                 name=self.name, group_name=self.group_name
             )
             result_datapoints = await self._evaluate_in_batches(evaluation.id)
@@ -261,7 +256,7 @@ class Evaluation:
         except Exception as e:
             self.reporter.stopWithError(e)
             await self._shutdown()
-            return {}
+            raise
 
         average_scores = get_average_scores(result_datapoints)
         self.reporter.stop(average_scores, evaluation.projectId, evaluation.id)
@@ -331,7 +326,7 @@ class Evaluation:
                     metadata=datapoint.metadata,
                 )
                 # First, create datapoint with trace_id so that we can show the dp in the UI
-                await self.client._evals.save_datapoints(
+                await self.client.evals.save_datapoints(
                     eval_id, [partial_datapoint], self.group_name
                 )
                 executor_span.set_attribute(SPAN_TYPE, SpanType.EXECUTOR.value)
@@ -389,7 +384,7 @@ class Evaluation:
 
         # Create background upload task without awaiting it
         upload_task = asyncio.create_task(
-            self.client._evals.save_datapoints(eval_id, [datapoint], self.group_name)
+            self.client.evals.save_datapoints(eval_id, [datapoint], self.group_name)
         )
         self.upload_tasks.append(upload_task)
 

lmnr/sdk/laminar.py

@@ -114,6 +114,12 @@ class Laminar:
         Raises:
             ValueError: If project API key is not set
         """
+        if cls.is_initialized():
+            cls.__logger.info(
+                "Laminar is already initialized. Skipping initialization."
+            )
+            return
+
         cls.__project_api_key = project_api_key or from_env("LMNR_PROJECT_API_KEY")
         if not cls.__project_api_key:
             raise ValueError(
@@ -691,6 +697,7 @@ class Laminar:
     def shutdown(cls):
         if cls.is_initialized():
             TracerManager.shutdown()
+            cls.__initialized = False
 
     @classmethod
     def set_span_tags(cls, tags: list[str]):

lmnr/version.py

@@ -3,7 +3,7 @@ import httpx
 from packaging import version
 
 
-__version__ = "0.6.9"
+__version__ = "0.6.11"
 PYTHON_VERSION = f"{sys.version_info.major}.{sys.version_info.minor}"
 
 

{lmnr-0.6.9.dist-info → lmnr-0.6.11.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: lmnr
-Version: 0.6.9
+Version: 0.6.11
 Summary: Python SDK for Laminar
 License: Apache-2.0
 Author: lmnr.ai

{lmnr-0.6.9.dist-info → lmnr-0.6.11.dist-info}/RECORD

@@ -1,14 +1,14 @@
 lmnr/__init__.py,sha256=eJ-gIHEk8KV-BeaU8c9spQww_T2G5_OMu4F8JEzngvA,1281
-lmnr/cli.py,sha256=X5YVOBjitRdZPfcF3qxR4SflgTMZ2wsW6s_yXgvdxkU,5621
+lmnr/cli.py,sha256=uHgLUfN_6eINtUlcQdOtODf2tI9AiwmlhojQF4UMB5Y,6047
 lmnr/opentelemetry_lib/.flake8,sha256=bCxuDlGx3YQ55QHKPiGJkncHanh9qGjQJUujcFa3lAU,150
-lmnr/opentelemetry_lib/__init__.py,sha256=E_NwAWxh3hckZjXTA80hOzmRUL8RvnSYRdcPExwVROc,2056
+lmnr/opentelemetry_lib/__init__.py,sha256=MHT91gFyPte8OHiy18rQuImy4Bee1DXFSR4CH6-B-Wc,2154
 lmnr/opentelemetry_lib/decorators/__init__.py,sha256=45HVoYnHC1Y9D_VSkioDbqD3gm4RPC5sKoztomBI5j8,8496
 lmnr/opentelemetry_lib/opentelemetry/instrumentation/google_genai/__init__.py,sha256=6Fvkc_zZEX1lk8g6ZGFrADLNOL055pkMdO-hEef8qBY,18525
 lmnr/opentelemetry_lib/opentelemetry/instrumentation/google_genai/config.py,sha256=25zevJ7g3MtJP_5gju3jBH7-wg7SbDkktysuUO29ksI,245
 lmnr/opentelemetry_lib/opentelemetry/instrumentation/google_genai/utils.py,sha256=ICQENOiICTKodjZVHhq3H5RIRY5bbuWp_KmzkDNgDRM,7471
-lmnr/opentelemetry_lib/opentelemetry/instrumentation/langgraph/__init__.py,sha256=khLC07QIsU15Sv8_Ax0ePjeTg7yP0vwhxvJIAqhU_4A,3099
+lmnr/opentelemetry_lib/opentelemetry/instrumentation/langgraph/__init__.py,sha256=Jyv9koZdGA4-oTaB7ATB7DaX7aNOY-3YOGL4wX0c7PM,3107
 lmnr/opentelemetry_lib/opentelemetry/instrumentation/langgraph/utils.py,sha256=nf9sJZXnnts4gYZortEiDvwYjYqYJZTAT0zutuP_R6Y,1512
-lmnr/opentelemetry_lib/tracing/__init__.py,sha256=dy3zrgeiZmLX-aLXuRUW8-RGR4FaIdRRKKEVR0eItGs,5662
+lmnr/opentelemetry_lib/tracing/__init__.py,sha256=27QogAe-aHyrVr6b56-DduUm0KEE24K1aV2e1nouTNg,6007
 lmnr/opentelemetry_lib/tracing/_instrument_initializers.py,sha256=RYSp4PxrF8yfG5qy0ALpx1EArLFBPDLQd6H6YeYw184,14567
 lmnr/opentelemetry_lib/tracing/attributes.py,sha256=MvowVluXfCqSIC3Cvx3tWDqB0Cpr9bpSlY91qL4Iy74,1497
 lmnr/opentelemetry_lib/tracing/context_properties.py,sha256=aWbvMdWB4Q7uqc0GGSsjcRXMTcO18aWOaIZe3QyS_aA,2314
@@ -28,31 +28,31 @@ lmnr/sdk/browser/playwright_otel.py,sha256=LFg1iJXbez-BEgEIY9eaO_2T2uR6SxyfFL46f
 lmnr/sdk/browser/pw_utils.py,sha256=nFqVujQb7owVFzT-31_g09CbfbBwUIXKxs3JxuE47ws,10835
 lmnr/sdk/browser/rrweb/rrweb.umd.min.cjs,sha256=Ly2jiwC7hTEtgiXzBpoJNSE1Vkzu0lZPZS8brjusAW0,260896
 lmnr/sdk/browser/utils.py,sha256=SmaHdtKTgQjSX7zs1hyOFxCk2j5WIw1f78pZZN0J48E,2371
-lmnr/sdk/client/asynchronous/async_client.py,sha256=5Hb1Z4tPdUATHgmQ8R6laCqWCxvm5MbxyU4jMmRPnO8,4579
+lmnr/sdk/client/asynchronous/async_client.py,sha256=2mIezUAzUrqk5tCZlzfkID4NzIy_JuyBQtDCAT-2Mro,4585
 lmnr/sdk/client/asynchronous/resources/__init__.py,sha256=9fkjlVJS8zhnCTITjhow173phBdZlyiae-X0LcTSWqM,381
 lmnr/sdk/client/asynchronous/resources/agent.py,sha256=Ong3K2KRLN7agx1_-aZxMGcT_OGF3_ZGtFLm8aPMbYw,17788
 lmnr/sdk/client/asynchronous/resources/base.py,sha256=aJ43Q1rltg23IQaI4eeaZKckxVTgDUbCJrChhQCUEoE,986
 lmnr/sdk/client/asynchronous/resources/browser_events.py,sha256=T-DUbbAfMQ2VqiVfgVplxuTaJZuoNcC1O6RCxdfw7UQ,1163
-lmnr/sdk/client/asynchronous/resources/evals.py,sha256=88PsegaPhqHTuTzMmG9qBrGAgd5peBgdOc_sL9zf2G8,2231
+lmnr/sdk/client/asynchronous/resources/evals.py,sha256=dYFuHmXW_FFNsmKC7_NuhxowzCJVUrRmrxeAJ_7EzOA,5420
 lmnr/sdk/client/asynchronous/resources/tags.py,sha256=VbsBMp120d_8drGFr1Obp4xSRktzPC-3kOYcblZnvKA,2565
 lmnr/sdk/client/synchronous/resources/__init__.py,sha256=hDGyNARdG3J25lLAP8JnlER7r8JL-JQuPN1xdheiCw4,318
 lmnr/sdk/client/synchronous/resources/agent.py,sha256=mnTu6toN2LbgmEhQ-mdZ0CzNAnkrGiksrys0AyMwz2A,17809
 lmnr/sdk/client/synchronous/resources/base.py,sha256=ne1ZZ10UmNkMrECVvClcEJfcFJlSGvaXOC8K6mZTPdY,971
 lmnr/sdk/client/synchronous/resources/browser_events.py,sha256=9rFYWZesXQomnFgbZ590tGFMTaNj0OAzT9RcFwD8q_Y,1135
-lmnr/sdk/client/synchronous/resources/evals.py,sha256=0vOVY6nNZkvhX6kgmpfeeMHWl97YoO1hUiu6CM8XOuM,3540
+lmnr/sdk/client/synchronous/resources/evals.py,sha256=odN9ZfZnUXKzFZJ6AQDrIjEljqnj8aQKP1ivY188WGo,6667
 lmnr/sdk/client/synchronous/resources/tags.py,sha256=cNMEzMDhlBNpI7J4x6xkFAANiNSq-Vuu_zi5NPk2kcA,2485
-lmnr/sdk/client/synchronous/sync_client.py,sha256=kPS14M0e99xMtLQ_yEOJrFpQWhstqARytkGIbfCoNVc,4906
-lmnr/sdk/datasets.py,sha256=jl5Wj5nEI9pww4Jwn4XKF8h0gXBU4TOIrhqNjTJsHZQ,1709
+lmnr/sdk/client/synchronous/sync_client.py,sha256=IIzj-mAwHHoRuUX9KkJtrzTGi5UOygbA8wiA9Aqzf2E,4907
+lmnr/sdk/datasets.py,sha256=P9hRxfl7-I6qhLFFGgU-r_I7RJfLtF6sL56g5fKIbAA,1708
 lmnr/sdk/decorators.py,sha256=1uu9xxBYgblFqlhQqH17cZYq7babAmB1lEtvBgTsP0E,4468
 lmnr/sdk/eval_control.py,sha256=KROUrDhcZTrptRZ-hxvr60_o_Gt_8u045jb4cBXcuoY,184
-lmnr/sdk/evaluations.py,sha256=ORGfoyxGJmqBTW3yd1mslr4TK0rWlySZLT4GlC6gVuI,21313
-lmnr/sdk/laminar.py,sha256=Ha6pJSzUqZQBJNfDtEXwYuMcyRvmsZFj7y3A7f0-Y5I,33785
+lmnr/sdk/evaluations.py,sha256=i5c9wi9ZWV-L7vYbHEnLQC2V34n3tasPRowJAnSr-qQ,21022
+lmnr/sdk/laminar.py,sha256=oOVco_c9ZstT71HsquGsgbtFumXd2Ejz0rl_qpmMlTU,33996
 lmnr/sdk/log.py,sha256=nt_YMmPw1IRbGy0b7q4rTtP4Yo3pQfNxqJPXK3nDSNQ,2213
 lmnr/sdk/types.py,sha256=5tEX7yoemb9wYyXLy4aqdazudO5I8dglU5A-IegDhsQ,12653
 lmnr/sdk/utils.py,sha256=yrcHIhoADf9lWH9qJWZMmkRWYvd0DuxPSLP3mY6YFw0,4327
-lmnr/version.py,sha256=By46D14Qb3GmEacSJyQ3-_aLJmKB4PmhLldX9eaM1Ic,1321
-lmnr-0.6.9.dist-info/LICENSE,sha256=67b_wJHVV1CBaWkrKFWU1wyqTPSdzH77Ls-59631COg,10411
-lmnr-0.6.9.dist-info/METADATA,sha256=SYj_iCKcXXUwR8WgW6qs72jYvwVQCKnA9EjpzaqFjRQ,15131
-lmnr-0.6.9.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-lmnr-0.6.9.dist-info/entry_points.txt,sha256=K1jE20ww4jzHNZLnsfWBvU3YKDGBgbOiYG5Y7ivQcq4,37
-lmnr-0.6.9.dist-info/RECORD,,
+lmnr/version.py,sha256=qnwKwsPBqcM4aZx6FBz8GRvhfVyvAhaXzQqQSfXM-k0,1322
+lmnr-0.6.11.dist-info/LICENSE,sha256=67b_wJHVV1CBaWkrKFWU1wyqTPSdzH77Ls-59631COg,10411
+lmnr-0.6.11.dist-info/METADATA,sha256=DpYsYjFiUQII2I71j7YJv6F10rgBqGsHCfG_lLQQfhQ,15132
+lmnr-0.6.11.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+lmnr-0.6.11.dist-info/entry_points.txt,sha256=K1jE20ww4jzHNZLnsfWBvU3YKDGBgbOiYG5Y7ivQcq4,37
+lmnr-0.6.11.dist-info/RECORD,,