lmnr 0.6.20__py3-none-any.whl → 0.7.0__py3-none-any.whl

lmnr/sdk/decorators.py

@@ -1,6 +1,6 @@
 from lmnr.opentelemetry_lib.decorators import (
-    entity_method,
-    aentity_method,
+    observe_base,
+    async_observe_base,
     json_dumps,
 )
 from opentelemetry.trace import INVALID_SPAN, get_current_span
@@ -28,6 +28,8 @@ def observe(
     ignore_output: bool = False,
     span_type: Literal["DEFAULT", "LLM", "TOOL"] = "DEFAULT",
     ignore_inputs: list[str] | None = None,
+    input_formatter: Callable[P, str] | None = None,
+    output_formatter: Callable[[R], str] | None = None,
     metadata: dict[str, Any] | None = None,
     tags: list[str] | None = None,
 ) -> Callable[[Callable[P, R]], Callable[P, R]]:
@@ -53,6 +55,16 @@ def observe(
             def foo(a, b, `sensitive_data`), and you want to ignore the\
             `sensitive_data` argument, you can pass ["sensitive_data"] to\
             this argument. Defaults to None.
+        input_formatter (Callable[P, str] | None, optional): A custom function\
+            to format the input of the wrapped function. All function arguments\
+            are passed to this function. Must return a string. Ignored if\
+            `ignore_input` is True. Does not respect `ignore_inputs` argument.
+            Defaults to None.
+        output_formatter (Callable[[R], str] | None, optional): A custom function\
+            to format the output of the wrapped function. The output is passed\
+            to this function. Must return a string. Ignored if `ignore_output`
+            is True. Does not respect `ignore_inputs` argument.
+            Defaults to None.
         metadata (dict[str, Any] | None, optional): Metadata to associate with\
             the trace. Must be JSON serializable. Defaults to None.
         tags (list[str] | None, optional): Tags to associate with the trace.
@@ -91,22 +103,45 @@ def observe(
                 logger.warning("Tags must be a list of strings. Tags will be ignored.")
             else:
                 association_properties["tags"] = tags
+        if input_formatter is not None and ignore_input:
+            logger.warning(
+                f"observe, function {func.__name__}: Input formatter"
+                " is ignored because `ignore_input` is True. Specify only one of"
+                " `ignore_input` or `input_formatter`."
+            )
+        if input_formatter is not None and ignore_inputs is not None:
+            logger.warning(
+                f"observe, function {func.__name__}: Both input formatter and"
+                " `ignore_inputs` are specified. Input formatter"
+                " will pass all arguments to the formatter regardless of"
+                " `ignore_inputs`."
+            )
+        if output_formatter is not None and ignore_output:
+            logger.warning(
+                f"observe, function {func.__name__}: Output formatter"
+                " is ignored because `ignore_output` is True. Specify only one of"
+                " `ignore_output` or `output_formatter`."
+            )
         result = (
-            aentity_method(
+            async_observe_base(
                 name=name,
                 ignore_input=ignore_input,
                 ignore_output=ignore_output,
                 span_type=span_type,
                 ignore_inputs=ignore_inputs,
+                input_formatter=input_formatter,
+                output_formatter=output_formatter,
                 association_properties=association_properties,
             )(func)
             if is_async(func)
-            else entity_method(
+            else observe_base(
                 name=name,
                 ignore_input=ignore_input,
                 ignore_output=ignore_output,
                 span_type=span_type,
                 ignore_inputs=ignore_inputs,
+                input_formatter=input_formatter,
+                output_formatter=output_formatter,
                 association_properties=association_properties,
             )(func)
         )

lmnr/sdk/evaluations.py

@@ -57,7 +57,7 @@ def get_average_scores(results: list[EvaluationResultDatapoint]) -> dict[str, Nu
     average_scores = {}
     for key, values in per_score_values.items():
         scores = [v for v in values if v is not None]
-        
+
         # If there are no scores, we don't want to include the key in the average scores
         if len(scores) > 0:
             average_scores[key] = sum(scores) / len(scores)
@@ -108,6 +108,7 @@ class Evaluation:
         concurrency_limit: int = DEFAULT_BATCH_SIZE,
         project_api_key: str | None = None,
         base_url: str | None = None,
+        base_http_url: str | None = None,
         http_port: int | None = None,
         grpc_port: int | None = None,
         instruments: set[Instruments] | None = None,
@@ -157,6 +158,10 @@ class Evaluation:
                 Useful if self-hosted. Do NOT include the port, use `http_port`\
                 and `grpc_port` instead.
                 Defaults to "https://api.lmnr.ai".
+            base_http_url (str | None, optional): The base HTTP URL for Laminar API.\
+                Only set this if your Laminar backend HTTP is proxied\
+                through a different host. If not specified, defaults\
+                to https://api.lmnr.ai.
             http_port (int | None, optional): The port for Laminar API\
                 HTTP service. Defaults to 443 if not specified.
             grpc_port (int | None, optional): The port for Laminar API\
@@ -199,7 +204,7 @@ class Evaluation:
         self.batch_size = concurrency_limit
         self._logger = get_default_logger(self.__class__.__name__)
         self.upload_tasks = []
-        self.base_http_url = f"{base_url}:{http_port or 443}"
+        self.base_http_url = f"{base_http_url or base_url}:{http_port or 443}"
 
         api_key = project_api_key or from_env("LMNR_PROJECT_API_KEY")
         if not api_key and not L.is_initialized():
@@ -224,6 +229,7 @@ class Evaluation:
         L.initialize(
             project_api_key=project_api_key,
             base_url=base_url,
+            base_http_url=self.base_http_url,
             http_port=http_port,
             grpc_port=grpc_port,
             instruments=instruments,
@@ -352,22 +358,24 @@ class Evaluation:
                 if isinstance(evaluator, HumanEvaluator):
                     # Create an empty span for human evaluators
                     with L.start_as_current_span(
-                        evaluator_name,
-                        input={"output": output, "target": target}
+                        evaluator_name, input={"output": output, "target": target}
                     ) as human_evaluator_span:
-                        human_evaluator_span.set_attribute(SPAN_TYPE, SpanType.HUMAN_EVALUATOR.value)
+                        human_evaluator_span.set_attribute(
+                            SPAN_TYPE, SpanType.HUMAN_EVALUATOR.value
+                        )
                         # Human evaluators don't execute automatically, just create the span
                         L.set_span_output(None)
-                    
+
                     # We don't want to save the score for human evaluators
                     scores[evaluator_name] = None
                 else:
                     # Regular evaluator function
                     with L.start_as_current_span(
-                        evaluator_name,
-                        input={"output": output, "target": target}
+                        evaluator_name, input={"output": output, "target": target}
                     ) as evaluator_span:
-                        evaluator_span.set_attribute(SPAN_TYPE, SpanType.EVALUATOR.value)
+                        evaluator_span.set_attribute(
+                            SPAN_TYPE, SpanType.EVALUATOR.value
+                        )
                         if is_async(evaluator):
                             value = await evaluator(output, target)
                         else:
@@ -416,6 +424,7 @@ def evaluate(
     concurrency_limit: int = DEFAULT_BATCH_SIZE,
     project_api_key: str | None = None,
     base_url: str | None = None,
+    base_http_url: str | None = None,
     http_port: int | None = None,
     grpc_port: int | None = None,
     instruments: set[Instruments] | None = None,
@@ -465,6 +474,10 @@ def evaluate(
                         Useful if self-hosted elsewhere. Do NOT include the\
                         port, use `http_port` and `grpc_port` instead.
                         Defaults to "https://api.lmnr.ai".
+        base_http_url (str | None, optional): The base HTTP URL for Laminar API.\
+                        Only set this if your Laminar backend HTTP is proxied\
+                        through a different host. If not specified, defaults\
+                        to https://api.lmnr.ai.
         http_port (int | None, optional): The port for Laminar API's HTTP\
                         service. 443 is used if not specified.
                         Defaults to None.
@@ -488,6 +501,7 @@ def evaluate(
         concurrency_limit=concurrency_limit,
         project_api_key=project_api_key,
         base_url=base_url,
+        base_http_url=base_http_url,
         http_port=http_port,
         grpc_port=grpc_port,
         instruments=instruments,