lmnr 0.7.8__tar.gz → 0.7.10__tar.gz

{lmnr-0.7.8 → lmnr-0.7.10}/PKG-INFO

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

{lmnr-0.7.8 → lmnr-0.7.10}/pyproject.toml

@@ -6,7 +6,7 @@
 
 [project]
 name = "lmnr"
-version = "0.7.8"
+version = "0.7.10"
 description = "Python SDK for Laminar"
 authors = [
   { name = "lmnr.ai", email = "founders@lmnr.ai" }

{lmnr-0.7.8 → lmnr-0.7.10}/src/lmnr/opentelemetry_lib/opentelemetry/instrumentation/google_genai/__init__.py

@@ -8,6 +8,7 @@ from typing import AsyncGenerator, Callable, Collection, Generator
 
 from google.genai import types
 
+from lmnr.opentelemetry_lib.decorators import json_dumps
 from lmnr.opentelemetry_lib.tracing.context import (
     get_current_context,
     get_event_attributes_from_context,
@@ -20,9 +21,10 @@ from .schema_utils import SchemaJSONEncoder, process_schema
 from .utils import (
     dont_throw,
     get_content,
+    process_content_union,
+    process_stream_chunk,
     role_from_content_union,
     set_span_attribute,
-    process_content_union,
     to_dict,
     with_tracer_wrapper,
 )
@@ -139,9 +141,7 @@ def _set_request_attributes(span, args, kwargs):
         try:
             set_span_attribute(
                 span,
-                # TODO: change to SpanAttributes.LLM_REQUEST_STRUCTURED_OUTPUT_SCHEMA
-                # when we upgrade to opentelemetry-semantic-conventions-ai>=0.4.10
-                "gen_ai.request.structured_output_schema",
+                SpanAttributes.LLM_REQUEST_STRUCTURED_OUTPUT_SCHEMA,
                 json.dumps(process_schema(schema), cls=SchemaJSONEncoder),
             )
         except Exception:
@@ -150,10 +150,8 @@ def _set_request_attributes(span, args, kwargs):
         try:
             set_span_attribute(
                 span,
-                # TODO: change to SpanAttributes.LLM_REQUEST_STRUCTURED_OUTPUT_SCHEMA
-                # when we upgrade to opentelemetry-semantic-conventions-ai>=0.4.10
-                "gen_ai.request.structured_output_schema",
-                json.dumps(json_schema),
+                SpanAttributes.LLM_REQUEST_STRUCTURED_OUTPUT_SCHEMA,
+                json_dumps(json_schema),
             )
         except Exception:
             pass
@@ -182,7 +180,7 @@ def _set_request_attributes(span, args, kwargs):
         set_span_attribute(
             span,
             f"{SpanAttributes.LLM_REQUEST_FUNCTIONS}.{tool_num}.parameters",
-            json.dumps(tool_dict.get("parameters")),
+            json_dumps(tool_dict.get("parameters")),
         )
 
     if should_send_prompts():
@@ -215,7 +213,7 @@ def _set_request_attributes(span, args, kwargs):
                 (
                     content_str
                     if isinstance(content_str, str)
-                    else json.dumps(content_str)
+                    else json_dumps(content_str)
                 ),
             )
             blocks = (
@@ -248,7 +246,7 @@ def _set_request_attributes(span, args, kwargs):
                 set_span_attribute(
                     span,
                     f"{gen_ai_attributes.GEN_AI_PROMPT}.{i}.tool_calls.{tool_call_index}.arguments",
-                    json.dumps(function_call.get("arguments")),
+                    json_dumps(function_call.get("arguments")),
                 )
                 tool_call_index += 1
 
@@ -300,22 +298,26 @@ def _set_response_attributes(span, response: types.GenerateContentResponse):
             span, f"{gen_ai_attributes.GEN_AI_COMPLETION}.0.role", "model"
         )
         candidates_list = candidates if isinstance(candidates, list) else [candidates]
-        for i, candidate in enumerate(candidates_list):
+        i = 0
+        for candidate in candidates_list:
+            has_content = False
             processed_content = process_content_union(candidate.content)
             content_str = get_content(processed_content)
 
             set_span_attribute(
                 span, f"{gen_ai_attributes.GEN_AI_COMPLETION}.{i}.role", "model"
             )
-            set_span_attribute(
-                span,
-                f"{gen_ai_attributes.GEN_AI_COMPLETION}.{i}.content",
-                (
-                    content_str
-                    if isinstance(content_str, str)
-                    else json.dumps(content_str)
-                ),
-            )
+            if content_str:
+                has_content = True
+                set_span_attribute(
+                    span,
+                    f"{gen_ai_attributes.GEN_AI_COMPLETION}.{i}.content",
+                    (
+                        content_str
+                        if isinstance(content_str, str)
+                        else json_dumps(content_str)
+                    ),
+                )
             blocks = (
                 processed_content
                 if isinstance(processed_content, list)
@@ -328,6 +330,7 @@ def _set_response_attributes(span, response: types.GenerateContentResponse):
                 if not block_dict.get("function_call"):
                     continue
                 function_call = to_dict(block_dict.get("function_call", {}))
+                has_content = True
                 set_span_attribute(
                     span,
                     f"{gen_ai_attributes.GEN_AI_COMPLETION}.{i}.tool_calls.{tool_call_index}.name",
@@ -345,9 +348,11 @@ def _set_response_attributes(span, response: types.GenerateContentResponse):
                 set_span_attribute(
                     span,
                     f"{gen_ai_attributes.GEN_AI_COMPLETION}.{i}.tool_calls.{tool_call_index}.arguments",
-                    json.dumps(function_call.get("arguments")),
+                    json_dumps(function_call.get("arguments")),
                 )
                 tool_call_index += 1
+            if has_content:
+                i += 1
 
 
 @dont_throw
@@ -359,54 +364,45 @@ def _build_from_streaming_response(
     aggregated_usage_metadata = defaultdict(int)
     model_version = None
     for chunk in response:
-        if chunk.model_version:
-            model_version = chunk.model_version
-
-        if chunk.candidates:
-            # Currently gemini throws an error if you pass more than one candidate
-            # with streaming
-            if chunk.candidates and len(chunk.candidates) > 0:
-                final_parts += chunk.candidates[0].content.parts or []
-                role = chunk.candidates[0].content.role or role
-        if chunk.usage_metadata:
-            usage_dict = to_dict(chunk.usage_metadata)
-            # prompt token count is sent in every chunk
-            # (and is less by 1 in the last chunk, so we set it once);
-            # total token count in every chunk is greater by prompt token count than it should be,
-            # thus this awkward logic here
-            if aggregated_usage_metadata.get("prompt_token_count") is None:
-                # or 0, not .get(key, 0), because sometimes the value is explicitly None
-                aggregated_usage_metadata["prompt_token_count"] = (
-                    usage_dict.get("prompt_token_count") or 0
-                )
-                aggregated_usage_metadata["total_token_count"] = (
-                    usage_dict.get("total_token_count") or 0
-                )
-            aggregated_usage_metadata["candidates_token_count"] += (
-                usage_dict.get("candidates_token_count") or 0
-            )
-            aggregated_usage_metadata["total_token_count"] += (
-                usage_dict.get("candidates_token_count") or 0
-            )
+        # Important: do all processing in a separate sync function, that is
+        # wrapped in @dont_throw. If we did it here, the @dont_throw on top of
+        # this function would not be able to catch the errors, as they are
+        # raised later, after the generator is returned, and when it is being
+        # consumed.
+        chunk_result = process_stream_chunk(
+            chunk,
+            role,
+            model_version,
+            aggregated_usage_metadata,
+            final_parts,
+        )
+        # even though process_stream_chunk can't return None, the result can be
+        # None, if the processing throws an error (see @dont_throw)
+        if chunk_result:
+            role = chunk_result["role"]
+            model_version = chunk_result["model_version"]
         yield chunk
 
-    compound_response = types.GenerateContentResponse(
-        candidates=[
-            {
-                "content": {
-                    "parts": final_parts,
-                    "role": role,
-                },
-            }
-        ],
-        usage_metadata=types.GenerateContentResponseUsageMetadataDict(
-            **aggregated_usage_metadata
-        ),
-        model_version=model_version,
-    )
-    if span.is_recording():
-        _set_response_attributes(span, compound_response)
-    span.end()
+    try:
+        compound_response = types.GenerateContentResponse(
+            candidates=[
+                {
+                    "content": {
+                        "parts": final_parts,
+                        "role": role,
+                    },
+                }
+            ],
+            usage_metadata=types.GenerateContentResponseUsageMetadataDict(
+                **aggregated_usage_metadata
+            ),
+            model_version=model_version,
+        )
+        if span.is_recording():
+            _set_response_attributes(span, compound_response)
+    finally:
+        if span.is_recording():
+            span.end()
 
 
 @dont_throw
@@ -418,54 +414,45 @@ async def _abuild_from_streaming_response(
     aggregated_usage_metadata = defaultdict(int)
     model_version = None
     async for chunk in response:
-        if chunk.model_version:
-            model_version = chunk.model_version
-
-        if chunk.candidates:
-            # Currently gemini throws an error if you pass more than one candidate
-            # with streaming
-            if chunk.candidates and len(chunk.candidates) > 0:
-                final_parts += chunk.candidates[0].content.parts or []
-                role = chunk.candidates[0].content.role or role
-        if chunk.usage_metadata:
-            usage_dict = to_dict(chunk.usage_metadata)
-            # prompt token count is sent in every chunk
-            # (and is less by 1 in the last chunk, so we set it once);
-            # total token count in every chunk is greater by prompt token count than it should be,
-            # thus this awkward logic here
-            if aggregated_usage_metadata.get("prompt_token_count") is None:
-                # or 0, not .get(key, 0), because sometimes the value is explicitly None
-                aggregated_usage_metadata["prompt_token_count"] = (
-                    usage_dict.get("prompt_token_count") or 0
-                )
-                aggregated_usage_metadata["total_token_count"] = (
-                    usage_dict.get("total_token_count") or 0
-                )
-            aggregated_usage_metadata["candidates_token_count"] += (
-                usage_dict.get("candidates_token_count") or 0
-            )
-            aggregated_usage_metadata["total_token_count"] += (
-                usage_dict.get("candidates_token_count") or 0
-            )
+        # Important: do all processing in a separate sync function, that is
+        # wrapped in @dont_throw. If we did it here, the @dont_throw on top of
+        # this function would not be able to catch the errors, as they are
+        # raised later, after the generator is returned, and when it is being
+        # consumed.
+        chunk_result = process_stream_chunk(
+            chunk,
+            role,
+            model_version,
+            aggregated_usage_metadata,
+            final_parts,
+        )
+        # even though process_stream_chunk can't return None, the result can be
+        # None, if the processing throws an error (see @dont_throw)
+        if chunk_result:
+            role = chunk_result["role"]
+            model_version = chunk_result["model_version"]
         yield chunk
 
-    compound_response = types.GenerateContentResponse(
-        candidates=[
-            {
-                "content": {
-                    "parts": final_parts,
-                    "role": role,
-                },
-            }
-        ],
-        usage_metadata=types.GenerateContentResponseUsageMetadataDict(
-            **aggregated_usage_metadata
-        ),
-        model_version=model_version,
-    )
-    if span.is_recording():
-        _set_response_attributes(span, compound_response)
-    span.end()
+    try:
+        compound_response = types.GenerateContentResponse(
+            candidates=[
+                {
+                    "content": {
+                        "parts": final_parts,
+                        "role": role,
+                    },
+                }
+            ],
+            usage_metadata=types.GenerateContentResponseUsageMetadataDict(
+                **aggregated_usage_metadata
+            ),
+            model_version=model_version,
+        )
+        if span.is_recording():
+            _set_response_attributes(span, compound_response)
+    finally:
+        if span.is_recording():
+            span.end()
 
 
 @with_tracer_wrapper
@@ -502,7 +489,7 @@ def _wrap(tracer: Tracer, to_wrap, wrapped, instance, args, kwargs):
         span.record_exception(e, attributes=attributes)
         span.set_status(Status(StatusCode.ERROR, str(e)))
         span.end()
-        raise e
+        raise
 
 
 @with_tracer_wrapper
@@ -541,7 +528,7 @@ async def _awrap(tracer: Tracer, to_wrap, wrapped, instance, args, kwargs):
         span.record_exception(e, attributes=attributes)
         span.set_status(Status(StatusCode.ERROR, str(e)))
         span.end()
-        raise e
+        raise
 
 
 class GoogleGenAiSdkInstrumentor(BaseInstrumentor):

{lmnr-0.7.8 → lmnr-0.7.10}/src/lmnr/opentelemetry_lib/opentelemetry/instrumentation/google_genai/schema_utils.py

@@ -10,9 +10,12 @@ DUMMY_CLIENT = BaseApiClient(api_key="dummy")
 
 def process_schema(schema: Any) -> dict[str, Any]:
     # The only thing we need from the client is the t_schema function
-    json_schema = t_schema(DUMMY_CLIENT, schema).json_schema.model_dump(
-        exclude_unset=True, exclude_none=True
-    )
+    try:
+        json_schema = t_schema(DUMMY_CLIENT, schema).json_schema.model_dump(
+            exclude_unset=True, exclude_none=True
+        )
+    except Exception:
+        json_schema = {}
     return json_schema
 
 

{lmnr-0.7.8 → lmnr-0.7.10}/src/lmnr/opentelemetry_lib/opentelemetry/instrumentation/google_genai/utils.py

@@ -1,6 +1,8 @@
 import base64
+from collections import defaultdict
 import logging
 import traceback
+from typing_extensions import TypedDict
 
 from .config import (
     Config,
@@ -33,10 +35,14 @@ class ProcessedContentPart(pydantic.BaseModel):
     image_url: ImageUrl | None = pydantic.Field(default=None)
 
 
-def set_span_attribute(span: Span, name: str, value: str):
-    if value is not None:
-        if value != "":
-            span.set_attribute(name, value)
+class ProcessChunkResult(TypedDict):
+    role: str
+    model_version: str | None
+
+
+def set_span_attribute(span: Span, name: str, value: Any):
+    if value is not None and value != "":
+        span.set_attribute(name, value)
     return
 
 
@@ -84,7 +90,7 @@ def get_content(
     content: (
         ProcessedContentPart | dict | list[ProcessedContentPart | dict] | str | None
     ),
-) -> list[Any] | None:
+) -> dict | list[dict] | None:
     if isinstance(content, dict):
         return content.get("content") or content.get("image_url")
     if isinstance(content, ProcessedContentPart):
@@ -98,7 +104,8 @@ def get_content(
         else:
             return None
     elif isinstance(content, list):
-        return [get_content(item) for item in content]
+        contents_list = [get_content(item) for item in content]
+        return [item for item in contents_list if item is not None]
     elif isinstance(content, str):
         return {
             "type": "text",
@@ -110,9 +117,6 @@ def get_content(
 
 def process_content_union(
     content: types.ContentUnion | types.ContentUnionDict,
-    trace_id: str | None = None,
-    span_id: str | None = None,
-    message_index: int = 0,
 ) -> ProcessedContentPart | dict | list[ProcessedContentPart | dict] | None:
     if isinstance(content, types.Content):
         parts = to_dict(content).get("parts", [])
@@ -123,25 +127,16 @@ def process_content_union(
         return _process_part_union(content)
     elif isinstance(content, dict):
         if "parts" in content:
-            return [
-                _process_part_union(
-                    item, trace_id, span_id, message_index, content_index
-                )
-                for content_index, item in enumerate(content.get("parts", []))
-            ]
+            return [_process_part_union(item) for item in content.get("parts", [])]
         else:
             # Assume it's PartDict
-            return _process_part_union(content, trace_id, span_id, message_index)
+            return _process_part_union(content)
     else:
         return None
 
 
 def _process_part_union(
     content: types.PartDict | types.File | types.Part | str,
-    trace_id: str | None = None,
-    span_id: str | None = None,
-    message_index: int = 0,
-    content_index: int = 0,
 ) -> ProcessedContentPart | dict | None:
     if isinstance(content, str):
         return ProcessedContentPart(content=content)
@@ -154,36 +149,31 @@ def _process_part_union(
         )
         return ProcessedContentPart(content=f"files/{name}")
     elif isinstance(content, (types.Part, dict)):
-        return _process_part(content, trace_id, span_id, message_index, content_index)
+        return _process_part(content)
     else:
         return None
 
 
 def _process_part(
     content: types.Part,
-    trace_id: str | None = None,
-    span_id: str | None = None,
-    message_index: int = 0,
-    content_index: int = 0,
 ) -> ProcessedContentPart | dict | None:
     part_dict = to_dict(content)
     if part_dict.get("inline_data"):
         blob = to_dict(part_dict.get("inline_data"))
-        if blob.get("mime_type").startswith("image/"):
-            return _process_image_item(
-                blob, trace_id, span_id, message_index, content_index
-            )
+        if blob.get("mime_type", "").startswith("image/"):
+            return _process_image_item(blob)
         else:
             # currently, only images are supported
             return ProcessedContentPart(
                 content=blob.get("mime_type") or "unknown_media"
             )
-    elif part_dict.get("function_call"):
+    elif function_call := part_dict.get("function_call"):
+        function_call_dict = to_dict(function_call)
         return ProcessedContentPart(
             function_call=ToolCall(
-                name=part_dict.get("function_call").get("name"),
-                id=part_dict.get("function_call").get("id"),
-                arguments=part_dict.get("function_call").get("args", {}),
+                name=function_call_dict.get("name"),
+                id=function_call_dict.get("id"),
+                arguments=function_call_dict.get("args", {}),
             )
         )
     elif part_dict.get("text") is not None:
@@ -220,26 +210,71 @@ def with_tracer_wrapper(func):
     return _with_tracer
 
 
-def _process_image_item(
-    blob: dict[str, Any],
-    trace_id: str,
-    span_id: str,
-    message_index: int,
-    content_index: int,
-) -> ProcessedContentPart | dict | None:
+def _process_image_item(blob: dict[str, Any]) -> ProcessedContentPart | dict | None:
     # Convert to openai format, so backends can handle it
     data = blob.get("data")
     encoded_data = (
         base64.b64encode(data).decode("utf-8") if isinstance(data, bytes) else data
     )
+    mime_type = blob.get("mime_type", "image/unknown")
+    image_type = mime_type.split("/")[1] if "/" in mime_type else "unknown"
+
     return (
         ProcessedContentPart(
             image_url=ImageUrl(
                 image_url=ImageUrlInner(
-                    url=f"data:image/{blob.get('mime_type').split('/')[1]};base64,{encoded_data}",
+                    url=f"data:image/{image_type};base64,{encoded_data}",
                 )
             )
         )
         if Config.convert_image_to_openai_format
         else blob
     )
+
+
+@dont_throw
+def process_stream_chunk(
+    chunk: types.GenerateContentResponse,
+    existing_role: str,
+    existing_model_version: str | None,
+    # ============================== #
+    # mutable states, passed by reference
+    aggregated_usage_metadata: defaultdict[str, int],
+    final_parts: list[types.Part | None],
+    # ============================== #
+) -> ProcessChunkResult:
+    role = existing_role
+    model_version = existing_model_version
+
+    if chunk.model_version:
+        model_version = chunk.model_version
+
+    # Currently gemini throws an error if you pass more than one candidate
+    # with streaming
+    if chunk.candidates and len(chunk.candidates) > 0 and chunk.candidates[0].content:
+        final_parts += chunk.candidates[0].content.parts or []
+        role = chunk.candidates[0].content.role or role
+    if chunk.usage_metadata:
+        usage_dict = to_dict(chunk.usage_metadata)
+        # prompt token count is sent in every chunk
+        # (and is less by 1 in the last chunk, so we set it once);
+        # total token count in every chunk is greater by prompt token count than it should be,
+        # thus this awkward logic here
+        if aggregated_usage_metadata.get("prompt_token_count") is None:
+            # or 0, not .get(key, 0), because sometimes the value is explicitly None
+            aggregated_usage_metadata["prompt_token_count"] = (
+                usage_dict.get("prompt_token_count") or 0
+            )
+            aggregated_usage_metadata["total_token_count"] = (
+                usage_dict.get("total_token_count") or 0
+            )
+        aggregated_usage_metadata["candidates_token_count"] += (
+            usage_dict.get("candidates_token_count") or 0
+        )
+        aggregated_usage_metadata["total_token_count"] += (
+            usage_dict.get("candidates_token_count") or 0
+        )
+    return ProcessChunkResult(
+        role=role,
+        model_version=model_version,
+    )

{lmnr-0.7.8 → lmnr-0.7.10}/src/lmnr/opentelemetry_lib/tracing/__init__.py

@@ -219,8 +219,19 @@ class TracerWrapper(object):
 
     @classmethod
     def verify_initialized(cls) -> bool:
-        with cls._lock:
-            return hasattr(cls, "instance") and hasattr(cls.instance, "_span_processor")
+        # This is not using lock, but it is fine to return False from here
+        # even if initialization is going on.
+
+        # If we try to acquire the lock here, it may deadlock if an automatic
+        # instrumentation is importing a file that (at the top level) has a
+        # function annotated with Laminar's `observe` decorator.
+        # The decorator is evaluated at import time, inside `init_instrumentations`,
+        # which is called by the `TracerWrapper` constructor while holding the lock.
+        # Without the lock here, we will simply return False, which will cause
+        # the decorator to return the original function. This is fine, at runtime,
+        # the next import statement will re-evaluate the decorator, and Laminar will
+        # have been initialized by that time.
+        return hasattr(cls, "instance") and hasattr(cls.instance, "_span_processor")
 
     @classmethod
     def clear(cls):

{lmnr-0.7.8 → lmnr-0.7.10}/src/lmnr/version.py

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