lmnr 0.4.11__py3-none-any.whl → 0.4.12__py3-none-any.whl

lmnr/traceloop_sdk/tracing/tracing.py

@@ -3,7 +3,6 @@ import logging
 import os
 
 
-from colorama import Fore
 from opentelemetry import trace
 from opentelemetry.exporter.otlp.proto.http.trace_exporter import (
     OTLPSpanExporter as HTTPExporter,
@@ -24,17 +23,16 @@ from opentelemetry.trace import get_tracer_provider, ProxyTracerProvider
 from opentelemetry.context import get_value, attach, set_value
 from opentelemetry.instrumentation.threading import ThreadingInstrumentor
 
-from opentelemetry.semconv_ai import SpanAttributes
-
 # from lmnr.traceloop_sdk import Telemetry
 from lmnr.traceloop_sdk.instruments import Instruments
+from lmnr.traceloop_sdk.tracing.attributes import ASSOCIATION_PROPERTIES
 from lmnr.traceloop_sdk.tracing.content_allow_list import ContentAllowList
 from lmnr.traceloop_sdk.utils import is_notebook
 from lmnr.traceloop_sdk.utils.package_check import is_package_installed
 from typing import Dict, Optional, Set
 
 
-TRACER_NAME = "traceloop.tracer"
+TRACER_NAME = "lmnr.tracer"
 EXCLUDED_URLS = """
     iam.cloud.ibm.com,
     dataplatform.cloud.ibm.com,
@@ -44,7 +42,7 @@ EXCLUDED_URLS = """
     api.anthropic.com,
     api.cohere.ai,
     pinecone.io,
-    traceloop.com,
+    api.lmnr.ai,
     posthog.com,
     sentry.io,
     bedrock-runtime,
@@ -124,196 +122,109 @@ class TracerWrapper(object):
             # this makes sure otel context is propagated so we always want it
             ThreadingInstrumentor().instrument()
 
-            instrument_set = False
             if instruments is None:
                 init_instrumentations(should_enrich_metrics)
-                instrument_set = True
             else:
                 for instrument in instruments:
                     if instrument == Instruments.OPENAI:
                         if not init_openai_instrumentor(should_enrich_metrics):
-                            print(Fore.RED + "Warning: OpenAI library does not exist.")
-                            print(Fore.RESET)
-                        else:
-                            instrument_set = True
+                            print("Warning: OpenAI library does not exist.")
                     elif instrument == Instruments.ANTHROPIC:
                         if not init_anthropic_instrumentor(should_enrich_metrics):
                             print(
-                                Fore.RED + "Warning: Anthropic library does not exist."
+                                 "Warning: Anthropic library does not exist."
                             )
-                            print(Fore.RESET)
-                        else:
-                            instrument_set = True
                     elif instrument == Instruments.COHERE:
                         if not init_cohere_instrumentor():
-                            print(Fore.RED + "Warning: Cohere library does not exist.")
-                            print(Fore.RESET)
-                        else:
-                            instrument_set = True
+                            print("Warning: Cohere library does not exist.")
                     elif instrument == Instruments.PINECONE:
                         if not init_pinecone_instrumentor():
                             print(
-                                Fore.RED + "Warning: Pinecone library does not exist."
+                                "Warning: Pinecone library does not exist."
                             )
-                            print(Fore.RESET)
-                        else:
-                            instrument_set = True
                     elif instrument == Instruments.CHROMA:
                         if not init_chroma_instrumentor():
-                            print(Fore.RED + "Warning: Chroma library does not exist.")
-                            print(Fore.RESET)
-                        else:
-                            instrument_set = True
+                            print("Warning: Chroma library does not exist.")
                     elif instrument == Instruments.GOOGLE_GENERATIVEAI:
                         if not init_google_generativeai_instrumentor():
-                            print(
-                                Fore.RED
-                                + "Warning: Google Generative AI library does not exist."
-                            )
-                            print(Fore.RESET)
-                        else:
-                            instrument_set = True
+                            print("Warning: Google Generative AI library does not exist.")
                     elif instrument == Instruments.LANGCHAIN:
                         if not init_langchain_instrumentor():
                             print(
-                                Fore.RED + "Warning: LangChain library does not exist."
+                                "Warning: LangChain library does not exist."
                             )
-                            print(Fore.RESET)
-                        else:
-                            instrument_set = True
                     elif instrument == Instruments.MISTRAL:
                         if not init_mistralai_instrumentor():
                             print(
-                                Fore.RED + "Warning: MistralAI library does not exist."
+                                "Warning: MistralAI library does not exist."
                             )
-                            print(Fore.RESET)
-                        else:
-                            instrument_set = True
                     elif instrument == Instruments.OLLAMA:
                         if not init_ollama_instrumentor():
-                            print(Fore.RED + "Warning: Ollama library does not exist.")
-                            print(Fore.RESET)
-                        else:
-                            instrument_set = True
+                            print("Warning: Ollama library does not exist.")
                     elif instrument == Instruments.LLAMA_INDEX:
                         if not init_llama_index_instrumentor():
                             print(
-                                Fore.RED + "Warning: LlamaIndex library does not exist."
+                                "Warning: LlamaIndex library does not exist."
                             )
-                            print(Fore.RESET)
-                        else:
-                            instrument_set = True
                     elif instrument == Instruments.MILVUS:
                         if not init_milvus_instrumentor():
-                            print(Fore.RED + "Warning: Milvus library does not exist.")
-                            print(Fore.RESET)
-                        else:
-                            instrument_set = True
+                            print("Warning: Milvus library does not exist.")
                     elif instrument == Instruments.TRANSFORMERS:
                         if not init_transformers_instrumentor():
-                            print(
-                                Fore.RED
-                                + "Warning: Transformers library does not exist."
-                            )
-                            print(Fore.RESET)
-                        else:
-                            instrument_set = True
+                            print("Warning: Transformers library does not exist.")
                     elif instrument == Instruments.TOGETHER:
                         if not init_together_instrumentor():
                             print(
-                                Fore.RED + "Warning: TogetherAI library does not exist."
+                                "Warning: TogetherAI library does not exist."
                             )
-                            print(Fore.RESET)
-                        else:
-                            instrument_set = True
                     elif instrument == Instruments.REQUESTS:
                         if not init_requests_instrumentor():
                             print(
-                                Fore.RED + "Warning: Requests library does not exist."
+                                "Warning: Requests library does not exist."
                             )
-                            print(Fore.RESET)
-                        else:
-                            instrument_set = True
                     elif instrument == Instruments.URLLIB3:
                         if not init_urllib3_instrumentor():
-                            print(Fore.RED + "Warning: urllib3 library does not exist.")
-                            print(Fore.RESET)
-                        else:
-                            instrument_set = True
+                            print("Warning: urllib3 library does not exist.")
                     elif instrument == Instruments.PYMYSQL:
                         if not init_pymysql_instrumentor():
-                            print(Fore.RED + "Warning: PyMySQL library does not exist.")
-                            print(Fore.RESET)
-                        else:
-                            instrument_set = True
+                            print("Warning: PyMySQL library does not exist.")
                     elif instrument == Instruments.BEDROCK:
                         if not init_bedrock_instrumentor(should_enrich_metrics):
-                            print(Fore.RED + "Warning: Bedrock library does not exist.")
-                            print(Fore.RESET)
-                        else:
-                            instrument_set = True
+                            print("Warning: Bedrock library does not exist.")
                     elif instrument == Instruments.REPLICATE:
                         if not init_replicate_instrumentor():
                             print(
-                                Fore.RED + "Warning: Replicate library does not exist."
+                                "Warning: Replicate library does not exist."
                             )
-                            print(Fore.RESET)
-                        else:
-                            instrument_set = True
                     elif instrument == Instruments.VERTEXAI:
                         if not init_vertexai_instrumentor():
                             print(
-                                Fore.RED + "Warning: Vertex AI library does not exist."
+                                "Warning: Vertex AI library does not exist."
                             )
-                            print(Fore.RESET)
-                        else:
-                            instrument_set = True
                     elif instrument == Instruments.WATSONX:
                         if not init_watsonx_instrumentor():
-                            print(Fore.RED + "Warning: Watsonx library does not exist.")
-                            print(Fore.RESET)
-                        else:
-                            instrument_set = True
+                            print("Warning: Watsonx library does not exist.")
                     elif instrument == Instruments.WEAVIATE:
                         if not init_weaviate_instrumentor():
                             print(
-                                Fore.RED + "Warning: Weaviate library does not exist."
+                                "Warning: Weaviate library does not exist."
                             )
-                            print(Fore.RESET)
-                        else:
-                            instrument_set = True
                     elif instrument == Instruments.ALEPHALPHA:
                         if not init_alephalpha_instrumentor():
-                            print(
-                                Fore.RED
-                                + "Warning: Aleph Alpha library does not exist."
-                            )
-                            print(Fore.RESET)
-                        else:
-                            instrument_set = True
+                            print("Warning: Aleph Alpha library does not exist.")
                     elif instrument == Instruments.MARQO:
                         if not init_marqo_instrumentor():
-                            print(Fore.RED + "Warning: marqo library does not exist.")
-                            print(Fore.RESET)
-                        else:
-                            instrument_set = True
+                            print("Warning: marqo library does not exist.")
                     elif instrument == Instruments.LANCEDB:
                         if not init_lancedb_instrumentor():
-                            print(Fore.RED + "Warning: LanceDB library does not exist.")
-                            print(Fore.RESET)
-                        else:
-                            instrument_set = True
+                            print("Warning: LanceDB library does not exist.")
                     elif instrument == Instruments.REDIS:
                         if not init_redis_instrumentor():
-                            print(Fore.RED + "Warning: redis library does not exist.")
-                            print(Fore.RESET)
-                        else:
-                            instrument_set = True
+                            print("Warning: redis library does not exist.")
 
                     else:
                         print(
-                            Fore.RED
-                            + "Warning: "
+                            "Warning: "
                             + instrument
                             + " instrumentation does not exist."
                         )
@@ -322,14 +233,6 @@ class TracerWrapper(object):
                             + "from lmnr.traceloop_sdk.instruments import Instruments\n"
                             + 'Traceloop.init(app_name="...", instruments=set([Instruments.OPENAI]))'
                         )
-                        print(Fore.RESET)
-
-            if not instrument_set:
-                print(
-                    Fore.RED + "Warning: No valid instruments set. Remove 'instrument' "
-                    "argument to use all instruments, or set a valid instrument."
-                )
-                print(Fore.RESET)
 
             obj.__content_allow_list = ContentAllowList()
 
@@ -352,49 +255,6 @@ class TracerWrapper(object):
                 else:
                     attach(set_value("override_enable_content_tracing", False))
 
-        if is_llm_span(span):
-            managed_prompt = get_value("managed_prompt")
-            if managed_prompt is not None:
-                span.set_attribute(
-                    SpanAttributes.TRACELOOP_PROMPT_MANAGED, managed_prompt
-                )
-
-            prompt_key = get_value("prompt_key")
-            if prompt_key is not None:
-                span.set_attribute(SpanAttributes.TRACELOOP_PROMPT_KEY, prompt_key)
-
-            prompt_version = get_value("prompt_version")
-            if prompt_version is not None:
-                span.set_attribute(
-                    SpanAttributes.TRACELOOP_PROMPT_VERSION, prompt_version
-                )
-
-            prompt_version_name = get_value("prompt_version_name")
-            if prompt_version_name is not None:
-                span.set_attribute(
-                    SpanAttributes.TRACELOOP_PROMPT_VERSION_NAME, prompt_version_name
-                )
-
-            prompt_version_hash = get_value("prompt_version_hash")
-            if prompt_version_hash is not None:
-                span.set_attribute(
-                    SpanAttributes.TRACELOOP_PROMPT_VERSION_HASH, prompt_version_hash
-                )
-
-            prompt_template = get_value("prompt_template")
-            if prompt_template is not None:
-                span.set_attribute(
-                    SpanAttributes.TRACELOOP_PROMPT_TEMPLATE, prompt_template
-                )
-
-            prompt_template_variables = get_value("prompt_template_variables")
-            if prompt_template_variables is not None:
-                for key, value in prompt_template_variables.items():
-                    span.set_attribute(
-                        f"{SpanAttributes.TRACELOOP_PROMPT_TEMPLATE_VARIABLES}.{key}",
-                        value,
-                    )
-
         # Call original on_start method if it exists in custom processor
         if self.__spans_processor_original_on_start:
             self.__spans_processor_original_on_start(span, parent_context)
@@ -419,11 +279,7 @@ class TracerWrapper(object):
         if (os.getenv("TRACELOOP_SUPPRESS_WARNINGS") or "false").lower() == "true":
             return False
 
-        print(
-            Fore.RED
-            + "Warning: Traceloop not initialized, make sure you call Traceloop.init()"
-        )
-        print(Fore.RESET)
+        print("Warning: Laminar not initialized, make sure to initialize")
         return False
 
     def flush(self):
@@ -458,7 +314,7 @@ def update_association_properties(properties: dict) -> None:
 def _set_association_properties_attributes(span, properties: dict) -> None:
     for key, value in properties.items():
         span.set_attribute(
-            f"{SpanAttributes.TRACELOOP_ASSOCIATION_PROPERTIES}.{key}", value
+            f"{ASSOCIATION_PROPERTIES}.{key}", value
         )
 
 
@@ -486,10 +342,6 @@ def set_external_prompt_tracing_context(
     attach(set_value("prompt_template_variables", variables))
 
 
-def is_llm_span(span) -> bool:
-    return span.attributes.get(SpanAttributes.LLM_REQUEST_TYPE) is not None
-
-
 def init_spans_exporter(api_endpoint: str, headers: Dict[str, str]) -> SpanExporter:
     if "http" in api_endpoint.lower() or "https" in api_endpoint.lower():
         return HTTPExporter(endpoint=f"{api_endpoint}/v1/traces", headers=headers)
@@ -558,7 +410,6 @@ def init_openai_instrumentor(should_enrich_metrics: bool):
                 # exception_logger=lambda e: Telemetry().log_exception(e),
                 enrich_assistant=should_enrich_metrics,
                 enrich_token_usage=should_enrich_metrics,
-                get_common_metrics_attributes=metrics_common_attributes,
             )
             if not instrumentor.is_instrumented_by_opentelemetry:
                 instrumentor.instrument()
@@ -579,7 +430,6 @@ def init_anthropic_instrumentor(should_enrich_metrics: bool):
             instrumentor = AnthropicInstrumentor(
                 # exception_logger=lambda e: Telemetry().log_exception(e),
                 enrich_token_usage=should_enrich_metrics,
-                get_common_metrics_attributes=metrics_common_attributes,
             )
             if not instrumentor.is_instrumented_by_opentelemetry:
                 instrumentor.instrument()
@@ -1047,23 +897,3 @@ def init_groq_instrumentor():
         logging.error(f"Error initializing Groq instrumentor: {e}")
         # Telemetry().log_exception(e)
         return False
-
-
-def metrics_common_attributes():
-    common_attributes = {}
-    workflow_name = get_value("workflow_name")
-    if workflow_name is not None:
-        common_attributes[SpanAttributes.TRACELOOP_WORKFLOW_NAME] = workflow_name
-
-    entity_name = get_value("entity_name")
-    if entity_name is not None:
-        common_attributes[SpanAttributes.TRACELOOP_ENTITY_NAME] = entity_name
-
-    association_properties = get_value("association_properties")
-    if association_properties is not None:
-        for key, value in association_properties.items():
-            common_attributes[
-                f"{SpanAttributes.TRACELOOP_ASSOCIATION_PROPERTIES}.{key}"
-            ] = value
-
-    return common_attributes

{lmnr-0.4.11.dist-info → lmnr-0.4.12.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lmnr
-Version: 0.4.11
+Version: 0.4.12
 Summary: Python SDK for Laminar AI
 License: Apache-2.0
 Author: lmnr.ai
@@ -11,9 +11,9 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: argparse (>=1.0,<2.0)
 Requires-Dist: asyncio (>=3.0,<4.0)
 Requires-Dist: backoff (>=2.0,<3.0)
-Requires-Dist: colorama (>=0.4,<0.5)
 Requires-Dist: deprecated (>=1.0,<2.0)
 Requires-Dist: jinja2 (>=3.0,<4.0)
 Requires-Dist: opentelemetry-api (>=1.27.0,<2.0.0)
@@ -54,67 +54,42 @@ Requires-Dist: pydantic (>=2.7,<3.0)
 Requires-Dist: python-dotenv (>=1.0,<2.0)
 Requires-Dist: requests (>=2.0,<3.0)
 Requires-Dist: tenacity (>=8.0,<9.0)
+Requires-Dist: tqdm (>=4.0,<5.0)
 Description-Content-Type: text/markdown
 
 # Laminar Python
 
-OpenTelemetry log sender for [Laminar](https://github.com/lmnr-ai/lmnr) for Python code.
+Python SDK for [Laminar](https://www.lmnr.ai).
+
+[Laminar](https://www.lmnr.ai) is an open-source platform for engineering LLM products. Trace, evaluate, annotate, and analyze LLM data. Bring LLM applications to production with confidence.
+
+Check our [open-source repo](https://github.com/lmnr-ai/lmnr) and don't forget to star it ⭐
 
  <a href="https://pypi.org/project/lmnr/"> ![PyPI - Version](https://img.shields.io/pypi/v/lmnr?label=lmnr&logo=pypi&logoColor=3775A9) </a>
 ![PyPI - Downloads](https://img.shields.io/pypi/dm/lmnr)
 ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/lmnr)
 
 
-
 ## Quickstart
 
 First, install the package:
 
 ```sh
-python3 -m venv .myenv
-source .myenv/bin/activate  # or use your favorite env management tool
-
 pip install lmnr
 ```
 
-Then, you can initialize Laminar in your main file and instrument your code.
+And then in the code
 
 ```python
-import os
-from openai import OpenAI
 from lmnr import Laminar as L
 
-L.initialize(
-    project_api_key=os.environ["LMNR_PROJECT_API_KEY"],
-)
-
-client = OpenAI(api_key=os.environ["OPENAI_API_KEY"])
-
-def poem_writer(topic: str):
-    prompt = f"write a poem about {topic}"
-
-    # OpenAI calls are automatically instrumented
-    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
-    return poem
-
-if __name__ == "__main__":
-    print(poem_writer("laminar flow"))
-
+L.initialize(project_api_key="<PROJECT_API_KEY>")
 ```
 
-Note that you need to only initialize Laminar once in your application.
+This will automatically instrument most of the LLM, Vector DB, and related
+calls with OpenTelemetry-compatible instrumentation.
 
-### Project API key
-
-Get the key from the settings page of your Laminar project ([Learn more](https://docs.lmnr.ai/api-reference/introduction#authentication)).
-You can either pass it to `.initialize()` or set it to `.env` at the root of your package with the key `LMNR_PROJECT_API_KEY`.
+Note that you need to only initialize Laminar once in your application.
 
 ## Instrumentation
 
@@ -195,7 +170,7 @@ L.initialize(project_api_key=os.environ["LMNR_PROJECT_API_KEY"], instruments={In
 
 If you want to fully disable any kind of autoinstrumentation, pass an empty set as `instruments=set()` to `.initialize()`. 
 
-Majority of the autoinstrumentations are provided by Traceloop's [OpenLLMetry](https://github.com/traceloop/openllmetry).
+Autoinstrumentations are provided by Traceloop's [OpenLLMetry](https://github.com/traceloop/openllmetry).
 
 ## Sending events
 
@@ -223,6 +198,67 @@ L.event("topic alignment", topic in poem)
 L.evaluate_event("excessive_wordiness", "check_wordy", {"text_input": poem})
 ```
 
+## Evaluations
+
+### Quickstart
+
+Install the package:
+
+```sh
+pip install lmnr
+```
+
+Create a file named `my_first_eval.py` with the following code:
+
+```python
+from lmnr import evaluate
+
+def write_poem(data):
+    return f"This is a good poem about {data['topic']}"
+
+def contains_poem(output, target):
+    return 1 if output in target['poem'] else 0
+
+# Evaluation data
+data = [
+    {"data": {"topic": "flowers"}, "target": {"poem": "This is a good poem about flowers"}},
+    {"data": {"topic": "cars"}, "target": {"poem": "I like cars"}},
+]
+
+evaluate(
+    data=data,
+    executor=write_poem,
+    evaluators={
+        "containsPoem": contains_poem
+    }
+)
+```
+
+Run the following commands:
+
+```sh
+export LMNR_PROJECT_API_KEY=<YOUR_PROJECT_API_KEY>  # get from Laminar project settings
+lmnr eval my_first_eval.py  # run in the virtual environment where lmnr is installed
+```
+
+Visit the URL printed in the console to see the results.
+
+### Overview
+
+Bring rigor to the development of your LLM applications with evaluations.
+
+You can run evaluations locally by providing executor (part of the logic used in your application) and evaluators (numeric scoring functions) to `evaluate` function.
+
+`evaluate` takes in the following parameters:
+- `data` – an array of `EvaluationDatapoint` objects, where each `EvaluationDatapoint` has two keys: `target` and `data`, each containing a key-value object. Alternatively, you can pass in dictionaries, and we will instantiate `EvaluationDatapoint`s with pydantic if possible
+- `executor` – the logic you want to evaluate. This function must take `data` as the first argument, and produce any output. It can be both a function or an `async` function.
+- `evaluators` – Dictionary which maps evaluator names to evaluators. Functions that take output of executor as the first argument, `target` as the second argument and produce a numeric scores. Each function can produce either a single number or `dict[str, int|float]` of scores. Each evaluator can be both a function or an `async` function.
+- `name` – optional name for the evaluation. Automatically generated if not provided.
+
+\* If you already have the outputs of executors you want to evaluate, you can specify the executor as an identity function, that takes in `data` and returns only needed value(s) from it.
+
+[Read docs](https://docs.lmnr.ai/evaluations/introduction) to learn more about evaluations.
+
 ## Laminar pipelines as prompt chain managers
 
 You can create Laminar pipelines in the UI and manage chains of LLM calls there.
@@ -257,65 +293,3 @@ PipelineRunResponse(
 )
 ```
 
-## Running offline evaluations on your data
-
-You can evaluate your code with your own data and send it to Laminar using the `Evaluation` class.
-
-Evaluation takes in the following parameters:
-- `name` – the name of your evaluation. If no such evaluation exists in the project, it will be created. Otherwise, data will be pushed to the existing evaluation
-- `data` – an array of `EvaluationDatapoint` objects, where each `EvaluationDatapoint` has two keys: `target` and `data`, each containing a key-value object. Alternatively, you can pass in dictionaries, and we will instantiate `EvaluationDatapoint`s with pydantic if possible
-- `executor` – the logic you want to evaluate. This function must take `data` as the first argument, and produce any output. *
-- `evaluators` – evaluaton logic. List of functions that take output of executor as the first argument, `target` as the second argument and produce a numeric scores. Each function can produce either a single number or `dict[str, int|float]` of scores.
-
-\* If you already have the outputs of executors you want to evaluate, you can specify the executor as an identity function, that takes in `data` and returns only needed value(s) from it.
-
-### Example
-
-```python
-from openai import AsyncOpenAI
-import asyncio
-import os
-
-openai_client = AsyncOpenAI(api_key=os.environ["OPENAI_API_KEY"])
-
-async def get_capital(data):
-    country = data["country"]
-    response = await openai_client.chat.completions.create(
-        model="gpt-4o-mini",
-        messages=[
-            {"role": "system", "content": "You are a helpful assistant."},
-            {
-                "role": "user",
-                "content": f"What is the capital of {country}? Just name the "
-                "city and nothing else",
-            },
-        ],
-    )
-    return response.choices[0].message.content.strip()
-
-
-# Evaluation data
-data = [
-    {"data": {"country": "Canada"}, "target": {"capital": "Ottawa"}},
-    {"data": {"country": "Germany"}, "target": {"capital": "Berlin"}},
-    {"data": {"country": "Tanzania"}, "target": {"capital": "Dodoma"}},
-]
-
-
-def evaluator_A(output, target):
-    return 1 if output == target["capital"] else 0
-
-
-# Create an Evaluation instance
-e = Evaluation(
-    name="py-evaluation-async",
-    data=data,
-    executor=get_capital,
-    evaluators=[evaluator_A],
-    project_api_key=os.environ["LMNR_PROJECT_API_KEY"],
-)
-
-# Run the evaluation
-asyncio.run(e.run())
-```
-