lmnr 0.4.3__py3-none-any.whl → 0.4.5__py3-none-any.whl

lmnr/sdk/evaluations.py

@@ -1,7 +1,7 @@
 from typing import Union
 
+from .types import EvaluatorFunction, ExecutorFunction, EvaluationDatapoint
 from .utils import is_async
-from .types import EvaluatorFunction, ExecutorFunction, EvaluationDatapoint, Numeric
 from .laminar import Laminar as L
 import asyncio
 
@@ -95,7 +95,7 @@ class Evaluation:
         self.batch_size = batch_size
         L.initialize(project_api_key=project_api_key, base_url=base_url)
 
-    async def run(self):
+    def run(self):
         """Runs the evaluation.
 
         Creates a new evaluation if no evaluation with such name exists, or
@@ -103,7 +103,23 @@ class Evaluation:
         batches of `self.batch_size`. The executor
         function is called on each data point to get the output,
         and then evaluate it by each evaluator function.
+
+        Usage:
+        ```python
+        # in a synchronous context:
+        e.run()
+        # in an asynchronous context:
+        await e.run()
+        ```
+
         """
+        loop = asyncio.get_event_loop()
+        if loop.is_running():
+            return loop.create_task(self._run())
+        else:
+            return loop.run_until_complete(self._run())
+
+    async def _run(self):
         response = L.create_evaluation(self.name)
 
         # Process batches sequentially
@@ -133,7 +149,7 @@ class Evaluation:
     async def _evaluate_datapoint(self, datapoint):
         output = (
             await self.executor(datapoint.data)
-            if asyncio.iscoroutinefunction(self.executor)
+            if is_async(self.executor)
             else self.executor(datapoint.data)
         )
         target = datapoint.target
@@ -144,7 +160,7 @@ class Evaluation:
             evaluator = self.evaluators[evaluator_name]
             value = (
                 await evaluator(output, target)
-                if asyncio.iscoroutinefunction(evaluator)
+                if is_async(evaluator)
                 else evaluator(output, target)
             )
 

lmnr/sdk/laminar.py

@@ -11,7 +11,7 @@ from traceloop.sdk import Traceloop
 from traceloop.sdk.tracing import get_tracer
 
 from pydantic.alias_generators import to_snake
-from typing import Any, Optional, Tuple, Union
+from typing import Any, Optional, Union
 
 import copy
 import datetime
@@ -201,15 +201,21 @@ class Laminar:
     def event(
         cls,
         name: str,
-        value: AttributeValue,
+        value: Optional[AttributeValue] = None,
         timestamp: Optional[Union[datetime.datetime, int]] = None,
     ):
-        """Associate an event with the current span
+        """Associate an event with the current span. If event with such name never
+        existed, Laminar will create a new event and infer its type from the value.
+        If the event already exists, Laminar will append the value to the event
+        if and only if the value is of a matching type. Otherwise, the event won't
+        be recorded Supported types are string, numeric, and boolean. If the value
+        is `None`, event is considered a boolean tag with the value of `True`.
 
         Args:
             name (str): event name
-            value (AttributeValue): event value. Must be a primitive type
-                            or a sequence of values of the same primitive type
+            value (Optional[AttributeValue]): event value. Must be a primitive type.
+                            Boolean true is assumed in the backend if value is None.
+                            Defaults to None.
             timestamp (Optional[Union[datetime.datetime, int]], optional):
                             If int, must be epoch nanoseconds. If not
                             specified, relies on the underlying OpenTelemetry
@@ -220,8 +226,9 @@ class Laminar:
 
         event = {
             "lmnr.event.type": "default",
-            "lmnr.event.value": value,
         }
+        if value is not None:
+            event["lmnr.event.value"] = value
 
         current_span = get_current_span()
         if current_span == INVALID_SPAN:
@@ -282,7 +289,7 @@ class Laminar:
         cls,
         name: str,
         input: Any = None,
-    ) -> Tuple[Span, object]:
+    ) -> Span:
         """Start a new span with the given name. Useful for manual
         instrumentation.
 
@@ -297,33 +304,34 @@ class Laminar:
                     that must be passed to `end_span` to end the span.
 
         """
-        with get_tracer() as tracer:
-            span = tracer.start_span(name)
-            ctx = set_span_in_context(span)
-            token = context.attach(ctx)
-            span.set_attribute(SpanAttributes.TRACELOOP_ENTITY_NAME, name)
-            if input is not None:
-                span.set_attribute(
-                    SpanAttributes.TRACELOOP_ENTITY_INPUT, json.dumps({"input": input})
-                )
-            return (span, token)
+        tracer = get_tracer().__enter__()
+        span = tracer.start_span(name)
+        # apparently, detaching from this context is not mandatory.
+        # According to traceloop, and the github issue in opentelemetry,
+        # the context is collected by the garbage collector.
+        # https://github.com/open-telemetry/opentelemetry-python/issues/2606#issuecomment-2106320379
+        context.attach(set_span_in_context(span))
+
+        if input is not None:
+            span.set_attribute(
+                SpanAttributes.TRACELOOP_ENTITY_INPUT, json.dumps({"input": input})
+            )
+
+        return span
 
     @classmethod
-    def end_span(cls, span: Span, token: object, output: Any = None):
-        """End the span started with `start_span`
+    def set_span_output(cls, span: Span, output: Any = None):
+        """Set the output of the span. Useful for manual instrumentation.
 
         Args:
-            span (Span): span returned by `start_span`
-            token (object): context token returned by `start_span`
+            span (Span): the span to set the output for
             output (Any, optional): output of the span. Will be sent as an
                 attribute, so must be json serializable. Defaults to None.
         """
         if output is not None:
             span.set_attribute(
-                SpanAttributes.TRACELOOP_ENTITY_OUTPUT, json.dumps({"output": output})
+                SpanAttributes.TRACELOOP_ENTITY_OUTPUT, json.dumps({output})
             )
-        span.end()
-        context.detach(token)
 
     @classmethod
     def set_session(

{lmnr-0.4.3.dist-info → lmnr-0.4.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lmnr
-Version: 0.4.3
+Version: 0.4.5
 Summary: Python SDK for Laminar AI
 License: Apache-2.0
 Author: lmnr.ai
@@ -89,6 +89,44 @@ def poem_writer(topic="turbulence"):
 print(poem_writer(topic="laminar flow"))
 ```
 
+### Manual instrumentation
+
+Our manual instrumentation is a very thin wrapper around OpenTelemetry's
+`trace.start_span`. Our wrapper sets the span into the active context.
+You don't have to explicitly pass the spans around, it is enough to
+just call `L.start_span`, and OpenTelemetry will handle the context management
+
+```python
+from lmnr import observe, Laminar as L
+L.initialize(project_api_key="<LMNR_PROJECT_API_KEY>")
+
+def poem_writer(topic="turbulence"):
+    
+    span = L.start_span("poem_writer", topic) # start a span
+
+    prompt = f"write a poem about {topic}"
+
+    # OpenAI calls are still automatically instrumented with OpenLLMetry
+    response = 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
+    # while within the span, you can attach laminar events to it
+    L.event("event_name", "event_value")
+
+    L.set_span_output(span, poem) # set an output
+    
+    # IMPORTANT: don't forget to end all the spans (usually in `finally` blocks)
+    # Otherwise, the trace may not be sent/displayed correctly
+    span.end()
+
+    return poem
+```
+
 
 ## Sending events
 

{lmnr-0.4.3.dist-info → lmnr-0.4.5.dist-info}/RECORD

@@ -1,13 +1,13 @@
 lmnr/__init__.py,sha256=wQwnHl662Xcz7GdSofFsEjmAK0nxioYA2Yq6Q78m4ps,194
 lmnr/sdk/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lmnr/sdk/decorators.py,sha256=Xs6n0TGX9LZ9i1hE_UZz4LEyd_ZAfpVGfNQh_rKwOuA,2493
-lmnr/sdk/evaluations.py,sha256=jdXWRJyr17iAWva8Vyvn8yT-rZAoQ8Xz0QQ_zzfPwvY,6044
-lmnr/sdk/laminar.py,sha256=pMgWugFvzqYaEf1TRIjfFl_yo17GdOGGagnPBEA8nHQ,16520
+lmnr/sdk/evaluations.py,sha256=Z0j2HyXgrwlGyiT_Ql7W3e_ZWjOlNlIj9RWAKjEgkkE,6366
+lmnr/sdk/laminar.py,sha256=LOttLBrQoAlduqLYL6sODYHzqRrt44mDNgnnE2it5CE,17114
 lmnr/sdk/log.py,sha256=EgAMY77Zn1bv1imCqrmflD3imoAJ2yveOkIcrIP3e98,1170
 lmnr/sdk/types.py,sha256=gDwRSWR9A1__FGtQhVaFc6PUYQuIhubo5tpfYAajTQQ,4055
 lmnr/sdk/utils.py,sha256=ZsGJ86tq8lIbvOhSb1gJWH5K3GylO_lgX68FN6rG2nM,3358
-lmnr-0.4.3.dist-info/LICENSE,sha256=67b_wJHVV1CBaWkrKFWU1wyqTPSdzH77Ls-59631COg,10411
-lmnr-0.4.3.dist-info/METADATA,sha256=woC24QpLILvRBtLdwCktKJydeiPXEOH8LBb7CSAnw4I,7025
-lmnr-0.4.3.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-lmnr-0.4.3.dist-info/entry_points.txt,sha256=Qg7ZRax4k-rcQsZ26XRYQ8YFSBiyY2PNxYfq4a6PYXI,41
-lmnr-0.4.3.dist-info/RECORD,,
+lmnr-0.4.5.dist-info/LICENSE,sha256=67b_wJHVV1CBaWkrKFWU1wyqTPSdzH77Ls-59631COg,10411
+lmnr-0.4.5.dist-info/METADATA,sha256=tmHMhn3OT6gvymqbZk1aDp5_LH-dHiOMc2m_Lpt8ptU,8292
+lmnr-0.4.5.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+lmnr-0.4.5.dist-info/entry_points.txt,sha256=Qg7ZRax4k-rcQsZ26XRYQ8YFSBiyY2PNxYfq4a6PYXI,41
+lmnr-0.4.5.dist-info/RECORD,,