lmnr 0.4.66__py3-none-any.whl → 0.5.1__py3-none-any.whl

lmnr/sdk/laminar.py

@@ -1,13 +1,12 @@
 from contextlib import contextmanager
 from contextvars import Context
-from lmnr.openllmetry_sdk import Traceloop
+from lmnr.openllmetry_sdk import TracerManager
 from lmnr.openllmetry_sdk.instruments import Instruments
 from lmnr.openllmetry_sdk.tracing import get_tracer
 from lmnr.openllmetry_sdk.tracing.attributes import (
     ASSOCIATION_PROPERTIES,
     Attributes,
     SPAN_TYPE,
-    OVERRIDE_PARENT_SPAN,
 )
 from lmnr.openllmetry_sdk.config import MAX_MANUAL_SPAN_PAYLOAD_SIZE
 from lmnr.openllmetry_sdk.decorators.base import json_dumps
@@ -20,19 +19,14 @@ from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import (
 from opentelemetry.sdk.trace.id_generator import RandomIdGenerator
 from opentelemetry.util.types import AttributeValue
 
-from typing import Any, Awaitable, Literal, Optional, Set, Union
+from typing import Any, Literal, Optional, Set, Union
 
-import atexit
 import copy
 import datetime
-import dotenv
-import json
 import logging
 import os
-import random
 import re
 import uuid
-import warnings
 
 from lmnr.openllmetry_sdk.tracing.attributes import (
     SESSION_ID,
@@ -46,15 +40,12 @@ from lmnr.openllmetry_sdk.tracing.tracing import (
     set_association_properties,
     update_association_properties,
 )
-from lmnr.sdk.client import LaminarClient
+from lmnr.sdk.utils import from_env
 
 from .log import VerboseColorfulFormatter
 
 from .types import (
     LaminarSpanContext,
-    PipelineRunResponse,
-    NodeInput,
-    SemanticSearchResponse,
     TraceType,
     TracingLevel,
 )
@@ -64,14 +55,12 @@ class Laminar:
     __base_http_url: str
     __base_grpc_url: str
     __project_api_key: Optional[str] = None
-    __env: dict[str, str] = {}
     __initialized: bool = False
 
     @classmethod
     def initialize(
         cls,
         project_api_key: Optional[str] = None,
-        env: dict[str, str] = {},
         base_url: Optional[str] = None,
         http_port: Optional[int] = None,
         grpc_port: Optional[int] = None,
@@ -92,10 +81,6 @@ class Laminar:
                             LMNR_PROJECT_API_KEY environment variable\
                             in os.environ or in .env file.
                             Defaults to None.
-            env (dict[str, str], optional): Default environment passed to\
-                            `run` requests, unless overriden at request time.\
-                            Usually, model provider keys are stored here.
-                            Defaults to {}.
             base_url (Optional[str], optional): Laminar API url. Do NOT include\
                             the port number, use `http_port` and `grpc_port`.\
                             If not specified, defaults to https://api.lmnr.ai.
@@ -119,38 +104,31 @@ class Laminar:
         Raises:
             ValueError: If project API key is not set
         """
-        cls.__project_api_key = project_api_key or os.environ.get(
-            "LMNR_PROJECT_API_KEY"
-        )
-        if not cls.__project_api_key:
-            dotenv_path = dotenv.find_dotenv(usecwd=True)
-            cls.__project_api_key = dotenv.get_key(
-                dotenv_path=dotenv_path, key_to_get="LMNR_PROJECT_API_KEY"
-            )
+        cls.__project_api_key = project_api_key or from_env("LMNR_PROJECT_API_KEY")
         if not cls.__project_api_key:
             raise ValueError(
                 "Please initialize the Laminar object with"
                 " your project API key or set the LMNR_PROJECT_API_KEY"
                 " environment variable in your environment or .env file"
             )
-        url = re.sub(r"/$", "", base_url or "https://api.lmnr.ai")
-        if re.search(r":\d{1,5}$", url):
-            raise ValueError(
-                "Please provide the `base_url` without the port number. "
-                "Use the `http_port` and `grpc_port` arguments instead."
-            )
+
+        cls._initialize_logger()
+
+        url = base_url or from_env("LMNR_BASE_URL") or "https://api.lmnr.ai"
+        url = url.rstrip("/")
+        if match := re.search(r":(\d{1,5})$", url):
+            url = url[: -len(match.group(0))]
+            if http_port is None:
+                cls.__logger.info(f"Using HTTP port from base URL: {match.group(1)}")
+                http_port = int(match.group(1))
+            else:
+                cls.__logger.info(f"Using HTTP port passed as an argument: {http_port}")
+
         cls.__base_http_url = f"{url}:{http_port or 443}"
         cls.__base_grpc_url = f"{url}:{grpc_port or 8443}"
 
-        cls.__env = env
         cls.__initialized = True
-        cls._initialize_logger()
-        LaminarClient.initialize(
-            base_url=cls.__base_http_url,
-            project_api_key=cls.__project_api_key,
-        )
-        atexit.register(LaminarClient.shutdown)
-        if not os.environ.get("OTEL_ATTRIBUTE_COUNT_LIMIT"):
+        if not os.getenv("OTEL_ATTRIBUTE_COUNT_LIMIT"):
             # each message is at least 2 attributes: role and content,
             # but the default attribute limit is 128, so raise it
             os.environ["OTEL_ATTRIBUTE_COUNT_LIMIT"] = "10000"
@@ -163,7 +141,7 @@ class Laminar:
         #         "`pip install --upgrade lmnr`."
         #     )
 
-        Traceloop.init(
+        TracerManager.init(
             base_http_url=cls.__base_http_url,
             project_api_key=cls.__project_api_key,
             exporter=OTLPSpanExporter(
@@ -195,83 +173,6 @@ class Laminar:
         console_log_handler.setFormatter(VerboseColorfulFormatter())
         cls.__logger.addHandler(console_log_handler)
 
-    @classmethod
-    def run(
-        cls,
-        pipeline: str,
-        inputs: dict[str, NodeInput],
-        env: dict[str, str] = {},
-        metadata: dict[str, str] = {},
-        parent_span_id: Optional[uuid.UUID] = None,
-        trace_id: Optional[uuid.UUID] = None,
-    ) -> Union[PipelineRunResponse, Awaitable[PipelineRunResponse]]:
-        """Runs the pipeline with the given inputs. If called from an async
-        function, must be awaited.
-
-        Args:
-            pipeline (str): name of the Laminar pipeline.\
-                The pipeline must have a target version set.
-            inputs (dict[str, NodeInput]):
-                inputs to the endpoint's target pipeline.\
-                Keys in the dictionary must match input node names
-            env (dict[str, str], optional):
-                Environment variables for the pipeline execution.
-                Defaults to {}.
-            metadata (dict[str, str], optional):
-                any custom metadata to be stored with execution trace.
-                Defaults to {}.
-            parent_span_id (Optional[uuid.UUID], optional): parent span id for\
-                the resulting span.
-                Defaults to None.
-            trace_id (Optional[uuid.UUID], optional): trace id for the\
-                resulting trace.
-                Defaults to None.
-
-        Returns:
-            PipelineRunResponse: response object containing the outputs
-
-        Raises:
-            ValueError: if project API key is not set
-            PipelineRunError: if the endpoint run fails
-        """
-        return LaminarClient.run_pipeline(
-            pipeline=pipeline,
-            inputs=inputs,
-            env=env or cls.__env,
-            metadata=metadata,
-            parent_span_id=parent_span_id,
-            trace_id=trace_id,
-        )
-
-    @classmethod
-    def semantic_search(
-        cls,
-        query: str,
-        dataset_id: uuid.UUID,
-        limit: Optional[int] = None,
-        threshold: Optional[float] = None,
-    ) -> SemanticSearchResponse:
-        """Perform a semantic search on a dataset. If called from an async
-        function, must be awaited.
-
-        Args:
-            query (str): query string to search by
-            dataset_id (uuid.UUID): id of the dataset to search in
-            limit (Optional[int], optional): maximum number of results to\
-                return. Defaults to None.
-            threshold (Optional[float], optional): minimum score for a result\
-                to be returned. Defaults to None.
-
-        Returns:
-            SemanticSearchResponse: response object containing the search results sorted by score in descending order
-        """
-        return LaminarClient.semantic_search(
-            query=query,
-            dataset_id=dataset_id,
-            limit=limit,
-            threshold=threshold,
-        )
-
     @classmethod
     def event(
         cls,
@@ -326,8 +227,6 @@ class Laminar:
         context: Optional[Context] = None,
         labels: Optional[list[str]] = None,
         parent_span_context: Optional[LaminarSpanContext] = None,
-        # deprecated, use parent_span_context instead
-        trace_id: Optional[uuid.UUID] = None,
     ):
         """Start a new span as the current span. Useful for manual
         instrumentation. If `span_type` is set to `"LLM"`, you should report
@@ -362,9 +261,6 @@ class Laminar:
                 Defaults to None.
             labels (Optional[list[str]], optional): labels to set for the\
                 span. Defaults to None.
-            trace_id (Optional[uuid.UUID], optional): [Deprecated] override\
-                the trace id for the span. If not provided, use the current\
-                trace id. Defaults to None.
         """
 
         if not cls.is_initialized():
@@ -379,13 +275,6 @@ class Laminar:
 
         with get_tracer() as tracer:
             ctx = context or context_api.get_current()
-            if trace_id is not None:
-                warnings.warn(
-                    "trace_id provided to `Laminar.start_as_current_span`"
-                    " is deprecated, use parent_span_context instead",
-                    DeprecationWarning,
-                    stacklevel=2,
-                )
             if parent_span_context is not None:
                 span_context = LaminarSpanContext.try_to_otel_span_context(
                     parent_span_context, cls.__logger
@@ -393,16 +282,6 @@ class Laminar:
                 ctx = trace.set_span_in_context(
                     trace.NonRecordingSpan(span_context), ctx
                 )
-            elif trace_id is not None and isinstance(trace_id, uuid.UUID):
-                span_context = trace.SpanContext(
-                    trace_id=int(trace_id),
-                    span_id=random.getrandbits(64),
-                    is_remote=False,
-                    trace_flags=trace.TraceFlags(trace.TraceFlags.SAMPLED),
-                )
-                ctx = trace.set_span_in_context(
-                    trace.NonRecordingSpan(span_context), ctx
-                )
             ctx_token = attach(ctx)
             label_props = {}
             try:
@@ -421,8 +300,6 @@ class Laminar:
                     **(label_props),
                 },
             ) as span:
-                if trace_id is not None and isinstance(trace_id, uuid.UUID):
-                    span.set_attribute(OVERRIDE_PARENT_SPAN, True)
                 if input is not None:
                     serialized_input = json_dumps(input)
                     if len(serialized_input) > MAX_MANUAL_SPAN_PAYLOAD_SIZE:
@@ -493,8 +370,6 @@ class Laminar:
         context: Optional[Context] = None,
         parent_span_context: Optional[LaminarSpanContext] = None,
         labels: Optional[dict[str, str]] = None,
-        # deprecated, use parent_span_context instead
-        trace_id: Optional[uuid.UUID] = None,
     ):
         """Start a new span. Useful for manual instrumentation.
         If `span_type` is set to `"LLM"`, you should report usage and response
@@ -548,9 +423,6 @@ class Laminar:
                 Defaults to None.
             labels (Optional[dict[str, str]], optional): labels to set for the\
                 span. Defaults to None.
-            trace_id (Optional[uuid.UUID], optional): Deprecated, use\
-                `parent_span_context` instead. If provided, it will be used to\
-                set the trace id for the span.
         """
         if not cls.is_initialized():
             return trace.NonRecordingSpan(
@@ -563,13 +435,6 @@ class Laminar:
 
         with get_tracer() as tracer:
             ctx = context or context_api.get_current()
-            if trace_id is not None:
-                warnings.warn(
-                    "trace_id provided to `Laminar.start_span`"
-                    " is deprecated, use parent_span_context instead",
-                    DeprecationWarning,
-                    stacklevel=2,
-                )
             if parent_span_context is not None:
                 span_context = LaminarSpanContext.try_to_otel_span_context(
                     parent_span_context, cls.__logger
@@ -577,16 +442,6 @@ class Laminar:
                 ctx = trace.set_span_in_context(
                     trace.NonRecordingSpan(span_context), ctx
                 )
-            elif trace_id is not None and isinstance(trace_id, uuid.UUID):
-                span_context = trace.SpanContext(
-                    trace_id=int(trace_id),
-                    span_id=random.getrandbits(64),
-                    is_remote=False,
-                    trace_flags=trace.TraceFlags(trace.TraceFlags.SAMPLED),
-                )
-                ctx = trace.set_span_in_context(
-                    trace.NonRecordingSpan(span_context), ctx
-                )
             label_props = {}
             try:
                 if labels:
@@ -606,8 +461,6 @@ class Laminar:
                     **(label_props),
                 },
             )
-            if trace_id is not None and isinstance(trace_id, uuid.UUID):
-                span.set_attribute(OVERRIDE_PARENT_SPAN, True)
             if input is not None:
                 serialized_input = json_dumps(input)
                 if len(serialized_input) > MAX_MANUAL_SPAN_PAYLOAD_SIZE:
@@ -743,7 +596,7 @@ class Laminar:
         span_context = cls.get_laminar_span_context(span)
         if span_context is None:
             return None
-        return span_context.to_dict()
+        return span_context.model_dump()
 
     @classmethod
     def serialize_span_context(cls, span: Optional[trace.Span] = None) -> Optional[str]:
@@ -777,7 +630,7 @@ class Laminar:
         span_context = cls.get_laminar_span_context(span)
         if span_context is None:
             return None
-        return json.dumps(span_context.to_dict())
+        return str(span_context)
 
     @classmethod
     def deserialize_span_context(
@@ -786,14 +639,21 @@ class Laminar:
         return LaminarSpanContext.deserialize(span_context)
 
     @classmethod
-    def shutdown(cls):
-        Traceloop.flush()
-        LaminarClient.shutdown()
+    def flush(cls) -> bool:
+        """Flush the internal tracer.
+
+        Returns:
+            bool: True if the tracer was flushed, False otherwise
+            (e.g. no tracer or timeout).
+        """
+        if not cls.is_initialized():
+            return False
+        return TracerManager.flush()
 
     @classmethod
-    async def shutdown_async(cls):
-        Traceloop.flush()
-        await LaminarClient.shutdown_async()
+    def shutdown(cls):
+        # other shutdown logic could be added here
+        cls.flush()
 
     @classmethod
     def set_session(

lmnr/sdk/types.py

@@ -1,11 +1,11 @@
 import logging
-import aiohttp
 import datetime
 from enum import Enum
+import httpx
 import json
 from opentelemetry.trace import SpanContext, TraceFlags
 import pydantic
-from typing import Any, Awaitable, Callable, Optional, Union
+from typing import Any, Awaitable, Callable, Literal, Optional, Union
 import uuid
 
 from .utils import serialize
@@ -91,11 +91,15 @@ class PipelineRunError(Exception):
     error_code: str
     error_message: str
 
-    def __init__(self, response: aiohttp.ClientResponse):
+    def __init__(self, response: httpx.Response):
         try:
             resp_json = response.json()
-            self.error_code = resp_json["error_code"]
-            self.error_message = resp_json["error_message"]
+            try:
+                resp_dict = dict(resp_json)
+            except Exception:
+                resp_dict = {}
+            self.error_code = resp_dict.get("error_code")
+            self.error_message = resp_dict.get("error_message")
             super().__init__(self.error_message)
         except Exception:
             super().__init__(response.text)
@@ -225,7 +229,6 @@ class SpanType(Enum):
 
 class TraceType(Enum):
     DEFAULT = "DEFAULT"
-    EVENT = "EVENT"  # deprecated
     EVALUATION = "EVALUATION"
 
 
@@ -257,21 +260,8 @@ class LaminarSpanContext(pydantic.BaseModel):
     span_id: uuid.UUID
     is_remote: bool = pydantic.Field(default=False)
 
-    # uuid is not serializable by default, so we need to convert it to a string
-    def to_dict(self):
-        return {
-            "traceId": str(self.trace_id),
-            "spanId": str(self.span_id),
-            "isRemote": self.is_remote,
-        }
-
-    @classmethod
-    def from_dict(cls, data: dict[str, Any]) -> "LaminarSpanContext":
-        return cls(
-            trace_id=uuid.UUID(data.get("traceId") or data.get("trace_id")),
-            span_id=uuid.UUID(data.get("spanId") or data.get("span_id")),
-            is_remote=data.get("isRemote") or data.get("is_remote") or False,
-        )
+    def __str__(self) -> str:
+        return self.model_dump_json()
 
     @classmethod
     def try_to_otel_span_context(
@@ -316,8 +306,119 @@ class LaminarSpanContext(pydantic.BaseModel):
     @classmethod
     def deserialize(cls, data: Union[dict[str, Any], str]) -> "LaminarSpanContext":
         if isinstance(data, dict):
-            return cls.from_dict(data)
+            # Convert camelCase to snake_case for known fields
+            converted_data = {
+                "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),
+            }
+            return cls.model_validate(converted_data)
         elif isinstance(data, str):
-            return cls.from_dict(json.loads(data))
+            return cls.deserialize(json.loads(data))
         else:
             raise ValueError("Invalid span_context provided")
+
+
+class ModelProvider(str, Enum):
+    ANTHROPIC = "anthropic"
+    BEDROCK = "bedrock"
+
+
+# class AgentChatMessageContentTextBlock(pydantic.BaseModel):
+#     type: Literal["text"]
+#     text: str
+
+
+# class AgentChatMessageImageUrlBlock(pydantic.BaseModel):
+#     type: Literal["image"]
+#     imageUrl: str
+
+
+# class AgentChatMessageImageBase64Block(pydantic.BaseModel):
+#     type: Literal["image"]
+#     imageB64: str
+
+
+# class AgentChatMessageImageBlock(pydantic.RootModel):
+#     root: Union[AgentChatMessageImageUrlBlock, AgentChatMessageImageBase64Block]
+
+
+# class AgentChatMessageContentBlock(pydantic.RootModel):
+#     root: Union[AgentChatMessageContentTextBlock, AgentChatMessageImageBlock]
+
+
+# class AgentChatMessageContent(pydantic.RootModel):
+#     root: Union[str, list[AgentChatMessageContentBlock]]
+
+
+# class AgentChatMessage(pydantic.BaseModel):
+#     role: str
+#     content: AgentChatMessageContent
+#     name: Optional[str] = None
+#     toolCallId: Optional[str] = None
+#     isStateMessage: bool = False
+
+
+# class AgentState(pydantic.BaseModel):
+# messages: str = pydantic.Field(default="")
+# messages: list[AgentChatMessage] = pydantic.Field(default_factory=list)
+# browser_state: Optional[BrowserState] = None
+
+
+class RunAgentRequest(pydantic.BaseModel):
+    prompt: str
+    state: Optional[str] = pydantic.Field(default=None)
+    parent_span_context: Optional[str] = pydantic.Field(default=None)
+    model_provider: Optional[ModelProvider] = pydantic.Field(default=None)
+    model: Optional[str] = pydantic.Field(default=None)
+    stream: bool = pydantic.Field(default=False)
+    enable_thinking: bool = pydantic.Field(default=True)
+    cdp_url: Optional[str] = pydantic.Field(default=None)
+    return_screenshots: bool = pydantic.Field(default=False)
+
+    def to_dict(self):
+        result = {
+            "prompt": self.prompt,
+            "stream": self.stream,
+            "enableThinking": self.enable_thinking,
+            "returnScreenshots": self.return_screenshots,
+        }
+        if self.state:
+            result["state"] = self.state
+        if self.parent_span_context:
+            result["parentSpanContext"] = self.parent_span_context
+        if self.model_provider:
+            result["modelProvider"] = self.model_provider.value
+        if self.model:
+            result["model"] = self.model
+        if self.cdp_url:
+            result["cdpUrl"] = self.cdp_url
+        return result
+
+
+class ActionResult(pydantic.BaseModel):
+    isDone: bool = pydantic.Field(default=False)
+    content: Optional[str] = pydantic.Field(default=None)
+    error: Optional[str] = pydantic.Field(default=None)
+
+
+class AgentOutput(pydantic.BaseModel):
+    result: ActionResult = pydantic.Field(default_factory=ActionResult)
+
+
+class StepChunkContent(pydantic.BaseModel):
+    chunkType: Literal["step"]
+    messageId: uuid.UUID
+    actionResult: ActionResult
+    summary: str
+    screenshot: Optional[str] = pydantic.Field(default=None)
+
+
+class FinalOutputChunkContent(pydantic.BaseModel):
+    chunkType: Literal["finalOutput"]
+    messageId: uuid.UUID
+    content: AgentOutput
+
+
+class RunAgentResponseChunk(pydantic.RootModel):
+    root: Union[StepChunkContent, FinalOutputChunkContent]

lmnr/sdk/utils.py

@@ -1,8 +1,10 @@
 import asyncio
 import datetime
 import dataclasses
+import dotenv
 import enum
 import inspect
+import os
 import pydantic
 import queue
 import typing
@@ -97,3 +99,11 @@ def get_input_from_func_args(
         if i < len(func_args):
             res[k] = func_args[i]
     return res
+
+
+def from_env(key: str) -> typing.Optional[str]:
+    if val := os.getenv(key):
+        return val
+    dotenv_path = dotenv.find_dotenv(usecwd=True)
+    # use DotEnv directly so we can set verbose to False
+    return dotenv.main.DotEnv(dotenv_path, verbose=False, encoding="utf-8").get(key)

lmnr/version.py

@@ -1,15 +1,15 @@
 import sys
-import requests
+import httpx
 from packaging import version
 
 
-SDK_VERSION = "0.4.66"
+__version__ = "0.5.1"
 PYTHON_VERSION = f"{sys.version_info.major}.{sys.version_info.minor}"
 
 
 def is_latest_version() -> bool:
     try:
-        return version.parse(SDK_VERSION) >= version.parse(get_latest_pypi_version())
+        return version.parse(__version__) >= version.parse(get_latest_pypi_version())
     except Exception:
         return True
 
@@ -20,7 +20,7 @@ def get_latest_pypi_version() -> str:
     Returns the version string or raises an exception if unable to fetch.
     """
     try:
-        response = requests.get("https://pypi.org/pypi/lmnr/json")
+        response = httpx.get("https://pypi.org/pypi/lmnr/json")
         response.raise_for_status()
 
         releases = response.json()["releases"]
@@ -35,7 +35,7 @@ def get_latest_pypi_version() -> str:
         if not stable_versions:
             # do not scare the user, assume they are on
             # latest version
-            return SDK_VERSION
+            return __version__
 
         latest_version = max(stable_versions, key=version.parse)
         return latest_version
@@ -43,4 +43,4 @@ def get_latest_pypi_version() -> str:
     except Exception:
         # do not scare the user, assume they are on
         # latest version
-        return SDK_VERSION
+        return __version__