lmnr 0.4.53.dev0__py3-none-any.whl → 0.7.26__py3-none-any.whl

lmnr/openllmetry_sdk/__init__.py

@@ -1,72 +0,0 @@
-import sys
-
-from typing import Optional, Set
-from opentelemetry.sdk.trace import SpanProcessor
-from opentelemetry.sdk.trace.export import SpanExporter
-from opentelemetry.sdk.resources import SERVICE_NAME
-from opentelemetry.propagators.textmap import TextMapPropagator
-from opentelemetry.util.re import parse_env_headers
-
-from lmnr.openllmetry_sdk.instruments import Instruments
-from lmnr.openllmetry_sdk.config import (
-    is_content_tracing_enabled,
-    is_tracing_enabled,
-)
-from lmnr.openllmetry_sdk.tracing.tracing import TracerWrapper
-from typing import Dict
-
-
-class Traceloop:
-    __tracer_wrapper: TracerWrapper
-
-    @staticmethod
-    def init(
-        app_name: Optional[str] = sys.argv[0],
-        api_endpoint: str = "https://api.lmnr.ai",
-        api_key: Optional[str] = None,
-        headers: Dict[str, str] = {},
-        disable_batch=False,
-        exporter: Optional[SpanExporter] = None,
-        processor: Optional[SpanProcessor] = None,
-        propagator: Optional[TextMapPropagator] = None,
-        should_enrich_metrics: bool = False,
-        resource_attributes: dict = {},
-        instruments: Optional[Set[Instruments]] = None,
-    ) -> None:
-        if not is_tracing_enabled():
-            return
-
-        enable_content_tracing = is_content_tracing_enabled()
-
-        if isinstance(headers, str):
-            headers = parse_env_headers(headers)
-
-        if (
-            not exporter
-            and not processor
-            and api_endpoint == "https://api.lmnr.ai"
-            and not api_key
-        ):
-            print(
-                "Set the LMNR_PROJECT_API_KEY environment variable to your project API key"
-            )
-            return
-
-        if api_key and not exporter and not processor and not headers:
-            headers = {
-                "Authorization": f"Bearer {api_key}",
-            }
-
-        # Tracer init
-        resource_attributes.update({SERVICE_NAME: app_name})
-        TracerWrapper.set_static_params(
-            resource_attributes, enable_content_tracing, api_endpoint, headers
-        )
-        Traceloop.__tracer_wrapper = TracerWrapper(
-            disable_batch=disable_batch,
-            processor=processor,
-            propagator=propagator,
-            exporter=exporter,
-            should_enrich_metrics=should_enrich_metrics,
-            instruments=instruments,
-        )

lmnr/openllmetry_sdk/config/__init__.py

@@ -1,9 +0,0 @@
-import os
-
-
-def is_tracing_enabled() -> bool:
-    return (os.getenv("TRACELOOP_TRACING_ENABLED") or "true").lower() == "true"
-
-
-def is_content_tracing_enabled() -> bool:
-    return (os.getenv("TRACELOOP_TRACE_CONTENT") or "true").lower() == "true"

lmnr/openllmetry_sdk/decorators/base.py

@@ -1,185 +0,0 @@
-import json
-from functools import wraps
-import logging
-import os
-import pydantic
-import types
-from typing import Any, Optional
-
-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.openllmetry_sdk.tracing import get_tracer
-from lmnr.openllmetry_sdk.tracing.attributes import SPAN_INPUT, SPAN_OUTPUT
-from lmnr.openllmetry_sdk.tracing.tracing import TracerWrapper
-from lmnr.openllmetry_sdk.utils.json_encoder import JSONEncoder
-
-
-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,
-):
-    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)
-
-                ctx = trace.set_span_in_context(span, context_api.get_current())
-                ctx_token = context_api.attach(ctx)
-
-                try:
-                    if _should_send_prompts():
-                        span.set_attribute(
-                            SPAN_INPUT,
-                            json_dumps(
-                                get_input_from_func_args(
-                                    fn, is_method(fn), args, kwargs
-                                )
-                            ),
-                        )
-                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 _should_send_prompts():
-                        span.set_attribute(
-                            SPAN_OUTPUT,
-                            json_dumps(res),
-                        )
-                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,
-):
-    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)
-
-                ctx = trace.set_span_in_context(span, context_api.get_current())
-                ctx_token = context_api.attach(ctx)
-
-                try:
-                    if _should_send_prompts():
-                        span.set_attribute(
-                            SPAN_INPUT,
-                            json_dumps(
-                                get_input_from_func_args(
-                                    fn, is_method(fn), args, kwargs
-                                )
-                            ),
-                        )
-                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 _should_send_prompts():
-                        span.set_attribute(SPAN_OUTPUT, json_dumps(res))
-                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 _should_send_prompts():
-    return (
-        os.getenv("TRACELOOP_TRACE_CONTENT") or "true"
-    ).lower() == "true" or context_api.get_value("override_enable_content_tracing")
-
-
-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/openllmetry_sdk/instruments.py

@@ -1,38 +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"
-    CHROMA = "chroma"
-    COHERE = "cohere"
-    GOOGLE_GENERATIVEAI = "google_generativeai"
-    GROQ = "groq"
-    HAYSTACK = "haystack"
-    LANCEDB = "lancedb"
-    LANGCHAIN = "langchain"
-    LLAMA_INDEX = "llama_index"
-    MARQO = "marqo"
-    MILVUS = "milvus"
-    MISTRAL = "mistral"
-    OLLAMA = "ollama"
-    OPENAI = "openai"
-    PINECONE = "pinecone"
-    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/openllmetry_sdk/tracing/__init__.py

@@ -1 +0,0 @@
-from lmnr.openllmetry_sdk.tracing.context_manager import get_tracer

lmnr/openllmetry_sdk/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"]

lmnr/openllmetry_sdk/tracing/context_manager.py

@@ -1,13 +0,0 @@
-from contextlib import contextmanager
-
-from lmnr.openllmetry_sdk.tracing.tracing import TracerWrapper
-
-
-@contextmanager
-def get_tracer(flush_on_exit: bool = False):
-    wrapper = TracerWrapper()
-    try:
-        yield wrapper.get_tracer()
-    finally:
-        if flush_on_exit:
-            wrapper.flush()