lmnr 0.3.6__py3-none-any.whl → 0.4.0__py3-none-any.whl

lmnr/sdk/tracing_types.py

@@ -1,194 +0,0 @@
-from typing import Any, Literal, Optional, Union
-import datetime
-import pydantic
-import uuid
-
-from .constants import CURRENT_TRACING_VERSION
-from .utils import to_dict
-
-
-class EvaluateEvent(pydantic.BaseModel):
-    name: str
-    data: str
-    timestamp: Optional[datetime.datetime] = None
-
-
-class Span(pydantic.BaseModel):
-    version: str = CURRENT_TRACING_VERSION
-    spanType: Literal["DEFAULT", "LLM"] = "DEFAULT"
-    id: uuid.UUID
-    traceId: uuid.UUID
-    parentSpanId: Optional[uuid.UUID] = None
-    name: str
-    # generated at start of span, so required
-    startTime: datetime.datetime
-    # generated at end of span, optional when span is still running
-    endTime: Optional[datetime.datetime] = None
-    attributes: dict[str, Any] = {}
-    input: Optional[Any] = None
-    output: Optional[Any] = None
-    metadata: Optional[dict[str, Any]] = None
-    evaluateEvents: list[EvaluateEvent] = []
-    events: list["Event"] = None
-
-    def __init__(
-        self,
-        name: str,
-        trace_id: uuid.UUID,
-        start_time: Optional[datetime.datetime] = None,
-        version: str = CURRENT_TRACING_VERSION,
-        span_type: Literal["DEFAULT", "LLM"] = "DEFAULT",
-        id: Optional[uuid.UUID] = None,
-        parent_span_id: Optional[uuid.UUID] = None,
-        input: Optional[Any] = None,
-        metadata: Optional[dict[str, Any]] = {},
-        attributes: Optional[dict[str, Any]] = {},
-        evaluate_events: list[EvaluateEvent] = [],
-    ):
-        super().__init__(
-            version=version,
-            spanType=span_type,
-            id=id or uuid.uuid4(),
-            traceId=trace_id,
-            parentSpanId=parent_span_id,
-            name=name,
-            startTime=start_time or datetime.datetime.now(datetime.timezone.utc),
-            input=input,
-            metadata=metadata or {},
-            attributes=attributes or {},
-            evaluateEvents=evaluate_events,
-            events=[],
-        )
-
-    def update(
-        self,
-        end_time: Optional[datetime.datetime],
-        input: Optional[Any] = None,
-        output: Optional[Any] = None,
-        metadata: Optional[dict[str, Any]] = None,
-        attributes: Optional[dict[str, Any]] = None,
-        evaluate_events: Optional[list[EvaluateEvent]] = None,
-        override: bool = False,
-    ):
-        self.endTime = end_time or datetime.datetime.now(datetime.timezone.utc)
-        self.input = input
-        self.output = output
-        new_metadata = (
-            metadata if override else {**(self.metadata or {}), **(metadata or {})}
-        )
-        new_attributes = (
-            attributes or {}
-            if override
-            else {**(self.attributes or {}), **(attributes or {})}
-        )
-        new_evaluate_events = (
-            evaluate_events or []
-            if override
-            else self.evaluateEvents + (evaluate_events or [])
-        )
-        self.metadata = new_metadata
-        self.attributes = new_attributes
-        self.evaluateEvents = new_evaluate_events
-
-    def add_event(self, event: "Event"):
-        self.events.append(event)
-
-    def to_dict(self) -> dict[str, Any]:
-        try:
-            obj = self.model_dump()
-        except TypeError:
-            # if inner values are pydantic models, we need to call model_dump on them
-            # see: https://github.com/pydantic/pydantic/issues/7713
-            obj = {}
-            for key, value in self.__dict__.items():
-                obj[key] = (
-                    value.model_dump()
-                    if isinstance(value, pydantic.BaseModel)
-                    else value
-                )
-        obj = to_dict(obj)
-        return obj
-
-
-class Trace(pydantic.BaseModel):
-    id: uuid.UUID
-    version: str = CURRENT_TRACING_VERSION
-    success: bool = True
-    userId: Optional[str] = None  # provided by user or null
-    sessionId: Optional[str] = None  # provided by user or uuid()
-    release: Optional[str] = None
-    metadata: Optional[dict[str, Any]] = None
-
-    def __init__(
-        self,
-        success: bool = True,
-        id: Optional[uuid.UUID] = None,
-        user_id: Optional[str] = None,
-        session_id: Optional[str] = None,
-        release: Optional[str] = None,
-        metadata: Optional[dict[str, Any]] = None,
-    ):
-        id_ = id or uuid.uuid4()
-        super().__init__(
-            id=id_,
-            success=success,
-            userId=user_id,
-            sessionId=session_id,
-            release=release,
-            metadata=metadata or {},
-        )
-
-    def to_dict(self) -> dict[str, Any]:
-        try:
-            obj = self.model_dump()
-        except TypeError:
-            # if inner values are pydantic models, we need to call model_dump on them
-            # see: https://github.com/pydantic/pydantic/issues/7713
-            obj = {}
-            for key, value in self.__dict__.items():
-                obj[key] = (
-                    value.model_dump()
-                    if isinstance(value, pydantic.BaseModel)
-                    else value
-                )
-        obj = to_dict(obj)
-        return obj
-
-
-class Event(pydantic.BaseModel):
-    id: uuid.UUID
-    templateName: str
-    timestamp: datetime.datetime
-    spanId: uuid.UUID
-    value: Optional[Union[int, str, float, bool]] = None
-
-    def __init__(
-        self,
-        name: str,
-        span_id: uuid.UUID,
-        timestamp: Optional[datetime.datetime] = None,
-        value: Optional[Union[int, str, float, bool]] = None,
-    ):
-        super().__init__(
-            id=uuid.uuid4(),
-            templateName=name,
-            spanId=span_id,
-            timestamp=timestamp or datetime.datetime.now(datetime.timezone.utc),
-            value=value,
-        )
-
-    def to_dict(self) -> dict[str, Any]:
-        try:
-            obj = self.model_dump()
-        except TypeError:
-            # if inner values are pydantic models, we need to call model_dump on them
-            # see: https://github.com/pydantic/pydantic/issues/7713
-            obj = {}
-            for key, value in self.__dict__.items():
-                obj[key] = (
-                    value.model_dump()
-                    if isinstance(value, pydantic.BaseModel)
-                    else value
-                )
-        obj = to_dict(obj)
-        return obj

lmnr/semantic_conventions/gen_ai_spans.py

@@ -1,48 +0,0 @@
-# source: https://github.com/open-telemetry/semantic-conventions/blob/main/docs/gen-ai/gen-ai-spans.md
-# last updated: 2024-08-26
-
-REQUEST_MODEL: str = "gen_ai.request.model"
-RESPONSE_MODEL: str = "gen_ai.response.model"
-PROVIDER: str = "gen_ai.system"
-INPUT_TOKEN_COUNT: str = "gen_ai.usage.input_tokens"
-OUTPUT_TOKEN_COUNT: str = "gen_ai.usage.output_tokens"
-TOTAL_TOKEN_COUNT: str = "gen_ai.usage.total_tokens"  # custom, not in the spec
-# https://github.com/openlit/openlit/blob/main/sdk/python/src/openlit/semcov/__init__.py
-COST: str = "gen_ai.usage.cost"
-
-OPERATION: str = "gen_ai.operation.name"
-
-FREQUENCY_PENALTY: str = "gen_ai.request.frequency_penalty"
-TEMPERATURE: str = "gen_ai.request.temperature"
-MAX_TOKENS: str = "gen_ai.request.max_tokens"
-PRESENCE_PENALTY: str = "gen_ai.request.presence_penalty"
-STOP_SEQUENCES: str = "gen_ai.request.stop_sequences"
-TEMPERATURE: str = "gen_ai.request.temperature"
-TOP_P: str = "gen_ai.request.top_p"
-TOP_K: str = "gen_ai.request.top_k"
-
-# https://github.com/openlit/openlit/blob/main/sdk/python/src/openlit/semcov/__init__.py
-STREAM: str = "gen_ai.request.is_stream"
-
-FINISH_REASONS = "gen_ai.response.finish_reasons"
-
-__all__ = [
-    "REQUEST_MODEL",
-    "RESPONSE_MODEL",
-    "PROVIDER",
-    "INPUT_TOKEN_COUNT",
-    "OUTPUT_TOKEN_COUNT",
-    "TOTAL_TOKEN_COUNT",
-    "COST",
-    "OPERATION",
-    "FREQUENCY_PENALTY",
-    "TEMPERATURE",
-    "MAX_TOKENS",
-    "PRESENCE_PENALTY",
-    "STOP_SEQUENCES",
-    "TEMPERATURE",
-    "TOP_P",
-    "TOP_K",
-    "STREAM",
-    "FINISH_REASONS",
-]

lmnr-0.3.6.dist-info/METADATA

@@ -1,257 +0,0 @@
-Metadata-Version: 2.1
-Name: lmnr
-Version: 0.3.6
-Summary: Python SDK for Laminar AI
-License: Apache-2.0
-Author: lmnr.ai
-Requires-Python: >=3.9,<4.0
-Classifier: License :: OSI Approved :: Apache Software License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Requires-Dist: backoff (>=2.2.1,<3.0.0)
-Requires-Dist: openai (>=1.41.1,<2.0.0)
-Requires-Dist: pydantic (>=2.7.4,<3.0.0)
-Requires-Dist: python-dotenv (>=1.0.1,<2.0.0)
-Requires-Dist: requests (>=2.32.3,<3.0.0)
-Description-Content-Type: text/markdown
-
-# Laminar AI
-
-This repo provides core for code generation, Laminar CLI, and Laminar SDK.
-
-## Quickstart
-```sh
-python3 -m venv .myenv
-source .myenv/bin/activate  # or use your favorite env management tool
-
-pip install lmnr
-```
-
-Create .env file at the root and add `LMNR_PROJECT_API_KEY` value to it.
-
-Read more [here](https://docs.lmnr.ai/api-reference/introduction#authentication) on how to get `LMNR_PROJECT_API_KEY`.
-
-## Sending events
-
-You can send events in two ways:
-- `.event(name, value)` – for a pre-defined event with one of possible values.
-- `.evaluate_event(name, data)` – for an event that our agent checks for and assigns a value from possible values.
-
-There are 3 types of events:
-- Number - Numeric value.
-- String - Arbitrary string.
-- Boolean - Convenient to classify if something has took place or not.
-
-Important notes:
-- If event name does not match anything pre-defined in the UI, the event won't be saved.
-
-## Instrumentation
-
-We provide two ways to instrument your python code:
-- With `@observe()` decorators and `wrap_llm_call` helpers
-- Manually
-
-It is important to not mix the two styles of instrumentation, this can lead to unpredictable results.
-
-## Decorator instrumentation example
-
-For easy automatic instrumentation, we provide you two simple primitives:
-
-- `observe` - a multi-purpose automatic decorator that starts traces and spans when functions are entered, and finishes them when functions return
-- `wrap_llm_call` - a function that takes in your LLM call and return a "decorated" version of it. This does all the same things as `observe`, plus
-a few utilities around LLM-specific things, such as counting tokens and recording model params.
-
-You can also import `lmnr_context` in order to interact and have more control over the context of the current span.
-
-```python
-import os
-from openai import OpenAI
-
-from lmnr import observe, wrap_llm_call, lmnr_context
-client = OpenAI(api_key=os.environ["OPENAI_API_KEY"])
-
-@observe()  # annotate all functions you want to trace
-def poem_writer(topic="turbulence"):
-    prompt = f"write a poem about {topic}"
-
-    # wrap the actual final call to LLM with `wrap_llm_call`
-    response = wrap_llm_call(client.chat.completions.create)(
-        model="gpt-4o",
-        messages=[
-            {"role": "system", "content": "You are a helpful assistant."},
-            {"role": "user", "content": prompt},
-        ],
-    )
-
-    poem = response.choices[0].message.content
-
-    if topic in poem:
-        # send an event with a pre-defined name
-        lmnr_context.event("topic_alignment", "good")
-    
-    # to trigger an automatic check for a possible event do:
-    lmnr_context.evaluate_event("excessive_wordiness", poem)
-
-    return poem
-
-if __name__ == "__main__":
-    print(poem_writer(topic="laminar flow"))
-```
-
-This gives an advantage of quick instrumentation, but is somewhat limited in flexibility + doesn't really work as expected with threading.
-This is due to the fact that we use `contextvars.ContextVar` for this, and how Python manages them between threads.
-
-If you want to instrument your code manually, follow on to the next section
-
-## Manual instrumentation example
-
-For manual instrumetation you will need to import the following:
-- `trace` - this is a function to start a trace. It returns a `TraceContext`
-- `TraceContext` - a pointer to the current trace that you can pass around functions as you want.
-- `SpanContext` - a pointer to the current span that you can pass around functions as you want
-
-Both `TraceContext` and `SpanContext` expose the following interfaces:
-- `span(name: str, **kwargs)` - create a child span within the current context. Returns `SpanContext`
-- `update(**kwargs)` - update the current trace or span and return it. Returns `TraceContext` or `SpanContext`. Useful when some metadata becomes known later during the program execution
-
-In addition, `SpanContext` allows you to:
-- `event(name: str, value: str | int)` - emit a custom event at any point
-- `evaluate_event(name: str, data: str)` - register a possible event for automatic checking by Laminar.
-- `end(**kwargs)` – update the current span, and terminate it
-
-Example:
-
-```python
-import os
-from openai import OpenAI
-
-from lmnr import trace, TraceContext, SpanContext, EvaluateEvent
-from lmnr.semantic_conventions.gen_ai_spans import INPUT_TOKEN_COUNT, OUTPUT_TOKEN_COUNT, RESPONSE_MODEL, PROVIDER, STREAM
-client = OpenAI(api_key=os.environ["OPENAI_API_KEY"])
-
-def poem_writer(t: TraceContext, topic = "turbulence"):
-    span: SpanContext = t.span(name="poem_writer", input=topic)
-
-    prompt = f"write a poem about {topic}"
-    messages = [
-        {"role": "system", "content": "You are a helpful assistant."},
-        {"role": "user", "content": prompt},
-    ]
-    # create a child span within the current `poem_writer` span.
-    llm_span = span.span(name="OpenAI completion", input=messages, span_type="LLM")
-    
-    response = client.chat.completions.create(
-        model="gpt-4o-mini",
-        messages=[
-            {"role": "system", "content": "You are a helpful assistant."},
-            {"role": "user", "content": "Hello. What is the capital of France?"},
-        ],
-    )
-    poem = response.choices[0].message.content
-    if topic in poem:
-        llm_span.event("topic_alignment", "good")  # send an event with a pre-defined name
-
-    # note that you can register possible events here as well,
-    # not only `llm_span.evaluate_event()`
-    llm_span.end(
-        output=poem,
-        evaluate_events=[EvaluateEvent(name="excessive_wordines", data=poem)],
-        attributes={
-            INPUT_TOKEN_COUNT: response.usage.prompt_tokens,
-            OUTPUT_TOKEN_COUNT: response.usage.completion_tokens,
-            RESPONSE_MODEL: response.model,
-            PROVIDER: 'openai',
-            STREAM: False
-        }
-    )
-    span.end(output=poem)
-    return poem
-
-
-t: TraceContext = trace(user_id="user123", session_id="session123", release="release")
-main(t, topic="laminar flow")
-```
-
-## Manual attributes
-
-You can specify span attributes when creating/updating/ending spans.
-
-If you use [decorator instrumentation](#decorator-instrumentation-example), `wrap_llm_call` handles all of this for you.
-
-Example usage:
-
-```python
-from lmnr.semantic_conventions.gen_ai_spans import REQUEST_MODEL
-
-# span_type = LLM is important for correct attribute semantics
-llm_span = span.span(name="OpenAI completion", input=messages, span_type="LLM")
-llm_span.update(
-    attributes={REQUEST_MODEL: "gpt-4o-mini"}
-)
-response = client.chat.completions.create(
-    model="gpt-4o-mini",
-    messages=[
-        {"role": "system", "content": "You are a helpful assistant."},
-        {"role": "user", "content": "Hello. What is the capital of France?"},
-    ],
-)
-```
-
-Semantics:
-
-Check for available semantic conventions in `lmnr.semantic_conventions.gen_ai_spans`.
-
-You can specify the cost with `COST`. Otherwise, the cost will be calculated 
-on the Laminar servers, given the following are specified:
-
-- span_type is `"LLM"`
-- Model provider: `PROVIDER`, e.g. 'openai', 'anthropic'
-- Output tokens: `OUTPUT_TOKEN_COUNT`
-- Input tokens: `INPUT_TOKEN_COUNT`*
-- Model. We look at `RESPONSE_MODEL` first, and then, if it is not present, we take the value of `REQUEST_MODEL`
-
-\* Also, for the case when `PROVIDER` is `"openai"`, the `STREAM` is set to `True`, and `INPUT_TOKEN_COUNT` is not set, we will calculate
-the number of input tokens, and the cost on the server using [tiktoken](https://github.com/zurawiki/tiktoken-rs) and 
-use it in cost calculation.
-This is done because OpenAI does not stream the usage back
-when streaming is enabled. Output token count is (approximately) equal to the number of streaming
-events sent by OpenAI, but there is no way to calculate the input token count, other than re-tokenizing.
-
-## Making Laminar pipeline calls
-
-After you are ready to use your pipeline in your code, deploy it in Laminar by selecting the target version for the pipeline.
-
-Once your pipeline target is set, you can call it from Python in just a few lines.
-
-Example use:
-
-```python
-from lmnr import Laminar 
-
-# for decorator instrumentation, do: `from lmnr inport lmnr_context`
-
-l = Laminar('<YOUR_PROJECT_API_KEY>')
-result = l.run(  # lmnr_context.run( for decorator instrumentation
-    pipeline = 'my_pipeline_name',
-    inputs = {'input_node_name': 'some_value'},
-    # all environment variables
-    env = {'OPENAI_API_KEY': 'sk-some-key'},
-    # any metadata to attach to this run's trace
-    metadata = {'session_id': 'your_custom_session_id'}
-)
-```
-
-Resulting in:
-
-```python
->>> result
-PipelineRunResponse(
-    outputs={'output': {'value': [ChatMessage(role='user', content='hello')]}},
-    # useful to locate your trace
-    run_id='53b012d5-5759-48a6-a9c5-0011610e3669'
-)
-```
-

lmnr-0.3.6.dist-info/RECORD

@@ -1,23 +0,0 @@
-lmnr/__init__.py,sha256=vUiBEqNVi-dWlFKqnyxt0387t1kzVXrwFp7ShhDJyXY,324
-lmnr/sdk/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-lmnr/sdk/client.py,sha256=e6cIvJq38a6XAU8FGWYtNXVAPlEoZEyKS7hC3M_6EkU,5749
-lmnr/sdk/collector.py,sha256=6LRmPhOcmGplUDWm_sJh0dVrLTHknd_kmq7POGuAvoQ,5338
-lmnr/sdk/constants.py,sha256=USCfwuUqRx6_0xC8WUxqGj766dInqQkWJcf8U5vPK7s,34
-lmnr/sdk/context.py,sha256=4ngtUYhix91hUW4Kpo-WplDiNs-SCqz6LmHMl84StoA,15398
-lmnr/sdk/decorators.py,sha256=vEGXYJUKGNVAVEt3sRKAUTtGAdhfQbyA474kfHsZHTk,12024
-lmnr/sdk/interface.py,sha256=ugtNIcHZhHC_qSyu_-1Fm62_phOb4vW-Lo5VZ1WaMhc,12255
-lmnr/sdk/providers/__init__.py,sha256=wNCgQnt9-bnTNXLQWdPgyKhqA1ajiaEd1Rr2KPOpazM,54
-lmnr/sdk/providers/base.py,sha256=xc6iA8yY_VK6tbzswt-3naZ53aAXtOLur9j8eimC_ZA,1054
-lmnr/sdk/providers/fallback.py,sha256=9-srLJgDK5CWD8DIdnxo6jbSsnwDvdHC-vA06BfEkqQ,5431
-lmnr/sdk/providers/openai.py,sha256=9X2VWz4_EqQBEA1UEww2EKdqods6IzOEmaO6dnhY-Lw,5725
-lmnr/sdk/providers/utils.py,sha256=ROt82VrvezExYOxionAynD3dp6oX5JoPW6F1ayTm7q8,946
-lmnr/sdk/tracing_types.py,sha256=O6sfTBRKxz8WtRy4uEr-_wkSqu58mmEa1SXXJXDGwBI,6267
-lmnr/sdk/types.py,sha256=5-Ft-l35wtmn2xxE8BTqsM3nx1zD799tRv4qiOkED50,2121
-lmnr/sdk/utils.py,sha256=9ScSKalwZbW5wAhGN_Mn26_LZewVBkTz_OG5uQi6Og4,3401
-lmnr/semantic_conventions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-lmnr/semantic_conventions/gen_ai_spans.py,sha256=3s-2J5v3t5LcMKwK2DefPn56XpxN5oMEYtb9Mf9D_gA,1541
-lmnr-0.3.6.dist-info/LICENSE,sha256=67b_wJHVV1CBaWkrKFWU1wyqTPSdzH77Ls-59631COg,10411
-lmnr-0.3.6.dist-info/METADATA,sha256=OcWavyUecfR_YwlTJF003WghB4mDqbvUg0ril4arC0k,9485
-lmnr-0.3.6.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-lmnr-0.3.6.dist-info/entry_points.txt,sha256=Qg7ZRax4k-rcQsZ26XRYQ8YFSBiyY2PNxYfq4a6PYXI,41
-lmnr-0.3.6.dist-info/RECORD,,