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

lmnr/sdk/interface.py

@@ -1,316 +0,0 @@
-from .context import LaminarSingleton
-from .tracing_types import EvaluateEvent, Span, Trace, Event
-
-from typing import Any, Literal, Optional, Union
-import datetime
-import logging
-import uuid
-
-
-laminar = LaminarSingleton().get()
-
-
-class ObservationContext:
-    observation: Union[Span, Trace] = None
-    _parent: "ObservationContext" = None
-    _children: dict[uuid.UUID, "ObservationContext"] = {}
-    _log = logging.getLogger("laminar.observation_context")
-
-    def __init__(self, observation: Union[Span, Trace], parent: "ObservationContext"):
-        self.observation = observation
-        self._parent = parent
-        self._children = {}
-
-    def _get_parent(self) -> "ObservationContext":
-        raise NotImplementedError
-
-    def update(self, *args, **kwargs):
-        raise NotImplementedError
-
-    def span(
-        self,
-        name: str,
-        input: Optional[Any] = None,
-        metadata: Optional[dict[str, Any]] = None,
-        attributes: Optional[dict[str, Any]] = None,
-        span_type: Literal["DEFAULT", "LLM"] = "DEFAULT",
-    ) -> "SpanContext":
-        """Create a span within the current (trace or span) context.
-
-        Args:
-            name (str): Span name
-            input (Optional[Any], optional): Inputs to the span. Defaults to None.
-            metadata (Optional[dict[str, Any]], optional): Any additional metadata. Defaults to None.
-            attributes (Optional[dict[str, Any]], optional): Any pre-defined attributes. Must comply to the convention. Defaults to None.
-            span_type (Literal["DEFAULT", "LLM"], optional): Type of the span. Defaults to "DEFAULT".
-
-        Returns:
-            SpanContext: The new span context
-        """
-        parent = self
-        parent_span_id = (
-            parent.observation.id if isinstance(parent.observation, Span) else None
-        )
-        trace_id = (
-            parent.observation.traceId
-            if isinstance(parent.observation, Span)
-            else parent.observation.id
-        )
-        span = laminar.create_span(
-            name=name,
-            trace_id=trace_id,
-            input=input,
-            metadata=metadata,
-            attributes=attributes,
-            parent_span_id=parent_span_id,
-            span_type=span_type,
-        )
-        span_context = SpanContext(span, self)
-        self._children[span.id] = span_context
-        return span_context
-
-    def id(self) -> uuid.UUID:
-        """Get the uuid of the current observation
-
-        Returns:
-            uuid.UUID: UUID of the observation
-        """
-        return self.observation.id
-
-
-class SpanContext(ObservationContext):
-    def _get_parent(self) -> ObservationContext:
-        return self._parent
-
-    def end(
-        self,
-        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,
-    ) -> "SpanContext":
-        """End the span with the given output and optional metadata and evaluate events.
-
-        Args:
-            input (Optional[Any], optional): Inputs to the span. Defaults to None.
-            output (Optional[Any], optional): output of the span. Defaults to None.
-            metadata (Optional[dict[str, Any]], optional): any additional metadata to the span. Defaults to None.
-            attributes (Optional[dict[str, Any]], optional): pre-defined attributes (see semantic-convention). Defaults to None.
-            override (bool, optional): override existing metadata fully. If False, metadata is merged. Defaults to False.
-
-        Returns:
-            SpanContext: the finished span context
-        """
-        if self._children:
-            self._log.warning(
-                "Ending span %s, but it has children that have not been finalized. Children: %s",
-                self.observation.name,
-                [child.observation.name for child in self._children.values()],
-            )
-        self._get_parent()._children.pop(self.observation.id)
-        return self._update(
-            input=input,
-            output=output,
-            metadata=metadata,
-            evaluate_events=evaluate_events,
-            attributes=attributes,
-            override=override,
-            finalize=True,
-        )
-
-    def update(
-        self,
-        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,
-    ) -> "SpanContext":
-        """Update the current span with (optionally) the given output and optional metadata and evaluate events, but don't end it.
-
-        Args:
-            input (Optional[Any], optional): Inputs to the span. Defaults to None.
-            output (Optional[Any], optional): output of the span. Defaults to None.
-            metadata (Optional[dict[str, Any]], optional): any additional metadata to the span. Defaults to None.
-            attributes (Optional[dict[str, Any]], optional): pre-defined attributes (see semantic-convention). Defaults to None.
-            override (bool, optional): override existing metadata fully. If False, metadata is merged. Defaults to False.
-
-        Returns:
-            SpanContext: the finished span context
-        """
-        return self._update(
-            input=input or self.observation.input,
-            output=output or self.observation.output,
-            metadata=metadata,
-            evaluate_events=evaluate_events,
-            attributes=attributes,
-            override=override,
-            finalize=False,
-        )
-
-    def event(
-        self,
-        name: str,
-        value: Optional[Union[str, int, float, bool]] = None,
-        timestamp: Optional[datetime.datetime] = None,
-    ) -> "SpanContext":
-        """Associate an event with the current span
-
-        Args:
-            name (str): name of the event. Must be predefined in the Laminar events page.
-            value (Optional[Union[str, int, float, bool]], optional): value of the event. Must match range definition in Laminar events page. Defaults to None.
-            timestamp (Optional[datetime.datetime], optional): If you need custom timestamp. If not specified, current time is used. Defaults to None.
-
-        Returns:
-            SpanContext: the updated span context
-        """
-        event = Event(
-            name=name,
-            span_id=self.observation.id,
-            timestamp=timestamp,
-            value=value,
-        )
-        self.observation.add_event(event)
-        return self
-
-    def evaluate_event(self, name: str, evaluator: str, data: dict) -> "SpanContext":
-        """Evaluate an event with the given name by evaluator based on the given data.
-        Evaluator is the Laminar pipeline name.
-        Data is passed as an input to the the evaluator pipeline, so you need to specify which data you want to evaluate. The prompt
-        of the evaluator will be templated with the keys of the data dictionary.
-
-        Usually, you would want to pass the output of LLM generation, users' messages, and some other surrounding data to 'data'.
-
-        Args:
-            name (str): Name of the event.
-            evaluator (str): Name of the evaluator pipeline.
-            data (dict): Data to be used when evaluating the event.
-
-        Returns:
-            SpanContext: the updated span context
-        """
-        self._update(
-            input=self.observation.input,
-            output=self.observation.output,
-            evaluate_events=[
-                EvaluateEvent(
-                    name=name,
-                    evaluator=evaluator,
-                    data=data,
-                    timestamp=datetime.datetime.now(datetime.timezone.utc),
-                )
-            ],
-            override=False,
-        )
-
-    def _update(
-        self,
-        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,
-        events: Optional[list[Event]] = None,
-        override: bool = False,
-        finalize: bool = False,
-    ) -> "SpanContext":
-        self.observation = laminar.update_span(
-            input=input,
-            output=output,
-            span=self.observation,
-            end_time=datetime.datetime.now(datetime.timezone.utc),
-            metadata=metadata,
-            attributes=attributes,
-            evaluate_events=evaluate_events,
-            finalize=finalize,
-            override=override,
-        )
-        return self
-
-
-class TraceContext(ObservationContext):
-    def _get_parent(self) -> "ObservationContext":
-        return self
-
-    def update(
-        self,
-        user_id: Optional[str] = None,
-        session_id: Optional[str] = None,
-        release: Optional[str] = None,
-        metadata: Optional[dict[str, Any]] = None,
-        success: bool = True,
-    ) -> "TraceContext":
-        """Update the current trace with the given metadata and success status.
-
-        Args:
-            user_id (Optional[str], optional): Custom user_id of your user. Useful for grouping and further analytics. Defaults to None.
-            session_id (Optional[str], optional): Custom session_id for your session. Random UUID is generated on Laminar side, if not specified.
-                                                  Defaults to None.
-            release (Optional[str], optional): _description_. Release of your application. Useful for grouping and further analytics. Defaults to None.
-            metadata (Optional[dict[str, Any]], optional):  any additional metadata to the trace. Defaults to None.
-            success (bool, optional): whether this trace ran successfully. Defaults to True.
-
-        Returns:
-            TraceContext: updated trace context
-        """
-        return self._update(
-            user_id=user_id or self.observation.userId,
-            session_id=session_id or self.observation.sessionId,
-            release=release or self.observation.release,
-            metadata=metadata or self.observation.metadata,
-            success=success if success is not None else self.observation.success,
-        )
-
-    def _update(
-        self,
-        user_id: Optional[str] = None,
-        session_id: Optional[str] = None,
-        release: Optional[str] = None,
-        metadata: Optional[dict[str, Any]] = None,
-        success: bool = True,
-        end_time: Optional[datetime.datetime] = None,
-    ) -> "TraceContext":
-        self.observation = laminar.update_trace(
-            id=self.observation.id,
-            user_id=user_id,
-            session_id=session_id,
-            release=release,
-            metadata=metadata,
-            success=success,
-        )
-        return self
-
-
-def trace(
-    user_id: Optional[str] = None,
-    session_id: Optional[str] = None,
-    release: Optional[str] = None,
-) -> TraceContext:
-    """Create the initial trace context. All further spans will be created within this context.
-
-    Args:
-        user_id (Optional[str], optional): Custom user_id of your user. Useful for grouping and further analytics. Defaults to None.
-        session_id (Optional[str], optional): Custom session_id for your session. Random UUID is generated on Laminar side, if not specified.
-                                                Defaults to None.
-        release (Optional[str], optional): _description_. Release of your application. Useful for grouping and further analytics. Defaults to None.
-
-    Returns:
-        TraceContext: the pointer to the trace context. Use `.span()` to create a new span within this context.
-    """
-    session_id = session_id or str(uuid.uuid4())
-    trace_id = uuid.uuid4()
-    trace = laminar.update_trace(
-        id=trace_id,
-        user_id=user_id,
-        session_id=session_id,
-        release=release,
-    )
-    return TraceContext(trace, None)
-
-
-def initialize(env: dict[str, str]) -> None:
-    laminar = LaminarSingleton().get()
-    laminar.set_env(env)

lmnr/sdk/providers/__init__.py

@@ -1,2 +0,0 @@
-from .base import Provider
-from .openai import OpenAI

lmnr/sdk/providers/base.py

@@ -1,28 +0,0 @@
-import abc
-import pydantic
-import typing
-
-
-class Provider(abc.ABC):
-    def display_name(self) -> str:
-        raise NotImplementedError("display_name not implemented")
-
-    def stream_list_to_dict(self, response: list[typing.Any]) -> dict[str, typing.Any]:
-        raise NotImplementedError("stream_list_to_dict not implemented")
-
-    def extract_llm_attributes_from_response(
-        self, response: typing.Union[str, dict[str, typing.Any], pydantic.BaseModel]
-    ) -> dict[str, typing.Any]:
-        raise NotImplementedError(
-            "extract_llm_attributes_from_response not implemented"
-        )
-
-    def extract_llm_output(
-        self, response: typing.Union[str, dict[str, typing.Any], pydantic.BaseModel]
-    ) -> typing.Any:
-        raise NotImplementedError("extract_llm_output not implemented")
-
-    def extract_llm_attributes_from_args(
-        self, func_args: list[typing.Any], func_kwargs: dict[str, typing.Any]
-    ) -> dict[str, typing.Any]:
-        raise NotImplementedError("_extract_llm_attributes_from_args not implemented")

lmnr/sdk/providers/fallback.py

@@ -1,154 +0,0 @@
-from ...semantic_conventions.gen_ai_spans import (
-    FINISH_REASONS,
-    FREQUENCY_PENALTY,
-    INPUT_TOKEN_COUNT,
-    MAX_TOKENS,
-    OUTPUT_TOKEN_COUNT,
-    PRESENCE_PENALTY,
-    REQUEST_MODEL,
-    RESPONSE_MODEL,
-    STOP_SEQUENCES,
-    STREAM,
-    TEMPERATURE,
-    TOP_K,
-    TOP_P,
-    TOTAL_TOKEN_COUNT,
-)
-from .base import Provider
-from .utils import parse_or_dump_to_dict
-
-from collections import defaultdict
-from typing import Any, Optional, Union
-import logging
-import pydantic
-
-
-class FallbackProvider(Provider):
-    logger = logging.getLogger("lmnr.sdk.tracing.providers.fallback")
-
-    def display_name(self) -> str:
-        return ""
-
-    def stream_list_to_dict(
-        self,
-        response: list[Union[dict[str, Any], str, pydantic.BaseModel]],
-    ) -> dict[str, Any]:
-        model = None
-        output_tokens = 0
-        outputs = defaultdict(lambda: defaultdict(str))
-        try:
-            for chunk in response:
-                chunk = parse_or_dump_to_dict(chunk)
-                if model is None:
-                    model = chunk.get("model")
-                for i, choice in enumerate(chunk.get("choices", [])):
-                    # TODO: not only content, but also tool_calls and refusal
-                    # also handle roles
-                    if choice["delta"] and isinstance(choice["delta"], dict):
-                        for key in choice["delta"]:
-                            if choice["delta"][key] is None:
-                                if key not in outputs[i]:
-                                    outputs[i][key] = None
-                                continue
-                            outputs[i][key] += choice["delta"][key]
-                        output_tokens += 1
-        except Exception as e:
-            self.logger.error(f"Error parsing streamming response: {e}")
-            pass
-
-        output_key_values = [
-            self._message_to_key_and_output(dict(outputs[i]))
-            for i in range(len(outputs))
-        ]
-        return {
-            "model": model,
-            "prompt_tokens": 0,
-            "usage": {
-                "prompt_tokens": 0,
-                "completion_tokens": output_tokens,
-                "total_tokens": output_tokens,
-            },
-            "choices": [
-                (
-                    {
-                        "message": {
-                            output[0]: output[1],
-                            "role": "assistant",
-                        }
-                    }
-                    if output
-                    else None
-                )
-                for output in output_key_values
-            ],
-        }
-
-    def extract_llm_attributes_from_response(
-        self, response: Union[str, dict[str, Any], pydantic.BaseModel]
-    ) -> dict[str, Any]:
-        obj = parse_or_dump_to_dict(response)
-
-        choices = obj.get("choices", [])
-        decisions = []
-        for choice in choices:
-            if choice.get("content"):
-                decisions.append("completion")
-            elif choice.get("refusal"):
-                decisions.append("refusal")
-            elif choice.get("tool_calls"):
-                decisions.append("tool_calls")
-            else:
-                decisions.append(None)
-
-        return {
-            RESPONSE_MODEL: obj.get("model"),
-            INPUT_TOKEN_COUNT: obj.get("usage", {}).get("prompt_tokens"),
-            OUTPUT_TOKEN_COUNT: obj.get("usage", {}).get("completion_tokens"),
-            TOTAL_TOKEN_COUNT: obj.get("usage", {}).get("total_tokens"),
-            FINISH_REASONS: obj.get("finish_reason"),
-            # "decision": self._from_singleton_list(decisions),
-        }
-
-    def extract_llm_output(
-        self, result: Union[str, dict[str, Any], pydantic.BaseModel]
-    ) -> Any:
-        result = parse_or_dump_to_dict(result)
-        choices = result.get("choices")
-        if not choices:
-            return None
-        outputs = [choice.get("message") for choice in choices]
-
-        return self._from_singleton_list(outputs)
-
-    def extract_llm_attributes_from_args(
-        self, func_args: list[Any], func_kwargs: dict[str, Any]
-    ) -> dict[str, Any]:
-        return {
-            REQUEST_MODEL: func_kwargs.get("model"),
-            TEMPERATURE: func_kwargs.get("temperature"),
-            TOP_P: func_kwargs.get("top_p"),
-            TOP_K: func_kwargs.get("top_k"),
-            FREQUENCY_PENALTY: func_kwargs.get("frequency_penalty"),
-            PRESENCE_PENALTY: func_kwargs.get("presence_penalty"),
-            STOP_SEQUENCES: func_kwargs.get("stop"),
-            MAX_TOKENS: func_kwargs.get("max_tokens"),
-            STREAM: func_kwargs.get("stream", False),
-        }
-
-    def _message_to_key_and_output(
-        self, message: Union[dict[str, Any], pydantic.BaseModel]
-    ) -> Optional[tuple[str, str]]:
-        message = parse_or_dump_to_dict(message)
-
-        for key in ["content", "refusal", "tool_calls"]:
-            if message.get(key) is not None:
-                return (key, message[key])
-        return None
-
-    def _from_singleton_list(self, obj: Any) -> Any:
-        # OpenAI returns list of choices. This will have more than one item
-        # only if request parameter `n` is specified and is grate than 1.
-        # That's a rare case, so we return the [contents of the] choice alone if there is just one.
-        if isinstance(obj, list) and len(obj) == 1:
-            return obj[0]
-        return obj

lmnr/sdk/providers/openai.py

@@ -1,159 +0,0 @@
-from .base import Provider
-from ...semantic_conventions.gen_ai_spans import (
-    FINISH_REASONS,
-    FREQUENCY_PENALTY,
-    INPUT_TOKEN_COUNT,
-    MAX_TOKENS,
-    OUTPUT_TOKEN_COUNT,
-    PRESENCE_PENALTY,
-    REQUEST_MODEL,
-    RESPONSE_MODEL,
-    STOP_SEQUENCES,
-    STREAM,
-    TEMPERATURE,
-    TOP_P,
-    TOTAL_TOKEN_COUNT,
-)
-from .utils import parse_or_dump_to_dict
-
-from collections import defaultdict
-from typing import Any, Optional, Union
-import logging
-import pydantic
-
-from openai.types.chat.chat_completion import ChatCompletion
-from openai.types.chat.chat_completion_message import ChatCompletionMessage
-from openai.types.chat.chat_completion_chunk import ChatCompletionChunk
-
-
-class OpenAI(Provider):
-    logger = logging.getLogger("lmnr.sdk.tracing.providers.openai")
-
-    def display_name(self) -> str:
-        return "OpenAI"
-
-    def stream_list_to_dict(
-        self, response: list[Union[ChatCompletionChunk, str]]
-    ) -> dict[str, Any]:
-        model = None
-        finish_reasons = []
-        output_tokens = 0
-        outputs = defaultdict(lambda: defaultdict(str))
-        try:
-            for chunk in response:
-                chunk = parse_or_dump_to_dict(chunk)
-                if model is None:
-                    model = chunk["model"]
-                finish_reasons = [
-                    choice.get("finish_reason") for choice in chunk.get("choices", [])
-                ]
-                for i, choice in enumerate(chunk.get("choices", [])):
-                    if choice["delta"] and isinstance(choice["delta"], dict):
-                        for key in choice["delta"]:
-                            if choice["delta"][key] is None:
-                                if key not in outputs[i]:
-                                    outputs[i][key] = None
-                                continue
-                            outputs[i][key] += choice["delta"][key]
-                        output_tokens += 1
-        except Exception as e:
-            self.logger.error(f"Error parsing streamming response: {e}")
-            pass
-
-        output_key_values = [
-            self._message_to_key_and_output(dict(outputs[i]))
-            for i in range(len(outputs))
-        ]
-        return {
-            "model": model,
-            "prompt_tokens": 0,
-            "usage": {
-                "prompt_tokens": 0,
-                "completion_tokens": output_tokens,
-                "total_tokens": output_tokens,
-                "finish_reason": self._from_singleton_list(finish_reasons),
-            },
-            "choices": [
-                (
-                    {
-                        "message": {
-                            output[0]: output[1],
-                            "role": "assistant",
-                        }
-                    }
-                    if output
-                    else None
-                )
-                for output in output_key_values
-            ],
-        }
-
-    def extract_llm_attributes_from_response(
-        self, response: Union[str, dict[str, Any], pydantic.BaseModel]
-    ) -> dict[str, Any]:
-        obj = parse_or_dump_to_dict(response)
-
-        choices = obj.get("choices", [])
-        decisions = []
-        for choice in choices:
-            # choice = parse_or_dump_to_dict(choice)
-            if choice.get("content"):
-                decisions.append("completion")
-            elif choice.get("refusal"):
-                decisions.append("refusal")
-            elif choice.get("tool_calls"):
-                decisions.append("tool_calls")
-            else:
-                decisions.append(None)
-
-        return {
-            RESPONSE_MODEL: obj.get("model"),
-            INPUT_TOKEN_COUNT: obj.get("usage", {}).get("prompt_tokens"),
-            OUTPUT_TOKEN_COUNT: obj.get("usage", {}).get("completion_tokens"),
-            TOTAL_TOKEN_COUNT: obj.get("usage", {}).get("total_tokens"),
-            FINISH_REASONS: obj.get("finish_reason"),
-            # "decision": self._from_singleton_list(decisions),
-        }
-
-    def extract_llm_output(
-        self, result: Union[str, dict[str, Any], ChatCompletion]
-    ) -> Any:
-        result = parse_or_dump_to_dict(result)
-        choices = result.get("choices")
-        if not choices:
-            return None
-        outputs = [choice["message"] for choice in choices]
-
-        return self._from_singleton_list(outputs)
-
-    def extract_llm_attributes_from_args(
-        self, func_args: list[Any], func_kwargs: dict[str, Any]
-    ) -> dict[str, Any]:
-        return {
-            REQUEST_MODEL: func_kwargs.get("model"),
-            TEMPERATURE: func_kwargs.get("temperature"),
-            TOP_P: func_kwargs.get("top_p"),
-            FREQUENCY_PENALTY: func_kwargs.get("frequency_penalty"),
-            PRESENCE_PENALTY: func_kwargs.get("presence_penalty"),
-            STOP_SEQUENCES: func_kwargs.get("stop"),
-            MAX_TOKENS: func_kwargs.get("max_tokens"),
-            STREAM: func_kwargs.get("stream", False),
-        }
-
-    def _message_to_key_and_output(
-        self, message: Union[dict[str, Any], ChatCompletionMessage]
-    ) -> Optional[tuple[str, str]]:
-        message = parse_or_dump_to_dict(message)
-
-        for key in ["content", "refusal", "tool_calls"]:
-            if message.get(key) is not None:
-                return (key, message[key])
-        return None
-
-    def _from_singleton_list(self, obj: Any) -> Any:
-        # OpenAI returns list of choices. This will have more than one item
-        # only if request parameter `n` is specified and is grate than 1.
-        # That's a rare case, so we return the [contents of the] choice alone if there is just one.
-        if isinstance(obj, list) and len(obj) == 1:
-            return obj[0]
-        return obj

lmnr/sdk/providers/utils.py

@@ -1,33 +0,0 @@
-import logging
-import json
-import pydantic
-import typing
-
-logger = logging.getLogger("lmnr.sdk.tracing.providers.utils")
-
-
-def parse_or_dump_to_dict(
-    obj: typing.Union[pydantic.BaseModel, dict[str, typing.Any], str]
-) -> dict[str, typing.Any]:
-    if isinstance(obj, pydantic.BaseModel):
-        return obj.model_dump()
-    if isinstance(obj, str):
-        try:
-            parsed = json.loads(obj)
-            if isinstance(parsed, dict):
-                return parsed
-            else:
-                logging.warning(
-                    f"Expected a dict, but got: {type(parsed)}. Returning empty dict."
-                )
-                return {}
-        except Exception as e:
-            logging.error(f"Error parsing string: {e}")
-            return {}
-
-    if isinstance(obj, dict):
-        return obj
-    logging.warning(
-        f"Expected a dict, BaseModel, or str, but got {type(obj)}. Returning empty dict."
-    )
-    return {}