lmnr 0.4.28__py3-none-any.whl → 0.4.29__py3-none-any.whl

lmnr/__init__.py

@@ -1,7 +1,14 @@
 from .sdk.datasets import EvaluationDataset, LaminarDataset
 from .sdk.evaluations import evaluate
 from .sdk.laminar import Laminar
-from .sdk.types import ChatMessage, PipelineRunError, PipelineRunResponse, NodeInput
+from .sdk.types import (
+    ChatMessage,
+    HumanEvaluator,
+    NodeInput,
+    PipelineRunError,
+    PipelineRunResponse,
+)
 from .sdk.decorators import observe
 from .traceloop_sdk import Instruments
 from .traceloop_sdk.tracing.attributes import Attributes
+from opentelemetry.trace import use_span

lmnr/sdk/evaluations.py

@@ -18,6 +18,7 @@ from .types import (
     EvaluationResultDatapoint,
     EvaluatorFunction,
     ExecutorFunction,
+    HumanEvaluator,
     Numeric,
     NumericTypes,
     SpanType,
@@ -99,6 +100,7 @@ class Evaluation:
         data: Union[EvaluationDataset, list[Union[Datapoint, dict]]],
         executor: Any,
         evaluators: dict[str, EvaluatorFunction],
+        human_evaluators: list[HumanEvaluator] = [],
         name: Optional[str] = None,
         group_id: Optional[str] = None,
         batch_size: int = DEFAULT_BATCH_SIZE,
@@ -126,6 +128,10 @@ class Evaluation:
                 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.
             name (Optional[str], optional): Optional name of the evaluation.\
                 Used to identify the evaluation in the group.\
                 If not provided, a random name will be generated.
@@ -159,9 +165,9 @@ class Evaluation:
         if not evaluators:
             raise ValueError("No evaluators provided")
 
-        # TODO: Compile regex once and then reuse it
+        evaluator_name_regex = re.compile(r"^[\w\s-]+$")
         for evaluator_name in evaluators:
-            if not re.match(r"^[\w\s-]+$", evaluator_name):
+            if not evaluator_name_regex.match(evaluator_name):
                 raise ValueError(
                     f'Invalid evaluator key: "{evaluator_name}". '
                     "Keys must only contain letters, digits, hyphens,"
@@ -183,6 +189,7 @@ class Evaluation:
         self.name = name
         self.batch_size = batch_size
         self._logger = get_default_logger(self.__class__.__name__)
+        self.human_evaluators = human_evaluators
         L.initialize(
             project_api_key=project_api_key,
             base_url=base_url,
@@ -202,9 +209,7 @@ class Evaluation:
             return loop.run_until_complete(self._run())
 
     async def _run(self) -> None:
-        self.reporter.start(
-            len(self.data),
-        )
+        self.reporter.start(len(self.data))
 
         try:
             result_datapoints = await self._evaluate_in_batches()
@@ -212,13 +217,19 @@ class Evaluation:
             self.reporter.stopWithError(e)
             self.is_finished = True
             return
-        else:
-            evaluation = L.create_evaluation(
-                data=result_datapoints, group_id=self.group_id, name=self.name
-            )
-            average_scores = get_average_scores(result_datapoints)
-            self.reporter.stop(average_scores, evaluation.projectId, evaluation.id)
-            self.is_finished = True
+
+        # 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
+        for result_datapoint in result_datapoints:
+            result_datapoint.human_evaluators = self.human_evaluators or {}
+
+        evaluation = L.create_evaluation(
+            data=result_datapoints, group_id=self.group_id, name=self.name
+        )
+        average_scores = get_average_scores(result_datapoints)
+        self.reporter.stop(average_scores, evaluation.projectId, evaluation.id)
+        self.is_finished = True
 
     async def _evaluate_in_batches(self) -> list[EvaluationResultDatapoint]:
         result_datapoints = []
@@ -256,6 +267,9 @@ class Evaluation:
                     else self.executor(datapoint.data)
                 )
                 L.set_span_output(output)
+                executor_span_id = uuid.UUID(
+                    int=executor_span.get_span_context().span_id
+                )
             target = datapoint.target
 
             # Iterate over evaluators
@@ -285,6 +299,7 @@ class Evaluation:
                 executor_output=output,
                 scores=scores,
                 trace_id=trace_id,
+                executor_span_id=executor_span_id,
             )
 
 
@@ -292,6 +307,7 @@ def evaluate(
     data: Union[EvaluationDataset, list[Union[Datapoint, dict]]],
     executor: ExecutorFunction,
     evaluators: dict[str, EvaluatorFunction],
+    human_evaluators: list[HumanEvaluator] = [],
     name: Optional[str] = None,
     group_id: Optional[str] = None,
     batch_size: int = DEFAULT_BATCH_SIZE,
@@ -326,6 +342,10 @@ def evaluate(
                 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.
         name (Optional[str], optional): Optional name of the evaluation.\
                         Used to identify the evaluation in the group.\
                         If not provided, a random name will be generated.
@@ -359,6 +379,7 @@ def evaluate(
         executor=executor,
         evaluators=evaluators,
         group_id=group_id,
+        human_evaluators=human_evaluators,
         name=name,
         batch_size=batch_size,
         project_api_key=project_api_key,

lmnr/sdk/laminar.py

@@ -1,3 +1,4 @@
+from contextvars import Context
 import re
 from lmnr.traceloop_sdk.instruments import Instruments
 from opentelemetry import context
@@ -294,6 +295,7 @@ class Laminar:
         name: str,
         input: Any = None,
         span_type: Union[Literal["DEFAULT"], Literal["LLM"]] = "DEFAULT",
+        context: Optional[Context] = None,
     ):
         """Start a new span as the current span. Useful for manual
         instrumentation. If `span_type` is set to `"LLM"`, you should report
@@ -314,10 +316,12 @@ class Laminar:
             span_type (Union[Literal["DEFAULT"], Literal["LLM"]], optional):\
                 type of the span. If you use `"LLM"`, you should report usage\
                 and response attributes manually. Defaults to "DEFAULT".
+            context (Optional[Context], optional): raw OpenTelemetry context\
+                to attach the span to. Defaults to None.
         """
         with get_tracer() as tracer:
             span_path = get_span_path(name)
-            ctx = set_value("span_path", span_path)
+            ctx = set_value("span_path", span_path, context)
             ctx_token = attach(ctx)
             with tracer.start_as_current_span(
                 name,
@@ -338,6 +342,67 @@ class Laminar:
             except Exception:
                 pass
 
+    @classmethod
+    def start_span(
+        cls,
+        name: str,
+        input: Any = None,
+        span_type: Union[Literal["DEFAULT"], Literal["LLM"]] = "DEFAULT",
+        context: Optional[Context] = None,
+    ):
+        """Start a new span. Useful for manual instrumentation.
+        If `span_type` is set to `"LLM"`, you should report usage and response
+        attributes manually. See `Laminar.set_span_attributes` for more
+        information.
+
+        Usage example:
+        ```python
+        from src.lmnr import Laminar, use_span
+        def foo(span):
+            with use_span(span):
+                with Laminar.start_as_current_span("foo_inner"):
+                    some_function()
+        
+        def bar():
+            with use_span(span):
+                openai_client.chat.completions.create()
+        
+        span = Laminar.start_span("outer")
+        foo(span)
+        bar(span)
+        # IMPORTANT: End the span manually
+        span.end()
+        
+        # Results in:
+        # | outer
+        # |   | foo
+        # |   |   | foo_inner
+        # |   | bar
+        # |   |   | openai.chat
+        ```
+
+        Args:
+            name (str): name of the span
+            input (Any, optional): input to the span. Will be sent as an\
+                attribute, so must be json serializable. Defaults to None.
+            span_type (Union[Literal["DEFAULT"], Literal["LLM"]], optional):\
+                type of the span. If you use `"LLM"`, you should report usage\
+                and response attributes manually. Defaults to "DEFAULT".
+            context (Optional[Context], optional): raw OpenTelemetry context\
+                to attach the span to. Defaults to None.
+        """
+        with get_tracer() as tracer:
+            span_path = get_span_path(name)
+            ctx = set_value("span_path", span_path, context)
+            span = tracer.start_span(name, context=ctx)
+            if input is not None:
+                span.set_attribute(
+                    SPAN_INPUT,
+                    json_dumps(input),
+                )
+            span.set_attribute(SPAN_TYPE, span_type)
+            return span
+
     @classmethod
     def set_span_output(cls, output: Any = None):
         """Set the output of the current span. Useful for manual

lmnr/sdk/types.py

@@ -77,18 +77,17 @@ class PipelineRunError(Exception):
             return super().__str__()
 
 
-EvaluationDatapointData = dict[str, Any]
-EvaluationDatapointTarget = dict[str, Any]
-EvaluationDatapointMetadata = Optional[dict[str, Any]]
+EvaluationDatapointData = Any  # non-null, must be JSON-serializable
+EvaluationDatapointTarget = Optional[Any]  # must be JSON-serializable
+EvaluationDatapointMetadata = Optional[Any]  # must be JSON-serializable
 
 
 # EvaluationDatapoint is a single data point in the evaluation
 class Datapoint(pydantic.BaseModel):
-    # input to the executor function. Must be a dict with string keys
+    # input to the executor function.
     data: EvaluationDatapointData
     # input to the evaluator function (alongside the executor output).
-    # Must be a dict with string keys
-    target: EvaluationDatapointTarget
+    target: EvaluationDatapointTarget = pydantic.Field(default=None)
     metadata: EvaluationDatapointMetadata = pydantic.Field(default=None)
 
 
@@ -110,6 +109,13 @@ EvaluatorFunction = Callable[
 ]
 
 
+class HumanEvaluator(pydantic.BaseModel):
+    queueName: str
+
+    def __init__(self, queue_name: str):
+        super().__init__(queueName=queue_name)
+
+
 class CreateEvaluationResponse(pydantic.BaseModel):
     id: uuid.UUID
     createdAt: datetime.datetime
@@ -123,23 +129,31 @@ class EvaluationResultDatapoint(pydantic.BaseModel):
     target: EvaluationDatapointTarget
     executor_output: ExecutorFunctionReturnType
     scores: dict[str, Numeric]
+    human_evaluators: list[HumanEvaluator] = pydantic.Field(default_factory=list)
     trace_id: uuid.UUID
+    executor_span_id: uuid.UUID
 
     # uuid is not serializable by default, so we need to convert it to a string
     def to_dict(self):
-        return {
-            "data": {
-                k: v.model_dump() if isinstance(v, pydantic.BaseModel) else serialize(v)
-                for k, v in self.data.items()
-            },
-            "target": {
-                k: v.model_dump() if isinstance(v, pydantic.BaseModel) else serialize(v)
-                for k, v in self.target.items()
-            },
-            "executorOutput": serialize(self.executor_output),
-            "scores": self.scores,
-            "traceId": str(self.trace_id),
-        }
+        try:
+            return {
+                "data": serialize(self.data),
+                "target": serialize(self.target),
+                "executorOutput": serialize(self.executor_output),
+                "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),
+            }
+        except Exception as e:
+            raise ValueError(f"Error serializing EvaluationResultDatapoint: {e}")
 
 
 class SpanType(Enum):
@@ -153,7 +167,7 @@ class SpanType(Enum):
 
 class TraceType(Enum):
     DEFAULT = "DEFAULT"
-    EVENT = "EVENT"  # must not be set manually
+    EVENT = "EVENT"  # deprecated
     EVALUATION = "EVALUATION"
 
 

lmnr/sdk/utils.py

@@ -50,7 +50,7 @@ def is_iterator(o: typing.Any) -> bool:
 
 
 def serialize(obj: typing.Any) -> dict[str, typing.Any]:
-    def to_dict_inner(o: typing.Any):
+    def serialize_inner(o: typing.Any):
         if isinstance(o, (datetime.datetime, datetime.date)):
             return o.strftime("%Y-%m-%dT%H:%M:%S.%f%z")
         elif o is None:
@@ -68,17 +68,17 @@ def serialize(obj: typing.Any) -> dict[str, typing.Any]:
         elif isinstance(o, pydantic.BaseModel):
             return o.model_dump()
         elif isinstance(o, (tuple, set, frozenset)):
-            return [to_dict_inner(item) for item in o]
+            return [serialize_inner(item) for item in o]
         elif isinstance(o, list):
-            return [to_dict_inner(item) for item in o]
+            return [serialize_inner(item) for item in o]
         elif isinstance(o, dict):
-            return {to_dict_inner(k): to_dict_inner(v) for k, v in o.items()}
+            return {serialize_inner(k): serialize_inner(v) for k, v in o.items()}
         elif isinstance(o, queue.Queue):
             return type(o).__name__
 
         return str(o)
 
-    return to_dict_inner(obj)
+    return serialize_inner(obj)
 
 
 def get_input_from_func_args(

lmnr/traceloop_sdk/instruments.py

@@ -4,27 +4,31 @@ from enum import Enum
 class Instruments(Enum):
     # The list of libraries which will be autoinstrumented
     # if no specific instruments are provided to initialize()
-    OPENAI = "openai"
+    ALEPHALPHA = "alephalpha"
     ANTHROPIC = "anthropic"
-    COHERE = "cohere"
-    PINECONE = "pinecone"
+    BEDROCK = "bedrock"
     CHROMA = "chroma"
+    COHERE = "cohere"
     GOOGLE_GENERATIVEAI = "google_generativeai"
+    GROQ = "groq"
+    HAYSTACK = "haystack"
+    LANCEDB = "lancedb"
     LANGCHAIN = "langchain"
-    MISTRAL = "mistral"
-    OLLAMA = "ollama"
     LLAMA_INDEX = "llama_index"
+    MARQO = "marqo"
     MILVUS = "milvus"
-    TRANSFORMERS = "transformers"
-    TOGETHER = "together"
-    BEDROCK = "bedrock"
+    MISTRAL = "mistral"
+    OLLAMA = "ollama"
+    OPENAI = "openai"
+    PINECONE = "pinecone"
+    QDRANT = "qdrant"
     REPLICATE = "replicate"
+    SAGEMAKER = "sagemaker"
+    TOGETHER = "together"
+    TRANSFORMERS = "transformers"
     VERTEXAI = "vertexai"
     WATSONX = "watsonx"
     WEAVIATE = "weaviate"
-    ALEPHALPHA = "alephalpha"
-    MARQO = "marqo"
-    LANCEDB = "lancedb"
 
     # The following libraries will not be autoinstrumented unless
     # specified explicitly in the initialize() call.

lmnr/traceloop_sdk/tracing/tracing.py

@@ -23,7 +23,6 @@ from opentelemetry.trace import get_tracer_provider, ProxyTracerProvider
 from opentelemetry.context import get_value, attach, set_value
 from opentelemetry.instrumentation.threading import ThreadingInstrumentor
 
-# from lmnr.traceloop_sdk import Telemetry
 from lmnr.traceloop_sdk.instruments import Instruments
 from lmnr.traceloop_sdk.tracing.attributes import (
     ASSOCIATION_PROPERTIES,
@@ -50,6 +49,7 @@ EXCLUDED_URLS = """
     posthog.com,
     sentry.io,
     bedrock-runtime,
+    sagemaker-runtime,
     googleapis.com,
     githubusercontent.com,
     openaipublic.blob.core.windows.net"""
@@ -79,27 +79,9 @@ class TracerWrapper(object):
             obj.__resource = Resource(attributes=TracerWrapper.resource_attributes)
             obj.__tracer_provider = init_tracer_provider(resource=obj.__resource)
             if processor:
-                # Telemetry().capture("tracer:init", {"processor": "custom"})
                 obj.__spans_processor: SpanProcessor = processor
                 obj.__spans_processor_original_on_start = processor.on_start
             else:
-                # if exporter:
-                #     Telemetry().capture(
-                #         "tracer:init",
-                #         {
-                #             "exporter": "custom",
-                #             "processor": "simple" if disable_batch else "batch",
-                #         },
-                #     )
-                # else:
-                #     Telemetry().capture(
-                #         "tracer:init",
-                #         {
-                #             "exporter": TracerWrapper.endpoint,
-                #             "processor": "simple" if disable_batch else "batch",
-                #         },
-                #     )
-
                 obj.__spans_exporter: SpanExporter = (
                     exporter
                     if exporter
@@ -126,99 +108,16 @@ class TracerWrapper(object):
             # this makes sure otel context is propagated so we always want it
             ThreadingInstrumentor().instrument()
 
-            if instruments is None:
-                init_instrumentations(should_enrich_metrics)
-            else:
-                for instrument in instruments:
-                    if instrument == Instruments.OPENAI:
-                        if not init_openai_instrumentor(should_enrich_metrics):
-                            print("Warning: OpenAI library does not exist.")
-                    elif instrument == Instruments.ANTHROPIC:
-                        if not init_anthropic_instrumentor(should_enrich_metrics):
-                            print("Warning: Anthropic library does not exist.")
-                    elif instrument == Instruments.COHERE:
-                        if not init_cohere_instrumentor():
-                            print("Warning: Cohere library does not exist.")
-                    elif instrument == Instruments.PINECONE:
-                        if not init_pinecone_instrumentor():
-                            print("Warning: Pinecone library does not exist.")
-                    elif instrument == Instruments.CHROMA:
-                        if not init_chroma_instrumentor():
-                            print("Warning: Chroma library does not exist.")
-                    elif instrument == Instruments.GOOGLE_GENERATIVEAI:
-                        if not init_google_generativeai_instrumentor():
-                            print(
-                                "Warning: Google Generative AI library does not exist."
-                            )
-                    elif instrument == Instruments.LANGCHAIN:
-                        if not init_langchain_instrumentor():
-                            print("Warning: LangChain library does not exist.")
-                    elif instrument == Instruments.MISTRAL:
-                        if not init_mistralai_instrumentor():
-                            print("Warning: MistralAI library does not exist.")
-                    elif instrument == Instruments.OLLAMA:
-                        if not init_ollama_instrumentor():
-                            print("Warning: Ollama library does not exist.")
-                    elif instrument == Instruments.LLAMA_INDEX:
-                        if not init_llama_index_instrumentor():
-                            print("Warning: LlamaIndex library does not exist.")
-                    elif instrument == Instruments.MILVUS:
-                        if not init_milvus_instrumentor():
-                            print("Warning: Milvus library does not exist.")
-                    elif instrument == Instruments.TRANSFORMERS:
-                        if not init_transformers_instrumentor():
-                            print("Warning: Transformers library does not exist.")
-                    elif instrument == Instruments.TOGETHER:
-                        if not init_together_instrumentor():
-                            print("Warning: TogetherAI library does not exist.")
-                    elif instrument == Instruments.REQUESTS:
-                        if not init_requests_instrumentor():
-                            print("Warning: Requests library does not exist.")
-                    elif instrument == Instruments.URLLIB3:
-                        if not init_urllib3_instrumentor():
-                            print("Warning: urllib3 library does not exist.")
-                    elif instrument == Instruments.PYMYSQL:
-                        if not init_pymysql_instrumentor():
-                            print("Warning: PyMySQL library does not exist.")
-                    elif instrument == Instruments.BEDROCK:
-                        if not init_bedrock_instrumentor(should_enrich_metrics):
-                            print("Warning: Bedrock library does not exist.")
-                    elif instrument == Instruments.REPLICATE:
-                        if not init_replicate_instrumentor():
-                            print("Warning: Replicate library does not exist.")
-                    elif instrument == Instruments.VERTEXAI:
-                        if not init_vertexai_instrumentor():
-                            print("Warning: Vertex AI library does not exist.")
-                    elif instrument == Instruments.WATSONX:
-                        if not init_watsonx_instrumentor():
-                            print("Warning: Watsonx library does not exist.")
-                    elif instrument == Instruments.WEAVIATE:
-                        if not init_weaviate_instrumentor():
-                            print("Warning: Weaviate library does not exist.")
-                    elif instrument == Instruments.ALEPHALPHA:
-                        if not init_alephalpha_instrumentor():
-                            print("Warning: Aleph Alpha library does not exist.")
-                    elif instrument == Instruments.MARQO:
-                        if not init_marqo_instrumentor():
-                            print("Warning: marqo library does not exist.")
-                    elif instrument == Instruments.LANCEDB:
-                        if not init_lancedb_instrumentor():
-                            print("Warning: LanceDB library does not exist.")
-                    elif instrument == Instruments.REDIS:
-                        if not init_redis_instrumentor():
-                            print("Warning: redis library does not exist.")
-
-                    else:
-                        print(
-                            "Warning: "
-                            + instrument
-                            + " instrumentation does not exist."
-                        )
-                        print(
-                            "Usage:\n"
-                            + "from lmnr.traceloop_sdk.instruments import Instruments\n"
-                            + 'Traceloop.init(app_name="...", instruments=set([Instruments.OPENAI]))'
-                        )
+            instrument_set = init_instrumentations(
+                should_enrich_metrics,
+                instruments,
+            )
+
+            if not instrument_set:
+                logging.warning(
+                    "Warning: No valid instruments set. Remove 'instrument' "
+                    "argument to use all instruments, or set a valid instrument."
+                )
 
             obj.__content_allow_list = ContentAllowList()
 
@@ -364,47 +263,140 @@ def init_tracer_provider(resource: Resource) -> TracerProvider:
     return provider
 
 
-def init_instrumentations(should_enrich_metrics: bool):
-    init_openai_instrumentor(should_enrich_metrics)
-    init_anthropic_instrumentor(should_enrich_metrics)
-    init_cohere_instrumentor()
-    init_pinecone_instrumentor()
-    init_qdrant_instrumentor()
-    init_chroma_instrumentor()
-    init_google_generativeai_instrumentor()
-    init_haystack_instrumentor()
-    init_langchain_instrumentor()
-    init_mistralai_instrumentor()
-    init_ollama_instrumentor()
-    init_llama_index_instrumentor()
-    init_milvus_instrumentor()
-    init_transformers_instrumentor()
-    init_together_instrumentor()
-    init_bedrock_instrumentor(should_enrich_metrics)
-    init_replicate_instrumentor()
-    init_vertexai_instrumentor()
-    init_watsonx_instrumentor()
-    init_weaviate_instrumentor()
-    init_alephalpha_instrumentor()
-    init_marqo_instrumentor()
-    init_lancedb_instrumentor()
-    init_groq_instrumentor()
-
-    # These libraries are not instrumented by default, but if the user wants, he can manually specify them
-    # init_redis_instrumentor()
-    # init_requests_instrumentor()
-    # init_urllib3_instrumentor()
-    # init_pymysql_instrumentor()
+def init_instrumentations(
+    should_enrich_metrics: bool,
+    instruments: Optional[Set[Instruments]] = None,
+    block_instruments: Optional[Set[Instruments]] = None,
+):
+    block_instruments = block_instruments or set()
+    # These libraries are not instrumented by default,
+    # but if the user wants, they can manually specify them
+    default_off_instruments = set(
+        [
+            Instruments.REQUESTS,
+            Instruments.URLLIB3,
+            Instruments.REDIS,
+            Instruments.PYMYSQL,
+        ]
+    )
+
+    instruments = instruments or (set(Instruments) - default_off_instruments)
+
+    # Remove any instruments that were explicitly blocked
+    instruments = instruments - block_instruments
+
+    instrument_set = False
+    for instrument in instruments:
+        if instrument == Instruments.ALEPHALPHA:
+            if init_alephalpha_instrumentor():
+                instrument_set = True
+        elif instrument == Instruments.ANTHROPIC:
+            if init_anthropic_instrumentor(should_enrich_metrics):
+                instrument_set = True
+        elif instrument == Instruments.BEDROCK:
+            if init_bedrock_instrumentor(should_enrich_metrics):
+                instrument_set = True
+        elif instrument == Instruments.CHROMA:
+            if init_chroma_instrumentor():
+                instrument_set = True
+        elif instrument == Instruments.COHERE:
+            if init_cohere_instrumentor():
+                instrument_set = True
+        elif instrument == Instruments.GOOGLE_GENERATIVEAI:
+            if init_google_generativeai_instrumentor():
+                instrument_set = True
+        elif instrument == Instruments.GROQ:
+            if init_groq_instrumentor():
+                instrument_set = True
+        elif instrument == Instruments.HAYSTACK:
+            if init_haystack_instrumentor():
+                instrument_set = True
+        elif instrument == Instruments.LANCEDB:
+            if init_lancedb_instrumentor():
+                instrument_set = True
+        elif instrument == Instruments.LANGCHAIN:
+            if init_langchain_instrumentor():
+                instrument_set = True
+        elif instrument == Instruments.LLAMA_INDEX:
+            if init_llama_index_instrumentor():
+                instrument_set = True
+        elif instrument == Instruments.MARQO:
+            if init_marqo_instrumentor():
+                instrument_set = True
+        elif instrument == Instruments.MILVUS:
+            if init_milvus_instrumentor():
+                instrument_set = True
+        elif instrument == Instruments.MISTRAL:
+            if init_mistralai_instrumentor():
+                instrument_set = True
+        elif instrument == Instruments.OLLAMA:
+            if init_ollama_instrumentor():
+                instrument_set = True
+        elif instrument == Instruments.OPENAI:
+            if init_openai_instrumentor(should_enrich_metrics):
+                instrument_set = True
+        elif instrument == Instruments.PINECONE:
+            if init_pinecone_instrumentor():
+                instrument_set = True
+        elif instrument == Instruments.PYMYSQL:
+            if init_pymysql_instrumentor():
+                instrument_set = True
+        elif instrument == Instruments.QDRANT:
+            if init_qdrant_instrumentor():
+                instrument_set = True
+        elif instrument == Instruments.REDIS:
+            if init_redis_instrumentor():
+                instrument_set = True
+        elif instrument == Instruments.REPLICATE:
+            if init_replicate_instrumentor():
+                instrument_set = True
+        elif instrument == Instruments.REQUESTS:
+            if init_requests_instrumentor():
+                instrument_set = True
+        elif instrument == Instruments.SAGEMAKER:
+            if init_sagemaker_instrumentor(should_enrich_metrics):
+                instrument_set = True
+        elif instrument == Instruments.TOGETHER:
+            if init_together_instrumentor():
+                instrument_set = True
+        elif instrument == Instruments.TRANSFORMERS:
+            if init_transformers_instrumentor():
+                instrument_set = True
+        elif instrument == Instruments.URLLIB3:
+            if init_urllib3_instrumentor():
+                instrument_set = True
+        elif instrument == Instruments.VERTEXAI:
+            if init_vertexai_instrumentor():
+                instrument_set = True
+        elif instrument == Instruments.WATSONX:
+            if init_watsonx_instrumentor():
+                instrument_set = True
+        elif instrument == Instruments.WEAVIATE:
+            if init_weaviate_instrumentor():
+                instrument_set = True
+        else:
+            logging.warning(f"Warning: {instrument} instrumentation does not exist.")
+            logging.warning(
+                "Usage:\n"
+                "from lmnr import Laminar, Instruments\n"
+                "Laminar.init(instruments=set([Instruments.OPENAI]))"
+            )
+
+    if not instrument_set:
+        logging.warning(
+            "Warning: No valid instruments set. "
+            + "Specify instruments or remove 'instruments' argument to use all instruments."
+        )
+
+    return instrument_set
 
 
 def init_openai_instrumentor(should_enrich_metrics: bool):
     try:
         if is_package_installed("openai"):
-            # Telemetry().capture("instrumentation:openai:init")
             from opentelemetry.instrumentation.openai import OpenAIInstrumentor
 
             instrumentor = OpenAIInstrumentor(
-                # exception_logger=lambda e: Telemetry().log_exception(e),
                 enrich_assistant=should_enrich_metrics,
                 enrich_token_usage=should_enrich_metrics,
             )
@@ -414,18 +406,15 @@ def init_openai_instrumentor(should_enrich_metrics: bool):
 
     except Exception as e:
         logging.error(f"Error initializing OpenAI instrumentor: {e}")
-        # Telemetry().log_exception(e)
         return False
 
 
 def init_anthropic_instrumentor(should_enrich_metrics: bool):
     try:
         if is_package_installed("anthropic"):
-            # Telemetry().capture("instrumentation:anthropic:init")
             from opentelemetry.instrumentation.anthropic import AnthropicInstrumentor
 
             instrumentor = AnthropicInstrumentor(
-                # exception_logger=lambda e: Telemetry().log_exception(e),
                 enrich_token_usage=should_enrich_metrics,
                 upload_base64_image=None,
             )
@@ -434,246 +423,193 @@ def init_anthropic_instrumentor(should_enrich_metrics: bool):
         return True
     except Exception as e:
         logging.error(f"Error initializing Anthropic instrumentor: {e}")
-        # Telemetry().log_exception(e)
         return False
 
 
 def init_cohere_instrumentor():
     try:
         if is_package_installed("cohere"):
-            # Telemetry().capture("instrumentation:cohere:init")
             from opentelemetry.instrumentation.cohere import CohereInstrumentor
 
-            instrumentor = CohereInstrumentor(
-                # exception_logger=lambda e: Telemetry().log_exception(e),
-            )
+            instrumentor = CohereInstrumentor()
             if not instrumentor.is_instrumented_by_opentelemetry:
                 instrumentor.instrument()
         return True
     except Exception as e:
         logging.error(f"Error initializing Cohere instrumentor: {e}")
-        # Telemetry().log_exception(e)
         return False
 
 
 def init_pinecone_instrumentor():
     try:
         if is_package_installed("pinecone"):
-            # Telemetry().capture("instrumentation:pinecone:init")
             from opentelemetry.instrumentation.pinecone import PineconeInstrumentor
 
-            instrumentor = PineconeInstrumentor(
-                # exception_logger=lambda e: Telemetry().log_exception(e),
-            )
+            instrumentor = PineconeInstrumentor()
             if not instrumentor.is_instrumented_by_opentelemetry:
                 instrumentor.instrument()
         return True
     except Exception as e:
         logging.error(f"Error initializing Pinecone instrumentor: {e}")
-        # Telemetry().log_exception(e)
         return False
 
 
 def init_qdrant_instrumentor():
     try:
         if is_package_installed("qdrant_client"):
-            # Telemetry().capture("instrumentation:qdrant:init")
             from opentelemetry.instrumentation.qdrant import QdrantInstrumentor
 
-            instrumentor = QdrantInstrumentor(
-                # exception_logger=lambda e: Telemetry().log_exception(e),
-            )
+            instrumentor = QdrantInstrumentor()
             if not instrumentor.is_instrumented_by_opentelemetry:
                 instrumentor.instrument()
     except Exception as e:
         logging.error(f"Error initializing Qdrant instrumentor: {e}")
-        # Telemetry().log_exception(e)
         return False
 
 
 def init_chroma_instrumentor():
     try:
         if is_package_installed("chromadb"):
-            # Telemetry().capture("instrumentation:chromadb:init")
             from opentelemetry.instrumentation.chromadb import ChromaInstrumentor
 
-            instrumentor = ChromaInstrumentor(
-                # exception_logger=lambda e: Telemetry().log_exception(e),
-            )
+            instrumentor = ChromaInstrumentor()
             if not instrumentor.is_instrumented_by_opentelemetry:
                 instrumentor.instrument()
         return True
     except Exception as e:
         logging.error(f"Error initializing Chroma instrumentor: {e}")
-        # Telemetry().log_exception(e)
         return False
 
 
 def init_google_generativeai_instrumentor():
     try:
         if is_package_installed("google.generativeai"):
-            # Telemetry().capture("instrumentation:gemini:init")
             from opentelemetry.instrumentation.google_generativeai import (
                 GoogleGenerativeAiInstrumentor,
             )
 
-            instrumentor = GoogleGenerativeAiInstrumentor(
-                # exception_logger=lambda e: Telemetry().log_exception(e),
-            )
+            instrumentor = GoogleGenerativeAiInstrumentor()
             if not instrumentor.is_instrumented_by_opentelemetry:
                 instrumentor.instrument()
         return True
     except Exception as e:
         logging.error(f"Error initializing Gemini instrumentor: {e}")
-        # Telemetry().log_exception(e)
         return False
 
 
 def init_haystack_instrumentor():
     try:
         if is_package_installed("haystack"):
-            # Telemetry().capture("instrumentation:haystack:init")
             from opentelemetry.instrumentation.haystack import HaystackInstrumentor
 
-            instrumentor = HaystackInstrumentor(
-                # exception_logger=lambda e: Telemetry().log_exception(e),
-            )
+            instrumentor = HaystackInstrumentor()
             if not instrumentor.is_instrumented_by_opentelemetry:
                 instrumentor.instrument()
         return True
     except Exception as e:
         logging.error(f"Error initializing Haystack instrumentor: {e}")
-        # Telemetry().log_exception(e)
         return False
 
 
 def init_langchain_instrumentor():
     try:
         if is_package_installed("langchain"):
-            # Telemetry().capture("instrumentation:langchain:init")
             from opentelemetry.instrumentation.langchain import LangchainInstrumentor
 
-            instrumentor = LangchainInstrumentor(
-                # exception_logger=lambda e: Telemetry().log_exception(e),
-            )
+            instrumentor = LangchainInstrumentor()
             if not instrumentor.is_instrumented_by_opentelemetry:
                 instrumentor.instrument()
         return True
     except Exception as e:
-        # FIXME: silence this error temporarily, it appears to not be critical
+        # FIXME: silencing this error temporarily, it appears to not be critical
         if str(e) != "No module named 'langchain_community'":
             logging.error(f"Error initializing LangChain instrumentor: {e}")
-        # Telemetry().log_exception(e)
         return False
 
 
 def init_mistralai_instrumentor():
     try:
         if is_package_installed("mistralai"):
-            # Telemetry().capture("instrumentation:mistralai:init")
             from opentelemetry.instrumentation.mistralai import MistralAiInstrumentor
 
-            instrumentor = MistralAiInstrumentor(
-                # exception_logger=lambda e: Telemetry().log_exception(e),
-            )
+            instrumentor = MistralAiInstrumentor()
             if not instrumentor.is_instrumented_by_opentelemetry:
                 instrumentor.instrument()
         return True
     except Exception as e:
         logging.error(f"Error initializing MistralAI instrumentor: {e}")
-        # Telemetry().log_exception(e)
         return False
 
 
 def init_ollama_instrumentor():
     try:
         if is_package_installed("ollama"):
-            # Telemetry().capture("instrumentation:ollama:init")
             from opentelemetry.instrumentation.ollama import OllamaInstrumentor
 
-            instrumentor = OllamaInstrumentor(
-                # exception_logger=lambda e: Telemetry().log_exception(e),
-            )
+            instrumentor = OllamaInstrumentor()
             if not instrumentor.is_instrumented_by_opentelemetry:
                 instrumentor.instrument()
         return True
     except Exception as e:
         logging.error(f"Error initializing Ollama instrumentor: {e}")
-        # Telemetry().log_exception(e)
         return False
 
 
 def init_transformers_instrumentor():
     try:
         if is_package_installed("transformers"):
-            # Telemetry().capture("instrumentation:transformers:init")
             from opentelemetry.instrumentation.transformers import (
                 TransformersInstrumentor,
             )
 
-            instrumentor = TransformersInstrumentor(
-                # exception_logger=lambda e: Telemetry().log_exception(e),
-            )
+            instrumentor = TransformersInstrumentor()
             if not instrumentor.is_instrumented_by_opentelemetry:
                 instrumentor.instrument()
         return True
     except Exception as e:
         logging.error(f"Error initializing Transformers instrumentor: {e}")
-        # Telemetry().log_exception(e)
         return False
 
 
 def init_together_instrumentor():
     try:
         if is_package_installed("together"):
-            # Telemetry().capture("instrumentation:together:init")
             from opentelemetry.instrumentation.together import TogetherAiInstrumentor
 
-            instrumentor = TogetherAiInstrumentor(
-                # exception_logger=lambda e: Telemetry().log_exception(e),
-            )
+            instrumentor = TogetherAiInstrumentor()
             if not instrumentor.is_instrumented_by_opentelemetry:
                 instrumentor.instrument()
         return True
     except Exception as e:
         logging.error(f"Error initializing TogetherAI instrumentor: {e}")
-        # Telemetry().log_exception(e)
         return False
 
 
 def init_llama_index_instrumentor():
     try:
         if is_package_installed("llama-index") or is_package_installed("llama_index"):
-            # Telemetry().capture("instrumentation:llamaindex:init")
             from opentelemetry.instrumentation.llamaindex import LlamaIndexInstrumentor
 
-            instrumentor = LlamaIndexInstrumentor(
-                # exception_logger=lambda e: Telemetry().log_exception(e),
-            )
+            instrumentor = LlamaIndexInstrumentor()
             if not instrumentor.is_instrumented_by_opentelemetry:
                 instrumentor.instrument()
         return True
     except Exception as e:
         logging.error(f"Error initializing LlamaIndex instrumentor: {e}")
-        # Telemetry().log_exception(e)
         return False
 
 
 def init_milvus_instrumentor():
     try:
         if is_package_installed("pymilvus"):
-            # Telemetry().capture("instrumentation:milvus:init")
             from opentelemetry.instrumentation.milvus import MilvusInstrumentor
 
-            instrumentor = MilvusInstrumentor(
-                # exception_logger=lambda e: Telemetry().log_exception(e),
-            )
+            instrumentor = MilvusInstrumentor()
             if not instrumentor.is_instrumented_by_opentelemetry:
                 instrumentor.instrument()
         return True
     except Exception as e:
         logging.error(f"Error initializing Milvus instrumentor: {e}")
-        # Telemetry().log_exception(e)
         return False
 
 
@@ -688,7 +624,6 @@ def init_requests_instrumentor():
         return True
     except Exception as e:
         logging.error(f"Error initializing Requests instrumentor: {e}")
-        # Telemetry().log_exception(e)
         return False
 
 
@@ -703,7 +638,6 @@ def init_urllib3_instrumentor():
         return True
     except Exception as e:
         logging.error(f"Error initializing urllib3 instrumentor: {e}")
-        # Telemetry().log_exception(e)
         return False
 
 
@@ -718,7 +652,6 @@ def init_pymysql_instrumentor():
         return True
     except Exception as e:
         logging.error(f"Error initializing SQLAlchemy instrumentor: {e}")
-        # Telemetry().log_exception(e)
         return False
 
 
@@ -728,7 +661,6 @@ def init_bedrock_instrumentor(should_enrich_metrics: bool):
             from opentelemetry.instrumentation.bedrock import BedrockInstrumentor
 
             instrumentor = BedrockInstrumentor(
-                # exception_logger=lambda e: Telemetry().log_exception(e),
                 enrich_token_usage=should_enrich_metrics,
             )
             if not instrumentor.is_instrumented_by_opentelemetry:
@@ -736,43 +668,34 @@ def init_bedrock_instrumentor(should_enrich_metrics: bool):
         return True
     except Exception as e:
         logging.error(f"Error initializing Bedrock instrumentor: {e}")
-        # Telemetry().log_exception(e)
         return False
 
 
 def init_replicate_instrumentor():
     try:
         if is_package_installed("replicate"):
-            # Telemetry().capture("instrumentation:replicate:init")
             from opentelemetry.instrumentation.replicate import ReplicateInstrumentor
 
-            instrumentor = ReplicateInstrumentor(
-                # exception_logger=lambda e: Telemetry().log_exception(e),
-            )
+            instrumentor = ReplicateInstrumentor()
             if not instrumentor.is_instrumented_by_opentelemetry:
                 instrumentor.instrument()
         return True
     except Exception as e:
         logging.error(f"Error initializing Replicate instrumentor: {e}")
-        # Telemetry().log_exception(e)
         return False
 
 
 def init_vertexai_instrumentor():
     try:
         if is_package_installed("vertexai"):
-            # Telemetry().capture("instrumentation:vertexai:init")
             from opentelemetry.instrumentation.vertexai import VertexAIInstrumentor
 
-            instrumentor = VertexAIInstrumentor(
-                # exception_logger=lambda e: Telemetry().log_exception(e),
-            )
+            instrumentor = VertexAIInstrumentor()
             if not instrumentor.is_instrumented_by_opentelemetry:
                 instrumentor.instrument()
         return True
     except Exception as e:
         logging.warning(f"Error initializing Vertex AI instrumentor: {e}")
-        # Telemetry().log_exception(e)
         return False
 
 
@@ -781,84 +704,65 @@ def init_watsonx_instrumentor():
         if is_package_installed("ibm-watsonx-ai") or is_package_installed(
             "ibm-watson-machine-learning"
         ):
-            # Telemetry().capture("instrumentation:watsonx:init")
             from opentelemetry.instrumentation.watsonx import WatsonxInstrumentor
 
-            instrumentor = WatsonxInstrumentor(
-                # exception_logger=lambda e: Telemetry().log_exception(e),
-            )
+            instrumentor = WatsonxInstrumentor()
             if not instrumentor.is_instrumented_by_opentelemetry:
                 instrumentor.instrument()
         return True
     except Exception as e:
         logging.warning(f"Error initializing Watsonx instrumentor: {e}")
-        # Telemetry().log_exception(e)
         return False
 
 
 def init_weaviate_instrumentor():
     try:
         if is_package_installed("weaviate"):
-            # Telemetry().capture("instrumentation:weaviate:init")
             from opentelemetry.instrumentation.weaviate import WeaviateInstrumentor
 
-            instrumentor = WeaviateInstrumentor(
-                # exception_logger=lambda e: Telemetry().log_exception(e),
-            )
+            instrumentor = WeaviateInstrumentor()
             if not instrumentor.is_instrumented_by_opentelemetry:
                 instrumentor.instrument()
         return True
     except Exception as e:
         logging.warning(f"Error initializing Weaviate instrumentor: {e}")
-        # Telemetry().log_exception(e)
         return False
 
 
 def init_alephalpha_instrumentor():
     try:
         if is_package_installed("aleph_alpha_client"):
-            # Telemetry().capture("instrumentation:alephalpha:init")
             from opentelemetry.instrumentation.alephalpha import AlephAlphaInstrumentor
 
-            instrumentor = AlephAlphaInstrumentor(
-                # exception_logger=lambda e: Telemetry().log_exception(e),
-            )
+            instrumentor = AlephAlphaInstrumentor()
             if not instrumentor.is_instrumented_by_opentelemetry:
                 instrumentor.instrument()
         return True
     except Exception as e:
         logging.error(f"Error initializing Aleph Alpha instrumentor: {e}")
-        # Telemetry().log_exception(e)
         return False
 
 
 def init_marqo_instrumentor():
     try:
         if is_package_installed("marqo"):
-            # Telemetry().capture("instrumentation:marqo:init")
             from opentelemetry.instrumentation.marqo import MarqoInstrumentor
 
-            instrumentor = MarqoInstrumentor(
-                # exception_logger=lambda e: Telemetry().log_exception(e),
-            )
+            instrumentor = MarqoInstrumentor()
             if not instrumentor.is_instrumented_by_opentelemetry:
                 instrumentor.instrument()
         return True
     except Exception as e:
         logging.error(f"Error initializing marqo instrumentor: {e}")
-        # Telemetry().log_exception(e)
         return False
 
 
 def init_lancedb_instrumentor():
     try:
         if is_package_installed("lancedb"):
-            # Telemetry().capture("instrumentation:lancedb:init")
             from opentelemetry.instrumentation.lancedb import LanceInstrumentor
 
-            instrumentor = LanceInstrumentor(
-                # exception_logger=lambda e: Telemetry().log_exception(e),
-            )
+            instrumentor = LanceInstrumentor()
             if not instrumentor.is_instrumented_by_opentelemetry:
                 instrumentor.instrument()
         return True
@@ -877,23 +781,34 @@ def init_redis_instrumentor():
         return True
     except Exception as e:
         logging.error(f"Error initializing redis instrumentor: {e}")
-        # Telemetry().log_exception(e)
         return False
 
 
 def init_groq_instrumentor():
     try:
         if is_package_installed("groq"):
-            # Telemetry().capture("instrumentation:groq:init")
             from opentelemetry.instrumentation.groq import GroqInstrumentor
 
-            instrumentor = GroqInstrumentor(
-                # exception_logger=lambda e: Telemetry().log_exception(e),
-            )
+            instrumentor = GroqInstrumentor()
             if not instrumentor.is_instrumented_by_opentelemetry:
                 instrumentor.instrument()
         return True
     except Exception as e:
         logging.error(f"Error initializing Groq instrumentor: {e}")
-        # Telemetry().log_exception(e)
+        return False
+
+
+def init_sagemaker_instrumentor(should_enrich_metrics: bool):
+    try:
+        if is_package_installed("boto3"):
+            from opentelemetry.instrumentation.sagemaker import SageMakerInstrumentor
+
+            instrumentor = SageMakerInstrumentor(
+                enrich_token_usage=should_enrich_metrics,
+            )
+            if not instrumentor.is_instrumented_by_opentelemetry:
+                instrumentor.instrument()
+        return True
+    except Exception as e:
+        logging.error(f"Error initializing SageMaker instrumentor: {e}")
         return False

{lmnr-0.4.28.dist-info → lmnr-0.4.29.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lmnr
-Version: 0.4.28
+Version: 0.4.29
 Summary: Python SDK for Laminar AI
 License: Apache-2.0
 Author: lmnr.ai
@@ -39,6 +39,7 @@ Requires-Dist: opentelemetry-instrumentation-pinecone (>=0.33.5)
 Requires-Dist: opentelemetry-instrumentation-qdrant (>=0.33.5)
 Requires-Dist: opentelemetry-instrumentation-replicate (>=0.33.5)
 Requires-Dist: opentelemetry-instrumentation-requests (>=0.48b0,<0.49)
+Requires-Dist: opentelemetry-instrumentation-sagemaker (>=0.33.5)
 Requires-Dist: opentelemetry-instrumentation-sqlalchemy (>=0.48b0,<0.49)
 Requires-Dist: opentelemetry-instrumentation-threading (>=0.48b0,<0.49)
 Requires-Dist: opentelemetry-instrumentation-together (>=0.33.5)

{lmnr-0.4.28.dist-info → lmnr-0.4.29.dist-info}/RECORD

@@ -1,20 +1,20 @@
-lmnr/__init__.py,sha256=87ZHKNA2xmZvqtXrWjhXUNR7YUrdP8-77fYqe-PEtrE,348
+lmnr/__init__.py,sha256=bIkXw003GaigTxNfGE_gwVtTDGdSdAPUr6CS_nN51oA,430
 lmnr/cli.py,sha256=Ptvm5dsNLKUY5lwnN8XkT5GtCYjzpRNi2WvefknB3OQ,1079
 lmnr/sdk/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lmnr/sdk/datasets.py,sha256=w8U9E6fvetAo65Cb2CbYzlfhY8CfXAR-VysrakG6-4I,1591
 lmnr/sdk/decorators.py,sha256=ZSDaEZyjo-RUzRCltsNbe6x0t9SKl2xRQ2q4uaKvXtk,2250
-lmnr/sdk/evaluations.py,sha256=vG788rSDppAGEvIpyglKvm8Ac_D5cw07a6btMeMr8AI,15124
-lmnr/sdk/laminar.py,sha256=H87fXSWb9shcPW4AeoYwvTXJ-jSTjzm2sI1A1U1Vkg8,18780
+lmnr/sdk/evaluations.py,sha256=5Vfyp0aIjuGpqfuM3cqsaaLpcoO7z6lcOOKxnyHCNHk,16264
+lmnr/sdk/laminar.py,sha256=jToA51Yy7c37CWYvgAo3mrfsqvf1huQepck6twgwP4s,21148
 lmnr/sdk/log.py,sha256=cZBeUoSK39LMEV-X4-eEhTWOciULRfHaKfRK8YqIM8I,1532
-lmnr/sdk/types.py,sha256=6_C2LhcbI9PwlntnSuREE0FRsBUxc3WS_yC_Y_trPBI,5052
-lmnr/sdk/utils.py,sha256=s81p6uJehgJSaLWy3sR5fTpEDH7vzn3i_UujUHChl6M,3346
+lmnr/sdk/types.py,sha256=qGD1tkGszd-_sZJaZ_Zx9U_CdUYzoDkUeN2g-o48Gls,5588
+lmnr/sdk/utils.py,sha256=Uk8y15x-sd5tP2ERONahElLDJVEy_3dA_1_5g9A6auY,3358
 lmnr/traceloop_sdk/.flake8,sha256=bCxuDlGx3YQ55QHKPiGJkncHanh9qGjQJUujcFa3lAU,150
 lmnr/traceloop_sdk/.python-version,sha256=9OLQBQVbD4zE4cJsPePhnAfV_snrPSoqEQw-PXgPMOs,6
 lmnr/traceloop_sdk/__init__.py,sha256=hp3q1OsFaGgaQCEanJrL38BJN32hWqCNVCSjYpndEsY,2957
 lmnr/traceloop_sdk/config/__init__.py,sha256=DliMGp2NjYAqRFLKpWQPUKjGMHRO8QsVfazBA1qENQ8,248
 lmnr/traceloop_sdk/decorators/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lmnr/traceloop_sdk/decorators/base.py,sha256=SeImd8SAeqdC8LV1bvoQUq0d_TLkOLyd5HCe7vXKhNU,5559
-lmnr/traceloop_sdk/instruments.py,sha256=oMvIASueW3GeChpjIdH-DD9aFBVB8OtHZ0HawppTrlI,942
+lmnr/traceloop_sdk/instruments.py,sha256=CGGUEELldrXkQwAzAkDeAtDq07_pjhz7i14a92P7C_E,1036
 lmnr/traceloop_sdk/tests/__init__.py,sha256=RYnG0-8zbXL0-2Ste1mEBf5sN4d_rQjGTCgPBuaZC74,20
 lmnr/traceloop_sdk/tests/cassettes/test_association_properties/test_langchain_and_external_association_properties.yaml,sha256=26g0wRA0juicHg_XrhcE8H4vhs1lawDs0o0aLFn-I7w,3103
 lmnr/traceloop_sdk/tests/cassettes/test_association_properties/test_langchain_association_properties.yaml,sha256=FNlSWlYCsWc3w7UPZzfGjDnxS3gAOhL-kpsu4BTxsDE,3061
@@ -39,14 +39,14 @@ lmnr/traceloop_sdk/tracing/__init__.py,sha256=Ckq7zCM26VdJVB5tIZv0GTPyMZKyfso_KW
 lmnr/traceloop_sdk/tracing/attributes.py,sha256=QeqItpCCwUipkwgXG7J7swJCD0yk9uuI28aepPhemtE,1201
 lmnr/traceloop_sdk/tracing/content_allow_list.py,sha256=3feztm6PBWNelc8pAZUcQyEGyeSpNiVKjOaDk65l2ps,846
 lmnr/traceloop_sdk/tracing/context_manager.py,sha256=csVlB6kDmbgSPsROHwnddvGGblx55v6lJMRj0wsSMQM,304
-lmnr/traceloop_sdk/tracing/tracing.py,sha256=2Vyc0hUdTqXYlBzoW7YO6DlLaUKWouLv7eEvrVMZYOo,35680
+lmnr/traceloop_sdk/tracing/tracing.py,sha256=hFqTp7OGMCZnfxVtrmRq3wP3Ph5YvHq3fz9p00_Yk-Q,29433
 lmnr/traceloop_sdk/utils/__init__.py,sha256=pNhf0G3vTd5ccoc03i1MXDbricSaiqCbi1DLWhSekK8,604
 lmnr/traceloop_sdk/utils/in_memory_span_exporter.py,sha256=H_4TRaThMO1H6vUQ0OpQvzJk_fZH0OOsRAM1iZQXsR8,2112
 lmnr/traceloop_sdk/utils/json_encoder.py,sha256=dK6b_axr70IYL7Vv-bu4wntvDDuyntoqsHaddqX7P58,463
 lmnr/traceloop_sdk/utils/package_check.py,sha256=TZSngzJOpFhfUZLXIs38cpMxQiZSmp0D-sCrIyhz7BA,251
 lmnr/traceloop_sdk/version.py,sha256=OlatFEFA4ttqSSIiV8jdE-sq3KG5zu2hnC4B4mzWF3s,23
-lmnr-0.4.28.dist-info/LICENSE,sha256=67b_wJHVV1CBaWkrKFWU1wyqTPSdzH77Ls-59631COg,10411
-lmnr-0.4.28.dist-info/METADATA,sha256=giQPDHe_FGDtrlT7gPGJIDCdY0aSWTuoq9j9CKE0nO8,10622
-lmnr-0.4.28.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-lmnr-0.4.28.dist-info/entry_points.txt,sha256=K1jE20ww4jzHNZLnsfWBvU3YKDGBgbOiYG5Y7ivQcq4,37
-lmnr-0.4.28.dist-info/RECORD,,
+lmnr-0.4.29.dist-info/LICENSE,sha256=67b_wJHVV1CBaWkrKFWU1wyqTPSdzH77Ls-59631COg,10411
+lmnr-0.4.29.dist-info/METADATA,sha256=e8-yJiO243QVOTNOMeoEcojnAflYXF8XNh8az7Y75h4,10688
+lmnr-0.4.29.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+lmnr-0.4.29.dist-info/entry_points.txt,sha256=K1jE20ww4jzHNZLnsfWBvU3YKDGBgbOiYG5Y7ivQcq4,37
+lmnr-0.4.29.dist-info/RECORD,,