lmnr 0.5.3__py3-none-any.whl → 0.6.0__py3-none-any.whl

lmnr/opentelemetry_lib/decorators/base.py

@@ -1,210 +0,0 @@
-import json
-from functools import wraps
-import logging
-import pydantic
-import types
-from typing import Any, Literal, Optional, Union
-
-from opentelemetry import trace
-from opentelemetry import context as context_api
-from opentelemetry.trace import Span
-
-from lmnr.sdk.utils import get_input_from_func_args, is_method
-from lmnr.opentelemetry_lib.tracing import get_tracer
-from lmnr.opentelemetry_lib.tracing.attributes import SPAN_INPUT, SPAN_OUTPUT, SPAN_TYPE
-from lmnr.opentelemetry_lib.tracing.tracing import TracerWrapper
-from lmnr.opentelemetry_lib.utils.json_encoder import JSONEncoder
-from lmnr.opentelemetry_lib.config import MAX_MANUAL_SPAN_PAYLOAD_SIZE
-
-
-class CustomJSONEncoder(JSONEncoder):
-    def default(self, o: Any) -> Any:
-        if isinstance(o, pydantic.BaseModel):
-            return o.model_dump_json()
-        try:
-            return super().default(o)
-        except TypeError:
-            return str(o)  # Fallback to string representation for unsupported types
-
-
-def json_dumps(data: dict) -> str:
-    try:
-        return json.dumps(data, cls=CustomJSONEncoder)
-    except Exception:
-        # Log the exception and return a placeholder if serialization completely fails
-        logging.warning("Failed to serialize data to JSON, type: %s", type(data))
-        return "{}"  # Return an empty JSON object as a fallback
-
-
-def entity_method(
-    name: Optional[str] = None,
-    ignore_input: bool = False,
-    ignore_inputs: Optional[list[str]] = None,
-    ignore_output: bool = False,
-    span_type: Union[Literal["DEFAULT"], Literal["LLM"], Literal["TOOL"]] = "DEFAULT",
-):
-    def decorate(fn):
-        @wraps(fn)
-        def wrap(*args, **kwargs):
-            if not TracerWrapper.verify_initialized():
-                return fn(*args, **kwargs)
-
-            span_name = name or fn.__name__
-
-            with get_tracer() as tracer:
-                span = tracer.start_span(span_name, attributes={SPAN_TYPE: span_type})
-
-                ctx = trace.set_span_in_context(span, context_api.get_current())
-                ctx_token = context_api.attach(ctx)
-
-                try:
-                    if not ignore_input:
-                        inp = json_dumps(
-                            get_input_from_func_args(
-                                fn,
-                                is_method=is_method(fn),
-                                func_args=args,
-                                func_kwargs=kwargs,
-                                ignore_inputs=ignore_inputs,
-                            )
-                        )
-                        if len(inp) > MAX_MANUAL_SPAN_PAYLOAD_SIZE:
-                            span.set_attribute(
-                                SPAN_INPUT, "Laminar: input too large to record"
-                            )
-                        else:
-                            span.set_attribute(SPAN_INPUT, inp)
-                except TypeError:
-                    pass
-
-                try:
-                    res = fn(*args, **kwargs)
-                except Exception as e:
-                    _process_exception(span, e)
-                    span.end()
-                    raise e
-
-                # span will be ended in the generator
-                if isinstance(res, types.GeneratorType):
-                    return _handle_generator(span, res)
-
-                try:
-                    if not ignore_output:
-                        output = json_dumps(res)
-                        if len(output) > MAX_MANUAL_SPAN_PAYLOAD_SIZE:
-                            span.set_attribute(
-                                SPAN_OUTPUT, "Laminar: output too large to record"
-                            )
-                        else:
-                            span.set_attribute(SPAN_OUTPUT, output)
-                except TypeError:
-                    pass
-
-                span.end()
-                context_api.detach(ctx_token)
-
-                return res
-
-        return wrap
-
-    return decorate
-
-
-# Async Decorators
-def aentity_method(
-    name: Optional[str] = None,
-    ignore_input: bool = False,
-    ignore_inputs: Optional[list[str]] = None,
-    ignore_output: bool = False,
-    span_type: Union[Literal["DEFAULT"], Literal["LLM"], Literal["TOOL"]] = "DEFAULT",
-):
-    def decorate(fn):
-        @wraps(fn)
-        async def wrap(*args, **kwargs):
-            if not TracerWrapper.verify_initialized():
-                return await fn(*args, **kwargs)
-
-            span_name = name or fn.__name__
-
-            with get_tracer() as tracer:
-                span = tracer.start_span(span_name, attributes={SPAN_TYPE: span_type})
-
-                ctx = trace.set_span_in_context(span, context_api.get_current())
-                ctx_token = context_api.attach(ctx)
-
-                try:
-                    if not ignore_input:
-                        inp = json_dumps(
-                            get_input_from_func_args(
-                                fn,
-                                is_method=is_method(fn),
-                                func_args=args,
-                                func_kwargs=kwargs,
-                                ignore_inputs=ignore_inputs,
-                            )
-                        )
-                        if len(inp) > MAX_MANUAL_SPAN_PAYLOAD_SIZE:
-                            span.set_attribute(
-                                SPAN_INPUT, "Laminar: input too large to record"
-                            )
-                        else:
-                            span.set_attribute(SPAN_INPUT, inp)
-                except TypeError:
-                    pass
-
-                try:
-                    res = await fn(*args, **kwargs)
-                except Exception as e:
-                    _process_exception(span, e)
-                    span.end()
-                    raise e
-
-                # span will be ended in the generator
-                if isinstance(res, types.AsyncGeneratorType):
-                    return await _ahandle_generator(span, ctx_token, res)
-
-                try:
-                    if not ignore_output:
-                        output = json_dumps(res)
-                        if len(output) > MAX_MANUAL_SPAN_PAYLOAD_SIZE:
-                            span.set_attribute(
-                                SPAN_OUTPUT, "Laminar: output too large to record"
-                            )
-                        else:
-                            span.set_attribute(SPAN_OUTPUT, output)
-                except TypeError:
-                    pass
-
-                span.end()
-                context_api.detach(ctx_token)
-
-                return res
-
-        return wrap
-
-    return decorate
-
-
-def _handle_generator(span, res):
-    # for some reason the SPAN_KEY is not being set in the context of the generator, so we re-set it
-    context_api.attach(trace.set_span_in_context(span))
-    yield from res
-
-    span.end()
-
-    # Note: we don't detach the context here as this fails in some situations
-    # https://github.com/open-telemetry/opentelemetry-python/issues/2606
-    # This is not a problem since the context will be detached automatically during garbage collection
-
-
-async def _ahandle_generator(span, ctx_token, res):
-    async for part in res:
-        yield part
-
-    span.end()
-    context_api.detach(ctx_token)
-
-
-def _process_exception(span: Span, e: Exception):
-    # Note that this `escaped` is sent as a StringValue("True"), not a boolean.
-    span.record_exception(e, escaped=True)

lmnr/opentelemetry_lib/instruments.py

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

lmnr/opentelemetry_lib/tracing/content_allow_list.py

@@ -1,24 +0,0 @@
-# Manages list of associated properties for which content tracing
-# (prompts, vector embeddings, etc.) is allowed.
-class ContentAllowList:
-    def __new__(cls) -> "ContentAllowList":
-        if not hasattr(cls, "instance"):
-            obj = cls.instance = super(ContentAllowList, cls).__new__(cls)
-            obj._allow_list: list[dict] = []
-
-        return cls.instance
-
-    def is_allowed(self, association_properties: dict) -> bool:
-        for allow_list_item in self._allow_list:
-            if all(
-                [
-                    association_properties.get(key) == value
-                    for key, value in allow_list_item.items()
-                ]
-            ):
-                return True
-
-        return False
-
-    def load(self, response_json: dict):
-        self._allow_list = response_json["associationPropertyAllowList"]