methodaws 0.0.10__py3-none-any.whl

method-security/methodaws/__init__.py

@@ -0,0 +1,33 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from .resources import (
+    Certificate,
+    IpAddressType,
+    Listener,
+    LoadBalancerReport,
+    LoadBalancerState,
+    LoadBalancerV1,
+    LoadBalancerV2,
+    Protocol,
+    Target,
+    TargetGroup,
+    TargetGroupIpAddressType,
+    TargetType,
+    loadbalancer,
+)
+
+__all__ = [
+    "Certificate",
+    "IpAddressType",
+    "Listener",
+    "LoadBalancerReport",
+    "LoadBalancerState",
+    "LoadBalancerV1",
+    "LoadBalancerV2",
+    "Protocol",
+    "Target",
+    "TargetGroup",
+    "TargetGroupIpAddressType",
+    "TargetType",
+    "loadbalancer",
+]

method-security/methodaws/core/__init__.py

@@ -0,0 +1,27 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from .datetime_utils import serialize_datetime
+from .pydantic_utilities import (
+    IS_PYDANTIC_V2,
+    UniversalBaseModel,
+    UniversalRootModel,
+    deep_union_pydantic_dicts,
+    parse_obj_as,
+    universal_field_validator,
+    universal_root_validator,
+    update_forward_refs,
+)
+from .serialization import FieldMetadata
+
+__all__ = [
+    "FieldMetadata",
+    "IS_PYDANTIC_V2",
+    "UniversalBaseModel",
+    "UniversalRootModel",
+    "deep_union_pydantic_dicts",
+    "parse_obj_as",
+    "serialize_datetime",
+    "universal_field_validator",
+    "universal_root_validator",
+    "update_forward_refs",
+]

method-security/methodaws/core/datetime_utils.py

@@ -0,0 +1,28 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import datetime as dt
+
+
+def serialize_datetime(v: dt.datetime) -> str:
+    """
+    Serialize a datetime including timezone info.
+
+    Uses the timezone info provided if present, otherwise uses the current runtime's timezone info.
+
+    UTC datetimes end in "Z" while all other timezones are represented as offset from UTC, e.g. +05:00.
+    """
+
+    def _serialize_zoned_datetime(v: dt.datetime) -> str:
+        if v.tzinfo is not None and v.tzinfo.tzname(None) == dt.timezone.utc.tzname(None):
+            # UTC is a special case where we use "Z" at the end instead of "+00:00"
+            return v.isoformat().replace("+00:00", "Z")
+        else:
+            # Delegate to the typical +/- offset format
+            return v.isoformat()
+
+    if v.tzinfo is not None:
+        return _serialize_zoned_datetime(v)
+    else:
+        local_tz = dt.datetime.now().astimezone().tzinfo
+        localized_dt = v.replace(tzinfo=local_tz)
+        return _serialize_zoned_datetime(localized_dt)

method-security/methodaws/core/pydantic_utilities.py

@@ -0,0 +1,179 @@
+# This file was auto-generated by Fern from our API Definition.
+
+# nopycln: file
+import datetime as dt
+import typing
+from collections import defaultdict
+from functools import wraps
+
+import pydantic
+
+from .datetime_utils import serialize_datetime
+
+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 get_origin as get_origin  # pyright: ignore[reportMissingImports] # Pydantic v2
+    from pydantic.v1.typing import (  # pyright: ignore[reportMissingImports] # Pydantic v2
+        is_literal_type as is_literal_type,
+    )
+    from pydantic.v1.typing import is_union as is_union  # pyright: ignore[reportMissingImports] # Pydantic v2
+    from pydantic.v1.fields import ModelField as ModelField  # type: ignore # pyright: ignore[reportMissingImports] # Pydantic v2
+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
+
+
+T = typing.TypeVar("T")
+Model = typing.TypeVar("Model", bound=pydantic.BaseModel)
+
+
+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:
+            destination[key] = value
+
+    return destination
+
+
+def parse_obj_as(type_: typing.Type[T], object_: typing.Any) -> T:
+    if IS_PYDANTIC_V2:
+        adapter = pydantic.TypeAdapter(type_)  # type: ignore # Pydantic v2
+        return adapter.validate_python(object_)
+    else:
+        return pydantic.parse_obj_as(type_, object_)
+
+
+def to_jsonable_with_fallback(
+    obj: typing.Any, fallback_serializer: typing.Callable[[typing.Any], typing.Any]
+) -> typing.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)
+
+
+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}
+
+    def json(self, **kwargs: typing.Any) -> str:
+        kwargs_with_defaults: typing.Any = {"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)
+
+    def dict(self, **kwargs: typing.Any) -> typing.Dict[str, typing.Any]:
+        kwargs_with_defaults_exclude_unset: typing.Any = {"by_alias": True, "exclude_unset": True, **kwargs}
+        kwargs_with_defaults_exclude_none: typing.Any = {"by_alias": True, "exclude_none": True, **kwargs}
+
+        if IS_PYDANTIC_V2:
+            return 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:
+            return deep_union_pydantic_dicts(
+                super().dict(**kwargs_with_defaults_exclude_unset), super().dict(**kwargs_with_defaults_exclude_none)
+            )
+
+
+UniversalRootModel: typing.Type[typing.Any]
+if IS_PYDANTIC_V2:
+
+    class V2RootModel(UniversalBaseModel, pydantic.RootModel):  # type: ignore # Pydantic v2
+        pass
+
+    UniversalRootModel = V2RootModel
+else:
+    UniversalRootModel = UniversalBaseModel
+
+
+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)
+    for type_, encoder in encoders_by_type.items():
+        encoders_by_class_tuples[encoder] += (type_,)
+
+    if type(o) in encoders_by_type:
+        return encoders_by_type[type(o)](o)
+    for encoder, classes_tuple in encoders_by_class_tuples.items():
+        if isinstance(o, classes_tuple):
+            return encoder(o)
+
+
+def update_forward_refs(model: typing.Type["Model"], **localns: typing.Any) -> None:
+    if IS_PYDANTIC_V2:
+        model.model_rebuild(force=True, raise_errors=False)  # type: ignore # Pydantic v2
+    else:
+        model.update_forward_refs(**localns)
+
+
+# Mirrors Pydantic's internal typing
+AnyCallable = typing.Callable[..., typing.Any]
+
+
+def universal_root_validator(pre: bool = False) -> typing.Callable[[AnyCallable], AnyCallable]:
+    def decorator(func: AnyCallable) -> AnyCallable:
+        @wraps(func)
+        def validate(*args: typing.Any, **kwargs: typing.Any) -> AnyCallable:
+            if IS_PYDANTIC_V2:
+                wrapped_func = pydantic.model_validator("before" if pre else "after")(func)  # type: ignore # Pydantic v2
+            else:
+                wrapped_func = pydantic.root_validator(pre=pre)(func)  # type: ignore # Pydantic v1
+
+            return wrapped_func(*args, **kwargs)
+
+        return validate
+
+    return decorator
+
+
+def universal_field_validator(field_name: str, pre: bool = False) -> typing.Callable[[AnyCallable], AnyCallable]:
+    def decorator(func: AnyCallable) -> AnyCallable:
+        @wraps(func)
+        def validate(*args: typing.Any, **kwargs: typing.Any) -> AnyCallable:
+            if IS_PYDANTIC_V2:
+                wrapped_func = pydantic.field_validator(field_name, mode="before" if pre else "after")(func)  # type: ignore # Pydantic v2
+            else:
+                wrapped_func = pydantic.validator(field_name, pre=pre)(func)
+
+            return wrapped_func(*args, **kwargs)
+
+        return validate
+
+    return decorator

method-security/methodaws/core/serialization.py

@@ -0,0 +1,167 @@
+# 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

method-security/methodaws/resources/__init__.py

@@ -0,0 +1,33 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from . import loadbalancer
+from .loadbalancer import (
+    Certificate,
+    IpAddressType,
+    Listener,
+    LoadBalancerReport,
+    LoadBalancerState,
+    LoadBalancerV1,
+    LoadBalancerV2,
+    Protocol,
+    Target,
+    TargetGroup,
+    TargetGroupIpAddressType,
+    TargetType,
+)
+
+__all__ = [
+    "Certificate",
+    "IpAddressType",
+    "Listener",
+    "LoadBalancerReport",
+    "LoadBalancerState",
+    "LoadBalancerV1",
+    "LoadBalancerV2",
+    "Protocol",
+    "Target",
+    "TargetGroup",
+    "TargetGroupIpAddressType",
+    "TargetType",
+    "loadbalancer",
+]

method-security/methodaws/resources/loadbalancer/__init__.py

@@ -0,0 +1,29 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from .certificate import Certificate
+from .ip_address_type import IpAddressType
+from .listener import Listener
+from .load_balancer_report import LoadBalancerReport
+from .load_balancer_state import LoadBalancerState
+from .load_balancer_v_1 import LoadBalancerV1
+from .load_balancer_v_2 import LoadBalancerV2
+from .protocol import Protocol
+from .target import Target
+from .target_group import TargetGroup
+from .target_group_ip_address_type import TargetGroupIpAddressType
+from .target_type import TargetType
+
+__all__ = [
+    "Certificate",
+    "IpAddressType",
+    "Listener",
+    "LoadBalancerReport",
+    "LoadBalancerState",
+    "LoadBalancerV1",
+    "LoadBalancerV2",
+    "Protocol",
+    "Target",
+    "TargetGroup",
+    "TargetGroupIpAddressType",
+    "TargetType",
+]

method-security/methodaws/resources/loadbalancer/certificate.py

@@ -0,0 +1,19 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+import pydantic
+
+from ...core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel
+
+
+class Certificate(UniversalBaseModel):
+    arn: str
+    is_default: bool = pydantic.Field(alias="isDefault")
+
+    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

method-security/methodaws/resources/loadbalancer/ip_address_type.py

@@ -0,0 +1,5 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+IpAddressType = typing.Union[typing.Literal["IPV4", "DUALSTACK", "DUALSTACK_WITHOUT_PUBLIC_IPV4"], typing.Any]

method-security/methodaws/resources/loadbalancer/listener.py

@@ -0,0 +1,24 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+import pydantic
+
+from ...core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel
+from .certificate import Certificate
+from .protocol import Protocol
+
+
+class Listener(UniversalBaseModel):
+    arn: typing.Optional[str] = None
+    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)
+
+    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

method-security/methodaws/resources/loadbalancer/load_balancer_report.py

@@ -0,0 +1,27 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+import pydantic
+
+from ...core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel
+from .load_balancer_v_1 import LoadBalancerV1
+from .load_balancer_v_2 import LoadBalancerV2
+
+
+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
+    )
+    errors: typing.Optional[typing.List[str]] = 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

method-security/methodaws/resources/loadbalancer/load_balancer_state.py

@@ -0,0 +1,5 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+LoadBalancerState = typing.Union[typing.Literal["ACTIVE", "PROVISIONING", "ACTIVE_IMPAIRED", "FAILED"], typing.Any]

method-security/methodaws/resources/loadbalancer/load_balancer_v_1.py

@@ -0,0 +1,29 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import datetime as dt
+import typing
+
+import pydantic
+
+from ...core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel
+from .listener import Listener
+from .target import Target
+
+
+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

method-security/methodaws/resources/loadbalancer/load_balancer_v_2.py

@@ -0,0 +1,39 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import datetime as dt
+import typing
+
+import pydantic
+
+from ...core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel
+from .ip_address_type import IpAddressType
+from .listener import Listener
+from .load_balancer_state import LoadBalancerState
+from .target_group import TargetGroup
+
+
+class LoadBalancerV2(UniversalBaseModel):
+    """
+    LoadBalancer represents a load balancer that distributes incoming network traffic across multiple servers.
+    As defined by the AWS Go SDK (https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2@v1.33.1/types#LoadBalancer)
+    """
+
+    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")
+    state: typing.Optional[LoadBalancerState] = None
+    vpc_id: str = pydantic.Field(alias="vpcId")
+    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")
+
+    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

method-security/methodaws/resources/loadbalancer/protocol.py

@@ -0,0 +1,5 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+Protocol = typing.Union[typing.Literal["HTTP", "HTTPS", "TCP", "TLS", "UDP", "TCP_UDP", "GENEVE"], typing.Any]

method-security/methodaws/resources/loadbalancer/target.py

@@ -0,0 +1,22 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+import pydantic
+
+from ...core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel
+from .target_type import TargetType
+
+
+class Target(UniversalBaseModel):
+    id: str
+    type: TargetType
+    port: int
+    availability_zone: typing.Optional[str] = pydantic.Field(alias="availabilityZone", default=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

method-security/methodaws/resources/loadbalancer/target_group.py

@@ -0,0 +1,28 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+import pydantic
+
+from ...core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel
+from .protocol import Protocol
+from .target import Target
+from .target_group_ip_address_type import TargetGroupIpAddressType
+
+
+class TargetGroup(UniversalBaseModel):
+    arn: str
+    name: str
+    ip_address_type: TargetGroupIpAddressType = pydantic.Field(alias="ipAddressType")
+    load_balancer_arn: str = pydantic.Field(alias="loadBalancerArn")
+    port: int
+    protocol: typing.Optional[Protocol] = None
+    vpc_id: str = pydantic.Field(alias="vpcId")
+    targets: typing.List[Target]
+
+    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

method-security/methodaws/resources/loadbalancer/target_group_ip_address_type.py

@@ -0,0 +1,5 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+TargetGroupIpAddressType = typing.Union[typing.Literal["IPV4", "IPV6"], typing.Any]

method-security/methodaws/resources/loadbalancer/target_type.py

@@ -0,0 +1,5 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+TargetType = typing.Union[typing.Literal["INSTANCE", "IP", "LAMBDA"], typing.Any]

methodaws-0.0.10.dist-info/METADATA

@@ -0,0 +1,25 @@
+Metadata-Version: 2.1
+Name: methodaws
+Version: 0.0.10
+Summary: 
+Requires-Python: >=3.8,<4.0
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: OS Independent
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Dist: pydantic (>=1.9.2)
+Requires-Dist: pydantic-core (>=2.18.2,<3.0.0)
+Description-Content-Type: text/markdown
+
+

methodaws-0.0.10.dist-info/RECORD

@@ -0,0 +1,23 @@
+method-security/methodaws/__init__.py,sha256=B84xoWeObgulwjGKjnpbEDk5yBfb98eMu4l2HqLACcw,621
+method-security/methodaws/core/__init__.py,sha256=Z7MBmjdOvLg2XS19a5VrUGugUtHHcL81I6q2UGb8zFk,673
+method-security/methodaws/core/datetime_utils.py,sha256=nBys2IsYrhPdszxGKCNRPSOCwa-5DWOHG95FB8G9PKo,1047
+method-security/methodaws/core/pydantic_utilities.py,sha256=5Fg3PRO5be9PZ4LKvMOLNs5zcT6WJGj22yZO1jfQhtU,7092
+method-security/methodaws/core/serialization.py,sha256=TLuzwJ-hs4-SvGQSME5-mhXmVyIEdmPTDMEjZzsPZ08,5849
+method-security/methodaws/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+method-security/methodaws/resources/__init__.py,sha256=Q7JXKbu89O5aC6a7by554p1WTcHE-g5qDHQioaIjNHs,633
+method-security/methodaws/resources/loadbalancer/__init__.py,sha256=dluY-TwlrZEACN4ydRiRikK3-qRDrbqt2SFRUrgP-k8,836
+method-security/methodaws/resources/loadbalancer/certificate.py,sha256=THjvxT-EPUMfcDJSht22qr12cWmwoNJnYTmXJ73Hsl8,506
+method-security/methodaws/resources/loadbalancer/ip_address_type.py,sha256=1q5ach_kZ-MsF5kt494kro2vpod8hAdaYDoRtk31guE,191
+method-security/methodaws/resources/loadbalancer/listener.py,sha256=5gSriXjA3qkj8QDRbKw0Nf3OQ953M_7P58hMmVpTaEk,766
+method-security/methodaws/resources/loadbalancer/load_balancer_report.py,sha256=Apry6cVOrF8UWwaFtBEJ4HMB0e9FNPq6xgR57wjm6AU,922
+method-security/methodaws/resources/loadbalancer/load_balancer_state.py,sha256=DWF5zlZi4nV3SnX7uTccNmIOnn12Dg0VyJ_uQUm6D4w,196
+method-security/methodaws/resources/loadbalancer/load_balancer_v_1.py,sha256=MgYhrgzb4TvfHXEE_xcdh5PEvEEatNm8dQHVtQ-PErs,1018
+method-security/methodaws/resources/loadbalancer/load_balancer_v_2.py,sha256=novAwRh4Is_AFdMYgTYtE9aOnYYU0wZGrK8qX2u1nn4,1607
+method-security/methodaws/resources/loadbalancer/protocol.py,sha256=2HUZTlYawxF4LnZaPl3w-R83NrheE28Q1_lPuU8I2J0,191
+method-security/methodaws/resources/loadbalancer/target.py,sha256=v3e0phJNuJP670HoVE6wgSipIBc-ARk1tMf0b70Cx8M,615
+method-security/methodaws/resources/loadbalancer/target_group.py,sha256=zJY5xUAZW3jcriBQKDqi84alQeAzSOzgpPmOV8gh5X8,885
+method-security/methodaws/resources/loadbalancer/target_group_ip_address_type.py,sha256=Bvs3mIEYUgNx3saQC2Pn4bs1teZ1vtO1IyrPe5dPvBk,164
+method-security/methodaws/resources/loadbalancer/target_type.py,sha256=5ALqbIeDr_fPwzDn4q3QcT8AnFD0YIre0iLqpcRt2II,162
+methodaws-0.0.10.dist-info/METADATA,sha256=mi--TIRHrUkwVBp-F7cEtsqW8aSRzUDR9nQ47RGOm6o,927
+methodaws-0.0.10.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+methodaws-0.0.10.dist-info/RECORD,,

methodaws-0.0.10.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 1.9.0
+Root-Is-Purelib: true
+Tag: py3-none-any