lmnr 0.6.11__tar.gz → 0.6.12__tar.gz

{lmnr-0.6.11 → lmnr-0.6.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: lmnr
-Version: 0.6.11
+Version: 0.6.12
 Summary: Python SDK for Laminar
 License: Apache-2.0
 Author: lmnr.ai
@@ -46,61 +46,61 @@ Requires-Dist: httpx (>=0.25.0)
 Requires-Dist: opentelemetry-api (>=1.33.0)
 Requires-Dist: opentelemetry-exporter-otlp-proto-grpc (>=1.33.0)
 Requires-Dist: opentelemetry-exporter-otlp-proto-http (>=1.33.0)
-Requires-Dist: opentelemetry-instrumentation-alephalpha (>=0.40.8) ; extra == "alephalpha"
-Requires-Dist: opentelemetry-instrumentation-alephalpha (>=0.40.8) ; extra == "all"
-Requires-Dist: opentelemetry-instrumentation-anthropic (>=0.40.8) ; extra == "all"
-Requires-Dist: opentelemetry-instrumentation-anthropic (>=0.40.8) ; extra == "anthropic"
-Requires-Dist: opentelemetry-instrumentation-bedrock (>=0.40.8) ; extra == "all"
-Requires-Dist: opentelemetry-instrumentation-bedrock (>=0.40.8) ; extra == "bedrock"
-Requires-Dist: opentelemetry-instrumentation-chromadb (>=0.40.8) ; extra == "all"
-Requires-Dist: opentelemetry-instrumentation-chromadb (>=0.40.8) ; extra == "chromadb"
-Requires-Dist: opentelemetry-instrumentation-cohere (>=0.40.8) ; extra == "all"
-Requires-Dist: opentelemetry-instrumentation-cohere (>=0.40.8) ; extra == "cohere"
-Requires-Dist: opentelemetry-instrumentation-crewai (>=0.40.8) ; extra == "all"
-Requires-Dist: opentelemetry-instrumentation-crewai (>=0.40.8) ; extra == "crewai"
-Requires-Dist: opentelemetry-instrumentation-google-generativeai (>=0.40.8) ; extra == "all"
-Requires-Dist: opentelemetry-instrumentation-google-generativeai (>=0.40.8) ; extra == "google-generativeai"
-Requires-Dist: opentelemetry-instrumentation-groq (>=0.40.8) ; extra == "all"
-Requires-Dist: opentelemetry-instrumentation-groq (>=0.40.8) ; extra == "groq"
-Requires-Dist: opentelemetry-instrumentation-haystack (>=0.40.8) ; extra == "all"
-Requires-Dist: opentelemetry-instrumentation-haystack (>=0.40.8) ; extra == "haystack"
-Requires-Dist: opentelemetry-instrumentation-lancedb (>=0.40.8) ; extra == "all"
-Requires-Dist: opentelemetry-instrumentation-lancedb (>=0.40.8) ; extra == "lancedb"
-Requires-Dist: opentelemetry-instrumentation-langchain (>=0.40.8) ; extra == "all"
-Requires-Dist: opentelemetry-instrumentation-langchain (>=0.40.8) ; extra == "langchain"
-Requires-Dist: opentelemetry-instrumentation-llamaindex (>=0.40.8) ; extra == "all"
-Requires-Dist: opentelemetry-instrumentation-llamaindex (>=0.40.8) ; extra == "llamaindex"
-Requires-Dist: opentelemetry-instrumentation-marqo (>=0.40.8) ; extra == "all"
-Requires-Dist: opentelemetry-instrumentation-marqo (>=0.40.8) ; extra == "marqo"
-Requires-Dist: opentelemetry-instrumentation-mcp (>=0.40.8) ; extra == "all"
-Requires-Dist: opentelemetry-instrumentation-mcp (>=0.40.8) ; extra == "mcp"
-Requires-Dist: opentelemetry-instrumentation-milvus (>=0.40.8) ; extra == "all"
-Requires-Dist: opentelemetry-instrumentation-milvus (>=0.40.8) ; extra == "milvus"
-Requires-Dist: opentelemetry-instrumentation-mistralai (>=0.40.8) ; extra == "all"
-Requires-Dist: opentelemetry-instrumentation-mistralai (>=0.40.8) ; extra == "mistralai"
-Requires-Dist: opentelemetry-instrumentation-ollama (>=0.40.8) ; extra == "all"
-Requires-Dist: opentelemetry-instrumentation-ollama (>=0.40.8) ; extra == "ollama"
-Requires-Dist: opentelemetry-instrumentation-openai (>=0.40.8) ; extra == "all"
-Requires-Dist: opentelemetry-instrumentation-openai (>=0.40.8) ; extra == "openai"
-Requires-Dist: opentelemetry-instrumentation-pinecone (>=0.40.8) ; extra == "all"
-Requires-Dist: opentelemetry-instrumentation-pinecone (>=0.40.8) ; extra == "pinecone"
-Requires-Dist: opentelemetry-instrumentation-qdrant (>=0.40.8) ; extra == "all"
-Requires-Dist: opentelemetry-instrumentation-qdrant (>=0.40.8) ; extra == "qdrant"
-Requires-Dist: opentelemetry-instrumentation-replicate (>=0.40.8) ; extra == "all"
-Requires-Dist: opentelemetry-instrumentation-replicate (>=0.40.8) ; extra == "replicate"
-Requires-Dist: opentelemetry-instrumentation-sagemaker (>=0.40.8) ; extra == "all"
-Requires-Dist: opentelemetry-instrumentation-sagemaker (>=0.40.8) ; extra == "sagemaker"
+Requires-Dist: opentelemetry-instrumentation-alephalpha (>=0.40.12) ; extra == "alephalpha"
+Requires-Dist: opentelemetry-instrumentation-alephalpha (>=0.40.12) ; extra == "all"
+Requires-Dist: opentelemetry-instrumentation-anthropic (>=0.40.12) ; extra == "all"
+Requires-Dist: opentelemetry-instrumentation-anthropic (>=0.40.12) ; extra == "anthropic"
+Requires-Dist: opentelemetry-instrumentation-bedrock (>=0.40.12) ; extra == "all"
+Requires-Dist: opentelemetry-instrumentation-bedrock (>=0.40.12) ; extra == "bedrock"
+Requires-Dist: opentelemetry-instrumentation-chromadb (>=0.40.12) ; extra == "all"
+Requires-Dist: opentelemetry-instrumentation-chromadb (>=0.40.12) ; extra == "chromadb"
+Requires-Dist: opentelemetry-instrumentation-cohere (>=0.40.12) ; extra == "all"
+Requires-Dist: opentelemetry-instrumentation-cohere (>=0.40.12) ; extra == "cohere"
+Requires-Dist: opentelemetry-instrumentation-crewai (>=0.40.12) ; extra == "all"
+Requires-Dist: opentelemetry-instrumentation-crewai (>=0.40.12) ; extra == "crewai"
+Requires-Dist: opentelemetry-instrumentation-google-generativeai (>=0.40.12) ; extra == "all"
+Requires-Dist: opentelemetry-instrumentation-google-generativeai (>=0.40.12) ; extra == "google-generativeai"
+Requires-Dist: opentelemetry-instrumentation-groq (>=0.40.12) ; extra == "all"
+Requires-Dist: opentelemetry-instrumentation-groq (>=0.40.12) ; extra == "groq"
+Requires-Dist: opentelemetry-instrumentation-haystack (>=0.40.12) ; extra == "all"
+Requires-Dist: opentelemetry-instrumentation-haystack (>=0.40.12) ; extra == "haystack"
+Requires-Dist: opentelemetry-instrumentation-lancedb (>=0.40.12) ; extra == "all"
+Requires-Dist: opentelemetry-instrumentation-lancedb (>=0.40.12) ; extra == "lancedb"
+Requires-Dist: opentelemetry-instrumentation-langchain (>=0.40.12) ; extra == "all"
+Requires-Dist: opentelemetry-instrumentation-langchain (>=0.40.12) ; extra == "langchain"
+Requires-Dist: opentelemetry-instrumentation-llamaindex (>=0.40.12) ; extra == "all"
+Requires-Dist: opentelemetry-instrumentation-llamaindex (>=0.40.12) ; extra == "llamaindex"
+Requires-Dist: opentelemetry-instrumentation-marqo (>=0.40.12) ; extra == "all"
+Requires-Dist: opentelemetry-instrumentation-marqo (>=0.40.12) ; extra == "marqo"
+Requires-Dist: opentelemetry-instrumentation-mcp (>=0.40.12) ; extra == "all"
+Requires-Dist: opentelemetry-instrumentation-mcp (>=0.40.12) ; extra == "mcp"
+Requires-Dist: opentelemetry-instrumentation-milvus (>=0.40.12) ; extra == "all"
+Requires-Dist: opentelemetry-instrumentation-milvus (>=0.40.12) ; extra == "milvus"
+Requires-Dist: opentelemetry-instrumentation-mistralai (>=0.40.12) ; extra == "all"
+Requires-Dist: opentelemetry-instrumentation-mistralai (>=0.40.12) ; extra == "mistralai"
+Requires-Dist: opentelemetry-instrumentation-ollama (>=0.40.12) ; extra == "all"
+Requires-Dist: opentelemetry-instrumentation-ollama (>=0.40.12) ; extra == "ollama"
+Requires-Dist: opentelemetry-instrumentation-openai (>=0.40.12) ; extra == "all"
+Requires-Dist: opentelemetry-instrumentation-openai (>=0.40.12) ; extra == "openai"
+Requires-Dist: opentelemetry-instrumentation-pinecone (>=0.40.12) ; extra == "all"
+Requires-Dist: opentelemetry-instrumentation-pinecone (>=0.40.12) ; extra == "pinecone"
+Requires-Dist: opentelemetry-instrumentation-qdrant (>=0.40.12) ; extra == "all"
+Requires-Dist: opentelemetry-instrumentation-qdrant (>=0.40.12) ; extra == "qdrant"
+Requires-Dist: opentelemetry-instrumentation-replicate (>=0.40.12) ; extra == "all"
+Requires-Dist: opentelemetry-instrumentation-replicate (>=0.40.12) ; extra == "replicate"
+Requires-Dist: opentelemetry-instrumentation-sagemaker (>=0.40.12) ; extra == "all"
+Requires-Dist: opentelemetry-instrumentation-sagemaker (>=0.40.12) ; extra == "sagemaker"
 Requires-Dist: opentelemetry-instrumentation-threading (>=0.54b0)
-Requires-Dist: opentelemetry-instrumentation-together (>=0.40.8) ; extra == "all"
-Requires-Dist: opentelemetry-instrumentation-together (>=0.40.8) ; extra == "together"
-Requires-Dist: opentelemetry-instrumentation-transformers (>=0.40.8) ; extra == "all"
-Requires-Dist: opentelemetry-instrumentation-transformers (>=0.40.8) ; extra == "transformers"
-Requires-Dist: opentelemetry-instrumentation-vertexai (>=0.40.8) ; extra == "all"
-Requires-Dist: opentelemetry-instrumentation-vertexai (>=0.40.8) ; extra == "vertexai"
-Requires-Dist: opentelemetry-instrumentation-watsonx (>=0.40.8) ; extra == "all"
-Requires-Dist: opentelemetry-instrumentation-watsonx (>=0.40.8) ; extra == "watsonx"
-Requires-Dist: opentelemetry-instrumentation-weaviate (>=0.40.8) ; extra == "all"
-Requires-Dist: opentelemetry-instrumentation-weaviate (>=0.40.8) ; extra == "weaviate"
+Requires-Dist: opentelemetry-instrumentation-together (>=0.40.12) ; extra == "all"
+Requires-Dist: opentelemetry-instrumentation-together (>=0.40.12) ; extra == "together"
+Requires-Dist: opentelemetry-instrumentation-transformers (>=0.40.12) ; extra == "all"
+Requires-Dist: opentelemetry-instrumentation-transformers (>=0.40.12) ; extra == "transformers"
+Requires-Dist: opentelemetry-instrumentation-vertexai (>=0.40.12) ; extra == "all"
+Requires-Dist: opentelemetry-instrumentation-vertexai (>=0.40.12) ; extra == "vertexai"
+Requires-Dist: opentelemetry-instrumentation-watsonx (>=0.40.12) ; extra == "all"
+Requires-Dist: opentelemetry-instrumentation-watsonx (>=0.40.12) ; extra == "watsonx"
+Requires-Dist: opentelemetry-instrumentation-weaviate (>=0.40.12) ; extra == "all"
+Requires-Dist: opentelemetry-instrumentation-weaviate (>=0.40.12) ; extra == "weaviate"
 Requires-Dist: opentelemetry-sdk (>=1.33.0)
 Requires-Dist: opentelemetry-semantic-conventions (>=0.54b0)
 Requires-Dist: opentelemetry-semantic-conventions-ai (>=0.4.8)

lmnr-0.6.12/pyproject.toml

@@ -0,0 +1,143 @@
+# Laminar Python
+
+# If you are looking for information about possible extras installations,
+# i.e. what you can pass into `pip install 'lmnr[extra1,extra2]'`, please see the
+# `[project.optional-dependencies]` section below.
+
+[project]
+name = "lmnr"
+version = "0.6.12"
+description = "Python SDK for Laminar"
+authors = [
+  { name = "lmnr.ai", email = "founders@lmnr.ai" }
+]
+readme = "README.md"
+requires-python = ">=3.10,<4"
+license = "Apache-2.0"
+dependencies = [
+  "pydantic (>=2.0.3,<3.0.0)",
+  "python-dotenv (>=1.0)",
+  "opentelemetry-api (>=1.33.0)",
+  "opentelemetry-sdk (>=1.33.0)",
+  "opentelemetry-exporter-otlp-proto-http (>=1.33.0)",
+  "opentelemetry-exporter-otlp-proto-grpc (>=1.33.0)",
+  "opentelemetry-semantic-conventions (>=0.54b0)",
+  "opentelemetry-semantic-conventions-ai (>=0.4.8)",
+  "tqdm (>=4.0)",
+  "argparse (>=1.0)",
+  "tenacity (>=8.0)",
+  # Since 1.68.0, grpcio writes a warning message
+  # that looks scary, but is harmless.
+  # WARNING: All log messages before absl::InitializeLog() is called are written to STDERR
+  # E0000 00:00:1737439981.199902 9456033 init.cc:229] grpc_wait_for_shutdown_with_timeout() timed out.
+  #
+  # Remove this comment when we make sure that grpcio has resolved this.
+  # Related issue:
+  # https://discuss.ai.google.dev/t/warning-all-log-messages-before-absl-initializelog-is-called-are-written-to-stderr-e0000-001731955515-629532-17124-init-cc-229-grpc-wait-for-shutdown-with-timeout-timed-out/50020
+  # https://github.com/grpc/grpc/issues/38490
+  "grpcio>=1",
+  "httpx>=0.25.0",
+  "opentelemetry-instrumentation-threading>=0.54b0",
+]
+
+[project.scripts]
+lmnr = "lmnr.cli:cli"
+
+[project.optional-dependencies]
+# List of all possible extras. You can specify one or more of these extras
+# when installing the package, using any of the following examples:
+# `pip install 'lmnr[anthropic,openai]'`
+# `uv pip install 'lmnr[anthropic,openai]'`
+# `uv add lmnr --extra anthropic --extra openai`
+# `poetry add 'lmnr[anthropic,openai]'`
+
+alephalpha=["opentelemetry-instrumentation-alephalpha>=0.40.12"]
+anthropic=["opentelemetry-instrumentation-anthropic>=0.40.12"]
+bedrock=["opentelemetry-instrumentation-bedrock>=0.40.12"]
+chromadb=["opentelemetry-instrumentation-chromadb>=0.40.12"]
+cohere=["opentelemetry-instrumentation-cohere>=0.40.12"]
+crewai=["opentelemetry-instrumentation-crewai>=0.40.12"]
+google-generativeai=["opentelemetry-instrumentation-google-generativeai>=0.40.12"]
+groq=["opentelemetry-instrumentation-groq>=0.40.12"]
+haystack=["opentelemetry-instrumentation-haystack>=0.40.12"]
+lancedb=["opentelemetry-instrumentation-lancedb>=0.40.12"]
+langchain=["opentelemetry-instrumentation-langchain>=0.40.12"]
+llamaindex=["opentelemetry-instrumentation-llamaindex>=0.40.12"]
+marqo=["opentelemetry-instrumentation-marqo>=0.40.12"]
+mcp=["opentelemetry-instrumentation-mcp>=0.40.12"]
+milvus=["opentelemetry-instrumentation-milvus>=0.40.12"]
+mistralai=["opentelemetry-instrumentation-mistralai>=0.40.12"]
+ollama=["opentelemetry-instrumentation-ollama>=0.40.12"]
+openai=["opentelemetry-instrumentation-openai>=0.40.12"]
+pinecone=["opentelemetry-instrumentation-pinecone>=0.40.12"]
+qdrant=["opentelemetry-instrumentation-qdrant>=0.40.12"]
+replicate=["opentelemetry-instrumentation-replicate>=0.40.12"]
+sagemaker=["opentelemetry-instrumentation-sagemaker>=0.40.12"]
+together=["opentelemetry-instrumentation-together>=0.40.12"]
+transformers=["opentelemetry-instrumentation-transformers>=0.40.12"]
+vertexai=["opentelemetry-instrumentation-vertexai>=0.40.12"]
+watsonx=["opentelemetry-instrumentation-watsonx>=0.40.12"]
+weaviate=["opentelemetry-instrumentation-weaviate>=0.40.12"]
+# `all` is the group added for convenience, if you want to install all
+# the instrumentations.
+# we suggest using package-manager-specific commands instead,
+# like `uv add lmnr --all-extras`
+all = [
+  "opentelemetry-instrumentation-alephalpha>=0.40.12",
+  "opentelemetry-instrumentation-anthropic>=0.40.12",
+  "opentelemetry-instrumentation-bedrock>=0.40.12",
+  "opentelemetry-instrumentation-chromadb>=0.40.12",
+  "opentelemetry-instrumentation-cohere>=0.40.12",
+  "opentelemetry-instrumentation-crewai>=0.40.12",
+  "opentelemetry-instrumentation-google-generativeai>=0.40.12",
+  "opentelemetry-instrumentation-groq>=0.40.12",
+  "opentelemetry-instrumentation-haystack>=0.40.12",
+  "opentelemetry-instrumentation-lancedb>=0.40.12",
+  "opentelemetry-instrumentation-langchain>=0.40.12",
+  "opentelemetry-instrumentation-llamaindex>=0.40.12",
+  "opentelemetry-instrumentation-marqo>=0.40.12",
+  "opentelemetry-instrumentation-mcp>=0.40.12",
+  "opentelemetry-instrumentation-milvus>=0.40.12",
+  "opentelemetry-instrumentation-mistralai>=0.40.12",
+  "opentelemetry-instrumentation-ollama>=0.40.12",
+  "opentelemetry-instrumentation-openai>=0.40.12",
+  "opentelemetry-instrumentation-pinecone>=0.40.12",
+  "opentelemetry-instrumentation-qdrant>=0.40.12",
+  "opentelemetry-instrumentation-replicate>=0.40.12",
+  "opentelemetry-instrumentation-sagemaker>=0.40.12",
+  "opentelemetry-instrumentation-together>=0.40.12",
+  "opentelemetry-instrumentation-transformers>=0.40.12",
+  "opentelemetry-instrumentation-vertexai>=0.40.12",
+  "opentelemetry-instrumentation-watsonx>=0.40.12",
+  "opentelemetry-instrumentation-weaviate>=0.40.12"
+]
+
+[dependency-groups]
+dev = [
+  "autopep8>=2.3.2",
+  "flake8>=7.2.0",
+  "pytest>=8.3.5",
+  "pytest-sugar>=1.0.0",
+  "pytest-asyncio>=0.26.0",
+  "playwright>=1.52.0",
+  "vcrpy>=7.0.0",
+  "openai>=1.77.0",
+  "pytest-recording>=0.13.4",
+  "patchright>=1.52.3",
+  "google-genai>=1.19.0",
+  "langgraph>=0.4.8",
+  "langchain-core>=0.3.64",
+  "langchain>=0.3.25",
+  "litellm>=1.72.6",
+]
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.uv.workspace]
+members = ["examples/fastapi-app"]
+# we can move to uv_build, once it's more stable
+# https://github.com/astral-sh/uv/issues/3957
+# requires = ["uv_build>=0.6.16,<0.7"]
+# build-backend = "uv_build"

{lmnr-0.6.11 → lmnr-0.6.12}/src/lmnr/__init__.py

@@ -13,6 +13,7 @@ from .sdk.types import (
 )
 from .sdk.decorators import observe
 from .sdk.types import LaminarSpanContext
+from .opentelemetry_lib.litellm import LaminarLiteLLMCallback
 from .opentelemetry_lib.tracing.attributes import Attributes
 from .opentelemetry_lib.tracing.instruments import Instruments
 from .opentelemetry_lib.tracing.processor import LaminarSpanProcessor
@@ -30,6 +31,7 @@ __all__ = [
     "Laminar",
     "LaminarClient",
     "LaminarDataset",
+    "LaminarLiteLLMCallback",
     "LaminarSpanContext",
     "LaminarSpanProcessor",
     "RunAgentResponseChunk",

{lmnr-0.6.11 → lmnr-0.6.12}/src/lmnr/opentelemetry_lib/__init__.py

@@ -7,7 +7,7 @@ from opentelemetry.sdk.resources import SERVICE_NAME
 from lmnr.opentelemetry_lib.tracing.instruments import Instruments
 from lmnr.opentelemetry_lib.tracing import TracerWrapper
 
-MAX_MANUAL_SPAN_PAYLOAD_SIZE = 1024 * 1024  # 1MB
+MAX_MANUAL_SPAN_PAYLOAD_SIZE = 1024 * 1024 * 10  # 10MB
 
 
 class TracerManager:

lmnr-0.6.12/src/lmnr/opentelemetry_lib/litellm/__init__.py

@@ -0,0 +1,371 @@
+"""LiteLLM callback logger for Laminar"""
+
+import json
+from datetime import datetime
+
+from opentelemetry.trace import SpanKind, Status, StatusCode, Tracer
+from lmnr.opentelemetry_lib.litellm.utils import model_as_dict, set_span_attribute
+from lmnr.opentelemetry_lib.tracing import TracerWrapper
+
+from lmnr.opentelemetry_lib.utils.package_check import is_package_installed
+from lmnr.sdk.log import get_default_logger
+
+logger = get_default_logger(__name__)
+
+SUPPORTED_CALL_TYPES = ["completion", "acompletion"]
+
+# Try to import the necessary LiteLLM components and gracefully handle ImportError
+try:
+    if not is_package_installed("litellm"):
+        raise ImportError("LiteLLM is not installed")
+
+    from litellm.integrations.custom_batch_logger import CustomBatchLogger
+
+    class LaminarLiteLLMCallback(CustomBatchLogger):
+        """Custom LiteLLM logger that sends logs to Laminar via OpenTelemetry spans
+
+        Usage:
+            import litellm
+            from lmnr import Laminar, LaminarLiteLLMCallback
+
+            # make sure this comes first
+            Laminar.initialize()
+
+            # Add the logger to LiteLLM callbacks
+            litellm.callbacks = [LaminarLiteLLMCallback()]
+        """
+
+        def __init__(self, **kwargs):
+            super().__init__(**kwargs)
+            if not hasattr(TracerWrapper, "instance") or TracerWrapper.instance is None:
+                raise ValueError("Laminar must be initialized before LiteLLM callback")
+
+        def _get_tracer(self) -> Tracer:
+            if not hasattr(TracerWrapper, "instance") or TracerWrapper.instance is None:
+                raise ValueError("Laminar must be initialized before LiteLLM callback")
+            return TracerWrapper().get_tracer()
+
+        def log_success_event(
+            self, kwargs, response_obj, start_time: datetime, end_time: datetime
+        ):
+            if kwargs.get("call_type") not in SUPPORTED_CALL_TYPES:
+                return
+            try:
+                self._create_span(
+                    kwargs, response_obj, start_time, end_time, is_success=True
+                )
+            except Exception as e:
+                logger.error(f"Error in log_success_event: {e}")
+
+        def log_failure_event(
+            self, kwargs, response_obj, start_time: datetime, end_time: datetime
+        ):
+            if kwargs.get("call_type") not in SUPPORTED_CALL_TYPES:
+                return
+            try:
+                self._create_span(
+                    kwargs, response_obj, start_time, end_time, is_success=False
+                )
+            except Exception as e:
+                logger.error(f"Error in log_failure_event: {e}")
+
+        async def async_log_success_event(
+            self, kwargs, response_obj, start_time: datetime, end_time: datetime
+        ):
+            self.log_success_event(kwargs, response_obj, start_time, end_time)
+
+        async def async_log_failure_event(
+            self, kwargs, response_obj, start_time: datetime, end_time: datetime
+        ):
+            self.log_failure_event(kwargs, response_obj, start_time, end_time)
+
+        def _create_span(
+            self,
+            kwargs,
+            response_obj,
+            start_time: datetime,
+            end_time: datetime,
+            is_success: bool,
+        ):
+            """Create an OpenTelemetry span for the LiteLLM call"""
+            span_name = "litellm.completion"
+            try:
+                tracer = self._get_tracer()
+            except Exception as e:
+                logger.error(f"Error getting tracer: {e}")
+                return
+            span = tracer.start_span(
+                span_name,
+                kind=SpanKind.CLIENT,
+                start_time=int(start_time.timestamp() * 1e9),
+                attributes={
+                    "lmnr.internal.provider": "litellm",
+                },
+            )
+            try:
+                model = kwargs.get("model", "unknown")
+                if kwargs.get("custom_llm_provider"):
+                    set_span_attribute(
+                        span, "gen_ai.system", kwargs["custom_llm_provider"]
+                    )
+
+                messages = kwargs.get("messages", [])
+                self._process_input_messages(span, messages)
+
+                tools = kwargs.get("tools", [])
+                self._process_request_tool_definitions(span, tools)
+
+                set_span_attribute(span, "gen_ai.request.model", model)
+
+                # Add more attributes from kwargs
+                if "temperature" in kwargs:
+                    set_span_attribute(
+                        span, "gen_ai.request.temperature", kwargs["temperature"]
+                    )
+                if "max_tokens" in kwargs:
+                    set_span_attribute(
+                        span, "gen_ai.request.max_tokens", kwargs["max_tokens"]
+                    )
+                if "top_p" in kwargs:
+                    set_span_attribute(span, "gen_ai.request.top_p", kwargs["top_p"])
+
+                if is_success:
+                    span.set_status(Status(StatusCode.OK))
+                    if kwargs.get("complete_streaming_response"):
+                        self._process_success_response(
+                            span,
+                            kwargs.get("complete_streaming_response"),
+                        )
+                    else:
+                        self._process_success_response(span, response_obj)
+                else:
+                    span.set_status(Status(StatusCode.ERROR))
+                    if isinstance(response_obj, Exception):
+                        span.record_exception(response_obj)
+
+            except Exception as e:
+                span.record_exception(e)
+                logger.error(f"Error in Laminar LiteLLM instrumentation: {e}")
+            finally:
+                span.end(int(end_time.timestamp() * 1e9))
+
+        def _process_input_messages(self, span, messages):
+            """Process and set message attributes on the span"""
+            if not isinstance(messages, list):
+                return
+
+            for i, message in enumerate(messages):
+                message_dict = model_as_dict(message)
+                role = message_dict.get("role", "unknown")
+                set_span_attribute(span, f"gen_ai.prompt.{i}.role", role)
+
+                tool_calls = message_dict.get("tool_calls", [])
+                self._process_tool_calls(span, tool_calls, i, is_response=False)
+
+                content = message_dict.get("content", "")
+                if content is None:
+                    continue
+                if isinstance(content, str):
+                    set_span_attribute(span, f"gen_ai.prompt.{i}.content", content)
+                elif isinstance(content, list):
+                    set_span_attribute(
+                        span, f"gen_ai.prompt.{i}.content", json.dumps(content)
+                    )
+                else:
+                    set_span_attribute(
+                        span,
+                        f"gen_ai.prompt.{i}.content",
+                        json.dumps(model_as_dict(content)),
+                    )
+                if role == "tool":
+                    set_span_attribute(
+                        span,
+                        f"gen_ai.prompt.{i}.tool_call_id",
+                        message_dict.get("tool_call_id"),
+                    )
+
+        def _process_request_tool_definitions(self, span, tools):
+            """Process and set tool definitions attributes on the span"""
+            if not isinstance(tools, list):
+                return
+
+            for i, tool in enumerate(tools):
+                tool_dict = model_as_dict(tool)
+                if tool_dict.get("type") != "function":
+                    # TODO: parse other tool types
+                    continue
+
+                function_dict = tool_dict.get("function", {})
+                function_name = function_dict.get("name", "")
+                function_description = function_dict.get("description", "")
+                function_parameters = function_dict.get("parameters", {})
+                set_span_attribute(
+                    span,
+                    f"llm.request.functions.{i}.name",
+                    function_name,
+                )
+                set_span_attribute(
+                    span,
+                    f"llm.request.functions.{i}.description",
+                    function_description,
+                )
+                set_span_attribute(
+                    span,
+                    f"llm.request.functions.{i}.parameters",
+                    json.dumps(function_parameters),
+                )
+
+        def _process_response_usage(self, span, usage):
+            """Process and set usage attributes on the span"""
+            usage_dict = model_as_dict(usage)
+            if (
+                not usage_dict.get("prompt_tokens")
+                and not usage_dict.get("completion_tokens")
+                and not usage_dict.get("total_tokens")
+            ):
+                return
+
+            set_span_attribute(
+                span, "gen_ai.usage.input_tokens", usage_dict.get("prompt_tokens")
+            )
+            set_span_attribute(
+                span, "gen_ai.usage.output_tokens", usage_dict.get("completion_tokens")
+            )
+            set_span_attribute(
+                span, "llm.usage.total_tokens", usage_dict.get("total_tokens")
+            )
+
+            if usage_dict.get("prompt_tokens_details"):
+                details = usage_dict.get("prompt_tokens_details", {})
+                details = model_as_dict(details)
+                if details.get("cached_tokens"):
+                    set_span_attribute(
+                        span,
+                        "gen_ai.usage.cache_read_input_tokens",
+                        details.get("cached_tokens"),
+                    )
+                # TODO: add audio/image/text token details
+            # TODO: add completion tokens details (reasoning tokens)
+
+        def _process_tool_calls(self, span, tool_calls, choice_index, is_response=True):
+            """Process and set tool call attributes on the span"""
+            attr_prefix = "completion" if is_response else "prompt"
+            if not isinstance(tool_calls, list):
+                return
+
+            for j, tool_call in enumerate(tool_calls):
+                tool_call_dict = model_as_dict(tool_call)
+
+                tool_name = tool_call_dict.get(
+                    "name", tool_call_dict.get("function", {}).get("name", "")
+                )
+                set_span_attribute(
+                    span,
+                    f"gen_ai.{attr_prefix}.{choice_index}.tool_calls.{j}.name",
+                    tool_name,
+                )
+
+                call_id = tool_call_dict.get("id", "")
+                set_span_attribute(
+                    span,
+                    f"gen_ai.{attr_prefix}.{choice_index}.tool_calls.{j}.id",
+                    call_id,
+                )
+
+                tool_arguments = tool_call_dict.get(
+                    "arguments", tool_call_dict.get("function", {}).get("arguments", "")
+                )
+                if isinstance(tool_arguments, str):
+                    set_span_attribute(
+                        span,
+                        f"gen_ai.{attr_prefix}.{choice_index}.tool_calls.{j}.arguments",
+                        tool_arguments,
+                    )
+                else:
+                    set_span_attribute(
+                        span,
+                        f"gen_ai.{attr_prefix}.{choice_index}.tool_calls.{j}.arguments",
+                        json.dumps(model_as_dict(tool_arguments)),
+                    )
+
+        def _process_response_choices(self, span, choices):
+            """Process and set choice attributes on the span"""
+            if not isinstance(choices, list):
+                return
+
+            for i, choice in enumerate(choices):
+                choice_dict = model_as_dict(choice)
+                message = choice_dict.get("message", choice_dict)
+
+                role = message.get("role", "unknown")
+                set_span_attribute(span, f"gen_ai.completion.{i}.role", role)
+
+                tool_calls = message.get("tool_calls", [])
+                self._process_tool_calls(span, tool_calls, i, is_response=True)
+
+                content = message.get("content", "")
+                if content is None:
+                    continue
+                if isinstance(content, str):
+                    set_span_attribute(span, f"gen_ai.completion.{i}.content", content)
+                elif isinstance(content, list):
+                    set_span_attribute(
+                        span, f"gen_ai.completion.{i}.content", json.dumps(content)
+                    )
+                else:
+                    set_span_attribute(
+                        span,
+                        f"gen_ai.completion.{i}.content",
+                        json.dumps(model_as_dict(content)),
+                    )
+
+        def _process_success_response(self, span, response_obj):
+            """Process successful response attributes"""
+            response_dict = model_as_dict(response_obj)
+            set_span_attribute(span, "gen_ai.response.id", response_dict.get("id"))
+            set_span_attribute(
+                span, "gen_ai.response.model", response_dict.get("model")
+            )
+
+            if response_dict.get("usage"):
+                self._process_response_usage(span, response_dict.get("usage"))
+
+            if response_dict.get("cache_creation_input_tokens"):
+                set_span_attribute(
+                    span,
+                    "gen_ai.usage.cache_creation_input_tokens",
+                    response_dict.get("cache_creation_input_tokens"),
+                )
+            if response_dict.get("cache_read_input_tokens"):
+                set_span_attribute(
+                    span,
+                    "gen_ai.usage.cache_read_input_tokens",
+                    response_dict.get("cache_read_input_tokens"),
+                )
+
+            if response_dict.get("choices"):
+                self._process_response_choices(span, response_dict.get("choices"))
+
+except ImportError as e:
+    logger.warning(f"LiteLLM callback unavailable: {e}")
+
+    # Create a no-op logger when LiteLLM is not available
+    class LaminarLiteLLMCallback:
+        """No-op logger when LiteLLM is not available"""
+
+        def __init__(self, **kwargs):
+            logger.warning(
+                "LiteLLM is not installed. Install with: pip install litellm"
+            )
+
+        def log_success_event(self, *args, **kwargs):
+            pass
+
+        def log_failure_event(self, *args, **kwargs):
+            pass
+
+        async def async_log_success_event(self, *args, **kwargs):
+            pass
+
+        async def async_log_failure_event(self, *args, **kwargs):
+            pass

lmnr-0.6.12/src/lmnr/opentelemetry_lib/litellm/utils.py

@@ -0,0 +1,18 @@
+from pydantic import BaseModel
+from opentelemetry.sdk.trace import Span
+from opentelemetry.util.types import AttributeValue
+
+
+def model_as_dict(model: BaseModel | dict) -> dict:
+    if isinstance(model, BaseModel) and hasattr(model, "model_dump"):
+        return model.model_dump()
+    elif isinstance(model, dict):
+        return model
+    else:
+        return dict(model)
+
+
+def set_span_attribute(span: Span, key: str, value: AttributeValue | None):
+    if value is None or value == "":
+        return
+    span.set_attribute(key, value)

{lmnr-0.6.11 → lmnr-0.6.12}/src/lmnr/sdk/evaluations.py

@@ -56,7 +56,11 @@ def get_average_scores(results: list[EvaluationResultDatapoint]) -> dict[str, Nu
 
     average_scores = {}
     for key, values in per_score_values.items():
-        average_scores[key] = sum(values) / len(values)
+        scores = [v for v in values if v is not None]
+        
+        # If there are no scores, we don't want to include the key in the average scores
+        if len(scores) > 0:
+            average_scores[key] = sum(scores) / len(scores)
 
     return average_scores
 
@@ -97,8 +101,7 @@ class Evaluation:
         self,
         data: EvaluationDataset | list[Datapoint | dict],
         executor: Any,
-        evaluators: dict[str, EvaluatorFunction],
-        human_evaluators: list[HumanEvaluator] = [],
+        evaluators: dict[str, EvaluatorFunction | HumanEvaluator],
         name: str | None = None,
         group_name: str | None = None,
         concurrency_limit: int = DEFAULT_BATCH_SIZE,
@@ -123,17 +126,15 @@ class Evaluation:
             executor (Callable[..., Any]): The executor function.\
                     Takes the data point + any additional arguments and returns\
                     the output to evaluate.
-            evaluators (dict[str, Callable[..., Any]]): Evaluator functions and\
-                names. Each evaluator function takes the output of the executor\
-                _and_ the target data, and returns a score. The score can be a\
-                single number or a dict of string keys and number values.\
-                If the score is a single number, it will be named after the\
-                evaluator function. Evaluator function names must contain only\
-                letters, digits, hyphens, underscores, or spaces.
-            human_evaluators (list[HumanEvaluator], optional):\
-                [Beta] List of instances of HumanEvaluator. For now, human\
-                evaluator only holds the queue name.
-                Defaults to an empty list.
+            evaluators (dict[str, Callable[..., Any] | HumanEvaluator]): Evaluator\
+                functions and HumanEvaluator instances with names. Each evaluator\
+                function takes the output of the executor _and_ the target data,\
+                and returns a score. The score can be a single number or a dict\
+                of string keys and number values. If the score is a single number,\
+                it will be named after the evaluator function.\
+                HumanEvaluator instances create empty spans for manual evaluation.\
+                Evaluator names must contain only letters, digits, hyphens,\
+                underscores, or spaces.
             name (str | None, optional): Optional name of the evaluation.\
                 Used to identify the evaluation in the group.\
                 If not provided, a random name will be generated.
@@ -194,7 +195,6 @@ class Evaluation:
         self.concurrency_limit = concurrency_limit
         self.batch_size = concurrency_limit
         self._logger = get_default_logger(self.__class__.__name__)
-        self.human_evaluators = human_evaluators
         self.upload_tasks = []
         self.base_http_url = f"{base_url}:{http_port or 443}"
 
@@ -345,24 +345,40 @@ class Evaluation:
             # Iterate over evaluators
             scores: dict[str, Numeric] = {}
             for evaluator_name, evaluator in self.evaluators.items():
-                with L.start_as_current_span(
-                    evaluator_name, input={"output": output, "target": target}
-                ) as evaluator_span:
-                    evaluator_span.set_attribute(SPAN_TYPE, SpanType.EVALUATOR.value)
-                    if is_async(evaluator):
-                        value = await evaluator(output, target)
-                    else:
-                        loop = asyncio.get_event_loop()
-                        value = await loop.run_in_executor(
-                            None, evaluator, output, target
-                        )
-                    L.set_span_output(value)
-
-                # If evaluator returns a single number, use evaluator name as key
-                if isinstance(value, NumericTypes):
-                    scores[evaluator_name] = value
+                # Check if evaluator is a HumanEvaluator instance
+                if isinstance(evaluator, HumanEvaluator):
+                    # Create an empty span for human evaluators
+                    with L.start_as_current_span(
+                        evaluator_name,
+                        input={"output": output, "target": target}
+                    ) as human_evaluator_span:
+                        human_evaluator_span.set_attribute(SPAN_TYPE, SpanType.HUMAN_EVALUATOR.value)
+                        # Human evaluators don't execute automatically, just create the span
+                        L.set_span_output(None)
+                    
+                    # We don't want to save the score for human evaluators
+                    scores[evaluator_name] = None
                 else:
-                    scores.update(value)
+                    # Regular evaluator function
+                    with L.start_as_current_span(
+                        evaluator_name,
+                        input={"output": output, "target": target}
+                    ) as evaluator_span:
+                        evaluator_span.set_attribute(SPAN_TYPE, SpanType.EVALUATOR.value)
+                        if is_async(evaluator):
+                            value = await evaluator(output, target)
+                        else:
+                            loop = asyncio.get_event_loop()
+                            value = await loop.run_in_executor(
+                                None, evaluator, output, target
+                            )
+                        L.set_span_output(value)
+
+                    # If evaluator returns a single number, use evaluator name as key
+                    if isinstance(value, NumericTypes):
+                        scores[evaluator_name] = value
+                    else:
+                        scores.update(value)
 
             trace_id = uuid.UUID(int=evaluation_span.get_span_context().trace_id)
 
@@ -373,10 +389,6 @@ class Evaluation:
             executor_output=output,
             scores=scores,
             trace_id=trace_id,
-            # For now add all human evaluators to all result datapoints
-            # In the future, we will add ways to specify which human evaluators
-            # to add to which result datapoints, e.g. sample some randomly
-            human_evaluators=self.human_evaluators,
             executor_span_id=executor_span_id,
             index=index,
             metadata=datapoint.metadata,
@@ -394,8 +406,7 @@ class Evaluation:
 def evaluate(
     data: EvaluationDataset | list[Datapoint | dict],
     executor: ExecutorFunction,
-    evaluators: dict[str, EvaluatorFunction],
-    human_evaluators: list[HumanEvaluator] = [],
+    evaluators: dict[str, EvaluatorFunction | HumanEvaluator],
     name: str | None = None,
     group_name: str | None = None,
     concurrency_limit: int = DEFAULT_BATCH_SIZE,
@@ -424,18 +435,15 @@ def evaluate(
         executor (Callable[..., Any]): The executor function.\
             Takes the data point + any additional arguments\
             and returns the output to evaluate.
-        evaluators (List[Callable[..., Any]]): 
-            evaluators (dict[str, Callable[..., Any]]): Evaluator functions and\
-                names. Each evaluator function takes the output of the executor\
-                _and_ the target data, and returns a score. The score can be a\
-                single number or a dict of string keys and number values.\
-                If the score is a single number, it will be named after the\
-                evaluator function. Evaluator function names must contain only\
-                letters, digits, hyphens, underscores, or spaces.
-        human_evaluators (list[HumanEvaluator], optional):\
-            [Beta] List of instances of HumanEvaluator. For now, human\
-            evaluator only holds the queue name.
-            Defaults to an empty list.
+        evaluators (dict[str, Callable[..., Any] | HumanEvaluator]): Evaluator\
+            functions and HumanEvaluator instances with names. Each evaluator\
+            function takes the output of the executor _and_ the target data,\
+            and returns a score. The score can be a single number or a dict\
+            of string keys and number values. If the score is a single number,\
+            it will be named after the evaluator function.\
+            HumanEvaluator instances create empty spans for manual evaluation.\
+            Evaluator function names must contain only letters, digits, hyphens,\
+            underscores, or spaces.
         name (str | None, optional): Optional name of the evaluation.\
             Used to identify the evaluation in the group. If not provided, a\
             random name will be generated.
@@ -470,7 +478,6 @@ def evaluate(
         executor=executor,
         evaluators=evaluators,
         group_name=group_name,
-        human_evaluators=human_evaluators,
         name=name,
         concurrency_limit=concurrency_limit,
         project_api_key=project_api_key,

{lmnr-0.6.11 → lmnr-0.6.12}/src/lmnr/sdk/types.py

@@ -9,7 +9,7 @@ import uuid
 
 from enum import Enum
 from opentelemetry.trace import SpanContext, TraceFlags
-from typing import Any, Awaitable, Callable, Literal
+from typing import Any, Awaitable, Callable, Literal, Optional
 
 from .utils import serialize
 
@@ -50,7 +50,7 @@ EvaluatorFunction = Callable[
 
 
 class HumanEvaluator(pydantic.BaseModel):
-    queueName: str
+    pass
 
 
 class InitEvaluationResponse(pydantic.BaseModel):
@@ -94,8 +94,7 @@ class EvaluationResultDatapoint(pydantic.BaseModel):
     data: EvaluationDatapointData
     target: EvaluationDatapointTarget
     executor_output: ExecutorFunctionReturnType
-    scores: dict[str, Numeric]
-    human_evaluators: list[HumanEvaluator] = pydantic.Field(default_factory=list)
+    scores: dict[str, Optional[Numeric]]
     trace_id: uuid.UUID
     executor_span_id: uuid.UUID
     metadata: EvaluationDatapointMetadata = pydantic.Field(default=None)
@@ -112,14 +111,6 @@ class EvaluationResultDatapoint(pydantic.BaseModel):
                 "executorOutput": str(serialize(self.executor_output))[:100],
                 "scores": self.scores,
                 "traceId": str(self.trace_id),
-                "humanEvaluators": [
-                    (
-                        v.model_dump()
-                        if isinstance(v, pydantic.BaseModel)
-                        else serialize(v)
-                    )
-                    for v in self.human_evaluators
-                ],
                 "executorSpanId": str(self.executor_span_id),
                 "index": self.index,
                 "metadata": (
@@ -136,6 +127,7 @@ class SpanType(Enum):
     PIPELINE = "PIPELINE"  # must not be set manually
     EXECUTOR = "EXECUTOR"
     EVALUATOR = "EVALUATOR"
+    HUMAN_EVALUATOR = "HUMAN_EVALUATOR"
     EVALUATION = "EVALUATION"
 
 

{lmnr-0.6.11 → lmnr-0.6.12}/src/lmnr/version.py

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

lmnr-0.6.11/pyproject.toml

@@ -1,142 +0,0 @@
-# Laminar Python
-
-# If you are looking for information about possible extras installations,
-# i.e. what you can pass into `pip install 'lmnr[extra1,extra2]'`, please see the
-# `[project.optional-dependencies]` section below.
-
-[project]
-name = "lmnr"
-version = "0.6.11"
-description = "Python SDK for Laminar"
-authors = [
-  { name = "lmnr.ai", email = "founders@lmnr.ai" }
-]
-readme = "README.md"
-requires-python = ">=3.10,<4"
-license = "Apache-2.0"
-dependencies = [
-  "pydantic (>=2.0.3,<3.0.0)",
-  "python-dotenv (>=1.0)",
-  "opentelemetry-api (>=1.33.0)",
-  "opentelemetry-sdk (>=1.33.0)",
-  "opentelemetry-exporter-otlp-proto-http (>=1.33.0)",
-  "opentelemetry-exporter-otlp-proto-grpc (>=1.33.0)",
-  "opentelemetry-semantic-conventions (>=0.54b0)",
-  "opentelemetry-semantic-conventions-ai (>=0.4.8)",
-  "tqdm (>=4.0)",
-  "argparse (>=1.0)",
-  "tenacity (>=8.0)",
-  # Since 1.68.0, grpcio writes a warning message
-  # that looks scary, but is harmless.
-  # WARNING: All log messages before absl::InitializeLog() is called are written to STDERR
-  # E0000 00:00:1737439981.199902 9456033 init.cc:229] grpc_wait_for_shutdown_with_timeout() timed out.
-  #
-  # Remove this comment when we make sure that grpcio has resolved this.
-  # Related issue:
-  # https://discuss.ai.google.dev/t/warning-all-log-messages-before-absl-initializelog-is-called-are-written-to-stderr-e0000-001731955515-629532-17124-init-cc-229-grpc-wait-for-shutdown-with-timeout-timed-out/50020
-  # https://github.com/grpc/grpc/issues/38490
-  "grpcio>=1",
-  "httpx>=0.25.0",
-  "opentelemetry-instrumentation-threading>=0.54b0",
-]
-
-[project.scripts]
-lmnr = "lmnr.cli:cli"
-
-[project.optional-dependencies]
-# List of all possible extras. You can specify one or more of these extras
-# when installing the package, using any of the following examples:
-# `pip install 'lmnr[anthropic,openai]'`
-# `uv pip install 'lmnr[anthropic,openai]'`
-# `uv add lmnr --extra anthropic --extra openai`
-# `poetry add 'lmnr[anthropic,openai]'`
-
-alephalpha=["opentelemetry-instrumentation-alephalpha>=0.40.8"]
-anthropic=["opentelemetry-instrumentation-anthropic>=0.40.8"]
-bedrock=["opentelemetry-instrumentation-bedrock>=0.40.8"]
-chromadb=["opentelemetry-instrumentation-chromadb>=0.40.8"]
-cohere=["opentelemetry-instrumentation-cohere>=0.40.8"]
-crewai=["opentelemetry-instrumentation-crewai>=0.40.8"]
-google-generativeai=["opentelemetry-instrumentation-google-generativeai>=0.40.8"]
-groq=["opentelemetry-instrumentation-groq>=0.40.8"]
-haystack=["opentelemetry-instrumentation-haystack>=0.40.8"]
-lancedb=["opentelemetry-instrumentation-lancedb>=0.40.8"]
-langchain=["opentelemetry-instrumentation-langchain>=0.40.8"]
-llamaindex=["opentelemetry-instrumentation-llamaindex>=0.40.8"]
-marqo=["opentelemetry-instrumentation-marqo>=0.40.8"]
-mcp=["opentelemetry-instrumentation-mcp>=0.40.8"]
-milvus=["opentelemetry-instrumentation-milvus>=0.40.8"]
-mistralai=["opentelemetry-instrumentation-mistralai>=0.40.8"]
-ollama=["opentelemetry-instrumentation-ollama>=0.40.8"]
-openai=["opentelemetry-instrumentation-openai>=0.40.8"]
-pinecone=["opentelemetry-instrumentation-pinecone>=0.40.8"]
-qdrant=["opentelemetry-instrumentation-qdrant>=0.40.8"]
-replicate=["opentelemetry-instrumentation-replicate>=0.40.8"]
-sagemaker=["opentelemetry-instrumentation-sagemaker>=0.40.8"]
-together=["opentelemetry-instrumentation-together>=0.40.8"]
-transformers=["opentelemetry-instrumentation-transformers>=0.40.8"]
-vertexai=["opentelemetry-instrumentation-vertexai>=0.40.8"]
-watsonx=["opentelemetry-instrumentation-watsonx>=0.40.8"]
-weaviate=["opentelemetry-instrumentation-weaviate>=0.40.8"]
-# `all` is the group added for convenience, if you want to install all
-# the instrumentations.
-# we suggest using package-manager-specific commands instead,
-# like `uv add lmnr --all-extras`
-all = [
-  "opentelemetry-instrumentation-alephalpha>=0.40.8",
-  "opentelemetry-instrumentation-anthropic>=0.40.8",
-  "opentelemetry-instrumentation-bedrock>=0.40.8",
-  "opentelemetry-instrumentation-chromadb>=0.40.8",
-  "opentelemetry-instrumentation-cohere>=0.40.8",
-  "opentelemetry-instrumentation-crewai>=0.40.8",
-  "opentelemetry-instrumentation-google-generativeai>=0.40.8",
-  "opentelemetry-instrumentation-groq>=0.40.8",
-  "opentelemetry-instrumentation-haystack>=0.40.8",
-  "opentelemetry-instrumentation-lancedb>=0.40.8",
-  "opentelemetry-instrumentation-langchain>=0.40.8",
-  "opentelemetry-instrumentation-llamaindex>=0.40.8",
-  "opentelemetry-instrumentation-marqo>=0.40.8",
-  "opentelemetry-instrumentation-mcp>=0.40.8",
-  "opentelemetry-instrumentation-milvus>=0.40.8",
-  "opentelemetry-instrumentation-mistralai>=0.40.8",
-  "opentelemetry-instrumentation-ollama>=0.40.8",
-  "opentelemetry-instrumentation-openai>=0.40.8",
-  "opentelemetry-instrumentation-pinecone>=0.40.8",
-  "opentelemetry-instrumentation-qdrant>=0.40.8",
-  "opentelemetry-instrumentation-replicate>=0.40.8",
-  "opentelemetry-instrumentation-sagemaker>=0.40.8",
-  "opentelemetry-instrumentation-together>=0.40.8",
-  "opentelemetry-instrumentation-transformers>=0.40.8",
-  "opentelemetry-instrumentation-vertexai>=0.40.8",
-  "opentelemetry-instrumentation-watsonx>=0.40.8",
-  "opentelemetry-instrumentation-weaviate>=0.40.8"
-]
-
-[dependency-groups]
-dev = [
-  "autopep8>=2.3.2",
-  "flake8>=7.2.0",
-  "pytest>=8.3.5",
-  "pytest-sugar>=1.0.0",
-  "pytest-asyncio>=0.26.0",
-  "playwright>=1.52.0",
-  "vcrpy>=7.0.0",
-  "openai>=1.77.0",
-  "pytest-recording>=0.13.4",
-  "patchright>=1.52.3",
-  "google-genai>=1.19.0",
-  "langgraph>=0.4.8",
-  "langchain-core>=0.3.64",
-  "langchain>=0.3.25",
-]
-
-[build-system]
-requires = ["poetry-core"]
-build-backend = "poetry.core.masonry.api"
-
-[tool.uv.workspace]
-members = ["examples/fastapi-app"]
-# we can move to uv_build, once it's more stable
-# https://github.com/astral-sh/uv/issues/3957
-# requires = ["uv_build>=0.6.16,<0.7"]
-# build-backend = "uv_build"