lmnr 0.4.17b0__py2.py3-none-any.whl

lmnr/traceloop_sdk/.flake8

@@ -0,0 +1,12 @@
+[flake8]
+exclude =
+	.git,
+	__pycache__,
+	build,
+	dist,
+	.tox,
+	venv,
+	.venv,
+	.pytest_cache
+max-line-length = 120
+per-file-ignores = __init__.py:F401

lmnr/traceloop_sdk/.python-version

@@ -0,0 +1 @@
+3.9.5

lmnr/traceloop_sdk/__init__.py

@@ -0,0 +1,89 @@
+import os
+import sys
+from pathlib import Path
+
+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.traceloop_sdk.instruments import Instruments
+from lmnr.traceloop_sdk.config import (
+    is_content_tracing_enabled,
+    is_tracing_enabled,
+)
+from lmnr.traceloop_sdk.tracing.tracing import TracerWrapper
+from typing import Dict
+
+
+class Traceloop:
+    AUTO_CREATED_KEY_PATH = str(
+        Path.home() / ".cache" / "traceloop" / "auto_created_key"
+    )
+    AUTO_CREATED_URL = str(Path.home() / ".cache" / "traceloop" / "auto_created_url")
+
+    __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 = True,
+        resource_attributes: dict = {},
+        instruments: Optional[Set[Instruments]] = None,
+    ) -> None:
+        api_endpoint = os.getenv("TRACELOOP_BASE_URL") or api_endpoint
+        api_key = os.getenv("TRACELOOP_API_KEY") or api_key
+
+        if not is_tracing_enabled():
+            # print(Fore.YELLOW + "Tracing is disabled" + Fore.RESET)
+            return
+
+        enable_content_tracing = is_content_tracing_enabled()
+
+        headers = os.getenv("TRACELOOP_HEADERS") or headers
+
+        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(
+                "Error: Missing API key,"
+                + " go to project settings to create one"
+            )
+            print("Set the LMNR_PROJECT_API_KEY environment variable to the key")
+            return
+
+        if api_key and not exporter and not processor and not headers:
+            headers = {
+                "Authorization": f"Bearer {api_key}",
+            }
+
+        # print(Fore.RESET)
+
+        # 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/traceloop_sdk/config/__init__.py

@@ -0,0 +1,9 @@
+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/traceloop_sdk/decorators/base.py

@@ -0,0 +1,178 @@
+import json
+from functools import wraps
+import os
+import types
+from typing import Any, Optional
+import warnings
+
+from opentelemetry import trace
+from opentelemetry import context as context_api
+
+from lmnr.sdk.utils import get_input_from_func_args, is_method
+from lmnr.traceloop_sdk.tracing import get_tracer
+from lmnr.traceloop_sdk.tracing.attributes import SPAN_INPUT, SPAN_OUTPUT, SPAN_PATH
+from lmnr.traceloop_sdk.tracing.tracing import TracerWrapper, get_span_path
+from lmnr.traceloop_sdk.utils.json_encoder import JSONEncoder
+
+
+class CustomJSONEncoder(JSONEncoder):
+    def default(self, o: Any) -> Any:
+        try:
+            return super().default(o)
+        except TypeError:
+            return str(o)  # Fallback to string representation for unsupported types
+
+
+def _json_dumps(data: dict) -> str:
+    try:
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore", RuntimeWarning)
+            return json.dumps(data, cls=CustomJSONEncoder)
+    except Exception:
+        # Log the exception and return a placeholder if serialization completely fails
+        # Telemetry().log_exception(e)
+        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)
+
+                span_path = get_span_path(span_name)
+                span.set_attribute(SPAN_PATH, span_path)
+                ctx = context_api.set_value("span_path", span_path)
+
+                ctx = trace.set_span_in_context(span, ctx)
+                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
+
+                res = fn(*args, **kwargs)
+
+                # 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)
+
+                span_path = get_span_path(span_name)
+                span.set_attribute(SPAN_PATH, span_path)
+                ctx = context_api.set_value("span_path", span_path)
+
+                ctx = trace.set_span_in_context(span, ctx)
+                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
+
+                res = await fn(*args, **kwargs)
+
+                # 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")

lmnr/traceloop_sdk/instruments.py

@@ -0,0 +1,34 @@
+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"
+    ANTHROPIC = "anthropic"
+    COHERE = "cohere"
+    PINECONE = "pinecone"
+    CHROMA = "chroma"
+    GOOGLE_GENERATIVEAI = "google_generativeai"
+    LANGCHAIN = "langchain"
+    MISTRAL = "mistral"
+    OLLAMA = "ollama"
+    LLAMA_INDEX = "llama_index"
+    MILVUS = "milvus"
+    TRANSFORMERS = "transformers"
+    TOGETHER = "together"
+    BEDROCK = "bedrock"
+    REPLICATE = "replicate"
+    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.
+    REDIS = "redis"
+    REQUESTS = "requests"
+    URLLIB3 = "urllib3"
+    PYMYSQL = "pymysql"

lmnr/traceloop_sdk/tests/__init__.py

@@ -0,0 +1 @@
+# """unit tests."""

lmnr/traceloop_sdk/tests/cassettes/test_association_properties/test_langchain_and_external_association_properties.yaml

@@ -0,0 +1,101 @@
+interactions:
+- request:
+    body: '{"messages": [{"content": "You are helpful assistant", "role": "system"},
+      {"content": "tell me a short joke", "role": "user"}], "model": "gpt-3.5-turbo",
+      "logprobs": false, "n": 1, "stream": false, "temperature": 0.7}'
+    headers:
+      accept:
+      - application/json
+      accept-encoding:
+      - gzip, deflate
+      connection:
+      - keep-alive
+      content-length:
+      - '217'
+      content-type:
+      - application/json
+      host:
+      - api.openai.com
+      user-agent:
+      - OpenAI/Python 1.35.15
+      x-stainless-arch:
+      - arm64
+      x-stainless-async:
+      - 'false'
+      x-stainless-lang:
+      - python
+      x-stainless-os:
+      - MacOS
+      x-stainless-package-version:
+      - 1.35.15
+      x-stainless-runtime:
+      - CPython
+      x-stainless-runtime-version:
+      - 3.9.5
+    method: POST
+    uri: https://api.openai.com/v1/chat/completions
+  response:
+    body:
+      string: !!binary |
+        H4sIAAAAAAAAA1SRS0/DMBCE7/kVW1+4tKgJCo9eEHABhHooLyGEKtfdJgbHa7wbaFX1v6OEtIWL
+        D/PtrGbW6wRA2bkagTKlFlMFN7jIbiaP44fF59Pt5Pj65epu6Zbf44un69MxLVW/cdDsHY1sXYeG
+        quBQLPlfbCJqwWZrepLlaTo8S7MWVDRH19iKIIOjw3wgdZzRYJhmeecsyRpkNYLXBABg3b5NRj/H
+        pRrBsL9VKmTWBarRbghARXKNojSzZdFeVH8PDXlB38a+ryP24LlcwZz8gQAbi14sC4PEmgW0UMXn
+        cIlG14wgJa6g0h8IdQD8wriS0vqi93d9xEXNuqnna+c6fbPL66gIkWbc8Z2+sN5yOY2omXyTjYWC
+        aukmAXhr71L/q6pCpCrIVOgDfbMw686i9j+xh2neQSHRbq8f5UmXT/GKBavpwvoCY4i2PVLbYpP8
+        AAAA//8DAFwYnEsjAgAA
+    headers:
+      CF-Cache-Status:
+      - DYNAMIC
+      CF-RAY:
+      - 8bbd5d409b62b0bd-ATL
+      Connection:
+      - keep-alive
+      Content-Encoding:
+      - gzip
+      Content-Type:
+      - application/json
+      Date:
+      - Sat, 31 Aug 2024 13:28:32 GMT
+      Server:
+      - cloudflare
+      Set-Cookie:
+      - __cf_bm=3B.f5aMPKiXVHyNDAIAPma3ZGvDnGViQrDAMvyT4n_8-1725110912-1.0.1.1-.elzfgXAenLSaVeAmcRwzq2OROEZMEvOpxSRlQ7PPZ8n6nkbc2NfZXBU1bijPQNxQ28MLNRJFyh4B4Mq4G3PPA;
+        path=/; expires=Sat, 31-Aug-24 13:58:32 GMT; domain=.api.openai.com; HttpOnly;
+        Secure; SameSite=None
+      - _cfuvid=LakflcrbwsF6x0qpc03TIL8jU8c3IjMCt5dua3l4dVA-1725110912530-0.0.1.1-604800000;
+        path=/; domain=.api.openai.com; HttpOnly; Secure; SameSite=None
+      Transfer-Encoding:
+      - chunked
+      X-Content-Type-Options:
+      - nosniff
+      access-control-expose-headers:
+      - X-Request-ID
+      alt-svc:
+      - h3=":443"; ma=86400
+      openai-organization:
+      - traceloop
+      openai-processing-ms:
+      - '233'
+      openai-version:
+      - '2020-10-01'
+      strict-transport-security:
+      - max-age=15552000; includeSubDomains; preload
+      x-ratelimit-limit-requests:
+      - '5000'
+      x-ratelimit-limit-tokens:
+      - '4000000'
+      x-ratelimit-remaining-requests:
+      - '4999'
+      x-ratelimit-remaining-tokens:
+      - '3999970'
+      x-ratelimit-reset-requests:
+      - 12ms
+      x-ratelimit-reset-tokens:
+      - 0s
+      x-request-id:
+      - req_459694e3c39fd24575ad9deb5b65a831
+    status:
+      code: 200
+      message: OK
+version: 1

lmnr/traceloop_sdk/tests/cassettes/test_association_properties/test_langchain_association_properties.yaml

@@ -0,0 +1,99 @@
+interactions:
+- request:
+    body: '{"messages": [{"content": "You are helpful assistant", "role": "system"},
+      {"content": "tell me a short joke", "role": "user"}], "model": "gpt-3.5-turbo",
+      "logprobs": false, "n": 1, "stream": false, "temperature": 0.7}'
+    headers:
+      accept:
+      - application/json
+      accept-encoding:
+      - gzip, deflate
+      connection:
+      - keep-alive
+      content-length:
+      - '217'
+      content-type:
+      - application/json
+      host:
+      - api.openai.com
+      user-agent:
+      - OpenAI/Python 1.35.15
+      x-stainless-arch:
+      - arm64
+      x-stainless-async:
+      - 'false'
+      x-stainless-lang:
+      - python
+      x-stainless-os:
+      - MacOS
+      x-stainless-package-version:
+      - 1.35.15
+      x-stainless-runtime:
+      - CPython
+      x-stainless-runtime-version:
+      - 3.9.5
+    method: POST
+    uri: https://api.openai.com/v1/chat/completions
+  response:
+    body:
+      string: !!binary |
+        H4sIAAAAAAAAA1SRzU7DMBCE73mKxRcuLYLSFsgFgbhwBCSQ+FHlONvE4Hgt71olQn135BBauPgw
+        s7P6dvxVAChbqxKUabWYLrjphdwk01VXzb1teXOX6pquzp9vKSwfFzdqkhNUvaOR39SRoS44FEv+
+        xzYRtWDeenI2m13Mzxfz5WB0VKPLsSbI9PRoMZUUK5oen8wWY7Ila5BVCS8FAMDX8GZGX+OnKuF4
+        8qt0yKwbVOVuCEBFcllRmtmyaC9qsjcNeUE/YD+kiBNoMSJYBg3cUhR4pw+ENUXoKZWv/tU/tT0Y
+        Sq72hwLSIlTW9MYh5N01pABVD1YY3foSrtHoxAhWYKMZZEMgNmJ9oEaE7Y7dURMiVflOn5zb6Wvr
+        LberiJrJZ04WCj/xbQHwNnSU/p2tQqQuyEroA31eOBsrUvtf+WMuR1NItNvr82Ux8inuWbBbra1v
+        MIZoh8IyZbEtvgEAAP//AwAFMxvRLwIAAA==
+    headers:
+      CF-Cache-Status:
+      - DYNAMIC
+      CF-RAY:
+      - 8aef251d0f8609c9-HFA
+      Connection:
+      - keep-alive
+      Content-Encoding:
+      - gzip
+      Content-Type:
+      - application/json
+      Date:
+      - Tue, 06 Aug 2024 12:49:06 GMT
+      Server:
+      - cloudflare
+      Set-Cookie:
+      - __cf_bm=SWNMVXkujzFcfmlIKZqekPtNke27ztV8lzplh5iUMes-1722948546-1.0.1.1-oRP4d5x5PiBOFu.G77C4XWWMxrsKragvFMrFNCIRwudZ7Z2NMrKgMa_A7eqXOME9rU2sqUIpS9c8T9SBEAR7Fg;
+        path=/; expires=Tue, 06-Aug-24 13:19:06 GMT; domain=.api.openai.com; HttpOnly;
+        Secure; SameSite=None
+      - _cfuvid=VuBkx.e0oap2GPCBPG260hGbmwEpoHckoHEm5vALKZs-1722948546860-0.0.1.1-604800000;
+        path=/; domain=.api.openai.com; HttpOnly; Secure; SameSite=None
+      Transfer-Encoding:
+      - chunked
+      X-Content-Type-Options:
+      - nosniff
+      alt-svc:
+      - h3=":443"; ma=86400
+      openai-organization:
+      - traceloop
+      openai-processing-ms:
+      - '400'
+      openai-version:
+      - '2020-10-01'
+      strict-transport-security:
+      - max-age=15552000; includeSubDomains; preload
+      x-ratelimit-limit-requests:
+      - '5000'
+      x-ratelimit-limit-tokens:
+      - '4000000'
+      x-ratelimit-remaining-requests:
+      - '4999'
+      x-ratelimit-remaining-tokens:
+      - '3999970'
+      x-ratelimit-reset-requests:
+      - 12ms
+      x-ratelimit-reset-tokens:
+      - 0s
+      x-request-id:
+      - req_bf54266d3b5b08c26a6dc51f55dd208c
+    status:
+      code: 200
+      message: OK
+version: 1

lmnr/traceloop_sdk/tests/cassettes/test_manual/test_manual_report.yaml

@@ -0,0 +1,98 @@
+interactions:
+- request:
+    body: '{"messages": [{"role": "user", "content": "Tell me a joke about opentelemetry"}],
+      "model": "gpt-3.5-turbo"}'
+    headers:
+      accept:
+      - application/json
+      accept-encoding:
+      - gzip, deflate
+      connection:
+      - keep-alive
+      content-length:
+      - '107'
+      content-type:
+      - application/json
+      host:
+      - api.openai.com
+      user-agent:
+      - OpenAI/Python 1.35.13
+      x-stainless-arch:
+      - arm64
+      x-stainless-async:
+      - 'false'
+      x-stainless-lang:
+      - python
+      x-stainless-os:
+      - MacOS
+      x-stainless-package-version:
+      - 1.35.13
+      x-stainless-runtime:
+      - CPython
+      x-stainless-runtime-version:
+      - 3.9.5
+    method: POST
+    uri: https://api.openai.com/v1/chat/completions
+  response:
+    body:
+      string: !!binary |
+        H4sIAAAAAAAAA1RRy07DMBC85ysWn1vUB6XQCxISIB5HJF5CletsElPHa603hYD678hpaMXFh5md
+        8ezsTwagbK4WoEylxdTBDc/dw93zi71/vbotwtNN+Xy9fnl4XH9/3xdnp2qQFLT6QCN/qmNDdXAo
+        lvyONoxaMLmO55PxaD6azmcdUVOOLsnKIMPp8WwoDa9oOBpPZr2yImswqgW8ZQAAP92bMvocv9QC
+        RoM/pMYYdYlqsR8CUEwuIUrHaKNoL2pwIA15Qd/FfqpayG0OUiFQQC/osEbhFnLcoKOADCtGvYYm
+        wKeVKk1ahqBZPPIFXKLRTcQEt/CJjCCWMQcqwJDvvnYtCGtjfdmLcYPcQk0bPFJ9qu1+HUdlYFql
+        1X3j3B4vrLexWjLqSD5Fj0JhJ99mAO9dbc2/JlRgqoMshdbok+F4trNTh0MdyMlJTwqJdgd8ep71
+        +VRso2C9LKwvkQPbrsOUMttmvwAAAP//AwAebllYQgIAAA==
+    headers:
+      CF-Cache-Status:
+      - DYNAMIC
+      CF-RAY:
+      - 8a3c07512da0135d-ATL
+      Connection:
+      - keep-alive
+      Content-Encoding:
+      - gzip
+      Content-Type:
+      - application/json
+      Date:
+      - Mon, 15 Jul 2024 19:06:15 GMT
+      Server:
+      - cloudflare
+      Set-Cookie:
+      - __cf_bm=14DjWb_t0PhGL5mOhK8gsqaD2anNOF1J7Y8Lo_SpKpw-1721070375-1.0.1.1-HZ1yyYErVn.USbzwQt76wp1v0Fpbz2MvF04IOMJMUI7ZFXPv0Np1tZ8z2AthYPyy1oxDYakl9du4ysPr.pp_jg;
+        path=/; expires=Mon, 15-Jul-24 19:36:15 GMT; domain=.api.openai.com; HttpOnly;
+        Secure; SameSite=None
+      - _cfuvid=KuBmiwwXOTWsR0nU52KjyIkpVEjiHsE8MSSzFnGTEv0-1721070375445-0.0.1.1-604800000;
+        path=/; domain=.api.openai.com; HttpOnly; Secure; SameSite=None
+      Transfer-Encoding:
+      - chunked
+      X-Content-Type-Options:
+      - nosniff
+      alt-svc:
+      - h3=":443"; ma=86400
+      openai-organization:
+      - traceloop
+      openai-processing-ms:
+      - '381'
+      openai-version:
+      - '2020-10-01'
+      strict-transport-security:
+      - max-age=15552000; includeSubDomains; preload
+      x-ratelimit-limit-requests:
+      - '5000'
+      x-ratelimit-limit-tokens:
+      - '160000'
+      x-ratelimit-remaining-requests:
+      - '4999'
+      x-ratelimit-remaining-tokens:
+      - '159974'
+      x-ratelimit-reset-requests:
+      - 12ms
+      x-ratelimit-reset-tokens:
+      - 9ms
+      x-request-id:
+      - req_7e9ec34ca2189a55d52eeb1828fcef25
+    status:
+      code: 200
+      message: OK
+version: 1