agenta 0.12.7__py3-none-any.whl → 0.13.0__py3-none-any.whl

agenta/client/backend/types/workspace_response.py

@@ -0,0 +1,44 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import datetime as dt
+import typing
+
+from ..core.datetime_utils import serialize_datetime
+from .workspace_member_response import WorkspaceMemberResponse
+
+try:
+    import pydantic.v1 as pydantic  # type: ignore
+except ImportError:
+    import pydantic  # type: ignore
+
+
+class WorkspaceResponse(pydantic.BaseModel):
+    created_at: typing.Optional[dt.datetime]
+    updated_at: typing.Optional[dt.datetime]
+    id: str
+    name: str
+    description: typing.Optional[str]
+    type: typing.Optional[str]
+    organization: str
+    members: typing.Optional[typing.List[WorkspaceMemberResponse]]
+
+    def json(self, **kwargs: typing.Any) -> str:
+        kwargs_with_defaults: typing.Any = {
+            "by_alias": True,
+            "exclude_unset": True,
+            **kwargs,
+        }
+        return super().json(**kwargs_with_defaults)
+
+    def dict(self, **kwargs: typing.Any) -> typing.Dict[str, typing.Any]:
+        kwargs_with_defaults: typing.Any = {
+            "by_alias": True,
+            "exclude_unset": True,
+            **kwargs,
+        }
+        return super().dict(**kwargs_with_defaults)
+
+    class Config:
+        frozen = True
+        smart_union = True
+        json_encoders = {dt.datetime: serialize_datetime}

agenta/client/backend/types/workspace_role.py

@@ -0,0 +1,41 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import enum
+import typing
+
+T_Result = typing.TypeVar("T_Result")
+
+
+class WorkspaceRole(str, enum.Enum):
+    """
+    An enumeration.
+    """
+
+    OWNER = "owner"
+    VIEWER = "viewer"
+    EDITOR = "editor"
+    EVALUATOR = "evaluator"
+    WORKSPACE_ADMIN = "workspace_admin"
+    DEPLOYMENT_MANAGER = "deployment_manager"
+
+    def visit(
+        self,
+        owner: typing.Callable[[], T_Result],
+        viewer: typing.Callable[[], T_Result],
+        editor: typing.Callable[[], T_Result],
+        evaluator: typing.Callable[[], T_Result],
+        workspace_admin: typing.Callable[[], T_Result],
+        deployment_manager: typing.Callable[[], T_Result],
+    ) -> T_Result:
+        if self is WorkspaceRole.OWNER:
+            return owner()
+        if self is WorkspaceRole.VIEWER:
+            return viewer()
+        if self is WorkspaceRole.EDITOR:
+            return editor()
+        if self is WorkspaceRole.EVALUATOR:
+            return evaluator()
+        if self is WorkspaceRole.WORKSPACE_ADMIN:
+            return workspace_admin()
+        if self is WorkspaceRole.DEPLOYMENT_MANAGER:
+            return deployment_manager()

agenta/client/backend/types/workspace_role_response.py

@@ -0,0 +1,38 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import datetime as dt
+import typing
+
+from ..core.datetime_utils import serialize_datetime
+from .workspace_role import WorkspaceRole
+
+try:
+    import pydantic.v1 as pydantic  # type: ignore
+except ImportError:
+    import pydantic  # type: ignore
+
+
+class WorkspaceRoleResponse(pydantic.BaseModel):
+    role_name: WorkspaceRole
+    role_description: typing.Optional[str]
+
+    def json(self, **kwargs: typing.Any) -> str:
+        kwargs_with_defaults: typing.Any = {
+            "by_alias": True,
+            "exclude_unset": True,
+            **kwargs,
+        }
+        return super().json(**kwargs_with_defaults)
+
+    def dict(self, **kwargs: typing.Any) -> typing.Dict[str, typing.Any]:
+        kwargs_with_defaults: typing.Any = {
+            "by_alias": True,
+            "exclude_unset": True,
+            **kwargs,
+        }
+        return super().dict(**kwargs_with_defaults)
+
+    class Config:
+        frozen = True
+        smart_union = True
+        json_encoders = {dt.datetime: serialize_datetime}

agenta/docker/docker_utils.py

@@ -3,11 +3,7 @@ import shutil
 import tarfile
 import tempfile
 from pathlib import Path
-from tempfile import TemporaryDirectory
 
-import docker
-from agenta.config import settings
-from docker.models.images import Image
 
 logger = logging.getLogger(__name__)
 logger.setLevel(logging.DEBUG)
@@ -15,7 +11,7 @@ logger.setLevel(logging.DEBUG)
 DEBUG = False
 
 
-def create_dockerfile(out_folder: Path):
+def create_dockerfile(out_folder: Path) -> Path:
     """Creates a dockerfile based on the template in the out_folder.
 
     Arguments:

agenta/sdk/__init__.py

@@ -15,7 +15,9 @@ from .types import (
     FileInputURL,
     BinaryParam,
 )
-from .agenta_init import Config, init
+from .tracing.decorators import span
+from .agenta_init import Config, init, llm_tracing
 from .utils.helper.openai_cost import calculate_token_usage
 
+
 config = PreInitObject("agenta.config", Config)

agenta/sdk/agenta_decorator.py

@@ -5,15 +5,15 @@ 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, Union
+from typing import Any, Callable, Dict, Optional, Tuple, List
 
-from fastapi import Body, FastAPI, UploadFile
-from fastapi.responses import JSONResponse
 from fastapi.middleware.cors import CORSMiddleware
+from fastapi import Body, FastAPI, UploadFile, HTTPException
 
 import agenta
 from .context import save_context
@@ -73,12 +73,34 @@ def entrypoint(func: Callable[..., Any]) -> Callable[..., Any]:
     config_params = agenta.config.all()
     ingestible_files = extract_ingestible_files(func_signature)
 
+    # Initialize tracing
+    tracing = agenta.llm_tracing()
+
     @functools.wraps(func)
     async def wrapper(*args, **kwargs) -> Any:
         func_params, api_config_params = split_kwargs(kwargs, config_params)
+
+        # Start tracing
+        tracing.start_parent_span(
+            name=func.__name__,
+            inputs=func_params,
+            config=config_params,
+            environment="playground",  # type: ignore #NOTE: wrapper is only called in playground
+        )
+
+        # Ingest files, prepare configurations and run llm app
         ingest_files(func_params, ingestible_files)
         agenta.config.set(**api_config_params)
-        return await execute_function(func, *args, **func_params)
+        llm_result = await execute_function(
+            func, *args, params=func_params, config_params=config_params
+        )
+
+        # End trace recording
+        tracing.end_recording(
+            outputs=llm_result.dict(),
+            span=tracing.active_trace,
+        )
+        return llm_result
 
     @functools.wraps(func)
     async def wrapper_deployed(*args, **kwargs) -> Any:
@@ -91,7 +113,27 @@ def entrypoint(func: Callable[..., Any]) -> Callable[..., Any]:
             agenta.config.pull(config_name=kwargs["config"])
         else:
             agenta.config.pull(config_name="default")
-        return await execute_function(func, *args, **func_params)
+
+        config = agenta.config.all()
+
+        # Start tracing
+        tracing.start_parent_span(
+            name=func.__name__,
+            inputs=func_params,
+            config=config,
+            environment=kwargs["environment"],  # type: ignore #NOTE: wrapper is only called in playground
+        )
+
+        llm_result = await execute_function(
+            func, *args, params=func_params, config_params=config_params
+        )
+
+        # End trace recording
+        tracing.end_recording(
+            outputs=llm_result.dict(),
+            span=tracing.active_trace,
+        )
+        return llm_result
 
     update_function_signature(wrapper, func_signature, config_params, ingestible_files)
     route = f"/{endpoint_name}"
@@ -153,9 +195,7 @@ def ingest_files(
             func_params[name] = ingest_file(func_params[name])
 
 
-async def execute_function(
-    func: Callable[..., Any], *args, **func_params
-) -> Union[Dict[str, Any], JSONResponse]:
+async def execute_function(func: Callable[..., Any], *args, **func_params):
     """Execute the function and handle any exceptions."""
 
     try:
@@ -167,30 +207,32 @@ async def execute_function(
         is_coroutine_function = inspect.iscoroutinefunction(func)
         start_time = time.perf_counter()
         if is_coroutine_function:
-            result = await func(*args, **func_params)
+            result = await func(*args, **func_params["params"])
         else:
-            result = func(*args, **func_params)
+            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)).dict()
+            return FuncResponse(**result, latency=round(latency, 4))
         if isinstance(result, str):
-            return FuncResponse(message=result, latency=round(latency, 4)).dict()
+            return FuncResponse(message=result, latency=round(latency, 4))  # type: ignore
     except Exception as e:
-        return handle_exception(e)
+        handle_exception(e)
+    return FuncResponse(message="Unexpected error occurred", latency=0)  # type: ignore
 
 
-def handle_exception(e: Exception) -> JSONResponse:
-    """Handle exceptions and return a JSONResponse."""
+def handle_exception(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__)
-    return JSONResponse(
+    traceback_str = traceback.format_exception(e, value=e, tb=e.__traceback__)  # type: ignore
+    raise HTTPException(
         status_code=status_code,
-        content={"error": str(e), "traceback": "".join(traceback_str)},
+        detail={"error": str(e), "traceback": "".join(traceback_str)},
     )
 
 
@@ -356,6 +398,14 @@ def handle_terminal_run(
         )
     agenta.config.set(**args_config_params)
 
+    loop = asyncio.get_event_loop()
+    result = loop.run_until_complete(
+        execute_function(
+            func, **{"params": args_func_params, "config_params": args_config_params}
+        )
+    )
+    print(result)
+
 
 def override_schema(openapi_schema: dict, func_name: str, endpoint: str, params: dict):
     """

agenta/sdk/agenta_init.py

@@ -1,11 +1,14 @@
-from agenta.client.exceptions import APIRequestError
-from agenta.client.backend.client import AgentaApi
 import os
 import logging
 from typing import Any, Optional
 
 from .utils.globals import set_global
 
+from agenta.client.backend.client import AgentaApi
+from agenta.sdk.tracing.llm_tracing import Tracing
+from agenta.client.exceptions import APIRequestError
+
+
 logger = logging.getLogger(__name__)
 logger.setLevel(logging.DEBUG)
 
@@ -40,6 +43,7 @@ class AgentaSingleton:
         base_name: Optional[str] = None,
         api_key: Optional[str] = None,
         base_id: Optional[str] = None,
+        app_id: Optional[str] = None,
         host: Optional[str] = None,
         **kwargs: Any,
     ) -> None:
@@ -75,30 +79,44 @@ class AgentaSingleton:
                 )
             else:
                 try:
-                    apps = client.list_apps(app_name=app_name)
-                    if len(apps) == 0:
-                        raise APIRequestError(f"App with name {app_name} not found")
-
-                    app_id = apps[0].app_id
-                    if not app_id:
-                        raise APIRequestError(
-                            f"App with name {app_name} does not exist on the server."
-                        )
-
-                    bases = client.list_bases(app_id=app_id, base_name=base_name)
-                    if len(bases) == 0:
-                        raise APIRequestError(f"No base was found for the app {app_id}")
-
-                    base_id = bases[0].base_id
+                    app_id = self.get_app(app_name)
+                    base_id = self.get_app_base(app_id, base_name)
                 except Exception as ex:
                     raise APIRequestError(
                         f"Failed to get base id and/or app_id from the server with error: {ex}"
                     )
+
         self.base_id = base_id
         self.host = host
+        self.app_id = os.environ.get("AGENTA_APP_ID") if app_id is None else app_id
+        self.variant_id = os.environ.get("AGENTA_VARIANT_ID")
+        self.variant_name = os.environ.get("AGENTA_VARIANT_NAME")
         self.api_key = api_key
         self.config = Config(base_id=base_id, host=host)
 
+    def get_app(self, app_name: str) -> str:
+        apps = client.apps.list_apps(app_name=app_name)
+        if len(apps) == 0:
+            raise APIRequestError(f"App with name {app_name} not found")
+
+        app_id = apps[0].app_id
+        return app_id
+
+    def get_app_base(self, app_id: str, base_name: str) -> str:
+        bases = client.bases.list_bases(app_id=app_id, base_name=base_name)
+        if len(bases) == 0:
+            raise APIRequestError(f"No base was found for the app {app_id}")
+        return bases[0].base_id
+
+    def get_current_config(self):
+        """
+        Retrieves the current active configuration
+        """
+
+        if self._config_data is None:
+            raise RuntimeError("AgentaSingleton has not been initialized")
+        return self._config_data
+
 
 class Config:
     def __init__(self, base_id, host):
@@ -139,7 +157,7 @@ class Config:
         if not self.persist:
             return
         try:
-            client.save_config(
+            client.configs.save_config(
                 base_id=self.base_id,
                 config_name=config_name,
                 parameters=kwargs,
@@ -161,12 +179,12 @@ class Config:
         if self.persist:
             try:
                 if environment_name:
-                    config = client.get_config(
+                    config = client.configs.get_config(
                         base_id=self.base_id, environment_name=environment_name
                     )
 
                 else:
-                    config = client.get_config(
+                    config = client.configs.get_config(
                         base_id=self.base_id,
                         config_name=config_name,
                     )
@@ -176,7 +194,7 @@ class Config:
                     + str(ex)
                 )
         try:
-            self.set(**config.parameters)
+            self.set(**{"current_version": config.current_version, **config.parameters})
         except Exception as ex:
             logger.warning("Failed to set the configuration with error: " + str(ex))
 
@@ -210,3 +228,17 @@ def init(app_name=None, base_name=None, **kwargs):
     singleton = AgentaSingleton()
     singleton.init(app_name=app_name, base_name=base_name, **kwargs)
     set_global(setup=singleton.setup, config=singleton.config)
+
+
+def llm_tracing(max_workers: Optional[int] = None) -> Tracing:
+    """Function to start llm tracing."""
+
+    singleton = AgentaSingleton()
+    return Tracing(
+        base_url=singleton.host,
+        app_id=singleton.app_id,  # type: ignore
+        variant_id=singleton.variant_id,  # type: ignore
+        variant_name=singleton.variant_name,
+        api_key=singleton.api_key,
+        max_workers=max_workers,
+    )

agenta/sdk/tracing/context_manager.py

@@ -0,0 +1,13 @@
+# Own Imports
+from agenta.sdk.tracing.llm_tracing import Tracing
+
+
+class TracingContextManager:
+    def __init__(self, tracing: Tracing):
+        ...
+
+    def __enter__(self):
+        ...
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        ...

agenta/sdk/tracing/decorators.py

@@ -0,0 +1,41 @@
+# Stdlib Imports
+import inspect
+from functools import wraps
+
+# Own Imports
+import agenta as ag
+
+
+def span(type: str):
+    """Decorator to automatically start and end spans."""
+
+    tracing = ag.llm_tracing()
+
+    def decorator(func):
+        @wraps(func)
+        async def wrapper(*args, **kwargs):
+            result = None
+            span = tracing.start_span(
+                name=func.__name__,
+                input=kwargs,
+                spankind=type,
+            )
+            try:
+                is_coroutine_function = inspect.iscoroutinefunction(func)
+                if is_coroutine_function:
+                    result = await func(*args, **kwargs)
+                else:
+                    result = func(*args, **kwargs)
+                tracing.update_span_status(span=span, value="OK")
+            except Exception as e:
+                result = str(e)
+                tracing.update_span_status(span=span, value="ERROR")
+            finally:
+                if not isinstance(result, dict):
+                    result = {"message": result}
+                tracing.end_span(outputs=result, span=span)
+            return result
+
+        return wrapper
+
+    return decorator