methodaws 0.0.16__tar.gz → 0.0.18__tar.gz

{methodaws-0.0.16 → methodaws-0.0.18}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: methodaws
-Version: 0.0.16
+Version: 0.0.18
 Summary: 
 Requires-Python: >=3.8,<4.0
 Classifier: Intended Audience :: Developers

{methodaws-0.0.16 → methodaws-0.0.18}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "methodaws"
-version = "v0.0.16"
+version = "v0.0.18"
 description = ""
 readme = "README.md"
 authors = []

{methodaws-0.0.16 → methodaws-0.0.18}/src/methodaws/core/pydantic_utilities.py

@@ -10,6 +10,7 @@ import typing_extensions
 import pydantic
 
 from .datetime_utils import serialize_datetime
+from .serialization import convert_and_respect_annotation_metadata
 
 IS_PYDANTIC_V2 = pydantic.VERSION.startswith("2.")
 
@@ -56,11 +57,12 @@ Model = typing.TypeVar("Model", bound=pydantic.BaseModel)
 
 
 def parse_obj_as(type_: typing.Type[T], object_: typing.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
-        return adapter.validate_python(object_)
+        return adapter.validate_python(dealiased_object)
     else:
-        return pydantic.parse_obj_as(type_, object_)
+        return pydantic.parse_obj_as(type_, dealiased_object)
 
 
 def to_jsonable_with_fallback(
@@ -75,11 +77,16 @@ def to_jsonable_with_fallback(
 
 
 class UniversalBaseModel(pydantic.BaseModel):
-    class Config:
-        populate_by_name = True
-        smart_union = True
-        allow_population_by_field_name = True
-        json_encoders = {dt.datetime: serialize_datetime}
+    if IS_PYDANTIC_V2:
+        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(
+            protected_namespaces=(),
+            json_encoders={dt.datetime: serialize_datetime},
+        )  # type: ignore # Pydantic v2
+    else:
+
+        class Config:
+            smart_union = True
+            json_encoders = {dt.datetime: serialize_datetime}
 
     def json(self, **kwargs: typing.Any) -> str:
         kwargs_with_defaults: typing.Any = {
@@ -97,30 +104,66 @@ class UniversalBaseModel(pydantic.BaseModel):
         Override the default dict method to `exclude_unset` by default. This function patches
         `exclude_unset` to work include fields within non-None default values.
         """
-        _fields_set = self.__fields_set__
-
-        fields = _get_model_fields(self.__class__)
-        for name, field in fields.items():
-            if name not in _fields_set:
-                default = _get_field_default(field)
-
-                # If the default values are non-null act like they've been set
-                # This effectively allows exclude_unset to work like exclude_none where
-                # the latter passes through intentionally set none values.
-                if default != None:
-                    _fields_set.add(name)
-
-        kwargs_with_defaults_exclude_unset: typing.Any = {
-            "by_alias": True,
-            "exclude_unset": True,
-            "include": _fields_set,
-            **kwargs,
-        }
-
+        # Note: the logic here is multi-plexed given the levers exposed in Pydantic V1 vs V2
+        # Pydantic V1's .dict can be extremely slow, so we do not want to call it twice.
+        #
+        # 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:
-            return super().model_dump(**kwargs_with_defaults_exclude_unset)  # type: ignore # Pydantic v2
+            kwargs_with_defaults_exclude_unset: typing.Any = {
+                **kwargs,
+                "by_alias": True,
+                "exclude_unset": True,
+                "exclude_none": False,
+            }
+            kwargs_with_defaults_exclude_none: typing.Any = {
+                **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
+            )
+
+        else:
+            _fields_set = self.__fields_set__
+
+            fields = _get_model_fields(self.__class__)
+            for name, field in fields.items():
+                if name not in _fields_set:
+                    default = _get_field_default(field)
+
+                    # If the default values are non-null act like they've been set
+                    # This effectively allows exclude_unset to work like exclude_none where
+                    # the latter passes through intentionally set none values.
+                    if default != None:
+                        _fields_set.add(name)
+
+            kwargs_with_defaults_exclude_unset_include_fields: typing.Any = {
+                "by_alias": True,
+                "exclude_unset": True,
+                "include": _fields_set,
+                **kwargs,
+            }
+
+            dict_dump = super().dict(**kwargs_with_defaults_exclude_unset_include_fields)
+
+        return convert_and_respect_annotation_metadata(object_=dict_dump, annotation=self.__class__, direction="write")
+
+
+def deep_union_pydantic_dicts(
+    source: typing.Dict[str, typing.Any], destination: typing.Dict[str, typing.Any]
+) -> typing.Dict[str, typing.Any]:
+    for key, value in source.items():
+        if isinstance(value, dict):
+            node = destination.setdefault(key, {})
+            deep_union_pydantic_dicts(value, node)
         else:
-            return super().dict(**kwargs_with_defaults_exclude_unset)
+            destination[key] = value
+
+    return destination
 
 
 if IS_PYDANTIC_V2:

methodaws-0.0.18/src/methodaws/core/serialization.py

@@ -0,0 +1,254 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import collections
+import inspect
+import typing
+
+import typing_extensions
+
+import pydantic
+
+
+class FieldMetadata:
+    """
+    Metadata class used to annotate fields to provide additional information.
+
+    Example:
+    class MyDict(TypedDict):
+        field: typing.Annotated[str, FieldMetadata(alias="field_name")]
+
+    Will serialize: `{"field": "value"}`
+    To: `{"field_name": "value"}`
+    """
+
+    alias: str
+
+    def __init__(self, *, alias: str) -> None:
+        self.alias = alias
+
+
+def convert_and_respect_annotation_metadata(
+    *,
+    object_: typing.Any,
+    annotation: typing.Any,
+    inner_type: typing.Optional[typing.Any] = None,
+    direction: typing.Literal["read", "write"],
+) -> typing.Any:
+    """
+    Respect the metadata annotations on a field, such as aliasing. This function effectively
+    manipulates the dict-form of an object to respect the metadata annotations. This is primarily used for
+    TypedDicts, which cannot support aliasing out of the box, and can be extended for additional
+    utilities, such as defaults.
+
+    Parameters
+    ----------
+    object_ : typing.Any
+
+    annotation : type
+        The type we're looking to apply typing annotations from
+
+    inner_type : typing.Optional[type]
+
+    Returns
+    -------
+    typing.Any
+    """
+
+    if object_ is None:
+        return None
+    if inner_type is None:
+        inner_type = annotation
+
+    clean_type = _remove_annotations(inner_type)
+    # Pydantic models
+    if (
+        inspect.isclass(clean_type)
+        and issubclass(clean_type, pydantic.BaseModel)
+        and isinstance(object_, typing.Mapping)
+    ):
+        return _convert_mapping(object_, clean_type, direction)
+    # TypedDicts
+    if typing_extensions.is_typeddict(clean_type) and isinstance(object_, typing.Mapping):
+        return _convert_mapping(object_, clean_type, direction)
+
+    # If you're iterating on a string, do not bother to coerce it to a sequence.
+    if not isinstance(object_, str):
+        if (
+            typing_extensions.get_origin(clean_type) == typing.Set
+            or typing_extensions.get_origin(clean_type) == set
+            or clean_type == typing.Set
+        ) and isinstance(object_, typing.Set):
+            inner_type = typing_extensions.get_args(clean_type)[0]
+            return {
+                convert_and_respect_annotation_metadata(
+                    object_=item,
+                    annotation=annotation,
+                    inner_type=inner_type,
+                    direction=direction,
+                )
+                for item in object_
+            }
+        elif (
+            (
+                typing_extensions.get_origin(clean_type) == typing.List
+                or typing_extensions.get_origin(clean_type) == list
+                or clean_type == typing.List
+            )
+            and isinstance(object_, typing.List)
+        ) or (
+            (
+                typing_extensions.get_origin(clean_type) == typing.Sequence
+                or typing_extensions.get_origin(clean_type) == collections.abc.Sequence
+                or clean_type == typing.Sequence
+            )
+            and isinstance(object_, typing.Sequence)
+        ):
+            inner_type = typing_extensions.get_args(clean_type)[0]
+            return [
+                convert_and_respect_annotation_metadata(
+                    object_=item,
+                    annotation=annotation,
+                    inner_type=inner_type,
+                    direction=direction,
+                )
+                for item in object_
+            ]
+
+    if typing_extensions.get_origin(clean_type) == typing.Union:
+        # We should be able to ~relatively~ safely try to convert keys against all
+        # member types in the union, the edge case here is if one member aliases a field
+        # of the same name to a different name from another member
+        # Or if another member aliases a field of the same name that another member does not.
+        for member in typing_extensions.get_args(clean_type):
+            object_ = convert_and_respect_annotation_metadata(
+                object_=object_,
+                annotation=annotation,
+                inner_type=member,
+                direction=direction,
+            )
+        return object_
+
+    annotated_type = _get_annotation(annotation)
+    if annotated_type is None:
+        return object_
+
+    # If the object is not a TypedDict, a Union, or other container (list, set, sequence, etc.)
+    # Then we can safely call it on the recursive conversion.
+    return object_
+
+
+def _convert_mapping(
+    object_: typing.Mapping[str, object],
+    expected_type: typing.Any,
+    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)
+    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:
+            dealiased_key = aliases_to_field_names.get(key)
+            if dealiased_key is not None:
+                type_ = annotations.get(dealiased_key)
+        else:
+            type_ = annotations.get(key)
+        # Note you can't get the annotation by the field name if you're in read mode, so you must check the aliases map
+        #
+        # So this is effectively saying if we're in write mode, and we don't have a type, or if we're in read mode and we don't have an alias
+        # then we can just pass the value through as is
+        if type_ is None:
+            converted_object[key] = value
+        elif direction == "read" and key not in aliases_to_field_names:
+            converted_object[key] = convert_and_respect_annotation_metadata(
+                object_=value, annotation=type_, direction=direction
+            )
+        else:
+            converted_object[_alias_key(key, type_, direction, aliases_to_field_names)] = (
+                convert_and_respect_annotation_metadata(object_=value, annotation=type_, direction=direction)
+            )
+    return converted_object
+
+
+def _get_annotation(type_: typing.Any) -> typing.Optional[typing.Any]:
+    maybe_annotated_type = typing_extensions.get_origin(type_)
+    if maybe_annotated_type is None:
+        return None
+
+    if maybe_annotated_type == typing_extensions.NotRequired:
+        type_ = typing_extensions.get_args(type_)[0]
+        maybe_annotated_type = typing_extensions.get_origin(type_)
+
+    if maybe_annotated_type == typing_extensions.Annotated:
+        return type_
+
+    return None
+
+
+def _remove_annotations(type_: typing.Any) -> typing.Any:
+    maybe_annotated_type = typing_extensions.get_origin(type_)
+    if maybe_annotated_type is None:
+        return type_
+
+    if maybe_annotated_type == typing_extensions.NotRequired:
+        return _remove_annotations(typing_extensions.get_args(type_)[0])
+
+    if maybe_annotated_type == typing_extensions.Annotated:
+        return _remove_annotations(typing_extensions.get_args(type_)[0])
+
+    return type_
+
+
+def get_alias_to_field_mapping(type_: typing.Any) -> typing.Dict[str, str]:
+    annotations = typing_extensions.get_type_hints(type_, include_extras=True)
+    return _get_alias_to_field_name(annotations)
+
+
+def get_field_to_alias_mapping(type_: typing.Any) -> typing.Dict[str, str]:
+    annotations = typing_extensions.get_type_hints(type_, include_extras=True)
+    return _get_field_to_alias_name(annotations)
+
+
+def _get_alias_to_field_name(
+    field_to_hint: typing.Dict[str, typing.Any],
+) -> typing.Dict[str, str]:
+    aliases = {}
+    for field, hint in field_to_hint.items():
+        maybe_alias = _get_alias_from_type(hint)
+        if maybe_alias is not None:
+            aliases[maybe_alias] = field
+    return aliases
+
+
+def _get_field_to_alias_name(
+    field_to_hint: typing.Dict[str, typing.Any],
+) -> typing.Dict[str, str]:
+    aliases = {}
+    for field, hint in field_to_hint.items():
+        maybe_alias = _get_alias_from_type(hint)
+        if maybe_alias is not None:
+            aliases[field] = maybe_alias
+    return aliases
+
+
+def _get_alias_from_type(type_: typing.Any) -> typing.Optional[str]:
+    maybe_annotated_type = _get_annotation(type_)
+
+    if maybe_annotated_type is not None:
+        # The actual annotations are 1 onward, the first is the annotated type
+        annotations = typing_extensions.get_args(maybe_annotated_type)[1:]
+
+        for annotation in annotations:
+            if isinstance(annotation, FieldMetadata) and annotation.alias is not None:
+                return annotation.alias
+    return None
+
+
+def _alias_key(
+    key: str,
+    type_: typing.Any,
+    direction: typing.Literal["read", "write"],
+    aliases_to_field_names: typing.Dict[str, str],
+) -> str:
+    if direction == "read":
+        return aliases_to_field_names.get(key, key)
+    return _get_alias_from_type(type_=type_) or key

{methodaws-0.0.16 → methodaws-0.0.18}/src/methodaws/resources/credential/credential_info.py

@@ -1,16 +1,18 @@
 # This file was auto-generated by Fern from our API Definition.
 
 from ...core.pydantic_utilities import UniversalBaseModel
+import typing_extensions
 import typing
-import pydantic
+from ...core.serialization import FieldMetadata
 import datetime as dt
 from ...core.pydantic_utilities import IS_PYDANTIC_V2
+import pydantic
 
 
 class CredentialInfo(UniversalBaseModel):
     url: str
     token: str
-    ca_cert: typing.Optional[str] = pydantic.Field(alias="caCert", default=None)
+    ca_cert: typing_extensions.Annotated[typing.Optional[str], FieldMetadata(alias="caCert")] = None
     expiration: typing.Optional[dt.datetime] = None
 
     if IS_PYDANTIC_V2:

{methodaws-0.0.16 → methodaws-0.0.18}/src/methodaws/resources/credential/credential_report.py

@@ -1,15 +1,17 @@
 # This file was auto-generated by Fern from our API Definition.
 
 from ...core.pydantic_utilities import UniversalBaseModel
-import pydantic
+import typing_extensions
+from ...core.serialization import FieldMetadata
 import typing
 from .credential_info import CredentialInfo
 from ...core.pydantic_utilities import IS_PYDANTIC_V2
+import pydantic
 
 
 class CredentialReport(UniversalBaseModel):
-    account_id: str = pydantic.Field(alias="accountId")
-    cluster_name: str = pydantic.Field(alias="clusterName")
+    account_id: typing_extensions.Annotated[str, FieldMetadata(alias="accountId")]
+    cluster_name: typing_extensions.Annotated[str, FieldMetadata(alias="clusterName")]
     credential: typing.Optional[CredentialInfo] = None
     errors: typing.Optional[typing.List[str]] = None
 

{methodaws-0.0.16 → methodaws-0.0.18}/src/methodaws/resources/loadbalancer/certificate.py

@@ -1,14 +1,16 @@
 # This file was auto-generated by Fern from our API Definition.
 
 from ...core.pydantic_utilities import UniversalBaseModel
-import pydantic
+import typing_extensions
+from ...core.serialization import FieldMetadata
 from ...core.pydantic_utilities import IS_PYDANTIC_V2
 import typing
+import pydantic
 
 
 class Certificate(UniversalBaseModel):
     arn: str
-    is_default: bool = pydantic.Field(alias="isDefault")
+    is_default: typing_extensions.Annotated[bool, FieldMetadata(alias="isDefault")]
 
     if IS_PYDANTIC_V2:
         model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow")  # type: ignore # Pydantic v2

{methodaws-0.0.16 → methodaws-0.0.18}/src/methodaws/resources/loadbalancer/listener.py

@@ -4,8 +4,10 @@ from ...core.pydantic_utilities import UniversalBaseModel
 import typing
 from .protocol import Protocol
 from .certificate import Certificate
-import pydantic
+import typing_extensions
+from ...core.serialization import FieldMetadata
 from ...core.pydantic_utilities import IS_PYDANTIC_V2
+import pydantic
 
 
 class Listener(UniversalBaseModel):
@@ -13,7 +15,7 @@ class Listener(UniversalBaseModel):
     protocol: typing.Optional[Protocol] = None
     port: int
     certificates: typing.Optional[typing.List[Certificate]] = None
-    load_balancer_arn: typing.Optional[str] = pydantic.Field(alias="loadBalancerArn", default=None)
+    load_balancer_arn: typing_extensions.Annotated[typing.Optional[str], FieldMetadata(alias="loadBalancerArn")] = None
 
     if IS_PYDANTIC_V2:
         model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow")  # type: ignore # Pydantic v2

{methodaws-0.0.16 → methodaws-0.0.18}/src/methodaws/resources/loadbalancer/load_balancer_report.py

@@ -1,21 +1,23 @@
 # This file was auto-generated by Fern from our API Definition.
 
 from ...core.pydantic_utilities import UniversalBaseModel
-import pydantic
+import typing_extensions
+from ...core.serialization import FieldMetadata
 import typing
 from .load_balancer_v_2 import LoadBalancerV2
 from .load_balancer_v_1 import LoadBalancerV1
 from ...core.pydantic_utilities import IS_PYDANTIC_V2
+import pydantic
 
 
 class LoadBalancerReport(UniversalBaseModel):
-    account_id: str = pydantic.Field(alias="accountId")
-    v_2_load_balancers: typing.Optional[typing.List[LoadBalancerV2]] = pydantic.Field(
-        alias="v2LoadBalancers", default=None
-    )
-    v_1_load_balancers: typing.Optional[typing.List[LoadBalancerV1]] = pydantic.Field(
-        alias="v1LoadBalancers", default=None
-    )
+    account_id: typing_extensions.Annotated[str, FieldMetadata(alias="accountId")]
+    v_2_load_balancers: typing_extensions.Annotated[
+        typing.Optional[typing.List[LoadBalancerV2]], FieldMetadata(alias="v2LoadBalancers")
+    ] = None
+    v_1_load_balancers: typing_extensions.Annotated[
+        typing.Optional[typing.List[LoadBalancerV1]], FieldMetadata(alias="v1LoadBalancers")
+    ] = None
     errors: typing.Optional[typing.List[str]] = None
 
     if IS_PYDANTIC_V2:

methodaws-0.0.18/src/methodaws/resources/loadbalancer/load_balancer_v_1.py

@@ -0,0 +1,33 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from ...core.pydantic_utilities import UniversalBaseModel
+import typing_extensions
+import datetime as dt
+from ...core.serialization import FieldMetadata
+import typing
+from .target import Target
+from .listener import Listener
+from ...core.pydantic_utilities import IS_PYDANTIC_V2
+import pydantic
+
+
+class LoadBalancerV1(UniversalBaseModel):
+    name: str
+    region: str
+    created_time: typing_extensions.Annotated[dt.datetime, FieldMetadata(alias="createdTime")]
+    dns_name: typing_extensions.Annotated[str, FieldMetadata(alias="dnsName")]
+    security_group_ids: typing_extensions.Annotated[
+        typing.Optional[typing.List[str]], FieldMetadata(alias="securityGroupIds")
+    ] = None
+    vpc_id: typing_extensions.Annotated[typing.Optional[str], FieldMetadata(alias="vpcId")] = None
+    subnet_ids: typing_extensions.Annotated[typing.Optional[typing.List[str]], FieldMetadata(alias="subnetIds")] = None
+    hosted_zone_id: typing_extensions.Annotated[typing.Optional[str], FieldMetadata(alias="hostedZoneId")] = None
+    targets: typing.Optional[typing.List[Target]] = None
+    listeners: typing.Optional[typing.List[Listener]] = None
+
+    if IS_PYDANTIC_V2:
+        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow")  # type: ignore # Pydantic v2
+    else:
+
+        class Config:
+            extra = pydantic.Extra.allow

{methodaws-0.0.16 → methodaws-0.0.18}/src/methodaws/resources/loadbalancer/load_balancer_v_2.py

@@ -1,14 +1,16 @@
 # This file was auto-generated by Fern from our API Definition.
 
 from ...core.pydantic_utilities import UniversalBaseModel
+import typing_extensions
 import datetime as dt
-import pydantic
+from ...core.serialization import FieldMetadata
 from .ip_address_type import IpAddressType
 import typing
 from .load_balancer_state import LoadBalancerState
 from .listener import Listener
 from .target_group import TargetGroup
 from ...core.pydantic_utilities import IS_PYDANTIC_V2
+import pydantic
 
 
 class LoadBalancerV2(UniversalBaseModel):
@@ -19,16 +21,21 @@ class LoadBalancerV2(UniversalBaseModel):
 
     arn: str
     name: str
-    created_time: dt.datetime = pydantic.Field(alias="createdTime")
-    dns_name: str = pydantic.Field(alias="dnsName")
-    ip_address_type: IpAddressType = pydantic.Field(alias="ipAddressType")
-    security_group_ids: typing.List[str] = pydantic.Field(alias="securityGroupIds")
+    region: str
+    created_time: typing_extensions.Annotated[dt.datetime, FieldMetadata(alias="createdTime")]
+    dns_name: typing_extensions.Annotated[str, FieldMetadata(alias="dnsName")]
+    ip_address_type: typing_extensions.Annotated[IpAddressType, FieldMetadata(alias="ipAddressType")]
+    security_group_ids: typing_extensions.Annotated[
+        typing.Optional[typing.List[str]], FieldMetadata(alias="securityGroupIds")
+    ] = None
     state: typing.Optional[LoadBalancerState] = None
-    vpc_id: str = pydantic.Field(alias="vpcId")
+    vpc_id: typing_extensions.Annotated[typing.Optional[str], FieldMetadata(alias="vpcId")] = None
     listeners: typing.Optional[typing.List[Listener]] = None
-    subnet_ids: typing.List[str] = pydantic.Field(alias="subnetIds")
-    hosted_zone_id: typing.Optional[str] = pydantic.Field(alias="hostedZoneId", default=None)
-    target_groups: typing.List[TargetGroup] = pydantic.Field(alias="targetGroups")
+    subnet_ids: typing_extensions.Annotated[typing.Optional[typing.List[str]], FieldMetadata(alias="subnetIds")] = None
+    hosted_zone_id: typing_extensions.Annotated[typing.Optional[str], FieldMetadata(alias="hostedZoneId")] = None
+    target_groups: typing_extensions.Annotated[
+        typing.Optional[typing.List[TargetGroup]], FieldMetadata(alias="targetGroups")
+    ] = None
 
     if IS_PYDANTIC_V2:
         model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow")  # type: ignore # Pydantic v2

{methodaws-0.0.16 → methodaws-0.0.18}/src/methodaws/resources/loadbalancer/target.py

@@ -2,16 +2,18 @@
 
 from ...core.pydantic_utilities import UniversalBaseModel
 from .target_type import TargetType
+import typing_extensions
 import typing
-import pydantic
+from ...core.serialization import FieldMetadata
 from ...core.pydantic_utilities import IS_PYDANTIC_V2
+import pydantic
 
 
 class Target(UniversalBaseModel):
     id: str
     type: TargetType
     port: int
-    availability_zone: typing.Optional[str] = pydantic.Field(alias="availabilityZone", default=None)
+    availability_zone: typing_extensions.Annotated[typing.Optional[str], FieldMetadata(alias="availabilityZone")] = None
 
     if IS_PYDANTIC_V2:
         model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow")  # type: ignore # Pydantic v2

{methodaws-0.0.16 → methodaws-0.0.18}/src/methodaws/resources/loadbalancer/target_group.py

@@ -1,23 +1,25 @@
 # This file was auto-generated by Fern from our API Definition.
 
 from ...core.pydantic_utilities import UniversalBaseModel
+import typing_extensions
 from .target_group_ip_address_type import TargetGroupIpAddressType
-import pydantic
+from ...core.serialization import FieldMetadata
 import typing
 from .protocol import Protocol
 from .target import Target
 from ...core.pydantic_utilities import IS_PYDANTIC_V2
+import pydantic
 
 
 class TargetGroup(UniversalBaseModel):
     arn: str
     name: str
-    ip_address_type: TargetGroupIpAddressType = pydantic.Field(alias="ipAddressType")
-    load_balancer_arn: str = pydantic.Field(alias="loadBalancerArn")
+    ip_address_type: typing_extensions.Annotated[TargetGroupIpAddressType, FieldMetadata(alias="ipAddressType")]
+    load_balancer_arn: typing_extensions.Annotated[str, FieldMetadata(alias="loadBalancerArn")]
     port: int
     protocol: typing.Optional[Protocol] = None
-    vpc_id: str = pydantic.Field(alias="vpcId")
-    targets: typing.List[Target]
+    vpc_id: typing_extensions.Annotated[typing.Optional[str], FieldMetadata(alias="vpcId")] = None
+    targets: typing.Optional[typing.List[Target]] = None
 
     if IS_PYDANTIC_V2:
         model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow")  # type: ignore # Pydantic v2

methodaws-0.0.18/src/methodaws/resources/s_3/bucket.py

@@ -0,0 +1,39 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from ...core.pydantic_utilities import UniversalBaseModel
+import typing_extensions
+import datetime as dt
+from ...core.serialization import FieldMetadata
+from .s_3_public_access_block_configuration import S3PublicAccessBlockConfiguration
+import typing
+from .bucket_versioning_status import BucketVersioningStatus
+from .s_3_mfa_delete_status import S3MfaDeleteStatus
+from .encryption_rule import EncryptionRule
+from ...core.pydantic_utilities import IS_PYDANTIC_V2
+import pydantic
+
+
+class Bucket(UniversalBaseModel):
+    name: str
+    arn: str
+    url: str
+    region: str
+    creation_date: typing_extensions.Annotated[dt.datetime, FieldMetadata(alias="creationDate")]
+    owner_id: typing_extensions.Annotated[str, FieldMetadata(alias="ownerID")]
+    owner_name: typing_extensions.Annotated[str, FieldMetadata(alias="ownerName")]
+    public_access_config: typing_extensions.Annotated[
+        S3PublicAccessBlockConfiguration, FieldMetadata(alias="publicAccessConfig")
+    ]
+    policy: typing.Optional[str] = None
+    bucket_versioning: typing_extensions.Annotated[
+        typing.Optional[BucketVersioningStatus], FieldMetadata(alias="bucketVersioning")
+    ] = None
+    mfa_delete: typing_extensions.Annotated[typing.Optional[S3MfaDeleteStatus], FieldMetadata(alias="mfaDelete")] = None
+    encryption_rules: typing_extensions.Annotated[typing.List[EncryptionRule], FieldMetadata(alias="encryptionRules")]
+
+    if IS_PYDANTIC_V2:
+        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow")  # type: ignore # Pydantic v2
+    else:
+
+        class Config:
+            extra = pydantic.Extra.allow

{methodaws-0.0.16 → methodaws-0.0.18}/src/methodaws/resources/s_3/encryption_rule.py

@@ -1,15 +1,19 @@
 # This file was auto-generated by Fern from our API Definition.
 
 from ...core.pydantic_utilities import UniversalBaseModel
+import typing_extensions
 import typing
 from .s_3_server_side_encryption import S3ServerSideEncryption
-import pydantic
+from ...core.serialization import FieldMetadata
 from ...core.pydantic_utilities import IS_PYDANTIC_V2
+import pydantic
 
 
 class EncryptionRule(UniversalBaseModel):
-    sse_algorithm: typing.Optional[S3ServerSideEncryption] = pydantic.Field(alias="sseAlgorithm", default=None)
-    kms_master_key_id: typing.Optional[str] = pydantic.Field(alias="kmsMasterKeyID", default=None)
+    sse_algorithm: typing_extensions.Annotated[
+        typing.Optional[S3ServerSideEncryption], FieldMetadata(alias="sseAlgorithm")
+    ] = None
+    kms_master_key_id: typing_extensions.Annotated[typing.Optional[str], FieldMetadata(alias="kmsMasterKeyID")] = None
 
     if IS_PYDANTIC_V2:
         model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow")  # type: ignore # Pydantic v2

{methodaws-0.0.16 → methodaws-0.0.18}/src/methodaws/resources/s_3/external_bucket.py

@@ -1,22 +1,24 @@
 # This file was auto-generated by Fern from our API Definition.
 
 from ...core.pydantic_utilities import UniversalBaseModel
+import typing_extensions
 import typing
 from .s_3_object_details import S3ObjectDetails
-import pydantic
+from ...core.serialization import FieldMetadata
 from .s_3_bucket_acl import S3BucketAcl
 from ...core.pydantic_utilities import IS_PYDANTIC_V2
+import pydantic
 
 
 class ExternalBucket(UniversalBaseModel):
     name: str
     url: str
     region: str
-    directory_contents: typing.Optional[typing.List[S3ObjectDetails]] = pydantic.Field(
-        alias="directoryContents", default=None
-    )
-    allow_directory_listing: bool = pydantic.Field(alias="allowDirectoryListing")
-    allow_anonymous_read: bool = pydantic.Field(alias="allowAnonymousRead")
+    directory_contents: typing_extensions.Annotated[
+        typing.Optional[typing.List[S3ObjectDetails]], FieldMetadata(alias="directoryContents")
+    ] = None
+    allow_directory_listing: typing_extensions.Annotated[bool, FieldMetadata(alias="allowDirectoryListing")]
+    allow_anonymous_read: typing_extensions.Annotated[bool, FieldMetadata(alias="allowAnonymousRead")]
     policy: typing.Optional[str] = None
     acls: typing.Optional[typing.List[S3BucketAcl]] = None
 

{methodaws-0.0.16 → methodaws-0.0.18}/src/methodaws/resources/s_3/external_s_3_report.py

@@ -1,16 +1,18 @@
 # This file was auto-generated by Fern from our API Definition.
 
 from ...core.pydantic_utilities import UniversalBaseModel
+import typing_extensions
 import typing
 from .external_bucket import ExternalBucket
-import pydantic
+from ...core.serialization import FieldMetadata
 from ...core.pydantic_utilities import IS_PYDANTIC_V2
+import pydantic
 
 
 class ExternalS3Report(UniversalBaseModel):
-    external_buckets: typing.Optional[typing.List[ExternalBucket]] = pydantic.Field(
-        alias="externalBuckets", default=None
-    )
+    external_buckets: typing_extensions.Annotated[
+        typing.Optional[typing.List[ExternalBucket]], FieldMetadata(alias="externalBuckets")
+    ] = None
     errors: typing.Optional[typing.List[str]] = None
 
     if IS_PYDANTIC_V2:

{methodaws-0.0.16 → methodaws-0.0.18}/src/methodaws/resources/s_3/s_3_bucket_acl.py

@@ -1,13 +1,15 @@
 # This file was auto-generated by Fern from our API Definition.
 
 from ...core.pydantic_utilities import UniversalBaseModel
-import pydantic
+import typing_extensions
+from ...core.serialization import FieldMetadata
 from ...core.pydantic_utilities import IS_PYDANTIC_V2
 import typing
+import pydantic
 
 
 class S3BucketAcl(UniversalBaseModel):
-    grantee_uri: str = pydantic.Field(alias="granteeURI")
+    grantee_uri: typing_extensions.Annotated[str, FieldMetadata(alias="granteeURI")]
     permission: str
 
     if IS_PYDANTIC_V2:

{methodaws-0.0.16 → methodaws-0.0.18}/src/methodaws/resources/s_3/s_3_object_details.py

@@ -1,18 +1,20 @@
 # This file was auto-generated by Fern from our API Definition.
 
 from ...core.pydantic_utilities import UniversalBaseModel
+import typing_extensions
 import typing
 import datetime as dt
-import pydantic
+from ...core.serialization import FieldMetadata
 from ...core.pydantic_utilities import IS_PYDANTIC_V2
+import pydantic
 
 
 class S3ObjectDetails(UniversalBaseModel):
     key: str
-    last_modified: typing.Optional[dt.datetime] = pydantic.Field(alias="lastModified", default=None)
+    last_modified: typing_extensions.Annotated[typing.Optional[dt.datetime], FieldMetadata(alias="lastModified")] = None
     size: typing.Optional[int] = None
-    owner_id: typing.Optional[str] = pydantic.Field(alias="ownerID", default=None)
-    owner_name: typing.Optional[str] = pydantic.Field(alias="ownerName", default=None)
+    owner_id: typing_extensions.Annotated[typing.Optional[str], FieldMetadata(alias="ownerID")] = None
+    owner_name: typing_extensions.Annotated[typing.Optional[str], FieldMetadata(alias="ownerName")] = None
 
     if IS_PYDANTIC_V2:
         model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow")  # type: ignore # Pydantic v2

{methodaws-0.0.16 → methodaws-0.0.18}/src/methodaws/resources/s_3/s_3_public_access_block_configuration.py

@@ -1,16 +1,18 @@
 # This file was auto-generated by Fern from our API Definition.
 
 from ...core.pydantic_utilities import UniversalBaseModel
-import pydantic
+import typing_extensions
+from ...core.serialization import FieldMetadata
 from ...core.pydantic_utilities import IS_PYDANTIC_V2
 import typing
+import pydantic
 
 
 class S3PublicAccessBlockConfiguration(UniversalBaseModel):
-    block_public_acls: bool = pydantic.Field(alias="blockPublicAcls")
-    ignore_public_acls: bool = pydantic.Field(alias="ignorePublicAcls")
-    block_public_policy: bool = pydantic.Field(alias="blockPublicPolicy")
-    restrict_public_buckets: bool = pydantic.Field(alias="restrictPublicBuckets")
+    block_public_acls: typing_extensions.Annotated[bool, FieldMetadata(alias="blockPublicAcls")]
+    ignore_public_acls: typing_extensions.Annotated[bool, FieldMetadata(alias="ignorePublicAcls")]
+    block_public_policy: typing_extensions.Annotated[bool, FieldMetadata(alias="blockPublicPolicy")]
+    restrict_public_buckets: typing_extensions.Annotated[bool, FieldMetadata(alias="restrictPublicBuckets")]
 
     if IS_PYDANTIC_V2:
         model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow")  # type: ignore # Pydantic v2

{methodaws-0.0.16 → methodaws-0.0.18}/src/methodaws/resources/s_3/s_3_report.py

@@ -1,16 +1,19 @@
 # This file was auto-generated by Fern from our API Definition.
 
 from ...core.pydantic_utilities import UniversalBaseModel
-import pydantic
+import typing_extensions
+from ...core.serialization import FieldMetadata
 import typing
 from .bucket import Bucket
 from ...core.pydantic_utilities import IS_PYDANTIC_V2
+import pydantic
 
 
 class S3Report(UniversalBaseModel):
-    account_id: str = pydantic.Field(alias="accountId")
-    region: str
-    s_3_buckets: typing.Optional[typing.List[Bucket]] = pydantic.Field(alias="s3Buckets", default=None)
+    account_id: typing_extensions.Annotated[str, FieldMetadata(alias="accountId")]
+    s_3_buckets: typing_extensions.Annotated[typing.Optional[typing.List[Bucket]], FieldMetadata(alias="s3Buckets")] = (
+        None
+    )
     errors: typing.Optional[typing.List[str]] = None
 
     if IS_PYDANTIC_V2:

methodaws-0.0.16/src/methodaws/core/serialization.py

@@ -1,170 +0,0 @@
-# This file was auto-generated by Fern from our API Definition.
-
-import collections
-import typing
-
-import typing_extensions
-
-
-class FieldMetadata:
-    """
-    Metadata class used to annotate fields to provide additional information.
-
-    Example:
-    class MyDict(TypedDict):
-        field: typing.Annotated[str, FieldMetadata(alias="field_name")]
-
-    Will serialize: `{"field": "value"}`
-    To: `{"field_name": "value"}`
-    """
-
-    alias: str
-
-    def __init__(self, *, alias: str) -> None:
-        self.alias = alias
-
-
-def convert_and_respect_annotation_metadata(
-    *,
-    object_: typing.Any,
-    annotation: typing.Any,
-    inner_type: typing.Optional[typing.Any] = None,
-) -> typing.Any:
-    """
-    Respect the metadata annotations on a field, such as aliasing. This function effectively
-    manipulates the dict-form of an object to respect the metadata annotations. This is primarily used for
-    TypedDicts, which cannot support aliasing out of the box, and can be extended for additional
-    utilities, such as defaults.
-
-    Parameters
-    ----------
-    object_ : typing.Any
-
-    annotation : type
-        The type we're looking to apply typing annotations from
-
-    inner_type : typing.Optional[type]
-
-    Returns
-    -------
-    typing.Any
-    """
-
-    if object_ is None:
-        return None
-    if inner_type is None:
-        inner_type = annotation
-
-    clean_type = _remove_annotations(inner_type)
-    if typing_extensions.is_typeddict(clean_type) and isinstance(object_, typing.Mapping):
-        return _convert_typeddict(object_, clean_type)
-
-    if (
-        # If you're iterating on a string, do not bother to coerce it to a sequence.
-        (not isinstance(object_, str))
-        and (
-            (
-                (
-                    typing_extensions.get_origin(clean_type) == typing.List
-                    or typing_extensions.get_origin(clean_type) == list
-                    or clean_type == typing.List
-                )
-                and isinstance(object_, typing.List)
-            )
-            or (
-                (
-                    typing_extensions.get_origin(clean_type) == typing.Set
-                    or typing_extensions.get_origin(clean_type) == set
-                    or clean_type == typing.Set
-                )
-                and isinstance(object_, typing.Set)
-            )
-            or (
-                (
-                    typing_extensions.get_origin(clean_type) == typing.Sequence
-                    or typing_extensions.get_origin(clean_type) == collections.abc.Sequence
-                    or clean_type == typing.Sequence
-                )
-                and isinstance(object_, typing.Sequence)
-            )
-        )
-    ):
-        inner_type = typing_extensions.get_args(clean_type)[0]
-        return [
-            convert_and_respect_annotation_metadata(object_=item, annotation=annotation, inner_type=inner_type)
-            for item in object_
-        ]
-
-    if typing_extensions.get_origin(clean_type) == typing.Union:
-        # We should be able to ~relatively~ safely try to convert keys against all
-        # member types in the union, the edge case here is if one member aliases a field
-        # of the same name to a different name from another member
-        # Or if another member aliases a field of the same name that another member does not.
-        for member in typing_extensions.get_args(clean_type):
-            object_ = convert_and_respect_annotation_metadata(object_=object_, annotation=annotation, inner_type=member)
-        return object_
-
-    annotated_type = _get_annotation(annotation)
-    if annotated_type is None:
-        return object_
-
-    # If the object is not a TypedDict, a Union, or other container (list, set, sequence, etc.)
-    # Then we can safely call it on the recursive conversion.
-    return object_
-
-
-def _convert_typeddict(object_: typing.Mapping[str, object], expected_type: typing.Any) -> typing.Mapping[str, object]:
-    converted_object: typing.Dict[str, object] = {}
-    annotations = typing_extensions.get_type_hints(expected_type, include_extras=True)
-    for key, value in object_.items():
-        type_ = annotations.get(key)
-        if type_ is None:
-            converted_object[key] = value
-        else:
-            converted_object[_alias_key(key, type_)] = convert_and_respect_annotation_metadata(
-                object_=value, annotation=type_
-            )
-    return converted_object
-
-
-def _get_annotation(type_: typing.Any) -> typing.Optional[typing.Any]:
-    maybe_annotated_type = typing_extensions.get_origin(type_)
-    if maybe_annotated_type is None:
-        return None
-
-    if maybe_annotated_type == typing_extensions.NotRequired:
-        type_ = typing_extensions.get_args(type_)[0]
-        maybe_annotated_type = typing_extensions.get_origin(type_)
-
-    if maybe_annotated_type == typing_extensions.Annotated:
-        return type_
-
-    return None
-
-
-def _remove_annotations(type_: typing.Any) -> typing.Any:
-    maybe_annotated_type = typing_extensions.get_origin(type_)
-    if maybe_annotated_type is None:
-        return type_
-
-    if maybe_annotated_type == typing_extensions.NotRequired:
-        return _remove_annotations(typing_extensions.get_args(type_)[0])
-
-    if maybe_annotated_type == typing_extensions.Annotated:
-        return _remove_annotations(typing_extensions.get_args(type_)[0])
-
-    return type_
-
-
-def _alias_key(key: str, type_: typing.Any) -> str:
-    maybe_annotated_type = _get_annotation(type_)
-
-    if maybe_annotated_type is not None:
-        # The actual annotations are 1 onward, the first is the annotated type
-        annotations = typing_extensions.get_args(maybe_annotated_type)[1:]
-
-        for annotation in annotations:
-            if isinstance(annotation, FieldMetadata) and annotation.alias is not None:
-                return annotation.alias
-
-    return key

methodaws-0.0.16/src/methodaws/resources/loadbalancer/load_balancer_v_1.py

@@ -1,28 +0,0 @@
-# This file was auto-generated by Fern from our API Definition.
-
-from ...core.pydantic_utilities import UniversalBaseModel
-import datetime as dt
-import pydantic
-import typing
-from .target import Target
-from .listener import Listener
-from ...core.pydantic_utilities import IS_PYDANTIC_V2
-
-
-class LoadBalancerV1(UniversalBaseModel):
-    name: str
-    created_time: dt.datetime = pydantic.Field(alias="createdTime")
-    dns_name: str = pydantic.Field(alias="dnsName")
-    security_group_ids: typing.List[str] = pydantic.Field(alias="securityGroupIds")
-    vpc_id: str = pydantic.Field(alias="vpcId")
-    subnet_ids: typing.List[str] = pydantic.Field(alias="subnetIds")
-    hosted_zone_id: typing.Optional[str] = pydantic.Field(alias="hostedZoneId", default=None)
-    targets: typing.List[Target]
-    listeners: typing.List[Listener]
-
-    if IS_PYDANTIC_V2:
-        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow")  # type: ignore # Pydantic v2
-    else:
-
-        class Config:
-            extra = pydantic.Extra.allow

methodaws-0.0.16/src/methodaws/resources/s_3/bucket.py

@@ -1,32 +0,0 @@
-# This file was auto-generated by Fern from our API Definition.
-
-from ...core.pydantic_utilities import UniversalBaseModel
-import datetime as dt
-import pydantic
-from .s_3_public_access_block_configuration import S3PublicAccessBlockConfiguration
-import typing
-from .bucket_versioning_status import BucketVersioningStatus
-from .s_3_mfa_delete_status import S3MfaDeleteStatus
-from .encryption_rule import EncryptionRule
-from ...core.pydantic_utilities import IS_PYDANTIC_V2
-
-
-class Bucket(UniversalBaseModel):
-    name: str
-    arn: str
-    url: str
-    creation_date: dt.datetime = pydantic.Field(alias="creationDate")
-    owner_id: str = pydantic.Field(alias="ownerID")
-    owner_name: str = pydantic.Field(alias="ownerName")
-    public_access_config: S3PublicAccessBlockConfiguration = pydantic.Field(alias="publicAccessConfig")
-    policy: typing.Optional[str] = None
-    bucket_versioning: typing.Optional[BucketVersioningStatus] = pydantic.Field(alias="bucketVersioning", default=None)
-    mfa_delete: typing.Optional[S3MfaDeleteStatus] = pydantic.Field(alias="mfaDelete", default=None)
-    encryption_rules: typing.List[EncryptionRule] = pydantic.Field(alias="encryptionRules")
-
-    if IS_PYDANTIC_V2:
-        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow")  # type: ignore # Pydantic v2
-    else:
-
-        class Config:
-            extra = pydantic.Extra.allow