lmnr 0.6.16__py3-none-any.whl → 0.7.26__py3-none-any.whl

lmnr/sdk/log.py

@@ -62,11 +62,16 @@ class VerboseFormatter(CustomFormatter):
         return formatter.format(record)
 
 
-def get_default_logger(name: str, level: int = logging.INFO, propagate: bool = False):
+def get_default_logger(
+    name: str, level: int = logging.INFO, propagate: bool = False, verbose: bool = True
+) -> logging.Logger:
     logger = logging.getLogger(name)
     logger.setLevel(level)
     console_log_handler = logging.StreamHandler()
-    console_log_handler.setFormatter(VerboseColorfulFormatter())
+    if verbose:
+        console_log_handler.setFormatter(VerboseColorfulFormatter())
+    else:
+        console_log_handler.setFormatter(ColorfulFormatter())
     logger.addHandler(console_log_handler)
     logger.propagate = propagate
     return logger

lmnr/sdk/types.py

@@ -3,15 +3,17 @@ from __future__ import annotations  # For "Self" | str | ... type hint
 import json
 import logging
 import datetime
-import pydantic
-import pydantic.alias_generators
+from pydantic import BaseModel, Field
 import uuid
 
 from enum import Enum
 from opentelemetry.trace import SpanContext, TraceFlags
-from typing import Any, Awaitable, Callable, Literal, Optional
+from typing import Any, Awaitable, Callable, Optional
+from typing_extensions import TypedDict  # compatibility with python < 3.12
 
-from .utils import serialize
+from .utils import serialize, json_dumps
+
+DEFAULT_DATAPOINT_MAX_DATA_LENGTH = 16_000_000  # 16MB
 
 
 Numeric = int | float
@@ -23,12 +25,24 @@ EvaluationDatapointMetadata = Any | None  # must be JSON-serializable
 
 
 # EvaluationDatapoint is a single data point in the evaluation
-class Datapoint(pydantic.BaseModel):
+class Datapoint(BaseModel):
     # input to the executor function.
     data: EvaluationDatapointData
     # input to the evaluator function (alongside the executor output).
-    target: EvaluationDatapointTarget = pydantic.Field(default=None)
-    metadata: EvaluationDatapointMetadata = pydantic.Field(default=None)
+    target: EvaluationDatapointTarget = Field(default_factory=dict)
+    metadata: EvaluationDatapointMetadata = Field(default_factory=dict)
+    id: uuid.UUID | None = Field(default=None)
+    created_at: datetime.datetime | None = Field(default=None, alias="createdAt")
+
+
+class Dataset(BaseModel):
+    id: uuid.UUID = Field()
+    name: str = Field()
+    created_at: datetime.datetime = Field(alias="createdAt")
+
+
+class PushDatapointsResponse(BaseModel):
+    dataset_id: uuid.UUID = Field(alias="datasetId")
 
 
 ExecutorFunctionReturnType = Any
@@ -49,11 +63,16 @@ EvaluatorFunction = Callable[
 ]
 
 
-class HumanEvaluator(pydantic.BaseModel):
-    pass
+class HumanEvaluatorOptionsEntry(TypedDict):
+    label: str
+    value: float
+
 
+class HumanEvaluator(BaseModel):
+    options: list[HumanEvaluatorOptionsEntry] = Field(default_factory=list)
 
-class InitEvaluationResponse(pydantic.BaseModel):
+
+class InitEvaluationResponse(BaseModel):
     id: uuid.UUID
     createdAt: datetime.datetime
     groupId: str
@@ -61,34 +80,65 @@ class InitEvaluationResponse(pydantic.BaseModel):
     projectId: uuid.UUID
 
 
-class PartialEvaluationDatapoint(pydantic.BaseModel):
+class EvaluationDatapointDatasetLink(BaseModel):
+    dataset_id: uuid.UUID
+    datapoint_id: uuid.UUID
+    created_at: datetime.datetime
+
+    def to_dict(self):
+        return {
+            "datasetId": str(self.dataset_id),
+            "datapointId": str(self.datapoint_id),
+            "createdAt": self.created_at.isoformat(),
+        }
+
+
+class PartialEvaluationDatapoint(BaseModel):
     id: uuid.UUID
     data: EvaluationDatapointData
     target: EvaluationDatapointTarget
     index: int
     trace_id: uuid.UUID
     executor_span_id: uuid.UUID
-    metadata: EvaluationDatapointMetadata = pydantic.Field(default=None)
+    metadata: EvaluationDatapointMetadata = Field(default=None)
+    dataset_link: EvaluationDatapointDatasetLink | None = Field(default=None)
 
     # uuid is not serializable by default, so we need to convert it to a string
-    def to_dict(self):
+    def to_dict(self, max_data_length: int = DEFAULT_DATAPOINT_MAX_DATA_LENGTH):
+        serialized_data = serialize(self.data)
+        serialized_target = serialize(self.target)
+        str_data = json_dumps(serialized_data)
+        str_target = json_dumps(serialized_target)
         try:
             return {
                 "id": str(self.id),
-                "data": str(serialize(self.data))[:100],
-                "target": str(serialize(self.target))[:100],
+                "data": (
+                    str_data[:max_data_length]
+                    if len(str_data) > max_data_length
+                    else serialized_data
+                ),
+                "target": (
+                    str_target[:max_data_length]
+                    if len(str_target) > max_data_length
+                    else serialized_target
+                ),
                 "index": self.index,
                 "traceId": str(self.trace_id),
                 "executorSpanId": str(self.executor_span_id),
                 "metadata": (
                     serialize(self.metadata) if self.metadata is not None else {}
                 ),
+                "datasetLink": (
+                    self.dataset_link.to_dict()
+                    if self.dataset_link is not None
+                    else None
+                ),
             }
         except Exception as e:
             raise ValueError(f"Error serializing PartialEvaluationDatapoint: {e}")
 
 
-class EvaluationResultDatapoint(pydantic.BaseModel):
+class EvaluationResultDatapoint(BaseModel):
     id: uuid.UUID
     index: int
     data: EvaluationDatapointData
@@ -97,18 +147,37 @@ class EvaluationResultDatapoint(pydantic.BaseModel):
     scores: dict[str, Optional[Numeric]]
     trace_id: uuid.UUID
     executor_span_id: uuid.UUID
-    metadata: EvaluationDatapointMetadata = pydantic.Field(default=None)
+    metadata: EvaluationDatapointMetadata = Field(default=None)
+    dataset_link: EvaluationDatapointDatasetLink | None = Field(default=None)
 
     # uuid is not serializable by default, so we need to convert it to a string
-    def to_dict(self):
+    def to_dict(self, max_data_length: int = DEFAULT_DATAPOINT_MAX_DATA_LENGTH):
         try:
+            serialized_data = serialize(self.data)
+            serialized_target = serialize(self.target)
+            serialized_executor_output = serialize(self.executor_output)
+            str_data = json.dumps(serialized_data)
+            str_target = json.dumps(serialized_target)
+            str_executor_output = json.dumps(serialized_executor_output)
             return {
                 # preserve only preview of the data, target and executor output
                 # (full data is in trace)
                 "id": str(self.id),
-                "data": str(serialize(self.data))[:100],
-                "target": str(serialize(self.target))[:100],
-                "executorOutput": str(serialize(self.executor_output))[:100],
+                "data": (
+                    str_data[:max_data_length]
+                    if len(str_data) > max_data_length
+                    else serialized_data
+                ),
+                "target": (
+                    str_target[:max_data_length]
+                    if len(str_target) > max_data_length
+                    else serialized_target
+                ),
+                "executorOutput": (
+                    str_executor_output[:max_data_length]
+                    if len(str_executor_output) > max_data_length
+                    else serialized_executor_output
+                ),
                 "scores": self.scores,
                 "traceId": str(self.trace_id),
                 "executorSpanId": str(self.executor_span_id),
@@ -116,6 +185,11 @@ class EvaluationResultDatapoint(pydantic.BaseModel):
                 "metadata": (
                     serialize(self.metadata) if self.metadata is not None else {}
                 ),
+                "datasetLink": (
+                    self.dataset_link.to_dict()
+                    if self.dataset_link is not None
+                    else None
+                ),
             }
         except Exception as e:
             raise ValueError(f"Error serializing EvaluationResultDatapoint: {e}")
@@ -136,24 +210,17 @@ class TraceType(Enum):
     EVALUATION = "EVALUATION"
 
 
-class GetDatapointsResponse(pydantic.BaseModel):
+class GetDatapointsResponse(BaseModel):
     items: list[Datapoint]
-    totalCount: int
+    total_count: int = Field(alias="totalCount")
 
 
-class TracingLevel(Enum):
-    OFF = 0
-    META_ONLY = 1
-    ALL = 2
-
-
-class LaminarSpanContext(pydantic.BaseModel):
+class LaminarSpanContext(BaseModel):
     """
     A span context that can be used to continue a trace across services. This
     is a slightly modified version of the OpenTelemetry span context. For
-    usage examples, see `Laminar.get_laminar_span_context_dict`,
-    `Laminar.get_laminar_span_context_str`, `Laminar.get_span_context`, and
-    `Laminar.deserialize_laminar_span_context`.
+    usage examples, see `Laminar.serialize_span_context`,
+    `Laminar.get_span_context`, and `Laminar.deserialize_laminar_span_context`.
 
     The difference between this and the OpenTelemetry span context is that
     the `trace_id` and `span_id` are stored as UUIDs instead of integers for
@@ -162,7 +229,13 @@ class LaminarSpanContext(pydantic.BaseModel):
 
     trace_id: uuid.UUID
     span_id: uuid.UUID
-    is_remote: bool = pydantic.Field(default=False)
+    is_remote: bool = Field(default=False)
+    span_path: list[str] = Field(default=[])
+    span_ids_path: list[str] = Field(default=[])  # stringified UUIDs
+    user_id: str | None = Field(default=None)
+    session_id: str | None = Field(default=None)
+    trace_type: TraceType | None = Field(default=None)
+    metadata: dict[str, Any] | None = Field(default=None)
 
     def __str__(self) -> str:
         return self.model_dump_json()
@@ -193,7 +266,7 @@ class LaminarSpanContext(pydantic.BaseModel):
                 "Please use `LaminarSpanContext` instead."
             )
             return span_context
-        elif isinstance(span_context, dict) or isinstance(span_context, str):
+        elif isinstance(span_context, (dict, str)):
             try:
                 laminar_span_context = cls.deserialize(span_context)
                 return SpanContext(
@@ -215,6 +288,13 @@ class LaminarSpanContext(pydantic.BaseModel):
                 "trace_id": data.get("trace_id") or data.get("traceId"),
                 "span_id": data.get("span_id") or data.get("spanId"),
                 "is_remote": data.get("is_remote") or data.get("isRemote", False),
+                "span_path": data.get("span_path") or data.get("spanPath", []),
+                "span_ids_path": data.get("span_ids_path")
+                or data.get("spanIdsPath", []),
+                "user_id": data.get("user_id") or data.get("userId"),
+                "session_id": data.get("session_id") or data.get("sessionId"),
+                "trace_type": data.get("trace_type") or data.get("traceType"),
+                "metadata": data.get("metadata") or data.get("metadata", {}),
             }
             return cls.model_validate(converted_data)
         elif isinstance(data, str):
@@ -230,113 +310,14 @@ class ModelProvider(str, Enum):
     GEMINI = "gemini"
 
 
-class RunAgentRequest(pydantic.BaseModel):
-    model_config = pydantic.ConfigDict(
-        alias_generator=pydantic.alias_generators.to_camel,
-        populate_by_name=True,
-    )
-    prompt: str
-    storage_state: str | None = pydantic.Field(default=None)
-    agent_state: str | None = pydantic.Field(default=None)
-    parent_span_context: str | None = pydantic.Field(default=None)
-    model_provider: ModelProvider | None = pydantic.Field(default=None)
-    model: str | None = pydantic.Field(default=None)
-    stream: bool = pydantic.Field(default=False)
-    enable_thinking: bool = pydantic.Field(default=True)
-    cdp_url: str | None = pydantic.Field(default=None)
-    return_screenshots: bool = pydantic.Field(default=False)
-    return_storage_state: bool = pydantic.Field(default=False)
-    return_agent_state: bool = pydantic.Field(default=False)
-    timeout: int | None = pydantic.Field(default=None)
-    max_steps: int | None = pydantic.Field(default=None)
-    thinking_token_budget: int | None = pydantic.Field(default=None)
-    start_url: str | None = pydantic.Field(default=None)
-    disable_give_control: bool = pydantic.Field(default=False)
-    user_agent: str | None = pydantic.Field(default=None)
-
-
-class ActionResult(pydantic.BaseModel):
-    model_config = pydantic.ConfigDict(
-        alias_generator=pydantic.alias_generators.to_camel
-    )
-    is_done: bool = pydantic.Field(default=False)
-    content: str | None = pydantic.Field(default=None)
-    error: str | None = pydantic.Field(default=None)
-
-
-class AgentOutput(pydantic.BaseModel):
-    model_config = pydantic.ConfigDict(
-        alias_generator=pydantic.alias_generators.to_camel
-    )
-    result: ActionResult = pydantic.Field(default_factory=ActionResult)
-    # Browser state with data related to auth, such as cookies.
-    # A stringified JSON object.
-    # Only returned if return_storage_state is True.
-    # CAUTION: This object may become large. It also may contain sensitive data.
-    storage_state: str | None = pydantic.Field(default=None)
-    # Agent state with data related to the agent's state, such as the chat history.
-    # A stringified JSON object.
-    # Only returned if return_agent_state is True.
-    # CAUTION: This object is large.
-    agent_state: str | None = pydantic.Field(default=None)
-
-
-class StepChunkContent(pydantic.BaseModel):
-    model_config = pydantic.ConfigDict(
-        alias_generator=pydantic.alias_generators.to_camel
-    )
-    chunk_type: Literal["step"] = pydantic.Field(default="step")
-    message_id: uuid.UUID = pydantic.Field()
-    action_result: ActionResult = pydantic.Field()
-    summary: str = pydantic.Field()
-    screenshot: str | None = pydantic.Field(default=None)
-
-
-class TimeoutChunkContent(pydantic.BaseModel):
-    """Chunk content to indicate that timeout has been hit. The only difference from a regular step
-    is the chunk type. This is the last chunk in the stream.
-    """
-
-    model_config = pydantic.ConfigDict(
-        alias_generator=pydantic.alias_generators.to_camel
-    )
-    chunk_type: Literal["timeout"] = pydantic.Field(default="timeout")
-    message_id: uuid.UUID = pydantic.Field()
-    summary: str = pydantic.Field()
-    screenshot: str | None = pydantic.Field(default=None)
+class MaskInputOptions(TypedDict):
+    textarea: bool | None
+    text: bool | None
+    number: bool | None
+    select: bool | None
+    email: bool | None
+    tel: bool | None
 
 
-class FinalOutputChunkContent(pydantic.BaseModel):
-    """Chunk content to indicate that the agent has finished executing. This
-    is the last chunk in the stream.
-    """
-
-    model_config = pydantic.ConfigDict(
-        alias_generator=pydantic.alias_generators.to_camel
-    )
-
-    chunk_type: Literal["finalOutput"] = pydantic.Field(default="finalOutput")
-    message_id: uuid.UUID = pydantic.Field()
-    content: AgentOutput = pydantic.Field()
-
-
-class ErrorChunkContent(pydantic.BaseModel):
-    """Chunk content to indicate that an error has occurred. Typically, this
-    is the last chunk in the stream.
-    """
-
-    model_config = pydantic.ConfigDict(
-        alias_generator=pydantic.alias_generators.to_camel
-    )
-    chunk_type: Literal["error"] = pydantic.Field(default="error")
-    message_id: uuid.UUID = pydantic.Field()
-    error: str = pydantic.Field()
-
-
-class RunAgentResponseChunk(pydantic.RootModel):
-    root: (
-        StepChunkContent
-        | FinalOutputChunkContent
-        | ErrorChunkContent
-        | TimeoutChunkContent
-    )
+class SessionRecordingOptions(TypedDict):
+    mask_input_options: MaskInputOptions | None

lmnr/sdk/utils.py

@@ -1,15 +1,19 @@
-import asyncio
 import datetime
 import dataclasses
 import dotenv
 import enum
 import inspect
 import os
+import orjson
 import pydantic
 import queue
 import typing
 import uuid
 
+from lmnr.sdk.log import get_default_logger
+
+logger = get_default_logger(__name__)
+
 
 def is_method(func: typing.Callable) -> bool:
     # inspect.ismethod is True for bound methods only, but in the decorator,
@@ -33,7 +37,7 @@ def is_async(func: typing.Callable) -> bool:
         return False
 
     # Check if the function is asynchronous
-    if asyncio.iscoroutinefunction(func):
+    if inspect.iscoroutinefunction(func):
         return True
 
     # Fallback: check if the function's code object contains 'async'.
@@ -128,3 +132,112 @@ def is_otel_attribute_value_type(value: typing.Any) -> bool:
             )
         return True
     return False
+
+
+def get_otel_env_var(var_name: str) -> str | None:
+    """Get OTEL environment variable with priority order.
+
+    Checks in order:
+    1. OTEL_EXPORTER_OTLP_TRACES_{var_name}
+    2. OTEL_EXPORTER_OTLP_{var_name}
+    3. OTEL_{var_name}
+
+    Args:
+        var_name: The variable name (e.g., 'ENDPOINT', 'HEADERS', 'TIMEOUT')
+
+    Returns:
+        str | None: The environment variable value or None if not found
+    """
+    candidates = [
+        f"OTEL_EXPORTER_OTLP_TRACES_{var_name}",
+        f"OTEL_EXPORTER_OTLP_{var_name}",
+        f"OTEL_{var_name}",
+    ]
+
+    for candidate in candidates:
+        if value := from_env(candidate):
+            return value
+    return None
+
+
+def parse_otel_headers(headers_str: str | None) -> dict[str, str]:
+    """Parse OTEL headers string into dictionary.
+
+    Format: key1=value1,key2=value2
+    Values are URL-decoded.
+
+    Args:
+        headers_str: Headers string in OTEL format
+
+    Returns:
+        dict[str, str]: Parsed headers dictionary
+    """
+    if not headers_str:
+        return {}
+
+    headers = {}
+    for pair in headers_str.split(","):
+        if "=" in pair:
+            key, value = pair.split("=", 1)
+            import urllib.parse
+
+            headers[key.strip()] = urllib.parse.unquote(value.strip())
+    return headers
+
+
+def format_id(id_value: str | int | uuid.UUID) -> str:
+    """Format trace/span/evaluation ID to a UUID string, or return valid UUID strings as-is.
+
+    Args:
+        id_value: The ID in various formats (UUID, int, or valid UUID string)
+
+    Returns:
+        str: UUID string representation
+
+    Raises:
+        ValueError: If id_value cannot be converted to a valid UUID
+    """
+    if isinstance(id_value, uuid.UUID):
+        return str(id_value)
+    elif isinstance(id_value, int):
+        return str(uuid.UUID(int=id_value))
+    elif isinstance(id_value, str):
+        uuid.UUID(id_value)
+        return id_value
+    else:
+        raise ValueError(f"Invalid ID type: {type(id_value)}")
+
+
+DEFAULT_PLACEHOLDER = {}
+
+
+def default_json(o):
+    if isinstance(o, pydantic.BaseModel):
+        return o.model_dump()
+
+    # Handle various sequence types, but not strings or bytes
+    if isinstance(o, (list, tuple, set, frozenset)):
+        return list(o)
+
+    try:
+        return str(o)
+    except Exception:
+        logger.debug("Failed to serialize data to JSON, inner type: %s", type(o))
+        pass
+    return DEFAULT_PLACEHOLDER
+
+
+def json_dumps(data: dict) -> str:
+    try:
+        return orjson.dumps(
+            data,
+            default=default_json,
+            option=orjson.OPT_SERIALIZE_DATACLASS
+            | orjson.OPT_SERIALIZE_UUID
+            | orjson.OPT_UTC_Z
+            | orjson.OPT_NON_STR_KEYS,
+        ).decode("utf-8")
+    except Exception:
+        # Log the exception and return a placeholder if serialization completely fails
+        logger.info("Failed to serialize data to JSON, type: %s", type(data))
+        return "{}"  # Return an empty JSON object as a fallback

lmnr/version.py

@@ -3,7 +3,7 @@ import httpx
 from packaging import version
 
 
-__version__ = "0.6.16"
+__version__ = "0.7.26"
 PYTHON_VERSION = f"{sys.version_info.major}.{sys.version_info.minor}"