agenta 0.14.14__tar.gz → 0.14.14a1__tar.gz

{agenta-0.14.14 → agenta-0.14.14a1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: agenta
-Version: 0.14.14
+Version: 0.14.14a1
 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.111.0,<0.112.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.7.1,<3.0.0)
 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.14.14 → agenta-0.14.14a1}/agenta/sdk/agenta_decorator.py

@@ -57,7 +57,7 @@ def ingest_file(upfile: UploadFile):
     return InFile(file_name=upfile.filename, file_path=temp_file.name)
 
 
-def entrypoint(func: Callable[..., Any]) -> Callable[..., Any]:
+def entrypoint(func: Callable[..., Any]):
     """
     Decorator to wrap a function for HTTP POST and terminal exposure.
 
@@ -97,8 +97,8 @@ def entrypoint(func: Callable[..., Any]) -> Callable[..., Any]:
 
         # End trace recording
         tracing.end_recording(
-            outputs=llm_result.dict(),
-            span=tracing.active_trace,
+            outputs=llm_result.model_dump(),
+            span=tracing.active_trace,  # type: ignore
         )
         return llm_result
 
@@ -130,8 +130,8 @@ def entrypoint(func: Callable[..., Any]) -> Callable[..., Any]:
 
         # End trace recording
         tracing.end_recording(
-            outputs=llm_result.dict(),
-            span=tracing.active_trace,
+            outputs=llm_result.model_dump(),
+            span=tracing.active_trace,  # type: ignore
         )
         return llm_result
 
@@ -144,6 +144,7 @@ def entrypoint(func: Callable[..., Any]) -> Callable[..., Any]:
         func_signature,
         ingestible_files,
     )
+
     route_deployed = f"/{endpoint_name}_deployed"
     app.post(route_deployed, response_model=FuncResponse)(wrapper_deployed)
     override_schema(
@@ -156,11 +157,10 @@ def entrypoint(func: Callable[..., Any]) -> Callable[..., Any]:
     if is_main_script(func):
         handle_terminal_run(
             func,
-            func_signature.parameters,
+            func_signature.parameters,  # type: ignore
             config_params,
             ingestible_files,
         )
-    return None
 
 
 def extract_ingestible_files(
@@ -248,7 +248,7 @@ def update_wrapper_signature(wrapper: Callable[..., Any], updated_params: List):
 
     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(
@@ -259,7 +259,7 @@ def update_function_signature(
 ) -> None:
     """Update the function signature to include new parameters."""
 
-    updated_params = []
+    updated_params: List[inspect.Parameter] = []
     add_config_params_to_parser(updated_params, config_params)
     add_func_params_to_parser(updated_params, func_signature, ingestible_files)
     update_wrapper_signature(wrapper, updated_params)
@@ -271,7 +271,7 @@ def update_deployed_function_signature(
     ingestible_files: Dict[str, inspect.Parameter],
 ) -> None:
     """Update the function signature to include new parameters."""
-    updated_params = []
+    updated_params: List[inspect.Parameter] = []
     add_func_params_to_parser(updated_params, func_signature, ingestible_files)
     for param in [
         "config",
@@ -293,12 +293,19 @@ def add_config_params_to_parser(
 ) -> 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.
             )
         )
 
@@ -315,12 +322,19 @@ def add_func_params_to_parser(
                 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,
+                    default=Body(param.default),
+                    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.
                 )
             )
 
@@ -375,8 +389,8 @@ def handle_terminal_run(
             parser.add_argument(
                 f"--{name}",
                 type=str,
-                default=param.default,
-                choices=param.choices,
+                default=param.default,  # type: ignore
+                choices=param.choices,  # type: ignore
             )
         else:
             parser.add_argument(
@@ -426,7 +440,9 @@ def override_schema(openapi_schema: dict, func_name: str, endpoint: str, params:
         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()
@@ -438,9 +454,17 @@ def override_schema(openapi_schema: dict, func_name: str, endpoint: str, params:
 
             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"][
@@ -448,16 +472,26 @@ def override_schema(openapi_schema: dict, func_name: str, endpoint: str, params:
     ]["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")
+            subschema = find_in_schema(
+                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
@@ -466,36 +500,71 @@ def override_schema(openapi_schema: dict, func_name: str, endpoint: str, params:
             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 = 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.14.14 → agenta-0.14.14a1}/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 = {}
 
@@ -143,31 +129,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):
@@ -182,28 +160,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.14.14 → agenta-0.14.14a1}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "agenta"
-version = "0.14.14"
+version = "0.14.14a1"
 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.111.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.7.1"
 httpx = ">=0.24, <0.28"
 pymongo = "^4.6.3"
 cachetools = "^5.3.3"

{agenta-0.14.14 → agenta-0.14.14a1}/agenta/docker/docker-assets/Dockerfile.cloud.template

@@ -1,9 +1,9 @@
 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 -r requirements.txt
 RUN pip install --no-cache-dir --disable-pip-version-check mangum
-RUN pip install --no-cache-dir --disable-pip-version-check -U agenta
 COPY . ${LAMBDA_TASK_ROOT}
 
 CMD [ "lambda_function.handler" ]

{agenta-0.14.14 → agenta-0.14.14a1}/agenta/docker/docker-assets/Dockerfile.template

@@ -4,8 +4,8 @@ WORKDIR /app
 
 COPY . .
 
-RUN pip install --no-cache-dir --disable-pip-version-check -r requirements.txt
 RUN pip install --no-cache-dir --disable-pip-version-check -U agenta
+RUN pip install --no-cache-dir --disable-pip-version-check -r requirements.txt
 
 EXPOSE 80