lmnr 0.7.13__tar.gz → 0.7.15__tar.gz

{lmnr-0.7.13 → lmnr-0.7.15}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lmnr
-Version: 0.7.13
+Version: 0.7.15
 Summary: Python SDK for Laminar
 Author: lmnr.ai
 Author-email: lmnr.ai <founders@lmnr.ai>

{lmnr-0.7.13 → lmnr-0.7.15}/pyproject.toml

@@ -6,7 +6,7 @@
 
 [project]
 name = "lmnr"
-version = "0.7.13"
+version = "0.7.15"
 description = "Python SDK for Laminar"
 authors = [
   { name = "lmnr.ai", email = "founders@lmnr.ai" }
@@ -124,15 +124,14 @@ dev = [
   "pytest-asyncio>=1.1.0",
   "playwright>=1.52.0",
   "vcrpy>=7.0.0",
-  # litellm breaks with openai>=1.100.0 (as of litellm 1.75.8)
-  "openai>=1.99.7,<1.100.0",
+  "openai>=1.107.0",
   "pytest-recording>=0.13.4",
   "patchright>=1.52.3",
   "google-genai>=1.31.0",
   "langgraph>=0.4.8",
   "langchain-core>=0.3.75",
   "langchain>=0.3.27",
-  "litellm>=1.75.8",
+  "litellm>=1.77.0",
   "groq>=0.30.0",
   "anthropic[bedrock]>=0.60.0",
   "langchain-openai>=0.3.32",

{lmnr-0.7.13 → lmnr-0.7.15}/src/lmnr/opentelemetry_lib/decorators/__init__.py

@@ -225,7 +225,7 @@ def observe_base(
                 detach_context(isolated_ctx_token)
             # span will be ended in the generator
             if isinstance(res, types.GeneratorType):
-                return _handle_generator(span, ctx_token, res)
+                return _handle_generator(span, wrapper, res)
             if isinstance(res, types.AsyncGeneratorType):
                 # async def foo() -> AsyncGenerator[int, None]:
                 # is not considered async in a classical sense in Python,
@@ -234,7 +234,7 @@ def observe_base(
                 # Flags are listed from LSB here:
                 # https://docs.python.org/3/library/inspect.html#inspect-module-co-flags
                 # See also: https://groups.google.com/g/python-tulip/c/6rWweGXLutU?pli=1
-                return _ahandle_generator(span, ctx_token, res)
+                return _ahandle_generator(span, wrapper, res)
 
             _process_output(span, res, ignore_output, output_formatter)
             _cleanup_span(span, wrapper)
@@ -306,7 +306,7 @@ def async_observe_base(
             if isinstance(res, types.AsyncGeneratorType):
                 # probably unreachable, read the comment in the similar
                 # part of the sync wrapper.
-                return await _ahandle_generator(span, ctx_token, res)
+                return await _ahandle_generator(span, wrapper, res)
 
             _process_output(span, res, ignore_output, output_formatter)
             _cleanup_span(span, wrapper)
@@ -317,18 +317,37 @@ def async_observe_base(
     return decorate
 
 
-def _handle_generator(span: Span, wrapper: TracerWrapper, res: Generator):
+def _handle_generator(
+    span: Span,
+    wrapper: TracerWrapper,
+    res: Generator,
+    ignore_output: bool = False,
+    output_formatter: Callable[..., str] | None = None,
+):
+    results = []
     try:
-        yield from res
+        for part in res:
+            results.append(part)
+            yield part
     finally:
+        _process_output(span, results, ignore_output, output_formatter)
         _cleanup_span(span, wrapper)
 
 
-async def _ahandle_generator(span: Span, wrapper: TracerWrapper, res: AsyncGenerator):
+async def _ahandle_generator(
+    span: Span,
+    wrapper: TracerWrapper,
+    res: AsyncGenerator,
+    ignore_output: bool = False,
+    output_formatter: Callable[..., str] | None = None,
+):
+    results = []
     try:
         async for part in res:
+            results.append(part)
             yield part
     finally:
+        _process_output(span, results, ignore_output, output_formatter)
         _cleanup_span(span, wrapper)
 
 

{lmnr-0.7.13 → lmnr-0.7.15}/src/lmnr/opentelemetry_lib/tracing/__init__.py

@@ -55,7 +55,7 @@ class TracerWrapper(object):
         exporter: SpanExporter | None = None,
         instruments: set[Instruments] | None = None,
         block_instruments: set[Instruments] | None = None,
-        base_url: str = "https://api.lmnr.ai",
+        base_url: str | None = None,
         port: int = 8443,
         http_port: int = 443,
         project_api_key: str | None = None,
@@ -69,7 +69,7 @@ class TracerWrapper(object):
         # Silence some opentelemetry warnings
         logging.getLogger("opentelemetry.trace").setLevel(otel_logger_level)
 
-        base_http_url = f"{base_url}:{http_port}"
+        base_http_url = f"{base_url}:{http_port}" if base_url else None
         with cls._lock:
             if not hasattr(cls, "instance"):
                 cls._initialize_logger(cls)
@@ -78,14 +78,18 @@ class TracerWrapper(object):
                 # Store session recording options
                 cls.session_recording_options = session_recording_options or {}
 
-                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,
-                )
+                if project_api_key:
+                    obj._client = LaminarClient(
+                        base_url=base_http_url or "https://api.lmnr.ai",
+                        project_api_key=project_api_key,
+                    )
+                    obj._async_client = AsyncLaminarClient(
+                        base_url=base_http_url or "https://api.lmnr.ai",
+                        project_api_key=project_api_key,
+                    )
+                else:
+                    obj._client = None
+                    obj._async_client = None
 
                 obj._resource = Resource(attributes=TracerWrapper.resource_attributes)
 

{lmnr-0.7.13 → lmnr-0.7.15}/src/lmnr/opentelemetry_lib/tracing/_instrument_initializers.py

@@ -91,6 +91,9 @@ class BrowserUseSessionInstrumentorInitializer(InstrumentorInitializer):
         if version and parse(version) >= parse("0.6.0rc1"):
             from lmnr.sdk.browser.browser_use_cdp_otel import BrowserUseInstrumentor
 
+            if async_client is None:
+                return None
+
             return BrowserUseInstrumentor(async_client)
 
         return None
@@ -348,6 +351,9 @@ class PatchrightInstrumentorInitializer(InstrumentorInitializer):
 
         from lmnr.sdk.browser.patchright_otel import PatchrightInstrumentor
 
+        if client is None and async_client is None:
+            return None
+
         return PatchrightInstrumentor(client, async_client)
 
 
@@ -372,6 +378,9 @@ class PlaywrightInstrumentorInitializer(InstrumentorInitializer):
 
         from lmnr.sdk.browser.playwright_otel import PlaywrightInstrumentor
 
+        if client is None and async_client is None:
+            return None
+
         return PlaywrightInstrumentor(client, async_client)
 
 

{lmnr-0.7.13 → lmnr-0.7.15}/src/lmnr/opentelemetry_lib/tracing/exporter.py

@@ -10,7 +10,10 @@ from opentelemetry.exporter.otlp.proto.http.trace_exporter import (
     OTLPSpanExporter as HTTPOTLPSpanExporter,
 )
 
-from lmnr.sdk.utils import from_env
+from lmnr.sdk.log import get_default_logger
+from lmnr.sdk.utils import from_env, get_otel_env_var, parse_otel_headers
+
+logger = get_default_logger(__name__)
 
 
 class LaminarSpanExporter(SpanExporter):
@@ -39,16 +42,39 @@ class LaminarSpanExporter(SpanExporter):
         final_url = f"{url}:{port or 443}"
         api_key = api_key or from_env("LMNR_PROJECT_API_KEY")
         self.endpoint = final_url
-        self.headers = (
-            {"Authorization": f"Bearer {api_key}"}
-            if force_http
-            else {"authorization": f"Bearer {api_key}"}
-        )
+        if api_key:
+            self.headers = (
+                {"Authorization": f"Bearer {api_key}"}
+                if force_http
+                else {"authorization": f"Bearer {api_key}"}
+            )
+        elif get_otel_env_var("HEADERS"):
+            self.headers = parse_otel_headers(get_otel_env_var("HEADERS"))
+        else:
+            self.headers = {}
         self.timeout = timeout_seconds
         self.force_http = force_http
-        self._init_instance()
+        if get_otel_env_var("ENDPOINT"):
+            if not base_url:
+                self.endpoint = get_otel_env_var("ENDPOINT")
+            else:
+                logger.warning(
+                    "OTEL_ENDPOINT is set, but Laminar base URL is also set. Ignoring OTEL_ENDPOINT."
+                )
+            protocol = get_otel_env_var("PROTOCOL") or "grpc/protobuf"
+            exporter_type = from_env("OTEL_EXPORTER") or "otlp_grpc"
+            self.force_http = (
+                protocol in ("http/protobuf", "http/json")
+                or exporter_type == "otlp_http"
+            )
+        if not self.endpoint:
+            raise ValueError(
+                "Laminar base URL is not set and OTEL_ENDPOINT is not set. Please either\n"
+                "- set the LMNR_BASE_URL environment variable\n"
+                "- set the OTEL_ENDPOINT environment variable\n"
+                "- pass the base_url parameter to Laminar.initialize"
+            )
 
-    def _init_instance(self):
         if self.force_http:
             self.instance = HTTPOTLPSpanExporter(
                 endpoint=self.endpoint,

{lmnr-0.7.13 → lmnr-0.7.15}/src/lmnr/sdk/client/asynchronous/async_client.py

@@ -12,7 +12,7 @@ from lmnr.sdk.client.asynchronous.resources import (
     AsyncBrowserEvents,
     AsyncEvals,
     AsyncTags,
-    AsyncEvaluators
+    AsyncEvaluators,
 )
 from lmnr.sdk.utils import from_env
 
@@ -66,6 +66,26 @@ class AsyncLaminarClient:
         self.__client = httpx.AsyncClient(
             headers=self._headers(),
             timeout=timeout,
+            # Context: If the server responds with a 413, the connection becomes
+            # poisoned and freezes on subsequent requests, and there is no way
+            # to recover or recycle such connection.
+            # Setting max_keepalive_connections to 0 will resolve this, but is
+            # less efficient, as it will create a new connection
+            # (not client, so still better) for each request.
+            #
+            # Note: from my experiments with a simple python server, forcing the
+            # server to read/consume the request payload from the socket seems
+            # to resolve this, but I haven't figured out how to do that in our
+            # real actix-web backend server and whether it makes sense to do so.
+            #
+            # TODO: investigate if there are better ways to fix this rather than
+            # setting keepalive_expiry to 0. Other alternative: migrate to
+            # requests + aiohttp.
+            #
+            # limits=httpx.Limits(
+            #     max_keepalive_connections=0,
+            #     keepalive_expiry=0,
+            # ),
         )
 
         # Initialize resource objects
@@ -157,5 +177,3 @@ class AsyncLaminarClient:
             "Content-Type": "application/json",
             "Accept": "application/json",
         }
-
-

{lmnr-0.7.13 → lmnr-0.7.15}/src/lmnr/sdk/client/asynchronous/resources/evals.py

@@ -1,21 +1,31 @@
 """Evals resource for interacting with Laminar evaluations API."""
 
-from typing import Any
+import urllib
 import uuid
+from typing import Any
 
 from lmnr.sdk.client.asynchronous.resources.base import BaseAsyncResource
+from lmnr.sdk.log import get_default_logger
 from lmnr.sdk.types import (
+    GetDatapointsResponse,
     InitEvaluationResponse,
     EvaluationResultDatapoint,
     PartialEvaluationDatapoint,
 )
+from lmnr.sdk.utils import serialize
+
+INITIAL_EVALUATION_DATAPOINT_MAX_DATA_LENGTH = 16_000_000  # 16MB
+logger = get_default_logger(__name__)
 
 
 class AsyncEvals(BaseAsyncResource):
     """Resource for interacting with Laminar evaluations API."""
 
     async def init(
-        self, name: str | None = None, group_name: str | None = None, metadata: dict[str, Any] | None = None
+        self,
+        name: str | None = None,
+        group_name: str | None = None,
+        metadata: dict[str, Any] | None = None,
     ) -> InitEvaluationResponse:
         """Initialize a new evaluation.
 
@@ -51,7 +61,7 @@ class AsyncEvals(BaseAsyncResource):
     ) -> 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.
@@ -60,7 +70,9 @@ class AsyncEvals(BaseAsyncResource):
         Returns:
             uuid.UUID: The evaluation ID.
         """
-        evaluation = await self.init(name=name, group_name=group_name, metadata=metadata)
+        evaluation = await self.init(
+            name=name, group_name=group_name, metadata=metadata
+        )
         return evaluation.id
 
     async def create_datapoint(
@@ -74,7 +86,7 @@ class AsyncEvals(BaseAsyncResource):
     ) -> uuid.UUID:
         """
         Create a datapoint for an evaluation.
-        
+
         Parameters:
             eval_id (uuid.UUID): The evaluation ID.
             data: The input data for the executor.
@@ -82,13 +94,13 @@ class AsyncEvals(BaseAsyncResource):
             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,
@@ -99,7 +111,7 @@ class AsyncEvals(BaseAsyncResource):
             executor_span_id=uuid.uuid4(),  # Will be updated when executor runs
             metadata=metadata,
         )
-        
+
         await self.save_datapoints(eval_id, [partial_datapoint])
         return datapoint_id
 
@@ -119,18 +131,61 @@ class AsyncEvals(BaseAsyncResource):
         Raises:
             ValueError: If there's an error saving the datapoints.
         """
+        length = INITIAL_EVALUATION_DATAPOINT_MAX_DATA_LENGTH
+        points = [datapoint.to_dict(max_data_length=length) for datapoint in datapoints]
         response = await self._client.post(
             self._base_url + f"/v1/evals/{eval_id}/datapoints",
             json={
-                "points": [datapoint.to_dict() for datapoint in datapoints],
+                "points": points,
                 "groupName": group_name,
             },
             headers=self._headers(),
         )
+        if response.status_code == 413:
+            await self._retry_save_datapoints(eval_id, datapoints, group_name)
+            return
+
         if response.status_code != 200:
-            raise ValueError(f"Error saving evaluation datapoints: {response.text}")
-        
-    
+            raise ValueError(
+                f"Error saving evaluation datapoints: [{response.status_code}] {response.text}"
+            )
+
+    async def get_datapoints(
+        self,
+        dataset_name: str,
+        offset: int,
+        limit: int,
+    ) -> GetDatapointsResponse:
+        """Get datapoints from a dataset.
+
+        Args:
+            dataset_name (str): The name of the dataset.
+            offset (int): The offset to start from.
+            limit (int): The maximum number of datapoints to return.
+
+        Returns:
+            GetDatapointsResponse: The response containing the datapoints.
+
+        Raises:
+            ValueError: If there's an error fetching the datapoints.
+        """
+        params = {"name": dataset_name, "offset": offset, "limit": limit}
+        url = (
+            self._base_url + "/v1/datasets/datapoints?" + urllib.parse.urlencode(params)
+        )
+        response = await self._client.get(url, headers=self._headers())
+        if response.status_code != 200:
+            try:
+                resp_json = response.json()
+                raise ValueError(
+                    f"Error fetching datapoints: [{response.status_code}] {resp_json}"
+                )
+            except Exception:
+                raise ValueError(
+                    f"Error fetching datapoints: [{response.status_code}] {response.text}"
+                )
+        return GetDatapointsResponse.model_validate(response.json())
+
     async def update_datapoint(
         self,
         eval_id: uuid.UUID,
@@ -146,17 +201,59 @@ class AsyncEvals(BaseAsyncResource):
             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,
+                "executorOutput": (
+                    str(serialize(executor_output))[
+                        :INITIAL_EVALUATION_DATAPOINT_MAX_DATA_LENGTH
+                    ]
+                    if executor_output is not None
+                    else None
+                ),
                 "scores": scores,
             },
             headers=self._headers(),
         )
 
         if response.status_code != 200:
-            raise ValueError(f"Error updating evaluation datapoint: {response.text}")
-        
-    
+            raise ValueError(
+                f"Error updating evaluation datapoint: [{response.status_code}] {response.text}"
+            )
+
+    async def _retry_save_datapoints(
+        self,
+        eval_id: uuid.UUID,
+        datapoints: list[EvaluationResultDatapoint | PartialEvaluationDatapoint],
+        group_name: str | None = None,
+        initial_length: int = INITIAL_EVALUATION_DATAPOINT_MAX_DATA_LENGTH,
+        max_retries: int = 20,
+    ):
+        retry = 0
+        length = initial_length
+        while retry < max_retries:
+            retry += 1
+            length = length // 2
+            logger.debug(
+                f"Retrying save datapoints: {retry} of {max_retries}, length: {length}"
+            )
+            if length == 0:
+                raise ValueError("Error saving evaluation datapoints")
+            points = [
+                datapoint.to_dict(max_data_length=length) for datapoint in datapoints
+            ]
+            response = await self._client.post(
+                self._base_url + f"/v1/evals/{eval_id}/datapoints",
+                json={
+                    "points": points,
+                    "groupName": group_name,
+                },
+                headers=self._headers(),
+            )
+            if response.status_code != 413:
+                break
+        if response.status_code != 200:
+            raise ValueError(
+                f"Error saving evaluation datapoints: [{response.status_code}] {response.text}"
+            )

{lmnr-0.7.13 → lmnr-0.7.15}/src/lmnr/sdk/client/synchronous/resources/evals.py

@@ -5,19 +5,27 @@ import urllib.parse
 from typing import Any
 
 from lmnr.sdk.client.synchronous.resources.base import BaseResource
+from lmnr.sdk.log import get_default_logger
 from lmnr.sdk.types import (
-    InitEvaluationResponse,
+    GetDatapointsResponse,
     EvaluationResultDatapoint,
+    InitEvaluationResponse,
     PartialEvaluationDatapoint,
-    GetDatapointsResponse,
 )
+from lmnr.sdk.utils import serialize
+
+INITIAL_EVALUATION_DATAPOINT_MAX_DATA_LENGTH = 16_000_000  # 16MB
+logger = get_default_logger(__name__)
 
 
 class Evals(BaseResource):
     """Resource for interacting with Laminar evaluations API."""
 
     def init(
-        self, name: str | None = None, group_name: str | None = None, metadata: dict[str, Any] | None = None
+        self,
+        name: str | None = None,
+        group_name: str | None = None,
+        metadata: dict[str, Any] | None = None,
     ) -> InitEvaluationResponse:
         """Initialize a new evaluation.
 
@@ -53,7 +61,7 @@ class Evals(BaseResource):
     ) -> 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.
@@ -76,7 +84,7 @@ class Evals(BaseResource):
     ) -> uuid.UUID:
         """
         Create a datapoint for an evaluation.
-        
+
         Parameters:
             eval_id (uuid.UUID): The evaluation ID.
             data: The input data for the executor.
@@ -84,13 +92,13 @@ class Evals(BaseResource):
             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,
@@ -101,7 +109,7 @@ class Evals(BaseResource):
             executor_span_id=uuid.uuid4(),  # Will be updated when executor runs
             metadata=metadata,
         )
-        
+
         self.save_datapoints(eval_id, [partial_datapoint])
         return datapoint_id
 
@@ -121,16 +129,24 @@ class Evals(BaseResource):
         Raises:
             ValueError: If there's an error saving the datapoints.
         """
+        length = INITIAL_EVALUATION_DATAPOINT_MAX_DATA_LENGTH
+        points = [datapoint.to_dict(max_data_length=length) for datapoint in datapoints]
         response = self._client.post(
             self._base_url + f"/v1/evals/{eval_id}/datapoints",
             json={
-                "points": [datapoint.to_dict() for datapoint in datapoints],
+                "points": points,
                 "groupName": group_name,
             },
             headers=self._headers(),
         )
+        if response.status_code == 413:
+            self._retry_save_datapoints(eval_id, datapoints, group_name)
+            return
+
         if response.status_code != 200:
-            raise ValueError(f"Error saving evaluation datapoints: {response.text}")
+            raise ValueError(
+                f"Error saving evaluation datapoints: [{response.status_code}] {response.text}"
+            )
 
     def update_datapoint(
         self,
@@ -147,11 +163,17 @@ class Evals(BaseResource):
             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,
+                "executorOutput": (
+                    str(serialize(executor_output))[
+                        :INITIAL_EVALUATION_DATAPOINT_MAX_DATA_LENGTH
+                    ]
+                    if executor_output is not None
+                    else None
+                ),
                 "scores": scores,
             },
             headers=self._headers(),
@@ -195,3 +217,39 @@ class Evals(BaseResource):
                     f"Error fetching datapoints: [{response.status_code}] {response.text}"
                 )
         return GetDatapointsResponse.model_validate(response.json())
+
+    def _retry_save_datapoints(
+        self,
+        eval_id: uuid.UUID,
+        datapoints: list[EvaluationResultDatapoint | PartialEvaluationDatapoint],
+        group_name: str | None = None,
+        initial_length: int = INITIAL_EVALUATION_DATAPOINT_MAX_DATA_LENGTH,
+        max_retries: int = 20,
+    ):
+        retry = 0
+        length = initial_length
+        while retry < max_retries:
+            retry += 1
+            length = length // 2
+            logger.debug(
+                f"Retrying save datapoints: {retry} of {max_retries}, length: {length}"
+            )
+            if length == 0:
+                raise ValueError("Error saving evaluation datapoints")
+            points = [
+                datapoint.to_dict(max_data_length=length) for datapoint in datapoints
+            ]
+            response = self._client.post(
+                self._base_url + f"/v1/evals/{eval_id}/datapoints",
+                json={
+                    "points": points,
+                    "groupName": group_name,
+                },
+                headers=self._headers(),
+            )
+            if response.status_code != 413:
+                break
+        if response.status_code != 200:
+            raise ValueError(
+                f"Error saving evaluation datapoints: [{response.status_code}] {response.text}"
+            )

{lmnr-0.7.13 → lmnr-0.7.15}/src/lmnr/sdk/client/synchronous/sync_client.py

@@ -71,6 +71,26 @@ class LaminarClient:
         self.__client = httpx.Client(
             headers=self._headers(),
             timeout=timeout,
+            # Context: If the server responds with a 413, the connection becomes
+            # poisoned and freezes on subsequent requests, and there is no way
+            # to recover or recycle such connection.
+            # Setting max_keepalive_connections to 0 will resolve this, but is
+            # less efficient, as it will create a new connection
+            # (not client, so still better) for each request.
+            #
+            # Note: from my experiments with a simple python server, forcing the
+            # server to read/consume the request payload from the socket seems
+            # to resolve this, but I haven't figured out how to do that in our
+            # real actix-web backend server and whether it makes sense to do so.
+            #
+            # TODO: investigate if there are better ways to fix this rather than
+            # setting keepalive_expiry to 0. Other alternative: migrate to
+            # requests + aiohttp.
+            #
+            # limits=httpx.Limits(
+            #     max_keepalive_connections=0,
+            #     keepalive_expiry=0,
+            # ),
         )
 
         # Initialize resource objects
@@ -169,5 +189,3 @@ class LaminarClient:
             "Content-Type": "application/json",
             "Accept": "application/json",
         }
-
-

{lmnr-0.7.13 → lmnr-0.7.15}/src/lmnr/sdk/laminar.py

@@ -23,6 +23,8 @@ from lmnr.opentelemetry_lib.tracing.attributes import (
 )
 from lmnr.opentelemetry_lib import MAX_MANUAL_SPAN_PAYLOAD_SIZE
 from lmnr.opentelemetry_lib.decorators import json_dumps
+from lmnr.sdk.utils import get_otel_env_var
+
 from opentelemetry import trace
 from opentelemetry import context as context_api
 from opentelemetry.trace import INVALID_TRACE_ID, Span, Status, StatusCode, use_span
@@ -140,7 +142,12 @@ class Laminar:
             return
 
         cls.__project_api_key = project_api_key or from_env("LMNR_PROJECT_API_KEY")
-        if not cls.__project_api_key:
+
+        if (
+            not cls.__project_api_key
+            and not get_otel_env_var("ENDPOINT")
+            and not get_otel_env_var("HEADERS")
+        ):
             raise ValueError(
                 "Please initialize the Laminar object with"
                 " your project API key or set the LMNR_PROJECT_API_KEY"
@@ -149,14 +156,15 @@ class Laminar:
 
         cls._initialize_logger()
 
-        url = base_url or from_env("LMNR_BASE_URL") or "https://api.lmnr.ai"
-        url = url.rstrip("/")
-        if not url.startswith("http:") and not url.startswith("https:"):
-            url = f"https://{url}"
-        if match := re.search(r":(\d{1,5})$", url):
-            url = url[: -len(match.group(0))]
-            cls.__logger.info(f"Ignoring port in base URL: {match.group(1)}")
-        http_url = base_http_url or url
+        url = base_url or from_env("LMNR_BASE_URL")
+        if url:
+            url = url.rstrip("/")
+            if not url.startswith("http:") and not url.startswith("https:"):
+                url = f"https://{url}"
+            if match := re.search(r":(\d{1,5})$", url):
+                url = url[: -len(match.group(0))]
+                cls.__logger.info(f"Ignoring port in base URL: {match.group(1)}")
+        http_url = base_http_url or url or "https://api.lmnr.ai"
         if not http_url.startswith("http:") and not http_url.startswith("https:"):
             http_url = f"https://{http_url}"
         if match := re.search(r":(\d{1,5})$", http_url):

{lmnr-0.7.13 → lmnr-0.7.15}/src/lmnr/sdk/types.py

@@ -14,7 +14,7 @@ from typing_extensions import TypedDict  # compatibility with python < 3.12
 
 from .utils import serialize
 
-EVALUATION_DATAPOINT_MAX_DATA_LENGTH = 8_000_000  # 8MB
+DEFAULT_DATAPOINT_MAX_DATA_LENGTH = 16_000_000  # 16MB
 
 
 Numeric = int | float
@@ -79,16 +79,26 @@ class PartialEvaluationDatapoint(pydantic.BaseModel):
     metadata: EvaluationDatapointMetadata = pydantic.Field(default=None)
 
     # uuid is not serializable by default, so we need to convert it to a string
-    def to_dict(self):
+    def to_dict(self, max_data_length: int = DEFAULT_DATAPOINT_MAX_DATA_LENGTH):
+        serialized_data = serialize(self.data)
+        serialized_target = serialize(self.target)
+        # TODO: use json_dumps instead of json.dumps once we
+        # move it to utils so we can avoid circular imports
+        str_data = json.dumps(serialized_data)
+        str_target = json.dumps(serialized_target)
         try:
             return {
                 "id": str(self.id),
-                "data": str(serialize(self.data))[
-                    :EVALUATION_DATAPOINT_MAX_DATA_LENGTH
-                ],
-                "target": str(serialize(self.target))[
-                    :EVALUATION_DATAPOINT_MAX_DATA_LENGTH
-                ],
+                "data": (
+                    str_data[:max_data_length]
+                    if len(str_data) > max_data_length
+                    else serialized_data
+                ),
+                "target": (
+                    str_target[:max_data_length]
+                    if len(str_target) > max_data_length
+                    else serialized_target
+                ),
                 "index": self.index,
                 "traceId": str(self.trace_id),
                 "executorSpanId": str(self.executor_span_id),
@@ -112,21 +122,33 @@ class EvaluationResultDatapoint(pydantic.BaseModel):
     metadata: EvaluationDatapointMetadata = pydantic.Field(default=None)
 
     # uuid is not serializable by default, so we need to convert it to a string
-    def to_dict(self):
+    def to_dict(self, max_data_length: int = DEFAULT_DATAPOINT_MAX_DATA_LENGTH):
         try:
+            serialized_data = serialize(self.data)
+            serialized_target = serialize(self.target)
+            serialized_executor_output = serialize(self.executor_output)
+            str_data = json.dumps(serialized_data)
+            str_target = json.dumps(serialized_target)
+            str_executor_output = json.dumps(serialized_executor_output)
             return {
                 # preserve only preview of the data, target and executor output
                 # (full data is in trace)
                 "id": str(self.id),
-                "data": str(serialize(self.data))[
-                    :EVALUATION_DATAPOINT_MAX_DATA_LENGTH
-                ],
-                "target": str(serialize(self.target))[
-                    :EVALUATION_DATAPOINT_MAX_DATA_LENGTH
-                ],
-                "executorOutput": str(serialize(self.executor_output))[
-                    :EVALUATION_DATAPOINT_MAX_DATA_LENGTH
-                ],
+                "data": (
+                    str_data[:max_data_length]
+                    if len(str_data) > max_data_length
+                    else serialized_data
+                ),
+                "target": (
+                    str_target[:max_data_length]
+                    if len(str_target) > max_data_length
+                    else serialized_target
+                ),
+                "executorOutput": (
+                    str_executor_output[:max_data_length]
+                    if len(str_executor_output) > max_data_length
+                    else serialized_executor_output
+                ),
                 "scores": self.scores,
                 "traceId": str(self.trace_id),
                 "executorSpanId": str(self.executor_span_id),

{lmnr-0.7.13 → lmnr-0.7.15}/src/lmnr/sdk/utils.py

@@ -130,6 +130,57 @@ def is_otel_attribute_value_type(value: typing.Any) -> bool:
     return False
 
 
+def get_otel_env_var(var_name: str) -> str | None:
+    """Get OTEL environment variable with priority order.
+
+    Checks in order:
+    1. OTEL_EXPORTER_OTLP_TRACES_{var_name}
+    2. OTEL_EXPORTER_OTLP_{var_name}
+    3. OTEL_{var_name}
+
+    Args:
+        var_name: The variable name (e.g., 'ENDPOINT', 'HEADERS', 'TIMEOUT')
+
+    Returns:
+        str | None: The environment variable value or None if not found
+    """
+    candidates = [
+        f"OTEL_EXPORTER_OTLP_TRACES_{var_name}",
+        f"OTEL_EXPORTER_OTLP_{var_name}",
+        f"OTEL_{var_name}",
+    ]
+
+    for candidate in candidates:
+        if value := from_env(candidate):
+            return value
+    return None
+
+
+def parse_otel_headers(headers_str: str | None) -> dict[str, str]:
+    """Parse OTEL headers string into dictionary.
+
+    Format: key1=value1,key2=value2
+    Values are URL-decoded.
+
+    Args:
+        headers_str: Headers string in OTEL format
+
+    Returns:
+        dict[str, str]: Parsed headers dictionary
+    """
+    if not headers_str:
+        return {}
+
+    headers = {}
+    for pair in headers_str.split(","):
+        if "=" in pair:
+            key, value = pair.split("=", 1)
+            import urllib.parse
+
+            headers[key.strip()] = urllib.parse.unquote(value.strip())
+    return headers
+
+
 def format_id(id_value: str | int | uuid.UUID) -> str:
     """Format trace/span/evaluation ID to a UUID string, or return valid UUID strings as-is.
 

{lmnr-0.7.13 → lmnr-0.7.15}/src/lmnr/version.py

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