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

agenta/sdk/agenta_init.py

@@ -1,9 +1,9 @@
 import os
 import logging
-import toml
-from typing import Optional
+from typing import Any, Optional
+
+from .utils.globals import set_global
 
-from agenta.sdk.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
@@ -13,97 +13,119 @@ logger = logging.getLogger(__name__)
 logger.setLevel(logging.DEBUG)
 
 
+BACKEND_URL_SUFFIX = os.environ.get("BACKEND_URL_SUFFIX", "api")
+CLIENT_API_KEY = os.environ.get("AGENTA_API_KEY")
+CLIENT_HOST = os.environ.get("AGENTA_HOST", "http://localhost")
+
+# initialize the client with the backend url and api key
+backend_url = f"{CLIENT_HOST}/{BACKEND_URL_SUFFIX}"
+client = AgentaApi(
+    base_url=backend_url,
+    api_key=CLIENT_API_KEY if CLIENT_API_KEY else "",
+)
+
+
 class AgentaSingleton:
     """Singleton class to save all the "global variables" for the sdk."""
 
     _instance = None
     setup = None
     config = None
-    tracing: Optional[Tracing] = None
 
     def __new__(cls):
         if not cls._instance:
             cls._instance = super(AgentaSingleton, cls).__new__(cls)
         return cls._instance
 
-    @property
-    def client(self):
-        """API Backend client.
-
-        Returns:
-            AgentaAPI: instance of agenta api backend
-        """
-
-        return AgentaApi(base_url=self.host + "/api", api_key=self.api_key)
-
     def init(
         self,
+        app_name: Optional[str] = None,
+        base_name: Optional[str] = None,
+        api_key: Optional[str] = None,
+        base_id: Optional[str] = None,
         app_id: Optional[str] = None,
         host: Optional[str] = None,
-        api_key: Optional[str] = None,
-        config_fname: Optional[str] = None,
+        **kwargs: Any,
     ) -> None:
         """Main function to initialize the singleton.
 
-        Initializes the singleton with the given `app_id`, `host`, and `api_key`. The order of precedence for these variables is:
-        1. Explicit argument provided in the function call.
-        2. Value from the configuration file specified by `config_fname`.
-        3. Environment variables.
-
-        Examples:
-        ag.init(app_id="xxxx", api_key="xxx")
-        ag.init(config_fname="config.toml")
-        ag.init() #assuming env vars are set
+        Initializes the singleton with the given `app_name`, `base_name`, and `host`. If any of these arguments are not provided,
+        the function will look for them in environment variables.
 
         Args:
-            app_id (Optional[str]): ID of the Agenta application. Defaults to None. If not provided, will look for "app_id" in the config file, then "AGENTA_APP_ID" in environment variables.
-            host (Optional[str]): Host name of the backend server. Defaults to None. If not provided, will look for "backend_host" in the config file, then "AGENTA_HOST" in environment variables.
-            api_key (Optional[str]): API Key to use with the host of the backend server. Defaults to None. If not provided, will look for "api_key" in the config file, then "AGENTA_API_KEY" in environment variables.
-            config_fname (Optional[str]): Path to the configuration file (relative or absolute). Defaults to None.
+            app_name (Optional[str]): Name of the Agenta application. Defaults to None. If not provided, will look for "AGENTA_APP_NAME" in environment variables.
+            base_name (Optional[str]): Base name for the Agenta setup. Defaults to None. If not provided, will look for "AGENTA_BASE_NAME" in environment variables.
+            host (Optional[str]): Host name of the backend server. Defaults to None. If not provided, will look for "AGENTA_HOST" in environment variables.
+            kwargs (Any): Additional keyword arguments.
 
         Raises:
-            ValueError: If `app_id` is not specified either as an argument, in the config file, or in the environment variables.
+            ValueError: If `app_name`, `base_name`, or `host` are not specified either as arguments or in the environment variables.
+        """
+        if app_name is None:
+            app_name = os.environ.get("AGENTA_APP_NAME")
+        if base_name is None:
+            base_name = os.environ.get("AGENTA_BASE_NAME")
+        if api_key is None:
+            api_key = os.environ.get("AGENTA_API_KEY")
+        if base_id is None:
+            base_id = os.environ.get("AGENTA_BASE_ID")
+        if host is None:
+            host = os.environ.get("AGENTA_HOST", "http://localhost")
+
+        if base_id is None:
+            if app_name is None or base_name is None:
+                print(
+                    f"Warning: Your configuration will not be saved permanently since app_name and base_name are not provided."
+                )
+            else:
+                try:
+                    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
         """
-        config = {}
-        if config_fname:
-            config = toml.load(config_fname)
-
-        self.app_id = app_id or config.get("app_id") or os.environ.get("AGENTA_APP_ID")
-        self.host = (
-            host
-            or config.get("backend_host")
-            or os.environ.get("AGENTA_HOST", "https://cloud.agenta.ai")
-        )
-        self.api_key = (
-            api_key or config.get("api_key") or os.environ.get("AGENTA_API_KEY")
-        )
-
-        if not self.app_id:
-            raise ValueError(
-                "App ID must be specified. You can provide it in one of the following ways:\n"
-                "1. As an argument when calling ag.init(app_id='your_app_id').\n"
-                "2. In the configuration file specified by config_fname.\n"
-                "3. As an environment variable 'AGENTA_APP_ID'."
-            )
-        self.base_id = os.environ.get("AGENTA_BASE_ID")
-        if self.base_id is None:
-            print(
-                "Warning: Your configuration will not be saved permanently since base_id is not provided."
-            )
 
-        self.config = Config(base_id=self.base_id, host=self.host)  # type: ignore
+        if self._config_data is None:
+            raise RuntimeError("AgentaSingleton has not been initialized")
+        return self._config_data
 
 
 class Config:
-    def __init__(self, base_id: str, host: str, api_key: str = ""):
+    def __init__(self, base_id, host):
         self.base_id = base_id
         self.host = host
-
         if base_id is None or host is None:
             self.persist = False
         else:
             self.persist = True
-            self.client = AgentaApi(base_url=self.host + "/api", api_key=api_key)
 
     def register_default(self, overwrite=False, **kwargs):
         """alias for default"""
@@ -122,7 +144,7 @@ class Config:
             self.push(config_name="default", overwrite=overwrite, **kwargs)
         except Exception as ex:
             logger.warning(
-                "Unable to push the default configuration to the server. %s", str(ex)
+                "Unable to push the default configuration to the server." + str(ex)
             )
 
     def push(self, config_name: str, overwrite=True, **kwargs):
@@ -135,7 +157,7 @@ class Config:
         if not self.persist:
             return
         try:
-            self.client.configs.save_config(
+            client.configs.save_config(
                 base_id=self.base_id,
                 config_name=config_name,
                 parameters=kwargs,
@@ -143,40 +165,38 @@ class Config:
             )
         except Exception as ex:
             logger.warning(
-                "Failed to push the configuration to the server with error: %s", ex
+                "Failed to push the configuration to the server with error: " + str(ex)
             )
 
-    def pull(
-        self, config_name: str = "default", environment_name: Optional[str] = None
-    ):
+    def pull(self, config_name: str = "default", environment_name: str = None):
         """Pulls the parameters for the app variant from the server and sets them to the config"""
         if not self.persist and (
             config_name != "default" or environment_name is not None
         ):
-            raise ValueError(
+            raise Exception(
                 "Cannot pull the configuration from the server since the app_name and base_name are not provided."
             )
         if self.persist:
             try:
                 if environment_name:
-                    config = self.client.configs.get_config(
+                    config = client.configs.get_config(
                         base_id=self.base_id, environment_name=environment_name
                     )
 
                 else:
-                    config = self.client.configs.get_config(
+                    config = client.configs.get_config(
                         base_id=self.base_id,
                         config_name=config_name,
                     )
             except Exception as ex:
                 logger.warning(
-                    "Failed to pull the configuration from the server with error: %s",
-                    str(ex),
+                    "Failed to pull the configuration from the server with error: "
+                    + str(ex)
                 )
         try:
             self.set(**{"current_version": config.current_version, **config.parameters})
         except Exception as ex:
-            logger.warning("Failed to set the configuration with error: %s", str(ex))
+            logger.warning("Failed to set the configuration with error: " + str(ex))
 
     def all(self):
         """Returns all the parameters for the app variant"""
@@ -184,15 +204,7 @@ class Config:
             k: v
             for k, v in self.__dict__.items()
             if k
-            not in [
-                "app_name",
-                "base_name",
-                "host",
-                "base_id",
-                "api_key",
-                "persist",
-                "client",
-            ]
+            not in ["app_name", "base_name", "host", "base_id", "api_key", "persist"]
         }
 
     # function to set the parameters for the app variant
@@ -205,52 +217,28 @@ class Config:
         for key, value in kwargs.items():
             setattr(self, key, value)
 
-    def dump(self):
-        """Returns all the information about the current version in the configuration.
-
-        Raises:
-            NotImplementedError: _description_
-        """
-
-        raise NotImplementedError()
-
-
-def init(
-    app_id: Optional[str] = None,
-    host: Optional[str] = None,
-    api_key: Optional[str] = None,
-    config_fname: Optional[str] = None,
-    max_workers: Optional[int] = None,
-):
-    """Main function to initialize the agenta sdk.
-
-    Initializes agenta with the given `app_id`, `host`, and `api_key`. The order of precedence for these variables is:
-    1. Explicit argument provided in the function call.
-    2. Value from the configuration file specified by `config_fname`.
-    3. Environment variables.
-
-    - `app_id` is a required parameter (to be specified in one of the above ways)
-    - `host` is optional and defaults to "https://cloud.agenta.ai"
-    - `api_key` is optional and defaults to "". It is required only when using cloud or enterprise version of agenta.
 
+def init(app_name=None, base_name=None, **kwargs):
+    """Main function to be called by the user to initialize the sdk.
 
     Args:
-        app_id (Optional[str]): ID of the Agenta application. Defaults to None. If not provided, will look for "app_id" in the config file, then "AGENTA_APP_ID" in environment variables.
-        host (Optional[str]): Host name of the backend server. Defaults to None. If not provided, will look for "backend_host" in the config file, then "AGENTA_HOST" in environment variables.
-        api_key (Optional[str]): API Key to use with the host of the backend server. Defaults to None. If not provided, will look for "api_key" in the config file, then "AGENTA_API_KEY" in environment variables.
-        config_fname (Optional[str]): Path to the configuration file. Defaults to None.
-
-    Raises:
-        ValueError: If `app_id` is not specified either as an argument, in the config file, or in the environment variables.
+        app_name: _description_. Defaults to None.
+        base_name: _description_. Defaults to None.
     """
-
     singleton = AgentaSingleton()
+    singleton.init(app_name=app_name, base_name=base_name, **kwargs)
+    set_global(setup=singleton.setup, config=singleton.config)
+
 
-    singleton.init(app_id=app_id, host=host, api_key=api_key, config_fname=config_fname)
-    tracing = Tracing(
-        host=singleton.host,  # type: ignore
+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,
     )
-    set_global(setup=singleton.setup, config=singleton.config, tracing=tracing)

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