agenta 0.16.0__tar.gz → 0.17.0__tar.gz

{agenta-0.16.0 → agenta-0.17.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: agenta
-Version: 0.16.0
+Version: 0.17.0
 Summary: The SDK for agenta is an open-source LLMOps platform.
 Home-page: https://agenta.ai
 Keywords: LLMOps,LLM,evaluation,prompt engineering
@@ -18,12 +18,12 @@ Classifier: Topic :: Software Development :: Libraries
 Requires-Dist: cachetools (>=5.3.3,<6.0.0)
 Requires-Dist: click (>=8.1.3,<9.0.0)
 Requires-Dist: docker (>=6.1.1,<8.0.0)
-Requires-Dist: fastapi (>=0.96.1)
+Requires-Dist: fastapi (>=0.100.0)
 Requires-Dist: httpx (>=0.24,<0.28)
 Requires-Dist: importlib-metadata (>=6.7,<8.0)
 Requires-Dist: ipdb (>=0.13)
 Requires-Dist: posthog (>=3.1.0,<4.0.0)
-Requires-Dist: pydantic (==1.10.13)
+Requires-Dist: pydantic (>=2)
 Requires-Dist: pymongo (>=4.6.3,<5.0.0)
 Requires-Dist: python-dotenv (>=1.0.0,<2.0.0)
 Requires-Dist: python-multipart (>=0.0.6,<0.0.10)

{agenta-0.16.0 → agenta-0.17.0}/agenta/docker/docker-assets/Dockerfile.cloud.template

@@ -2,7 +2,7 @@ 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
-RUN pip install --no-cache-dir --disable-pip-version-check -U -r requirements.txt
+RUN pip install --no-cache-dir --disable-pip-version-check -r requirements.txt
 RUN pip install --no-cache-dir --disable-pip-version-check mangum
 COPY . ${LAMBDA_TASK_ROOT}
 

{agenta-0.16.0 → agenta-0.17.0}/agenta/sdk/decorators/llm_entrypoint.py

@@ -203,15 +203,22 @@ class entrypoint(BaseDecorator):
             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))
+                return FuncResponse(
+                    message=str(result),
+                    usage=None,
+                    cost=None,
+                    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?",
+                    usage=None,
+                    cost=None,
                     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
+        return FuncResponse(message="Unexpected error occurred when calling the @entrypoint decorated function", latency=0)  # type: ignore
 
     def handle_exception(self, e: Exception):
         """Handle exceptions."""
@@ -237,7 +244,7 @@ class entrypoint(BaseDecorator):
 
         wrapper_signature = inspect.signature(wrapper)
         wrapper_signature = wrapper_signature.replace(parameters=updated_params)
-        wrapper.__signature__ = wrapper_signature
+        wrapper.__signature__ = wrapper_signature  # type: ignore
 
     def update_function_signature(
         self,
@@ -248,7 +255,7 @@ class entrypoint(BaseDecorator):
     ) -> None:
         """Update the function signature to include new parameters."""
 
-        updated_params = []
+        updated_params: List[inspect.Parameter] = []
         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)
@@ -260,7 +267,8 @@ class entrypoint(BaseDecorator):
         ingestible_files: Dict[str, inspect.Parameter],
     ) -> None:
         """Update the function signature to include new parameters."""
-        updated_params = []
+
+        updated_params: List[inspect.Parameter] = []
         self.add_func_params_to_parser(updated_params, func_signature, ingestible_files)
         for param in [
             "config",
@@ -281,12 +289,19 @@ class entrypoint(BaseDecorator):
     ) -> None:
         """Add configuration parameters to function signature."""
         for name, param in config_params.items():
+            assert (
+                len(param.__class__.__bases__) == 1
+            ), f"Inherited standard type of {param.__class__} needs to be one."
             updated_params.append(
                 inspect.Parameter(
                     name,
                     inspect.Parameter.KEYWORD_ONLY,
                     default=Body(param),
-                    annotation=Optional[type(param)],
+                    annotation=param.__class__.__bases__[
+                        0
+                    ],  # determines and get the base (parent/inheritance) type of the sdk-type at run-time. \
+                    # E.g __class__ is ag.MessagesInput() and accessing it parent type will return (<class 'list'>,), \
+                    # thus, why we are accessing the first item.
                 )
             )
 
@@ -303,12 +318,19 @@ class entrypoint(BaseDecorator):
                     inspect.Parameter(name, param.kind, annotation=UploadFile)
                 )
             else:
+                assert (
+                    len(param.default.__class__.__bases__) == 1
+                ), f"Inherited standard type of {param.default.__class__} needs to be one."
                 updated_params.append(
                     inspect.Parameter(
                         name,
                         inspect.Parameter.KEYWORD_ONLY,
                         default=Body(..., embed=True),
-                        annotation=param.annotation,
+                        annotation=param.default.__class__.__bases__[
+                            0
+                        ],  # determines and get the base (parent/inheritance) type of the sdk-type at run-time. \
+                        # E.g __class__ is ag.MessagesInput() and accessing it parent type will return (<class 'list'>,), \
+                        # thus, why we are accessing the first item.
                     )
                 )
 
@@ -358,7 +380,7 @@ class entrypoint(BaseDecorator):
                     f"--{name}",
                     type=str,
                     default=param.default,
-                    choices=param.choices,
+                    choices=param.choices,  # type: ignore
                 )
             else:
                 parser.add_argument(
@@ -420,7 +442,9 @@ class entrypoint(BaseDecorator):
             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):
+        def find_in_schema(
+            schema_type_properties: dict, 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()
@@ -432,9 +456,17 @@ class entrypoint(BaseDecorator):
 
                 if (
                     isinstance(value, dict)
-                    and value.get("x-parameter") == xparam
+                    and schema_type_properties.get("x-parameter") == xparam
                     and value_title == param_name
                 ):
+                    # this will update the default type schema with the properties gotten
+                    # from the schema type (param_val) __schema_properties__ classmethod
+                    for type_key, type_value in schema_type_properties.items():
+                        # BEFORE:
+                        # value = {'temperature': {'title': 'Temperature'}}
+                        value[type_key] = type_value
+                        # AFTER:
+                        # value = {'temperature': { "type": "number", "title": "Temperature", "x-parameter": "float" }}
                     return value
 
         schema_to_override = openapi_schema["components"]["schemas"][
@@ -443,17 +475,26 @@ class entrypoint(BaseDecorator):
         for param_name, param_val in params.items():
             if isinstance(param_val, GroupedMultipleChoiceParam):
                 subschema = find_in_schema(
-                    schema_to_override, param_name, "grouped_choice"
+                    param_val.__schema_type_properties__(),
+                    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
+                subschema["choices"] = param_val.choices  # type: ignore
+                subschema["default"] = param_val.default  # type: ignore
+
             if isinstance(param_val, MultipleChoiceParam):
-                subschema = find_in_schema(schema_to_override, param_name, "choice")
+                subschema = find_in_schema(
+                    param_val.__schema_type_properties__(),
+                    schema_to_override,
+                    param_name,
+                    "choice",
+                )
                 default = str(param_val)
-                param_choices = param_val.choices
+                param_choices = param_val.choices  # type: ignore
                 choices = (
                     [default] + param_choices
                     if param_val not in param_choices
@@ -463,37 +504,79 @@ class entrypoint(BaseDecorator):
                 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 = find_in_schema(
+                    param_val.__schema_type_properties__(),
+                    schema_to_override,
+                    param_name,
+                    "float",
+                )
+                subschema["minimum"] = param_val.minval  # type: ignore
+                subschema["maximum"] = param_val.maxval  # type: ignore
                 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 = find_in_schema(
+                    param_val.__schema_type_properties__(),
+                    schema_to_override,
+                    param_name,
+                    "int",
+                )
+                subschema["minimum"] = param_val.minval  # type: ignore
+                subschema["maximum"] = param_val.maxval  # type: ignore
                 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 = find_in_schema(
+                    param_val.annotation.__schema_type_properties__(),
+                    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 = find_in_schema(
+                    param_val.__schema_type_properties__(),
+                    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 = find_in_schema(
+                    param_val.annotation.__schema_type_properties__(),
+                    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 = find_in_schema(
+                    param_val.annotation.__schema_type_properties__(),
+                    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
+                subschema = find_in_schema(
+                    param_val.__schema_type_properties__(),
+                    schema_to_override,
+                    param_name,
+                    "bool",
+                )
+                subschema["default"] = param_val.default  # type: ignore

{agenta-0.16.0 → agenta-0.17.0}/agenta/sdk/types.py

@@ -1,7 +1,7 @@
 import json
-from typing import Any, Dict, List, Optional
+from typing import Dict, List, Optional
 
-from pydantic import BaseModel, Extra, HttpUrl, Field
+from pydantic import ConfigDict, BaseModel, HttpUrl
 
 
 class InFile:
@@ -24,87 +24,75 @@ class FuncResponse(BaseModel):
 
 
 class DictInput(dict):
-    def __new__(cls, default_keys=None):
+    def __new__(cls, default_keys: Optional[List[str]] = None):
         instance = super().__new__(cls, default_keys)
         if default_keys is None:
             default_keys = []
-        instance.data = [key for key in default_keys]
+        instance.data = [key for key in default_keys]  # type: ignore
         return instance
 
     @classmethod
-    def __modify_schema__(cls, field_schema):
-        field_schema.update({"x-parameter": "dict"})
+    def __schema_type_properties__(cls) -> dict:
+        return {"x-parameter": "dict"}
 
 
 class TextParam(str):
     @classmethod
-    def __modify_schema__(cls, field_schema):
-        field_schema.update({"x-parameter": "text"})
+    def __schema_type_properties__(cls) -> dict:
+        return {"x-parameter": "text", "type": "string"}
 
 
 class BinaryParam(int):
     def __new__(cls, value: bool = False):
         instance = super().__new__(cls, int(value))
-        instance.default = value
+        instance.default = value  # type: ignore
         return instance
 
     @classmethod
-    def __modify_schema__(cls, field_schema):
-        field_schema.update(
-            {
-                "x-parameter": "bool",
-                "type": "boolean",
-            }
-        )
+    def __schema_type_properties__(cls) -> dict:
+        return {
+            "x-parameter": "bool",
+            "type": "boolean",
+        }
 
 
 class IntParam(int):
     def __new__(cls, default: int = 6, minval: float = 1, maxval: float = 10):
         instance = super().__new__(cls, default)
-        instance.minval = minval
-        instance.maxval = maxval
+        instance.minval = minval  # type: ignore
+        instance.maxval = maxval  # type: ignore
         return instance
 
     @classmethod
-    def __modify_schema__(cls, field_schema):
-        field_schema.update(
-            {
-                "x-parameter": "int",
-                "type": "integer",
-                "minimum": 1,
-                "maximum": 10,
-            }
-        )
+    def __schema_type_properties__(cls) -> dict:
+        return {"x-parameter": "int", "type": "integer"}
 
 
 class FloatParam(float):
     def __new__(cls, default: float = 0.5, minval: float = 0.0, maxval: float = 1.0):
         instance = super().__new__(cls, default)
-        instance.minval = minval
-        instance.maxval = maxval
+        instance.default = default  # type: ignore
+        instance.minval = minval  # type: ignore
+        instance.maxval = maxval  # type: ignore
         return instance
 
     @classmethod
-    def __modify_schema__(cls, field_schema):
-        field_schema.update(
-            {
-                "x-parameter": "float",
-                "type": "number",
-                "minimum": 0.0,
-                "maximum": 1.0,
-            }
-        )
+    def __schema_type_properties__(cls) -> dict:
+        return {"x-parameter": "float", "type": "number"}
 
 
 class MultipleChoiceParam(str):
-    def __new__(cls, default: str = None, choices: List[str] = None):
-        if type(default) is list:
+    def __new__(
+        cls, default: Optional[str] = None, choices: Optional[List[str]] = None
+    ):
+        if default is not None and type(default) is list:
             raise ValueError(
                 "The order of the parameters for MultipleChoiceParam is wrong! It's MultipleChoiceParam(default, choices) and not the opposite"
             )
-        if default is None and choices:
+
+        if not default and choices is not None:
             # if a default value is not provided,
-            # uset the first value in the choices list
+            # set the first value in the choices list
             default = choices[0]
 
         if default is None and not choices:
@@ -112,23 +100,21 @@ class MultipleChoiceParam(str):
             raise ValueError("You must provide either a default value or choices")
 
         instance = super().__new__(cls, default)
-        instance.choices = choices
-        instance.default = default
+        instance.choices = choices  # type: ignore
+        instance.default = default  # type: ignore
         return instance
 
     @classmethod
-    def __modify_schema__(cls, field_schema: dict[str, Any]):
-        field_schema.update(
-            {
-                "x-parameter": "choice",
-                "type": "string",
-                "enum": [],
-            }
-        )
+    def __schema_type_properties__(cls) -> dict:
+        return {"x-parameter": "choice", "type": "string", "enum": []}
 
 
 class GroupedMultipleChoiceParam(str):
-    def __new__(cls, default: str = None, choices: Dict[str, List[str]] = None):
+    def __new__(
+        cls,
+        default: Optional[str] = None,
+        choices: Optional[Dict[str, List[str]]] = None,
+    ):
         if choices is None:
             choices = {}
         if default and not any(
@@ -144,31 +130,23 @@ class GroupedMultipleChoiceParam(str):
                 )
 
         if not default:
-            for choices in choices.values():
-                if choices:
-                    default = choices[0]
-                    break
+            default_selected_choice = next(
+                (choices for choices in choices.values()), None
+            )
+            if default_selected_choice:
+                default = default_selected_choice[0]
 
         instance = super().__new__(cls, default)
-        instance.choices = choices
-        instance.default = default
+        instance.choices = choices  # type: ignore
+        instance.default = default  # type: ignore
         return instance
 
     @classmethod
-    def __modify_schema__(cls, field_schema: dict[str, Any], **kwargs):
-        choices = kwargs.get("choices", {})
-        field_schema.update(
-            {
-                "x-parameter": "grouped_choice",
-                "type": "string",
-                "choices": choices,
-            }
-        )
-
-
-class Message(BaseModel):
-    role: str
-    content: str
+    def __schema_type_properties__(cls) -> dict:
+        return {
+            "x-parameter": "grouped_choice",
+            "type": "string",
+        }
 
 
 class MessagesInput(list):
@@ -183,28 +161,32 @@ class MessagesInput(list):
 
     """
 
-    def __new__(cls, messages: List[Dict[str, str]] = None):
-        instance = super().__new__(cls, messages)
-        instance.default = messages
+    def __new__(cls, messages: List[Dict[str, str]] = []):
+        instance = super().__new__(cls)
+        instance.default = messages  # type: ignore
         return instance
 
     @classmethod
-    def __modify_schema__(cls, field_schema: dict[str, Any]):
-        field_schema.update({"x-parameter": "messages", "type": "array"})
+    def __schema_type_properties__(cls) -> dict:
+        return {"x-parameter": "messages", "type": "array"}
 
 
 class FileInputURL(HttpUrl):
+    def __new__(cls, url: str):
+        instance = super().__new__(cls, url)
+        instance.default = url  # type: ignore
+        return instance
+
     @classmethod
-    def __modify_schema__(cls, field_schema: Dict[str, Any]) -> None:
-        field_schema.update({"x-parameter": "file_url", "type": "string"})
+    def __schema_type_properties__(cls) -> dict:
+        return {"x-parameter": "file_url", "type": "string"}
 
 
 class Context(BaseModel):
-    class Config:
-        extra = Extra.allow
+    model_config = ConfigDict(extra="allow")
 
     def to_json(self):
-        return self.json()
+        return self.model_dump()
 
     @classmethod
     def from_json(cls, json_str: str):

{agenta-0.16.0 → agenta-0.17.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "agenta"
-version = "0.16.0"
+version = "0.17.0"
 description = "The SDK for agenta is an open-source LLMOps platform."
 readme = "README.md"
 authors = ["Mahmoud Mabrouk <mahmoud@agenta.ai>"]
@@ -19,7 +19,7 @@ keywords = ["LLMOps", "LLM", "evaluation", "prompt engineering"]
 python = "^3.9"
 docker = ">=6.1.1,<8.0.0"
 click = "^8.1.3"
-fastapi = ">=0.96.1"
+fastapi = ">=0.100.0"
 toml = "^0.10.2"
 questionary = ">=1.10,<3.0"
 ipdb = ">=0.13"
@@ -27,7 +27,7 @@ python-dotenv = "^1.0.0"
 python-multipart = ">=0.0.6,<0.0.10"
 importlib-metadata = ">=6.7,<8.0"
 posthog = "^3.1.0"
-pydantic = "1.10.13"
+pydantic = ">=2"
 httpx = ">=0.24, <0.28"
 pymongo = "^4.6.3"
 cachetools = "^5.3.3"