agenta 0.15.0__py3-none-any.whl → 0.15.0a0__py3-none-any.whl

{agenta-0.15.0.dist-info → agenta-0.15.0a0.dist-info}/RECORD

@@ -1,4 +1,4 @@
-agenta/__init__.py,sha256=O7kq034_S58b2yzrtR_m3Qd-0t7FAh9q7Z7_HsoD-9Y,796
+agenta/__init__.py,sha256=rCZ-mUOGnyKQpfWQFzXIEFX7KBlGC3qFMighdIVJgDc,610
 agenta/cli/evaluation_commands.py,sha256=fs6492tprPId9p8eGO02Xy-NCBm2RZNJLZWcUxugwd8,474
 agenta/cli/helper.py,sha256=vRxHyeNaltzNIGrfU2vO0H28_rXDzx9QqIZ_S-W6zL4,6212
 agenta/cli/main.py,sha256=Wz0ODhoeKK3Qg_CFUhu6D909szk05tc8ZVBB6H1-w7k,9763
@@ -10,7 +10,7 @@ agenta/client/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 agenta/client/api.py,sha256=0u1vd7V2ctFEtY6KeGGiOeoDv6vyeit32u6c6BVyc4w,2434
 agenta/client/api_models.py,sha256=zebfE2-0-SW1SvzyarzmSJMXqyiCLKrX2sHpzoX-RnU,623
 agenta/client/backend/__init__.py,sha256=tkSqI-dciccMpM2diWMe7pF0SjsGXPV_kR-029xNN9w,3853
-agenta/client/backend/client.py,sha256=LDuJbFQ9wnhBDeldrlJfOt2TsvO102fy1iKbQG4n_fE,73738
+agenta/client/backend/client.py,sha256=UvNYKUplPdK1AkFfRsOdyEI7hoTqNCtD_pKlkgtUGGo,73690
 agenta/client/backend/core/__init__.py,sha256=QJS3CJ2TYP2E1Tge0CS6Z7r8LTNzJHQVX1hD3558eP0,519
 agenta/client/backend/core/api_error.py,sha256=TtMtCdxXjd7Tasc9c8ooFg124nPrb2MXG-tKOXV4u9I,440
 agenta/client/backend/core/client_wrapper.py,sha256=kQEqxdm31r7V9x--mMliWOdMujD3dtPZyYBNzxgNdrs,972
@@ -54,7 +54,7 @@ agenta/client/backend/types/base_output.py,sha256=ynXhDBQKrkR6Lnkx-yv6Q8xW4wXmzX
 agenta/client/backend/types/body_import_testset.py,sha256=7dVF3mv3VO0Co8F0qxLAgu4jabqDPjebK4mYvcd_TuA,1061
 agenta/client/backend/types/config_db.py,sha256=P0cSYvVOn0ZxpYMIdvhWpQVjRuBS5APe6qlc69AXaF4,1028
 agenta/client/backend/types/create_app_output.py,sha256=pgnTnfZx35Q-8wZ1yTZBQ0ydYacGzFC9kyLug_UvymM,986
-agenta/client/backend/types/create_span.py,sha256=Ldb2zclVtVyBRKxM2Ap3YjE-FP3jbaOya96_ZsYw1cg,1794
+agenta/client/backend/types/create_span.py,sha256=_3G4WUnmgXtTCkIJFpce-9PDh6KDDZ2YkvXVOE8GSx8,1793
 agenta/client/backend/types/create_trace_response.py,sha256=FO-Ii9JEn2AQ1nmZYmjnKRbACsNxRvY_-xn7Ys7Yo8A,1012
 agenta/client/backend/types/docker_env_vars.py,sha256=altCvA1k-zdAkKNYLwaCnmV48HZg9cwe2cHu_BGImac,986
 agenta/client/backend/types/environment_output.py,sha256=dl0GKodeqB7kWK5mH6Y4iBppkpwRzSTmtkXH1II4L6w,1257
@@ -119,27 +119,26 @@ agenta/client/client.py,sha256=DWOGS9A8u4wu28s9jGOR4eRhf7vo4zT7GyDvrIGu59Y,19648
 agenta/client/exceptions.py,sha256=cxLjjKvZKlUgBxt4Vn9J_SsezJPPNHvrZxnoq-D6zmw,94
 agenta/config.py,sha256=Id-Ie1yf9QRP1YPhRYaYSOruRe6RBrsCXkG9rAa-ZtA,732
 agenta/config.toml,sha256=ptE0P49bwsu3Luyn7OLFmk2buPhj5D-MA-O_ErOGoLg,223
-agenta/docker/docker-assets/Dockerfile.cloud.template,sha256=Mn9g7bTQSnPXcCLZo-iVirV3cveCQHC_F7IECQufmME,389
+agenta/docker/docker-assets/Dockerfile.cloud.template,sha256=uJuXKvtkMY6f4KaOh3XE5pmuJR7mfZEXJk_8hj2uatc,386
 agenta/docker/docker-assets/Dockerfile.template,sha256=aVA_okx0xXalcTvdQGhSfzSjNpQZVoLJCGYA39-2Nwk,280
 agenta/docker/docker-assets/README.md,sha256=XHxwh2ks_ozrtAU7SLbL3J14SB2holG6buoTxwmMiZM,102
 agenta/docker/docker-assets/entrypoint.sh,sha256=29XK8VQjQsx4hN2j-4JDy-6kQb5y4LCqZEa7PD4eqCQ,74
 agenta/docker/docker-assets/lambda_function.py,sha256=h4UZSSfqwpfsCgERv6frqwm_4JrYu9rLz3I-LxCfeEg,83
 agenta/docker/docker-assets/main.py,sha256=7MI-21n81U7N7A0GxebNi0cmGWtJKcR2sPB6FcH2QfA,251
 agenta/docker/docker_utils.py,sha256=5uHMCzXkCvIsDdEiwbnnn97KkzsFbBvyMwogCsv_Z5U,3509
-agenta/sdk/__init__.py,sha256=oHgl-qoEyi3d2VI_Kv-rIMSx9zgs6b5MP62PLq5GqYI,762
-agenta/sdk/agenta_init.py,sha256=j7qwyDtXfLozWpnayJHPz2aQOzHSGvHo9V6s0FXeUe8,9937
+agenta/sdk/__init__.py,sha256=jmeLRuXrew02ZruODZYIu4kpw0S8vV6JhMPQWFGtj30,648
+agenta/sdk/agenta_decorator.py,sha256=_WaU-KkqnGTQobobX0LU2QszS9RdR8oOgIFksd40wh0,20210
+agenta/sdk/agenta_init.py,sha256=wDfStpe8_3ZXRLtikarwDKI_VpA1YW4eIz_3fXq39is,9044
 agenta/sdk/client.py,sha256=trKyBOYFZRk0v5Eptxvh87yPf50Y9CqY6Qgv4Fy-VH4,2142
 agenta/sdk/context.py,sha256=q-PxL05-I84puunUAs9LGsffEXcYhDxhQxjuOz2vK90,901
-agenta/sdk/decorators/base.py,sha256=9aNdX5h8a2mFweuhdO-BQPwXGKY9ONPIdLRhSGAGMfY,217
-agenta/sdk/decorators/llm_entrypoint.py,sha256=QjkpKEgsKzO83MNOb37MupwCX5hrm7_1-qbtbpqVMYM,19400
-agenta/sdk/decorators/tracing.py,sha256=bC-YlPQUrHBEqvhLJxr63N0qlo1jvrbt7ro2AMGXXZw,3160
 agenta/sdk/router.py,sha256=0sbajvn5C7t18anH6yNo7-oYxldHnYfwcbmQnIXBePw,269
 agenta/sdk/tracing/context_manager.py,sha256=HskDaiORoOhjeN375gm05wYnieQzh5UnoIsnSAHkAyc,252
-agenta/sdk/tracing/llm_tracing.py,sha256=PmMYQ5N8atYut85Rk2hZ1jmvSF80Duuy6Clf7URcTCA,8193
-agenta/sdk/tracing/logger.py,sha256=GfH7V-jBHcn7h5dbdrnkDMe_ml3wkXFBeoQiqR4KVRc,474
-agenta/sdk/tracing/tasks_manager.py,sha256=ROrWIaqS2J2HHiJtRWiHKlLY8CCsqToP5VeXu7mamck,3748
-agenta/sdk/types.py,sha256=pjVThuJ9iGbWnwmDmKJnG8S6Q_wHe1fRtMS6jknYSJM,5881
-agenta/sdk/utils/globals.py,sha256=JmhJcCOSbwvjQ6GDyUc2_SYR27DZk7YcrRH80ktHHOM,435
+agenta/sdk/tracing/decorators.py,sha256=ujtU8gf3GDoHYuLTfEYK_2eIYZ-1oX5dpv02Mf4l_II,1191
+agenta/sdk/tracing/llm_tracing.py,sha256=UiotJ56EFA3VPt7LREkcK2w51D9-0T1QNvBy4zNWEdY,7348
+agenta/sdk/tracing/logger.py,sha256=4zG9c51p8xPdKA5SL8MOgBfkpCnBSuV6JfWiXO0A7oc,473
+agenta/sdk/tracing/tasks_manager.py,sha256=XVGBEOwmHa6KcCC0PApk0_bZ0Ilk2ESuduNObB1rw2s,3792
+agenta/sdk/types.py,sha256=_rE1lPBlhwwwzPeSaPJYVaZSOg6l4alGBL8aufI8LJM,5711
+agenta/sdk/utils/globals.py,sha256=lpgflY8xovZJtHfJf41dbNCZGwx07YNkG9ldruv6xoI,360
 agenta/sdk/utils/helper/openai_cost.py,sha256=1VkgvucDnNZm1pTfcVLz9icWunntp1d7zwMmnviy3Uw,5877
 agenta/sdk/utils/preinit.py,sha256=YlJL7RLfel0R7DFp-jK7OV-z4ZIQJM0oupYlk7g8b5o,1278
 agenta/templates/compose_email/README.md,sha256=ss7vZPpI1Hg0VmYtFliwq_r5LnqbCy_S5OQDXg8UoIA,308
@@ -157,7 +156,7 @@ agenta/templates/simple_prompt/app.py,sha256=kODgF6lhzsaJPdgL5b21bUki6jkvqjWZzWR
 agenta/templates/simple_prompt/env.example,sha256=g9AE5bYcGPpxawXMJ96gh8oenEPCHTabsiOnfQo3c5k,70
 agenta/templates/simple_prompt/requirements.txt,sha256=ywRglRy7pPkw8bljmMEJJ4aOOQKrt9FGKULZ-DGkoBU,23
 agenta/templates/simple_prompt/template.toml,sha256=DQBtRrF4GU8LBEXOZ-GGuINXMQDKGTEG5y37tnvIUIE,60
-agenta-0.15.0.dist-info/METADATA,sha256=fw71SzzTzKG1bcyoCV78EtObsmPtFUsUmFcAZQ6HtA4,26463
-agenta-0.15.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-agenta-0.15.0.dist-info/entry_points.txt,sha256=PDiu8_8AsL7ibU9v4iNoOKR1S7F2rdxjlEprjM9QOgo,46
-agenta-0.15.0.dist-info/RECORD,,
+agenta-0.15.0a0.dist-info/METADATA,sha256=g_MOVUim-ykewN3u3F7zkFtRebo7gxuYnZsEwGO21XM,26480
+agenta-0.15.0a0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+agenta-0.15.0a0.dist-info/entry_points.txt,sha256=PDiu8_8AsL7ibU9v4iNoOKR1S7F2rdxjlEprjM9QOgo,46
+agenta-0.15.0a0.dist-info/RECORD,,

agenta/sdk/decorators/base.py

@@ -1,10 +0,0 @@
-# Stdlib Imports
-from typing import Any, Callable
-
-
-class BaseDecorator:
-    def __init__(self):
-        pass
-
-    def __call__(self, func: Callable[..., Any]) -> Callable[..., Any]:
-        raise NotImplementedError

agenta/sdk/decorators/llm_entrypoint.py

@@ -1,499 +0,0 @@
-"""The code for the Agenta SDK"""
-
-import os
-import sys
-import time
-import inspect
-import argparse
-import asyncio
-import traceback
-import functools
-from pathlib import Path
-from tempfile import NamedTemporaryFile
-from typing import Any, Callable, Dict, Optional, Tuple, List
-
-from fastapi.middleware.cors import CORSMiddleware
-from fastapi import Body, FastAPI, UploadFile, HTTPException
-
-import agenta
-from agenta.sdk.context import save_context
-from agenta.sdk.router import router as router
-from agenta.sdk.tracing.llm_tracing import Tracing
-from agenta.sdk.decorators.base import BaseDecorator
-from agenta.sdk.types import (
-    Context,
-    DictInput,
-    FloatParam,
-    InFile,
-    IntParam,
-    MultipleChoiceParam,
-    GroupedMultipleChoiceParam,
-    TextParam,
-    MessagesInput,
-    FileInputURL,
-    FuncResponse,
-    BinaryParam,
-)
-
-app = FastAPI()
-
-origins = [
-    "*",
-]
-
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=origins,
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-
-app.include_router(router, prefix="")
-
-
-class entrypoint(BaseDecorator):
-    """Decorator class to wrap a function for HTTP POST, terminal exposure and enable tracing.
-
-
-    Example:
-    ```python
-        import agenta as ag
-
-        @ag.entrypoint
-        async def chain_of_prompts_llm(prompt: str):
-            return ...
-    ```
-    """
-
-    def __init__(self, func: Callable[..., Any]):
-        endpoint_name = "generate"
-        func_signature = inspect.signature(func)
-        config_params = agenta.config.all()
-        ingestible_files = self.extract_ingestible_files(func_signature)
-
-        @functools.wraps(func)
-        async def wrapper(*args, **kwargs) -> Any:
-            func_params, api_config_params = self.split_kwargs(kwargs, config_params)
-            self.ingest_files(func_params, ingestible_files)
-            agenta.config.set(**api_config_params)
-
-            # Set the configuration and environment of the LLM app parent span at run-time
-            agenta.tracing.set_span_attribute(
-                {"config": config_params, "environment": "playground"}
-            )
-
-            llm_result = await self.execute_function(
-                func, *args, params=func_params, config_params=config_params
-            )
-            return llm_result
-
-        @functools.wraps(func)
-        async def wrapper_deployed(*args, **kwargs) -> Any:
-            func_params = {
-                k: v for k, v in kwargs.items() if k not in ["config", "environment"]
-            }
-
-            if "environment" in kwargs and kwargs["environment"] is not None:
-                agenta.config.pull(environment_name=kwargs["environment"])
-            elif "config" in kwargs and kwargs["config"] is not None:
-                agenta.config.pull(config_name=kwargs["config"])
-            else:
-                agenta.config.pull(config_name="default")
-
-            # Set the configuration and environment of the LLM app parent span at run-time
-            agenta.tracing.set_span_attribute(
-                {"config": config_params, "environment": kwargs["environment"]}
-            )
-
-            llm_result = await self.execute_function(
-                func, *args, params=func_params, config_params=config_params
-            )
-            return llm_result
-
-        self.update_function_signature(
-            wrapper, func_signature, config_params, ingestible_files
-        )
-        route = f"/{endpoint_name}"
-        app.post(route, response_model=FuncResponse)(wrapper)
-
-        self.update_deployed_function_signature(
-            wrapper_deployed,
-            func_signature,
-            ingestible_files,
-        )
-        route_deployed = f"/{endpoint_name}_deployed"
-        app.post(route_deployed, response_model=FuncResponse)(wrapper_deployed)
-        self.override_schema(
-            openapi_schema=app.openapi(),
-            func_name=func.__name__,
-            endpoint=endpoint_name,
-            params={**config_params, **func_signature.parameters},
-        )
-
-        if self.is_main_script(func):
-            self.handle_terminal_run(
-                func,
-                func_signature.parameters,  # type: ignore
-                config_params,
-                ingestible_files,
-            )
-
-    def extract_ingestible_files(
-        self,
-        func_signature: inspect.Signature,
-    ) -> Dict[str, inspect.Parameter]:
-        """Extract parameters annotated as InFile from function signature."""
-
-        return {
-            name: param
-            for name, param in func_signature.parameters.items()
-            if param.annotation is InFile
-        }
-
-    def split_kwargs(
-        self, kwargs: Dict[str, Any], config_params: Dict[str, Any]
-    ) -> Tuple[Dict[str, Any], Dict[str, Any]]:
-        """Split keyword arguments into function parameters and API configuration parameters."""
-
-        func_params = {k: v for k, v in kwargs.items() if k not in config_params}
-        api_config_params = {k: v for k, v in kwargs.items() if k in config_params}
-        return func_params, api_config_params
-
-    def ingest_file(self, upfile: UploadFile):
-        temp_file = NamedTemporaryFile(delete=False)
-        temp_file.write(upfile.file.read())
-        temp_file.close()
-        return InFile(file_name=upfile.filename, file_path=temp_file.name)
-
-    def ingest_files(
-        self,
-        func_params: Dict[str, Any],
-        ingestible_files: Dict[str, inspect.Parameter],
-    ) -> None:
-        """Ingest files specified in function parameters."""
-
-        for name in ingestible_files:
-            if name in func_params and func_params[name] is not None:
-                func_params[name] = self.ingest_file(func_params[name])
-
-    async def execute_function(self, func: Callable[..., Any], *args, **func_params):
-        """Execute the function and handle any exceptions."""
-
-        try:
-            """Note: The following block is for backward compatibility.
-            It allows functions to work seamlessly whether they are synchronous or asynchronous.
-            For synchronous functions, it calls them directly, while for asynchronous functions,
-            it awaits their execution.
-            """
-            is_coroutine_function = inspect.iscoroutinefunction(func)
-            start_time = time.perf_counter()
-            if is_coroutine_function:
-                result = await func(*args, **func_params["params"])
-            else:
-                result = func(*args, **func_params["params"])
-
-            end_time = time.perf_counter()
-            latency = end_time - start_time
-
-            if isinstance(result, Context):
-                save_context(result)
-            if isinstance(result, Dict):
-                return FuncResponse(**result, latency=round(latency, 4))
-            if isinstance(result, str):
-                return FuncResponse(message=result, latency=round(latency, 4))  # type: ignore
-            if isinstance(result, int) or isinstance(result, float):
-                return FuncResponse(message=str(result), latency=round(latency, 4))
-            if result is None:
-                return FuncResponse(
-                    message="Function executed successfully, but did return None. \n Are you sure you did not forget to return a value?",
-                    latency=round(latency, 4),
-                )
-        except Exception as e:
-            self.handle_exception(e)
-        return FuncResponse(message="Unexpected error occurred when calling the @entrypoing decorated function", latency=0)  # type: ignore
-
-    def handle_exception(self, e: Exception):
-        """Handle exceptions."""
-
-        status_code: int = e.status_code if hasattr(e, "status_code") else 500
-        traceback_str = traceback.format_exception(e, value=e, tb=e.__traceback__)  # type: ignore
-        raise HTTPException(
-            status_code=status_code,
-            detail={"error": str(e), "traceback": "".join(traceback_str)},
-        )
-
-    def update_wrapper_signature(
-        self, wrapper: Callable[..., Any], updated_params: List
-    ):
-        """
-        Updates the signature of a wrapper function with a new list of parameters.
-
-        Args:
-            wrapper (callable): A callable object, such as a function or a method, that requires a signature update.
-            updated_params (List[inspect.Parameter]): A list of `inspect.Parameter` objects representing the updated parameters
-                for the wrapper function.
-        """
-
-        wrapper_signature = inspect.signature(wrapper)
-        wrapper_signature = wrapper_signature.replace(parameters=updated_params)
-        wrapper.__signature__ = wrapper_signature
-
-    def update_function_signature(
-        self,
-        wrapper: Callable[..., Any],
-        func_signature: inspect.Signature,
-        config_params: Dict[str, Any],
-        ingestible_files: Dict[str, inspect.Parameter],
-    ) -> None:
-        """Update the function signature to include new parameters."""
-
-        updated_params = []
-        self.add_config_params_to_parser(updated_params, config_params)
-        self.add_func_params_to_parser(updated_params, func_signature, ingestible_files)
-        self.update_wrapper_signature(wrapper, updated_params)
-
-    def update_deployed_function_signature(
-        self,
-        wrapper: Callable[..., Any],
-        func_signature: inspect.Signature,
-        ingestible_files: Dict[str, inspect.Parameter],
-    ) -> None:
-        """Update the function signature to include new parameters."""
-        updated_params = []
-        self.add_func_params_to_parser(updated_params, func_signature, ingestible_files)
-        for param in [
-            "config",
-            "environment",
-        ]:  # we add the config and environment parameters
-            updated_params.append(
-                inspect.Parameter(
-                    param,
-                    inspect.Parameter.KEYWORD_ONLY,
-                    default=Body(None),
-                    annotation=str,
-                )
-            )
-        self.update_wrapper_signature(wrapper, updated_params)
-
-    def add_config_params_to_parser(
-        self, updated_params: list, config_params: Dict[str, Any]
-    ) -> None:
-        """Add configuration parameters to function signature."""
-        for name, param in config_params.items():
-            updated_params.append(
-                inspect.Parameter(
-                    name,
-                    inspect.Parameter.KEYWORD_ONLY,
-                    default=Body(param),
-                    annotation=Optional[type(param)],
-                )
-            )
-
-    def add_func_params_to_parser(
-        self,
-        updated_params: list,
-        func_signature: inspect.Signature,
-        ingestible_files: Dict[str, inspect.Parameter],
-    ) -> None:
-        """Add function parameters to function signature."""
-        for name, param in func_signature.parameters.items():
-            if name in ingestible_files:
-                updated_params.append(
-                    inspect.Parameter(name, param.kind, annotation=UploadFile)
-                )
-            else:
-                updated_params.append(
-                    inspect.Parameter(
-                        name,
-                        inspect.Parameter.KEYWORD_ONLY,
-                        default=Body(..., embed=True),
-                        annotation=param.annotation,
-                    )
-                )
-
-    def is_main_script(self, func: Callable) -> bool:
-        """
-        Check if the script containing the function is the main script being run.
-
-        Args:
-            func (Callable): The function object to check.
-
-        Returns:
-            bool: True if the script containing the function is the main script, False otherwise.
-
-        Example:
-            if is_main_script(my_function):
-                print("This is the main script.")
-        """
-        return func.__module__ == "__main__"
-
-    def handle_terminal_run(
-        self,
-        func: Callable,
-        func_params: Dict[str, inspect.Parameter],
-        config_params: Dict[str, Any],
-        ingestible_files: Dict,
-    ):
-        """
-        Parses command line arguments and sets configuration when script is run from the terminal.
-
-        Args:
-            func_params (dict): A dictionary containing the function parameters and their annotations.
-            config_params (dict): A dictionary containing the configuration parameters.
-            ingestible_files (dict): A dictionary containing the files that should be ingested.
-        """
-
-        # For required parameters, we add them as arguments
-        parser = argparse.ArgumentParser()
-        for name, param in func_params.items():
-            if name in ingestible_files:
-                parser.add_argument(name, type=str)
-            else:
-                parser.add_argument(name, type=param.annotation)
-
-        for name, param in config_params.items():
-            if type(param) is MultipleChoiceParam:
-                parser.add_argument(
-                    f"--{name}",
-                    type=str,
-                    default=param.default,
-                    choices=param.choices,
-                )
-            else:
-                parser.add_argument(
-                    f"--{name}",
-                    type=type(param),
-                    default=param,
-                )
-
-        args = parser.parse_args()
-
-        # split the arg list into the arg in the app_param and
-        # the args from the sig.parameter
-        args_config_params = {k: v for k, v in vars(args).items() if k in config_params}
-        args_func_params = {
-            k: v for k, v in vars(args).items() if k not in config_params
-        }
-        for name in ingestible_files:
-            args_func_params[name] = InFile(
-                file_name=Path(args_func_params[name]).stem,
-                file_path=args_func_params[name],
-            )
-
-        agenta.config.set(**args_config_params)
-
-        # Set the configuration and environment of the LLM app parent span at run-time
-        agenta.tracing.set_span_attribute(
-            {"config": agenta.config.all(), "environment": "bash"}
-        )
-
-        loop = asyncio.get_event_loop()
-        result = loop.run_until_complete(
-            self.execute_function(
-                func,
-                **{"params": args_func_params, "config_params": args_config_params},
-            )
-        )
-        print(
-            f"\n========== Result ==========\n\nMessage: {result.message}\nCost: {result.cost}\nToken Usage: {result.usage}"
-        )
-
-    def override_schema(
-        self, openapi_schema: dict, func_name: str, endpoint: str, params: dict
-    ):
-        """
-        Overrides the default openai schema generated by fastapi with additional information about:
-        - The choices available for each MultipleChoiceParam instance
-        - The min and max values for each FloatParam instance
-        - The min and max values for each IntParam instance
-        - The default value for DictInput instance
-        - The default value for MessagesParam instance
-        - The default value for FileInputURL instance
-        - The default value for BinaryParam instance
-        - ... [PLEASE ADD AT EACH CHANGE]
-
-        Args:
-            openapi_schema (dict): The openapi schema generated by fastapi
-            func_name (str): The name of the function to override
-            endpoint (str): The name of the endpoint to override
-            params (dict(param_name, param_val)): The dictionary of the parameters for the function
-        """
-
-        def find_in_schema(schema: dict, param_name: str, xparam: str):
-            """Finds a parameter in the schema based on its name and x-parameter value"""
-            for _, value in schema.items():
-                value_title_lower = str(value.get("title")).lower()
-                value_title = (
-                    "_".join(value_title_lower.split())
-                    if len(value_title_lower.split()) >= 2
-                    else value_title_lower
-                )
-
-                if (
-                    isinstance(value, dict)
-                    and value.get("x-parameter") == xparam
-                    and value_title == param_name
-                ):
-                    return value
-
-        schema_to_override = openapi_schema["components"]["schemas"][
-            f"Body_{func_name}_{endpoint}_post"
-        ]["properties"]
-        for param_name, param_val in params.items():
-            if isinstance(param_val, GroupedMultipleChoiceParam):
-                subschema = find_in_schema(
-                    schema_to_override, param_name, "grouped_choice"
-                )
-                assert (
-                    subschema
-                ), f"GroupedMultipleChoiceParam '{param_name}' is in the parameters but could not be found in the openapi.json"
-                subschema["choices"] = param_val.choices
-                subschema["default"] = param_val.default
-            if isinstance(param_val, MultipleChoiceParam):
-                subschema = find_in_schema(schema_to_override, param_name, "choice")
-                default = str(param_val)
-                param_choices = param_val.choices
-                choices = (
-                    [default] + param_choices
-                    if param_val not in param_choices
-                    else param_choices
-                )
-                subschema["enum"] = choices
-                subschema["default"] = (
-                    default if default in param_choices else choices[0]
-                )
-            if isinstance(param_val, FloatParam):
-                subschema = find_in_schema(schema_to_override, param_name, "float")
-                subschema["minimum"] = param_val.minval
-                subschema["maximum"] = param_val.maxval
-                subschema["default"] = param_val
-            if isinstance(param_val, IntParam):
-                subschema = find_in_schema(schema_to_override, param_name, "int")
-                subschema["minimum"] = param_val.minval
-                subschema["maximum"] = param_val.maxval
-                subschema["default"] = param_val
-            if (
-                isinstance(param_val, inspect.Parameter)
-                and param_val.annotation is DictInput
-            ):
-                subschema = find_in_schema(schema_to_override, param_name, "dict")
-                subschema["default"] = param_val.default["default_keys"]
-            if isinstance(param_val, TextParam):
-                subschema = find_in_schema(schema_to_override, param_name, "text")
-                subschema["default"] = param_val
-            if (
-                isinstance(param_val, inspect.Parameter)
-                and param_val.annotation is MessagesInput
-            ):
-                subschema = find_in_schema(schema_to_override, param_name, "messages")
-                subschema["default"] = param_val.default
-            if (
-                isinstance(param_val, inspect.Parameter)
-                and param_val.annotation is FileInputURL
-            ):
-                subschema = find_in_schema(schema_to_override, param_name, "file_url")
-                subschema["default"] = "https://example.com"
-            if isinstance(param_val, BinaryParam):
-                subschema = find_in_schema(schema_to_override, param_name, "bool")
-                subschema["default"] = param_val.default

agenta/sdk/decorators/tracing.py

@@ -1,98 +0,0 @@
-# Stdlib Imports
-import inspect
-from functools import wraps
-from typing import Any, Callable, Optional
-
-# Own Imports
-import agenta as ag
-from agenta.sdk.decorators.base import BaseDecorator
-
-
-class instrument(BaseDecorator):
-    """Decorator class for monitoring llm apps functions.
-
-    Args:
-        BaseDecorator (object): base decorator class
-
-    Example:
-    ```python
-        import agenta as ag
-
-        prompt_config = {"system_prompt": ..., "temperature": 0.5, "max_tokens": ...}
-
-        @ag.instrument(spankind="llm")
-        async def litellm_openai_call(prompt:str) -> str:
-            return "do something"
-
-        @ag.instrument(config=prompt_config) # spankind for parent span defaults to workflow
-        async def generate(prompt: str):
-            return ...
-    ```
-    """
-
-    def __init__(
-        self, config: Optional[dict] = None, spankind: str = "workflow"
-    ) -> None:
-        self.config = config
-        self.spankind = spankind
-        self.tracing = ag.tracing
-
-    def __call__(self, func: Callable[..., Any]):
-        is_coroutine_function = inspect.iscoroutinefunction(func)
-
-        @wraps(func)
-        async def async_wrapper(*args, **kwargs):
-            result = None
-            func_args = inspect.getfullargspec(func).args
-            input_dict = {name: value for name, value in zip(func_args, args)}
-            input_dict.update(kwargs)
-
-            span = self.tracing.start_span(
-                name=func.__name__,
-                input=input_dict,
-                spankind=self.spankind,
-                config=self.config,
-            )
-
-            try:
-                result = await func(*args, **kwargs)
-                self.tracing.update_span_status(span=span, value="OK")
-            except Exception as e:
-                result = str(e)
-                self.tracing.update_span_status(span=span, value="ERROR")
-            finally:
-                self.tracing.end_span(
-                    outputs=(
-                        {"message": result} if not isinstance(result, dict) else result
-                    )
-                )
-            return result
-
-        @wraps(func)
-        def sync_wrapper(*args, **kwargs):
-            result = None
-            func_args = inspect.getfullargspec(func).args
-            input_dict = {name: value for name, value in zip(func_args, args)}
-            input_dict.update(kwargs)
-
-            span = self.tracing.start_span(
-                name=func.__name__,
-                input=input_dict,
-                spankind=self.spankind,
-                config=self.config,
-            )
-
-            try:
-                result = func(*args, **kwargs)
-                self.tracing.update_span_status(span=span, value="OK")
-            except Exception as e:
-                result = str(e)
-                self.tracing.update_span_status(span=span, value="ERROR")
-            finally:
-                self.tracing.end_span(
-                    outputs=(
-                        {"message": result} if not isinstance(result, dict) else result
-                    )
-                )
-
-        return async_wrapper if is_coroutine_function else sync_wrapper