agenta 0.48.8__py3-none-any.whl → 0.48.10__py3-none-any.whl

agenta/client/backend/core/pydantic_utilities.py

@@ -2,93 +2,83 @@
 
 # nopycln: file
 import datetime as dt
-import typing
 from collections import defaultdict
-
-import typing_extensions
+from typing import (
+    Any,
+    Callable,
+    ClassVar,
+    Dict,
+    List,
+    Mapping,
+    Optional,
+    Set,
+    Tuple,
+    Type,
+    TypeVar,
+    Union,
+    cast,
+)
 
 import pydantic
 
-from .datetime_utils import serialize_datetime
-from .serialization import convert_and_respect_annotation_metadata
-
 IS_PYDANTIC_V2 = pydantic.VERSION.startswith("2.")
 
 if IS_PYDANTIC_V2:
-    # isort will try to reformat the comments on these imports, which breaks mypy
-    # isort: off
-    from pydantic.v1.datetime_parse import (  # type: ignore # pyright: ignore[reportMissingImports] # Pydantic v2
-        parse_date as parse_date,
-    )
-    from pydantic.v1.datetime_parse import (  # pyright: ignore[reportMissingImports] # Pydantic v2
-        parse_datetime as parse_datetime,
-    )
-    from pydantic.v1.json import (  # type: ignore # pyright: ignore[reportMissingImports] # Pydantic v2
-        ENCODERS_BY_TYPE as encoders_by_type,
-    )
-    from pydantic.v1.typing import (  # type: ignore # pyright: ignore[reportMissingImports] # Pydantic v2
-        get_args as get_args,
-    )
-    from pydantic.v1.typing import (  # pyright: ignore[reportMissingImports] # Pydantic v2
-        get_origin as get_origin,
-    )
-    from pydantic.v1.typing import (  # pyright: ignore[reportMissingImports] # Pydantic v2
-        is_literal_type as is_literal_type,
-    )
-    from pydantic.v1.typing import (  # pyright: ignore[reportMissingImports] # Pydantic v2
-        is_union as is_union,
-    )
-    from pydantic.v1.fields import ModelField as ModelField  # type: ignore # pyright: ignore[reportMissingImports] # Pydantic v2
+    from pydantic.v1.datetime_parse import parse_date as parse_date
+    from pydantic.v1.datetime_parse import parse_datetime as parse_datetime
+    from pydantic.v1.fields import ModelField as ModelField
+    from pydantic.v1.json import ENCODERS_BY_TYPE as encoders_by_type  # type: ignore[attr-defined]
+    from pydantic.v1.typing import get_args as get_args
+    from pydantic.v1.typing import get_origin as get_origin
+    from pydantic.v1.typing import is_literal_type as is_literal_type
+    from pydantic.v1.typing import is_union as is_union
 else:
-    from pydantic.datetime_parse import parse_date as parse_date  # type: ignore # Pydantic v1
-    from pydantic.datetime_parse import parse_datetime as parse_datetime  # type: ignore # Pydantic v1
-    from pydantic.fields import ModelField as ModelField  # type: ignore # Pydantic v1
-    from pydantic.json import ENCODERS_BY_TYPE as encoders_by_type  # type: ignore # Pydantic v1
-    from pydantic.typing import get_args as get_args  # type: ignore # Pydantic v1
-    from pydantic.typing import get_origin as get_origin  # type: ignore # Pydantic v1
-    from pydantic.typing import is_literal_type as is_literal_type  # type: ignore # Pydantic v1
-    from pydantic.typing import is_union as is_union  # type: ignore # Pydantic v1
-
-    # isort: on
+    from pydantic.datetime_parse import parse_date as parse_date  # type: ignore[no-redef]
+    from pydantic.datetime_parse import parse_datetime as parse_datetime  # type: ignore[no-redef]
+    from pydantic.fields import ModelField as ModelField  # type: ignore[attr-defined, no-redef]
+    from pydantic.json import ENCODERS_BY_TYPE as encoders_by_type  # type: ignore[no-redef]
+    from pydantic.typing import get_args as get_args  # type: ignore[no-redef]
+    from pydantic.typing import get_origin as get_origin  # type: ignore[no-redef]
+    from pydantic.typing import is_literal_type as is_literal_type  # type: ignore[no-redef]
+    from pydantic.typing import is_union as is_union  # type: ignore[no-redef]
 
+from .datetime_utils import serialize_datetime
+from .serialization import convert_and_respect_annotation_metadata
+from typing_extensions import TypeAlias
 
-T = typing.TypeVar("T")
-Model = typing.TypeVar("Model", bound=pydantic.BaseModel)
+T = TypeVar("T")
+Model = TypeVar("Model", bound=pydantic.BaseModel)
 
 
-def parse_obj_as(type_: typing.Type[T], object_: typing.Any) -> T:
+def parse_obj_as(type_: Type[T], object_: Any) -> T:
     dealiased_object = convert_and_respect_annotation_metadata(
         object_=object_, annotation=type_, direction="read"
     )
     if IS_PYDANTIC_V2:
-        adapter = pydantic.TypeAdapter(type_)  # type: ignore # Pydantic v2
+        adapter = pydantic.TypeAdapter(type_)  # type: ignore[attr-defined]
         return adapter.validate_python(dealiased_object)
-    else:
-        return pydantic.parse_obj_as(type_, dealiased_object)
+    return pydantic.parse_obj_as(type_, dealiased_object)
 
 
 def to_jsonable_with_fallback(
-    obj: typing.Any, fallback_serializer: typing.Callable[[typing.Any], typing.Any]
-) -> typing.Any:
+    obj: Any, fallback_serializer: Callable[[Any], Any]
+) -> Any:
     if IS_PYDANTIC_V2:
         from pydantic_core import to_jsonable_python
 
         return to_jsonable_python(obj, fallback=fallback_serializer)
-    else:
-        return fallback_serializer(obj)
+    return fallback_serializer(obj)
 
 
 class UniversalBaseModel(pydantic.BaseModel):
     if IS_PYDANTIC_V2:
-        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(
+        model_config: ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(  # type: ignore[typeddict-unknown-key]
             # Allow fields beginning with `model_` to be used in the model
             protected_namespaces=(),
-        )  # type: ignore # Pydantic v2
+        )
 
-        @pydantic.model_serializer(mode="wrap", when_used="json")  # type: ignore # Pydantic v2
-        def serialize_model(
-            self, handler: pydantic.SerializerFunctionWrapHandler
-        ) -> typing.Any:  # type: ignore # Pydantic v2
+        @pydantic.model_serializer(mode="wrap", when_used="json")  # type: ignore[attr-defined]
+        def serialize_model(self, handler: pydantic.SerializerFunctionWrapHandler) -> Any:  # type: ignore[name-defined]
             serialized = handler(self)
             data = {
                 k: serialize_datetime(v) if isinstance(v, dt.datetime) else v
@@ -104,9 +94,7 @@ class UniversalBaseModel(pydantic.BaseModel):
 
     @classmethod
     def model_construct(
-        cls: typing.Type["Model"],
-        _fields_set: typing.Optional[typing.Set[str]] = None,
-        **values: typing.Any,
+        cls: Type["Model"], _fields_set: Optional[Set[str]] = None, **values: Any
     ) -> "Model":
         dealiased_object = convert_and_respect_annotation_metadata(
             object_=values, annotation=cls, direction="read"
@@ -115,30 +103,26 @@ class UniversalBaseModel(pydantic.BaseModel):
 
     @classmethod
     def construct(
-        cls: typing.Type["Model"],
-        _fields_set: typing.Optional[typing.Set[str]] = None,
-        **values: typing.Any,
+        cls: Type["Model"], _fields_set: Optional[Set[str]] = None, **values: Any
     ) -> "Model":
         dealiased_object = convert_and_respect_annotation_metadata(
             object_=values, annotation=cls, direction="read"
         )
         if IS_PYDANTIC_V2:
-            return super().model_construct(_fields_set, **dealiased_object)  # type: ignore # Pydantic v2
-        else:
-            return super().construct(_fields_set, **dealiased_object)
+            return super().model_construct(_fields_set, **dealiased_object)  # type: ignore[misc]
+        return super().construct(_fields_set, **dealiased_object)
 
-    def json(self, **kwargs: typing.Any) -> str:
-        kwargs_with_defaults: typing.Any = {
+    def json(self, **kwargs: Any) -> str:
+        kwargs_with_defaults = {
             "by_alias": True,
             "exclude_unset": True,
             **kwargs,
         }
         if IS_PYDANTIC_V2:
-            return super().model_dump_json(**kwargs_with_defaults)  # type: ignore # Pydantic v2
-        else:
-            return super().json(**kwargs_with_defaults)
+            return super().model_dump_json(**kwargs_with_defaults)  # type: ignore[misc]
+        return super().json(**kwargs_with_defaults)
 
-    def dict(self, **kwargs: typing.Any) -> typing.Dict[str, typing.Any]:
+    def dict(self, **kwargs: Any) -> Dict[str, Any]:
         """
         Override the default dict method to `exclude_unset` by default. This function patches
         `exclude_unset` to work include fields within non-None default values.
@@ -149,21 +133,21 @@ class UniversalBaseModel(pydantic.BaseModel):
         # We'd ideally do the same for Pydantic V2, but it shells out to a library to serialize models
         # that we have less control over, and this is less intrusive than custom serializers for now.
         if IS_PYDANTIC_V2:
-            kwargs_with_defaults_exclude_unset: typing.Any = {
+            kwargs_with_defaults_exclude_unset = {
                 **kwargs,
                 "by_alias": True,
                 "exclude_unset": True,
                 "exclude_none": False,
             }
-            kwargs_with_defaults_exclude_none: typing.Any = {
+            kwargs_with_defaults_exclude_none = {
                 **kwargs,
                 "by_alias": True,
                 "exclude_none": True,
                 "exclude_unset": False,
             }
             dict_dump = deep_union_pydantic_dicts(
-                super().model_dump(**kwargs_with_defaults_exclude_unset),  # type: ignore # Pydantic v2
-                super().model_dump(**kwargs_with_defaults_exclude_none),  # type: ignore # Pydantic v2
+                super().model_dump(**kwargs_with_defaults_exclude_unset),  # type: ignore[misc]
+                super().model_dump(**kwargs_with_defaults_exclude_none),  # type: ignore[misc]
             )
 
         else:
@@ -185,7 +169,7 @@ class UniversalBaseModel(pydantic.BaseModel):
                         if default is not None:
                             self.__fields_set__.add(name)
 
-            kwargs_with_defaults_exclude_unset_include_fields: typing.Any = {
+            kwargs_with_defaults_exclude_unset_include_fields = {
                 "by_alias": True,
                 "exclude_unset": True,
                 "include": _fields_set,
@@ -202,11 +186,11 @@ class UniversalBaseModel(pydantic.BaseModel):
 
 
 def _union_list_of_pydantic_dicts(
-    source: typing.List[typing.Any], destination: typing.List[typing.Any]
-) -> typing.List[typing.Any]:
-    converted_list: typing.List[typing.Any] = []
+    source: List[Any], destination: List[Any]
+) -> List[Any]:
+    converted_list: List[Any] = []
     for i, item in enumerate(source):
-        destination_value = destination[i]  # type: ignore
+        destination_value = destination[i]
         if isinstance(item, dict):
             converted_list.append(deep_union_pydantic_dicts(item, destination_value))
         elif isinstance(item, list):
@@ -219,8 +203,8 @@ def _union_list_of_pydantic_dicts(
 
 
 def deep_union_pydantic_dicts(
-    source: typing.Dict[str, typing.Any], destination: typing.Dict[str, typing.Any]
-) -> typing.Dict[str, typing.Any]:
+    source: Dict[str, Any], destination: Dict[str, Any]
+) -> Dict[str, Any]:
     for key, value in source.items():
         node = destination.setdefault(key, {})
         if isinstance(value, dict):
@@ -238,18 +222,18 @@ def deep_union_pydantic_dicts(
 
 if IS_PYDANTIC_V2:
 
-    class V2RootModel(UniversalBaseModel, pydantic.RootModel):  # type: ignore # Pydantic v2
+    class V2RootModel(UniversalBaseModel, pydantic.RootModel):  # type: ignore[misc, name-defined, type-arg]
         pass
 
-    UniversalRootModel: typing_extensions.TypeAlias = V2RootModel  # type: ignore
+    UniversalRootModel: TypeAlias = V2RootModel  # type: ignore[misc]
 else:
-    UniversalRootModel: typing_extensions.TypeAlias = UniversalBaseModel  # type: ignore
+    UniversalRootModel: TypeAlias = UniversalBaseModel  # type: ignore[misc, no-redef]
 
 
-def encode_by_type(o: typing.Any) -> typing.Any:
-    encoders_by_class_tuples: typing.Dict[
-        typing.Callable[[typing.Any], typing.Any], typing.Tuple[typing.Any, ...]
-    ] = defaultdict(tuple)
+def encode_by_type(o: Any) -> Any:
+    encoders_by_class_tuples: Dict[Callable[[Any], Any], Tuple[Any, ...]] = defaultdict(
+        tuple
+    )
     for type_, encoder in encoders_by_type.items():
         encoders_by_class_tuples[encoder] += (type_,)
 
@@ -260,60 +244,51 @@ def encode_by_type(o: typing.Any) -> typing.Any:
             return encoder(o)
 
 
-def update_forward_refs(model: typing.Type["Model"], **localns: typing.Any) -> None:
+def update_forward_refs(model: Type["Model"], **localns: Any) -> None:
     if IS_PYDANTIC_V2:
-        model.model_rebuild(raise_errors=False)  # type: ignore # Pydantic v2
+        model.model_rebuild(raise_errors=False)  # type: ignore[attr-defined]
     else:
         model.update_forward_refs(**localns)
 
 
 # Mirrors Pydantic's internal typing
-AnyCallable = typing.Callable[..., typing.Any]
+AnyCallable = Callable[..., Any]
 
 
 def universal_root_validator(
     pre: bool = False,
-) -> typing.Callable[[AnyCallable], AnyCallable]:
+) -> Callable[[AnyCallable], AnyCallable]:
     def decorator(func: AnyCallable) -> AnyCallable:
         if IS_PYDANTIC_V2:
-            return pydantic.model_validator(mode="before" if pre else "after")(func)  # type: ignore # Pydantic v2
-        else:
-            return pydantic.root_validator(pre=pre)(func)  # type: ignore # Pydantic v1
+            return cast(AnyCallable, pydantic.model_validator(mode="before" if pre else "after")(func))  # type: ignore[attr-defined]
+        return cast(AnyCallable, pydantic.root_validator(pre=pre)(func))  # type: ignore[call-overload]
 
     return decorator
 
 
 def universal_field_validator(
     field_name: str, pre: bool = False
-) -> typing.Callable[[AnyCallable], AnyCallable]:
+) -> Callable[[AnyCallable], AnyCallable]:
     def decorator(func: AnyCallable) -> AnyCallable:
         if IS_PYDANTIC_V2:
-            return pydantic.field_validator(
-                field_name, mode="before" if pre else "after"
-            )(
-                func
-            )  # type: ignore # Pydantic v2
-        else:
-            return pydantic.validator(field_name, pre=pre)(func)  # type: ignore # Pydantic v1
+            return cast(AnyCallable, pydantic.field_validator(field_name, mode="before" if pre else "after")(func))  # type: ignore[attr-defined]
+        return cast(AnyCallable, pydantic.validator(field_name, pre=pre)(func))
 
     return decorator
 
 
-PydanticField = typing.Union[ModelField, pydantic.fields.FieldInfo]
+PydanticField = Union[ModelField, pydantic.fields.FieldInfo]
 
 
-def _get_model_fields(
-    model: typing.Type["Model"],
-) -> typing.Mapping[str, PydanticField]:
+def _get_model_fields(model: Type["Model"]) -> Mapping[str, PydanticField]:
     if IS_PYDANTIC_V2:
-        return model.model_fields  # type: ignore # Pydantic v2
-    else:
-        return model.__fields__  # type: ignore # Pydantic v1
+        return cast(Mapping[str, PydanticField], model.model_fields)  # type: ignore[attr-defined]
+    return cast(Mapping[str, PydanticField], model.__fields__)
 
 
-def _get_field_default(field: PydanticField) -> typing.Any:
+def _get_field_default(field: PydanticField) -> Any:
     try:
-        value = field.get_default()  # type: ignore # Pydantic < v1.10.15
+        value = field.get_default()  # type: ignore[union-attr]
     except:
         value = field.default
     if IS_PYDANTIC_V2:

agenta/client/backend/core/serialization.py

@@ -4,9 +4,8 @@ import collections
 import inspect
 import typing
 
-import typing_extensions
-
 import pydantic
+import typing_extensions
 
 
 class FieldMetadata:
@@ -163,7 +162,14 @@ def _convert_mapping(
     direction: typing.Literal["read", "write"],
 ) -> typing.Mapping[str, object]:
     converted_object: typing.Dict[str, object] = {}
-    annotations = typing_extensions.get_type_hints(expected_type, include_extras=True)
+    try:
+        annotations = typing_extensions.get_type_hints(
+            expected_type, include_extras=True
+        )
+    except NameError:
+        # The TypedDict contains a circular reference, so
+        # we use the __annotations__ attribute directly.
+        annotations = getattr(expected_type, "__annotations__", {})
     aliases_to_field_names = _get_alias_to_field_name(annotations)
     for key, value in object_.items():
         if direction == "read" and key in aliases_to_field_names:

agenta/client/backend/environment.py

@@ -0,0 +1,7 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import enum
+
+
+class AgentaApiEnvironment(enum.Enum):
+    DEFAULT = "https://cloud.agenta.ai/api"

agenta/client/backend/environments/__init__.py

@@ -1 +1,3 @@
 # This file was auto-generated by Fern from our API Definition.
+
+# isort: skip_file

agenta/client/backend/environments/client.py

@@ -1,14 +1,10 @@
 # This file was auto-generated by Fern from our API Definition.
 
 import typing
-from ..core.client_wrapper import SyncClientWrapper
+
+from ..core.client_wrapper import AsyncClientWrapper, SyncClientWrapper
 from ..core.request_options import RequestOptions
-from ..core.pydantic_utilities import parse_obj_as
-from ..errors.unprocessable_entity_error import UnprocessableEntityError
-from ..types.http_validation_error import HttpValidationError
-from json.decoder import JSONDecodeError
-from ..core.api_error import ApiError
-from ..core.client_wrapper import AsyncClientWrapper
+from .raw_client import AsyncRawEnvironmentsClient, RawEnvironmentsClient
 
 # this is used as the default value for optional parameters
 OMIT = typing.cast(typing.Any, ...)
@@ -16,13 +12,25 @@ OMIT = typing.cast(typing.Any, ...)
 
 class EnvironmentsClient:
     def __init__(self, *, client_wrapper: SyncClientWrapper):
-        self._client_wrapper = client_wrapper
+        self._raw_client = RawEnvironmentsClient(client_wrapper=client_wrapper)
+
+    @property
+    def with_raw_response(self) -> RawEnvironmentsClient:
+        """
+        Retrieves a raw implementation of this client that returns raw responses.
+
+        Returns
+        -------
+        RawEnvironmentsClient
+        """
+        return self._raw_client
 
     def deploy_to_environment(
         self,
         *,
         environment_name: str,
         variant_id: str,
+        commit_message: typing.Optional[str] = OMIT,
         request_options: typing.Optional[RequestOptions] = None,
     ) -> typing.Optional[typing.Any]:
         """
@@ -41,6 +49,8 @@ class EnvironmentsClient:
 
         variant_id : str
 
+        commit_message : typing.Optional[str]
+
         request_options : typing.Optional[RequestOptions]
             Request-specific configuration.
 
@@ -55,60 +65,42 @@ class EnvironmentsClient:
 
         client = AgentaApi(
             api_key="YOUR_API_KEY",
-            base_url="https://yourhost.com/path/to/api",
         )
         client.environments.deploy_to_environment(
             environment_name="environment_name",
             variant_id="variant_id",
         )
         """
-        _response = self._client_wrapper.httpx_client.request(
-            "environments/deploy",
-            method="POST",
-            json={
-                "environment_name": environment_name,
-                "variant_id": variant_id,
-            },
-            headers={
-                "content-type": "application/json",
-            },
+        _response = self._raw_client.deploy_to_environment(
+            environment_name=environment_name,
+            variant_id=variant_id,
+            commit_message=commit_message,
             request_options=request_options,
-            omit=OMIT,
         )
-        try:
-            if 200 <= _response.status_code < 300:
-                return typing.cast(
-                    typing.Optional[typing.Any],
-                    parse_obj_as(
-                        type_=typing.Optional[typing.Any],  # type: ignore
-                        object_=_response.json(),
-                    ),
-                )
-            if _response.status_code == 422:
-                raise UnprocessableEntityError(
-                    typing.cast(
-                        HttpValidationError,
-                        parse_obj_as(
-                            type_=HttpValidationError,  # type: ignore
-                            object_=_response.json(),
-                        ),
-                    )
-                )
-            _response_json = _response.json()
-        except JSONDecodeError:
-            raise ApiError(status_code=_response.status_code, body=_response.text)
-        raise ApiError(status_code=_response.status_code, body=_response_json)
+        return _response.data
 
 
 class AsyncEnvironmentsClient:
     def __init__(self, *, client_wrapper: AsyncClientWrapper):
-        self._client_wrapper = client_wrapper
+        self._raw_client = AsyncRawEnvironmentsClient(client_wrapper=client_wrapper)
+
+    @property
+    def with_raw_response(self) -> AsyncRawEnvironmentsClient:
+        """
+        Retrieves a raw implementation of this client that returns raw responses.
+
+        Returns
+        -------
+        AsyncRawEnvironmentsClient
+        """
+        return self._raw_client
 
     async def deploy_to_environment(
         self,
         *,
         environment_name: str,
         variant_id: str,
+        commit_message: typing.Optional[str] = OMIT,
         request_options: typing.Optional[RequestOptions] = None,
     ) -> typing.Optional[typing.Any]:
         """
@@ -127,6 +119,8 @@ class AsyncEnvironmentsClient:
 
         variant_id : str
 
+        commit_message : typing.Optional[str]
+
         request_options : typing.Optional[RequestOptions]
             Request-specific configuration.
 
@@ -143,7 +137,6 @@ class AsyncEnvironmentsClient:
 
         client = AsyncAgentaApi(
             api_key="YOUR_API_KEY",
-            base_url="https://yourhost.com/path/to/api",
         )
 
 
@@ -156,39 +149,10 @@ class AsyncEnvironmentsClient:
 
         asyncio.run(main())
         """
-        _response = await self._client_wrapper.httpx_client.request(
-            "environments/deploy",
-            method="POST",
-            json={
-                "environment_name": environment_name,
-                "variant_id": variant_id,
-            },
-            headers={
-                "content-type": "application/json",
-            },
+        _response = await self._raw_client.deploy_to_environment(
+            environment_name=environment_name,
+            variant_id=variant_id,
+            commit_message=commit_message,
             request_options=request_options,
-            omit=OMIT,
         )
-        try:
-            if 200 <= _response.status_code < 300:
-                return typing.cast(
-                    typing.Optional[typing.Any],
-                    parse_obj_as(
-                        type_=typing.Optional[typing.Any],  # type: ignore
-                        object_=_response.json(),
-                    ),
-                )
-            if _response.status_code == 422:
-                raise UnprocessableEntityError(
-                    typing.cast(
-                        HttpValidationError,
-                        parse_obj_as(
-                            type_=HttpValidationError,  # type: ignore
-                            object_=_response.json(),
-                        ),
-                    )
-                )
-            _response_json = _response.json()
-        except JSONDecodeError:
-            raise ApiError(status_code=_response.status_code, body=_response.text)
-        raise ApiError(status_code=_response.status_code, body=_response_json)
+        return _response.data