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

agenta/docker/docker-assets/Dockerfile.cloud.template

@@ -1,4 +1,4 @@
-FROM public.ecr.aws/h3w6n5z0/agentaai/lambda_templates_public:main
+FROM public.ecr.aws/s2t9a1r1/agentaai/lambda_templates_public:main
 
 COPY requirements.txt ${LAMBDA_TASK_ROOT}
 RUN pip install --no-cache-dir --disable-pip-version-check -U agenta

agenta/sdk/__init__.py

@@ -1,9 +1,6 @@
 from typing import Optional
 
 from .utils.preinit import PreInitObject  # always the first import!
-
-import agenta.client.backend.types as client_types  # pylint: disable=wrong-import-order
-
 from .types import (
     DictInput,
     MultipleChoice,
@@ -16,28 +13,19 @@ from .types import (
     MessagesInput,
     FileInputURL,
     BinaryParam,
-    Prompt,
 )
 
 from .tracing import Tracing, get_tracer
 from .decorators.tracing import instrument
-from .tracing.conventions import Reference
 from .decorators.routing import entrypoint, app, route
 from .agenta_init import Config, AgentaSingleton, init as _init
 from .utils.costs import calculate_token_usage
-from .managers.config import ConfigManager
-from .managers.variant import VariantManager
-from .managers.deployment import DeploymentManager
+from .config_manager import ConfigManager
 
 config = PreInitObject("agenta.config", Config)
 DEFAULT_AGENTA_SINGLETON_INSTANCE = AgentaSingleton()
-
-types = client_types
-
-api = None
-async_api = None
-
 tracing = DEFAULT_AGENTA_SINGLETON_INSTANCE.tracing  # type: ignore
+
 tracer = get_tracer(tracing)
 
 
@@ -47,18 +35,14 @@ def init(
     api_key: Optional[str] = None,
     config_fname: Optional[str] = None,
 ):
-    global api, async_api, tracing, tracer
+    global tracing
+    global tracer
 
     _init(
         host=host,
+        app_id=app_id,
         api_key=api_key,
         config_fname=config_fname,
-        # DEPRECATING
-        app_id=app_id,
     )
 
-    api = DEFAULT_AGENTA_SINGLETON_INSTANCE.api  # type: ignore
-    async_api = DEFAULT_AGENTA_SINGLETON_INSTANCE.async_api  # type: ignore
-
-    tracing = DEFAULT_AGENTA_SINGLETON_INSTANCE.tracing  # type: ignore
     tracer = get_tracer(tracing)

agenta/sdk/agenta_init.py

@@ -6,7 +6,7 @@ from importlib.metadata import version
 
 from agenta.sdk.utils.logging import log
 from agenta.sdk.utils.globals import set_global
-from agenta.client.backend.client import AgentaApi, AsyncAgentaApi
+from agenta.client.backend.client import AgentaApi
 from agenta.sdk.tracing import Tracing
 from agenta.client.exceptions import APIRequestError
 
@@ -22,9 +22,6 @@ class AgentaSingleton:
     config = None
     tracing = None
 
-    api = None
-    async_api = None
-
     def __new__(cls):
         if not cls._instance:
             cls._instance = super(AgentaSingleton, cls).__new__(cls)
@@ -34,13 +31,17 @@ class AgentaSingleton:
         self,
         *,
         host: Optional[str] = None,
+        project_id: Optional[str] = None,
         api_key: Optional[str] = None,
         config_fname: Optional[str] = None,
-        # DEPRECATING
+        #
         app_id: Optional[str] = None,
     ) -> None:
-        """
-        Main function to initialize the singleton.
+        log.info(f"\n--------------------------------")
+        log.info(f"Using Agenta Python SDK version: {version('agenta')}")
+        log.info(f"--------------------------------\n")
+
+        """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.
@@ -62,10 +63,6 @@ class AgentaSingleton:
             ValueError: If `app_id` is not specified either as an argument, in the config file, or in the environment variables.
         """
 
-        log.info("---------------------------")
-        log.info("Agenta SDK - using version: %s", version("agenta"))
-        log.info("---------------------------")
-
         config = {}
         if config_fname:
             config = toml.load(config_fname)
@@ -79,38 +76,35 @@ class AgentaSingleton:
         )
 
         self.app_id = app_id or config.get("app_id") or os.environ.get("AGENTA_APP_ID")
-        # 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'."
-        #     )
+        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.project_id = (
+            project_id
+            or os.environ.get("AGENTA_PROJECT_ID")
+            or config.get("project_id")
+        )
 
         self.api_key = (
             api_key or os.environ.get("AGENTA_API_KEY") or config.get("api_key")
         )
 
         self.tracing = Tracing(
-            url=f"{self.host}/api/observability/v1/otlp/traces",  # type: ignore
+            url=f"{self.host}/api/observability/v1/traces",  # type: ignore
         )
 
         self.tracing.configure(
+            project_id=self.project_id,
             api_key=self.api_key,
-            # DEPRECATING
+            # DEPRECATED
             app_id=self.app_id,
         )
 
-        self.api = AgentaApi(
-            base_url=self.host + "/api",
-            api_key=api_key if api_key else "",
-        )
-
-        self.async_api = AsyncAgentaApi(
-            base_url=self.host + "/api",
-            api_key=api_key if api_key else "",
-        )
-
         self.base_id = os.environ.get("AGENTA_BASE_ID")
 
         self.config = Config(
@@ -132,10 +126,9 @@ class Config:
         self.base_id = base_id
 
         if self.base_id is None:
-            # print(
-            #    "Warning: Your configuration will not be saved permanently since base_id is not provided.\n"
-            # )
-            pass
+            print(
+                "Warning: Your configuration will not be saved permanently since base_id is not provided.\n"
+            )
 
         if base_id is None or host is None:
             self.persist = False
@@ -258,6 +251,7 @@ class Config:
 
 def init(
     host: Optional[str] = None,
+    project_id: Optional[str] = None,
     api_key: Optional[str] = None,
     config_fname: Optional[str] = None,
     # DEPRECATED
@@ -289,6 +283,7 @@ def init(
 
     singleton.init(
         host=host,
+        project_id=project_id,
         api_key=api_key,
         config_fname=config_fname,
         # DEPRECATED

agenta/sdk/config_manager.py

@@ -0,0 +1,205 @@
+import json
+import logging
+from pathlib import Path
+from typing import Optional, Type, TypeVar
+
+import yaml
+from pydantic import BaseModel, ValidationError
+
+from agenta.client.backend.client import AgentaApi
+from agenta.sdk.context.routing import routing_context
+
+from . import AgentaSingleton
+
+T = TypeVar("T", bound=BaseModel)
+
+logger = logging.getLogger(__name__)
+singleton = AgentaSingleton()
+
+AVAILABLE_ENVIRONMENTS = ["development", "production", "staging"]
+
+
+class ConfigManager:
+    client = None
+
+    @staticmethod
+    def get_from_route(schema: Type[T]) -> T:
+        """
+        Retrieves the configuration from the route context and returns a config object.
+
+        This method checks the route context for configuration information and returns
+        an instance of the specified schema based on the available context data.
+
+        Args:
+            schema (Type[T]): A Pydantic model class that defines the structure of the configuration.
+
+        Returns:
+            T: An instance of the specified schema populated with the configuration data.
+
+        Raises:
+            ValueError: If conflicting configuration sources are provided or if no valid
+                        configuration source is found in the context.
+
+        Note:
+            The method prioritizes the inputs in the following way:
+            1. 'config' (i.e. when called explicitly from the playground)
+            2. 'environment'
+            3. 'variant'
+            Only one of these should be provided.
+        """
+        context = routing_context.get()
+        if ("config" in context and context["config"]) and (
+            ("environment" in context and context["environment"])
+            or ("variant" in context and context["variant"])
+        ):
+            raise ValueError(
+                "Either config, environment or variant must be provided. Not both."
+            )
+        if "config" in context and context["config"]:
+            return schema(**context["config"])
+        elif "environment" in context and context["environment"]:
+            return ConfigManager.get_from_registry(
+                schema, environment=context["environment"]
+            )
+        elif "variant" in context and context["variant"]:
+            return ConfigManager.get_from_registry(schema, variant=context["variant"])
+        else:
+            raise ValueError("Either config, environment or variant must be provided")
+
+    @staticmethod
+    def get_from_registry(
+        schema: Type[T],
+        environment: Optional[str] = None,
+        version: Optional[str] = None,
+        variant: Optional[str] = None,
+    ) -> T:
+        """
+        Pulls the parameters for the app variant from the server and returns a config object.
+
+        This method retrieves the configuration from the backend server based on the provided
+        environment or variant. It then validates and returns the configuration as an instance
+        of the specified schema.
+
+        Args:
+            schema (Type[T]): A Pydantic model class that defines the structure of the configuration.
+            environment (Optional[str]): The environment name to fetch the configuration for.
+                                         Must be one of "development", "production", or "staging".
+            version (Optional[str]): Currently not implemented. Will raise NotImplementedError if provided.
+            variant (Optional[str]): The variant name to fetch the configuration for.
+
+        Returns:
+            T: An instance of the specified schema populated with the configuration data.
+
+        Raises:
+            ValueError: If neither environment nor variant is provided.
+            NotImplementedError: If a specific version is requested (not yet implemented).
+            ValidationError: If the retrieved configuration data doesn't match the schema.
+            Exception: For any other errors during the process (e.g., API communication issues).
+
+        Note:
+            Either environment or variant must be provided, but not both.
+        """
+        if not ConfigManager.client:
+            try:
+                ConfigManager.client = AgentaApi(
+                    base_url=singleton.host + "/api",
+                    api_key=singleton.api_key if singleton.api_key else "",
+                )
+            except Exception as ex:
+                logger.error(
+                    "Failed to initialize Agenta client with error: %s", str(ex)
+                )
+                raise
+        if not environment and not variant:
+            raise ValueError("Either environment or variant must be provided")
+        try:
+            if environment:
+                if version:
+                    raise NotImplementedError(
+                        "Getting config for a specific version is not implemented yet."
+                    )
+                else:
+                    assert (
+                        environment in AVAILABLE_ENVIRONMENTS
+                    ), f"Environment must be in {AVAILABLE_ENVIRONMENTS}"
+                    config = ConfigManager.client.configs.get_config(
+                        base_id=singleton.base_id, environment_name=environment
+                    )
+            elif variant:
+                config = ConfigManager.client.configs.get_config(
+                    base_id=singleton.base_id, config_name=variant
+                )
+        except Exception as ex:
+            logger.error(
+                "Failed to pull the configuration from the server with error: %s",
+                str(ex),
+            )
+
+        try:
+            result = schema(**config.parameters)
+        except ValidationError as ex:
+            logger.error("Failed to validate the configuration with error: %s", str(ex))
+            raise
+        return result
+
+    @staticmethod
+    def get_from_yaml(filename: str, schema: Type[T]) -> T:
+        """
+        Loads configuration from a YAML file and returns a config object.
+
+        Args:
+            filename (str): The name of the YAML file to load.
+            schema (Type[T]): A Pydantic model class that defines the structure of the configuration.
+
+        Returns:
+            T: An instance of the specified schema populated with the configuration data.
+
+        Raises:
+            FileNotFoundError: If the specified file doesn't exist.
+            ValidationError: If the loaded configuration data doesn't match the schema.
+        """
+        file_path = Path(filename)
+        if not file_path.exists():
+            raise FileNotFoundError(f"Config file not found: {filename}")
+
+        with open(file_path, "r") as file:
+            config_data = yaml.safe_load(file)
+
+        try:
+            return schema(**config_data)
+        except ValidationError as ex:
+            logger.error(
+                f"Failed to validate the configuration from {filename} with error: {str(ex)}"
+            )
+            raise
+
+    @staticmethod
+    def get_from_json(filename: str, schema: Type[T]) -> T:
+        """
+        Loads configuration from a JSON file and returns a config object.
+
+        Args:
+            filename (str): The name of the JSON file to load.
+            schema (Type[T]): A Pydantic model class that defines the structure of the configuration.
+
+        Returns:
+            T: An instance of the specified schema populated with the configuration data.
+
+        Raises:
+            FileNotFoundError: If the specified file doesn't exist.
+            ValidationError: If the loaded configuration data doesn't match the schema.
+        """
+        file_path = Path(filename)
+        if not file_path.exists():
+            raise FileNotFoundError(f"Config file not found: {filename}")
+
+        with open(file_path, "r") as file:
+            config_data = json.load(file)
+
+        try:
+            return schema(**config_data)
+        except ValidationError as ex:
+            logger.error(
+                f"Failed to validate the configuration from {filename} with error: {str(ex)}"
+            )
+            raise

agenta/sdk/context/routing.py

@@ -7,17 +7,16 @@ routing_context = ContextVar("routing_context", default={})
 
 @contextmanager
 def routing_context_manager(
-    *,
     config: Optional[Dict[str, Any]] = None,
-    application: Optional[Dict[str, Any]] = None,
-    variant: Optional[Dict[str, Any]] = None,
-    environment: Optional[Dict[str, Any]] = None,
+    environment: Optional[str] = None,
+    version: Optional[str] = None,
+    variant: Optional[str] = None,
 ):
     context = {
         "config": config,
-        "application": application,
-        "variant": variant,
         "environment": environment,
+        "version": version,
+        "variant": variant,
     }
     token = routing_context.set(context)
     try: