methodazure 0.0.12__py3-none-any.whl

methodazure/__init__.py

@@ -0,0 +1,51 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from .resources import (
+    BackendAddressPool,
+    InterfaceIpConfiguration,
+    LoadBalancer,
+    LoadBalancerBackendAddress,
+    LoadBalancerBackendAddressAdminState,
+    LoadBalancerReport,
+    LoadBalancerSku,
+    LoadBalancerSkuName,
+    LoadBalancerSkuTier,
+    LoadBalancingRule,
+    NatRulePortMapping,
+    NetworkInterface,
+    PublicIpAddress,
+    PublicIpAddressDnsSettings,
+    ResourceGroup,
+    Subnet,
+    Subresource,
+    SyncMode,
+    TransportProtocol,
+    azure,
+    interface,
+    loadbalancer,
+)
+
+__all__ = [
+    "BackendAddressPool",
+    "InterfaceIpConfiguration",
+    "LoadBalancer",
+    "LoadBalancerBackendAddress",
+    "LoadBalancerBackendAddressAdminState",
+    "LoadBalancerReport",
+    "LoadBalancerSku",
+    "LoadBalancerSkuName",
+    "LoadBalancerSkuTier",
+    "LoadBalancingRule",
+    "NatRulePortMapping",
+    "NetworkInterface",
+    "PublicIpAddress",
+    "PublicIpAddressDnsSettings",
+    "ResourceGroup",
+    "Subnet",
+    "Subresource",
+    "SyncMode",
+    "TransportProtocol",
+    "azure",
+    "interface",
+    "loadbalancer",
+]

methodazure/core/__init__.py

@@ -0,0 +1,25 @@
+# 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,
+    parse_obj_as,
+    universal_field_validator,
+    universal_root_validator,
+    update_forward_refs,
+)
+from .serialization import FieldMetadata
+
+__all__ = [
+    "FieldMetadata",
+    "IS_PYDANTIC_V2",
+    "UniversalBaseModel",
+    "UniversalRootModel",
+    "parse_obj_as",
+    "serialize_datetime",
+    "universal_field_validator",
+    "universal_root_validator",
+    "update_forward_refs",
+]

methodazure/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)

methodazure/core/pydantic_utilities.py

@@ -0,0 +1,206 @@
+# This file was auto-generated by Fern from our API Definition.
+
+# nopycln: file
+import datetime as dt
+import typing
+from collections import defaultdict
+
+import typing_extensions
+
+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 (  # 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
+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 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]:
+        """
+        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,
+        }
+
+        if IS_PYDANTIC_V2:
+            return super().model_dump(**kwargs_with_defaults_exclude_unset)  # type: ignore # Pydantic v2
+        else:
+            return super().dict(**kwargs_with_defaults_exclude_unset)
+
+
+if IS_PYDANTIC_V2:
+
+    class V2RootModel(UniversalBaseModel, pydantic.RootModel):  # type: ignore # Pydantic v2
+        pass
+
+    UniversalRootModel: typing_extensions.TypeAlias = V2RootModel  # type: ignore
+else:
+    UniversalRootModel: typing_extensions.TypeAlias = UniversalBaseModel  # type: ignore
+
+
+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"]) -> None:
+    if IS_PYDANTIC_V2:
+        model.model_rebuild(raise_errors=False)  # type: ignore # Pydantic v2
+    else:
+        model.update_forward_refs()
+
+
+# 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:
+        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 decorator
+
+
+def universal_field_validator(field_name: str, pre: bool = False) -> typing.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 decorator
+
+
+PydanticField = typing.Union[ModelField, pydantic.fields.FieldInfo]
+
+
+def _get_model_fields(
+    model: typing.Type["Model"],
+) -> typing.Mapping[str, PydanticField]:
+    if IS_PYDANTIC_V2:
+        return model.model_fields  # type: ignore # Pydantic v2
+    else:
+        return model.__fields__  # type: ignore # Pydantic v1
+
+
+def _get_field_default(field: PydanticField) -> typing.Any:
+    try:
+        value = field.get_default()  # type: ignore # Pydantic < v1.10.15
+    except:
+        value = field.default
+    if IS_PYDANTIC_V2:
+        from pydantic_core import PydanticUndefined
+
+        if value == PydanticUndefined:
+            return None
+        return value
+    return value

methodazure/core/serialization.py

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

methodazure/resources/__init__.py

@@ -0,0 +1,50 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from . import azure, interface, loadbalancer
+from .azure import ResourceGroup, Subresource
+from .interface import (
+    InterfaceIpConfiguration,
+    NetworkInterface,
+    PublicIpAddress,
+    PublicIpAddressDnsSettings,
+    Subnet,
+    TransportProtocol,
+)
+from .loadbalancer import (
+    BackendAddressPool,
+    LoadBalancer,
+    LoadBalancerBackendAddress,
+    LoadBalancerBackendAddressAdminState,
+    LoadBalancerReport,
+    LoadBalancerSku,
+    LoadBalancerSkuName,
+    LoadBalancerSkuTier,
+    LoadBalancingRule,
+    NatRulePortMapping,
+    SyncMode,
+)
+
+__all__ = [
+    "BackendAddressPool",
+    "InterfaceIpConfiguration",
+    "LoadBalancer",
+    "LoadBalancerBackendAddress",
+    "LoadBalancerBackendAddressAdminState",
+    "LoadBalancerReport",
+    "LoadBalancerSku",
+    "LoadBalancerSkuName",
+    "LoadBalancerSkuTier",
+    "LoadBalancingRule",
+    "NatRulePortMapping",
+    "NetworkInterface",
+    "PublicIpAddress",
+    "PublicIpAddressDnsSettings",
+    "ResourceGroup",
+    "Subnet",
+    "Subresource",
+    "SyncMode",
+    "TransportProtocol",
+    "azure",
+    "interface",
+    "loadbalancer",
+]

methodazure/resources/azure/__init__.py

@@ -0,0 +1,6 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from .resource_group import ResourceGroup
+from .subresource import Subresource
+
+__all__ = ["ResourceGroup", "Subresource"]

methodazure/resources/azure/resource_group.py

@@ -0,0 +1,18 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from ...core.pydantic_utilities import UniversalBaseModel
+from ...core.pydantic_utilities import IS_PYDANTIC_V2
+import typing
+import pydantic
+
+
+class ResourceGroup(UniversalBaseModel):
+    id: str
+    name: str
+
+    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

methodazure/resources/azure/subresource.py

@@ -0,0 +1,17 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from ...core.pydantic_utilities import UniversalBaseModel
+from ...core.pydantic_utilities import IS_PYDANTIC_V2
+import typing
+import pydantic
+
+
+class Subresource(UniversalBaseModel):
+    id: str
+
+    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

methodazure/resources/interface/__init__.py

@@ -0,0 +1,17 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from .interface_ip_configuration import InterfaceIpConfiguration
+from .network_interface import NetworkInterface
+from .public_ip_address import PublicIpAddress
+from .public_ip_address_dns_settings import PublicIpAddressDnsSettings
+from .subnet import Subnet
+from .transport_protocol import TransportProtocol
+
+__all__ = [
+    "InterfaceIpConfiguration",
+    "NetworkInterface",
+    "PublicIpAddress",
+    "PublicIpAddressDnsSettings",
+    "Subnet",
+    "TransportProtocol",
+]

methodazure/resources/interface/interface_ip_configuration.py

@@ -0,0 +1,24 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from ...core.pydantic_utilities import UniversalBaseModel
+import typing
+import pydantic
+from .public_ip_address import PublicIpAddress
+from .subnet import Subnet
+from ...core.pydantic_utilities import IS_PYDANTIC_V2
+
+
+class InterfaceIpConfiguration(UniversalBaseModel):
+    id: str
+    name: str
+    type: typing.Optional[str] = None
+    private_ip_address: typing.Optional[str] = pydantic.Field(alias="privateIpAddress", default=None)
+    public_ip_address: typing.Optional[PublicIpAddress] = pydantic.Field(alias="publicIpAddress", default=None)
+    subnet: typing.Optional[Subnet] = 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

methodazure/resources/interface/network_interface.py

@@ -0,0 +1,20 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from ...core.pydantic_utilities import UniversalBaseModel
+import typing
+import pydantic
+from ...core.pydantic_utilities import IS_PYDANTIC_V2
+
+
+class NetworkInterface(UniversalBaseModel):
+    id: str
+    name: str
+    network_security_group_id: typing.Optional[str] = pydantic.Field(alias="networkSecurityGroupID", default=None)
+    mac_address: typing.Optional[str] = pydantic.Field(alias="macAddress", 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

methodazure/resources/interface/public_ip_address.py

@@ -0,0 +1,21 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from ...core.pydantic_utilities import UniversalBaseModel
+import pydantic
+import typing
+from .public_ip_address_dns_settings import PublicIpAddressDnsSettings
+from ...core.pydantic_utilities import IS_PYDANTIC_V2
+
+
+class PublicIpAddress(UniversalBaseModel):
+    id: str
+    location: str
+    ip_address: str = pydantic.Field(alias="ipAddress")
+    dns_settings: typing.Optional[PublicIpAddressDnsSettings] = pydantic.Field(alias="dnsSettings", 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

methodazure/resources/interface/public_ip_address_dns_settings.py

@@ -0,0 +1,19 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from ...core.pydantic_utilities import UniversalBaseModel
+import pydantic
+from ...core.pydantic_utilities import IS_PYDANTIC_V2
+import typing
+
+
+class PublicIpAddressDnsSettings(UniversalBaseModel):
+    domain_name_label: str = pydantic.Field(alias="domainNameLabel")
+    fqdn: str
+    reverse_fqdn: str = pydantic.Field(alias="reverseFqdn")
+
+    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

methodazure/resources/interface/subnet.py

@@ -0,0 +1,22 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from ...core.pydantic_utilities import UniversalBaseModel
+import typing
+import pydantic
+from ...core.pydantic_utilities import IS_PYDANTIC_V2
+
+
+class Subnet(UniversalBaseModel):
+    id: str
+    name: str
+    type: typing.Optional[str] = None
+    address_prefix: typing.Optional[str] = pydantic.Field(alias="addressPrefix", default=None)
+    address_prefixes: typing.Optional[typing.List[str]] = pydantic.Field(alias="addressPrefixes", default=None)
+    network_security_group_id: typing.Optional[str] = pydantic.Field(alias="networkSecurityGroupID", 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

methodazure/resources/interface/transport_protocol.py

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

methodazure/resources/loadbalancer/__init__.py

@@ -0,0 +1,27 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from .backend_address_pool import BackendAddressPool
+from .load_balancer import LoadBalancer
+from .load_balancer_backend_address import LoadBalancerBackendAddress
+from .load_balancer_backend_address_admin_state import LoadBalancerBackendAddressAdminState
+from .load_balancer_report import LoadBalancerReport
+from .load_balancer_sku import LoadBalancerSku
+from .load_balancer_sku_name import LoadBalancerSkuName
+from .load_balancer_sku_tier import LoadBalancerSkuTier
+from .load_balancing_rule import LoadBalancingRule
+from .nat_rule_port_mapping import NatRulePortMapping
+from .sync_mode import SyncMode
+
+__all__ = [
+    "BackendAddressPool",
+    "LoadBalancer",
+    "LoadBalancerBackendAddress",
+    "LoadBalancerBackendAddressAdminState",
+    "LoadBalancerReport",
+    "LoadBalancerSku",
+    "LoadBalancerSkuName",
+    "LoadBalancerSkuTier",
+    "LoadBalancingRule",
+    "NatRulePortMapping",
+    "SyncMode",
+]

methodazure/resources/loadbalancer/backend_address_pool.py

@@ -0,0 +1,37 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from ...core.pydantic_utilities import UniversalBaseModel
+import typing
+from .load_balancer_backend_address import LoadBalancerBackendAddress
+import pydantic
+from .sync_mode import SyncMode
+from ..azure.subresource import Subresource
+from ..interface.interface_ip_configuration import InterfaceIpConfiguration
+from ...core.pydantic_utilities import IS_PYDANTIC_V2
+
+
+class BackendAddressPool(UniversalBaseModel):
+    """
+    Collection of backend address pools used by the load balancer:
+    https://pkg.go.dev/github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/network/armnetwork/v5#BackendAddressPool
+    """
+
+    id: str
+    name: str
+    type: str
+    load_balancer_backend_addresses: typing.Optional[typing.List[LoadBalancerBackendAddress]] = pydantic.Field(
+        alias="loadBalancerBackendAddresses", default=None
+    )
+    location: typing.Optional[str] = None
+    sync_mode: typing.Optional[SyncMode] = pydantic.Field(alias="syncMode", default=None)
+    virtual_network: typing.Optional[Subresource] = pydantic.Field(alias="virtualNetwork", default=None)
+    backend_ip_configurations: typing.Optional[typing.List[InterfaceIpConfiguration]] = pydantic.Field(
+        alias="backendIpConfigurations", 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

methodazure/resources/loadbalancer/load_balancer.py

@@ -0,0 +1,40 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from ...core.pydantic_utilities import UniversalBaseModel
+import pydantic
+from .load_balancer_sku import LoadBalancerSku
+import typing
+from .backend_address_pool import BackendAddressPool
+from ..interface.interface_ip_configuration import InterfaceIpConfiguration
+from .load_balancing_rule import LoadBalancingRule
+from ...core.pydantic_utilities import IS_PYDANTIC_V2
+
+
+class LoadBalancer(UniversalBaseModel):
+    """
+    LoadBalancer represents an Azure Load Balancer as defined in the Azure Go SDK:
+    https://pkg.go.dev/github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/network/armnetwork/v5#LoadBalancer
+    """
+
+    id: str
+    name: str
+    location: str
+    resource_group: str = pydantic.Field(alias="resourceGroup")
+    resource_group_id: str = pydantic.Field(alias="resourceGroupId")
+    sku: LoadBalancerSku
+    backend_address_pools: typing.Optional[typing.List[BackendAddressPool]] = pydantic.Field(
+        alias="backendAddressPools", default=None
+    )
+    frontend_ip_configurations: typing.Optional[typing.List[InterfaceIpConfiguration]] = pydantic.Field(
+        alias="frontendIPConfigurations", default=None
+    )
+    load_balancing_rules: typing.Optional[typing.List[LoadBalancingRule]] = pydantic.Field(
+        alias="loadBalancingRules", 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

methodazure/resources/loadbalancer/load_balancer_backend_address.py

@@ -0,0 +1,37 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from ...core.pydantic_utilities import UniversalBaseModel
+import typing
+from .load_balancer_backend_address_admin_state import LoadBalancerBackendAddressAdminState
+import pydantic
+from ..azure.subresource import Subresource
+from .nat_rule_port_mapping import NatRulePortMapping
+from ..interface.network_interface import NetworkInterface
+from ...core.pydantic_utilities import IS_PYDANTIC_V2
+
+
+class LoadBalancerBackendAddress(UniversalBaseModel):
+    name: str
+    admin_state: typing.Optional[LoadBalancerBackendAddressAdminState] = pydantic.Field(
+        alias="adminState", default=None
+    )
+    ip_address: typing.Optional[str] = pydantic.Field(alias="ipAddress", default=None)
+    load_balancer_frontend_ip_configuration: typing.Optional[Subresource] = pydantic.Field(
+        alias="loadBalancerFrontendIPConfiguration", default=None
+    )
+    subnet: typing.Optional[Subresource] = None
+    virtual_network: typing.Optional[Subresource] = pydantic.Field(alias="virtualNetwork", default=None)
+    inbound_nat_rules_port_mapping: typing.Optional[typing.List[NatRulePortMapping]] = pydantic.Field(
+        alias="inboundNatRulesPortMapping", default=None
+    )
+    network_interface_ip_configurations: typing.Optional[Subresource] = pydantic.Field(
+        alias="networkInterfaceIpConfigurations", default=None
+    )
+    network_interface: typing.Optional[NetworkInterface] = pydantic.Field(alias="networkInterface", 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

methodazure/resources/loadbalancer/load_balancer_backend_address_admin_state.py

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

methodazure/resources/loadbalancer/load_balancer_report.py

@@ -0,0 +1,21 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from ...core.pydantic_utilities import UniversalBaseModel
+import pydantic
+import typing
+from .load_balancer import LoadBalancer
+from ...core.pydantic_utilities import IS_PYDANTIC_V2
+
+
+class LoadBalancerReport(UniversalBaseModel):
+    subscription_id: str = pydantic.Field(alias="subscriptionId")
+    tenant_id: str = pydantic.Field(alias="tenantId")
+    load_balancers: typing.List[LoadBalancer] = pydantic.Field(alias="loadBalancers")
+    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

methodazure/resources/loadbalancer/load_balancer_sku.py

@@ -0,0 +1,20 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from ...core.pydantic_utilities import UniversalBaseModel
+from .load_balancer_sku_name import LoadBalancerSkuName
+from .load_balancer_sku_tier import LoadBalancerSkuTier
+from ...core.pydantic_utilities import IS_PYDANTIC_V2
+import typing
+import pydantic
+
+
+class LoadBalancerSku(UniversalBaseModel):
+    name: LoadBalancerSkuName
+    tier: LoadBalancerSkuTier
+
+    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

methodazure/resources/loadbalancer/load_balancer_sku_name.py

@@ -0,0 +1,5 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+LoadBalancerSkuName = typing.Union[typing.Literal["Basic", "Gateway", "Standard", "Unknown"], typing.Any]

methodazure/resources/loadbalancer/load_balancer_sku_tier.py

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

methodazure/resources/loadbalancer/load_balancing_rule.py

@@ -0,0 +1,35 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from ...core.pydantic_utilities import UniversalBaseModel
+import pydantic
+from ..interface.transport_protocol import TransportProtocol
+import typing
+from ..azure.subresource import Subresource
+from ...core.pydantic_utilities import IS_PYDANTIC_V2
+
+
+class LoadBalancingRule(UniversalBaseModel):
+    """
+    LoadBalancingRule represents an Azure Load Balancing Rule as defined in the Azure Go SDK:
+    https://pkg.go.dev/github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/network/armnetwork/v5#LoadBalancingRule
+    """
+
+    id: str
+    name: str
+    frontend_port: int = pydantic.Field(alias="frontendPort")
+    protocol: TransportProtocol
+    backend_address_pool: typing.Optional[Subresource] = pydantic.Field(alias="backendAddressPool", default=None)
+    backend_address_pools: typing.Optional[typing.List[Subresource]] = pydantic.Field(
+        alias="backendAddressPools", default=None
+    )
+    backend_port: int = pydantic.Field(alias="backendPort")
+    frontend_ip_configuration: typing.Optional[Subresource] = pydantic.Field(
+        alias="frontendIPConfiguration", 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

methodazure/resources/loadbalancer/nat_rule_port_mapping.py

@@ -0,0 +1,19 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from ...core.pydantic_utilities import UniversalBaseModel
+import pydantic
+from ...core.pydantic_utilities import IS_PYDANTIC_V2
+import typing
+
+
+class NatRulePortMapping(UniversalBaseModel):
+    backend_port: int = pydantic.Field(alias="backendPort")
+    frontend_port: int = pydantic.Field(alias="frontendPort")
+    inbound_nat_rule_name: str = pydantic.Field(alias="inboundNatRuleName")
+
+    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

methodazure/resources/loadbalancer/sync_mode.py

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

methodazure-0.0.12.dist-info/METADATA

@@ -0,0 +1,25 @@
+Metadata-Version: 2.1
+Name: methodazure
+Version: 0.0.12
+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
+
+

methodazure-0.0.12.dist-info/RECORD

@@ -0,0 +1,32 @@
+methodazure/__init__.py,sha256=-f8jCpf0_CT3QaGdfF6Njop-T6ViXzumhqxvQKHUVwk,1135
+methodazure/core/__init__.py,sha256=uJtC1p-Mzsx4cdi6jZqTlg0nwdauSLoFaWQItpqpRkw,609
+methodazure/core/datetime_utils.py,sha256=nBys2IsYrhPdszxGKCNRPSOCwa-5DWOHG95FB8G9PKo,1047
+methodazure/core/pydantic_utilities.py,sha256=F91xFonOmTu3AdWJtQduQoS8Gn_K7y8ln9IT8LU6WPM,7549
+methodazure/core/serialization.py,sha256=X1W2KRWxKwOL7k4EatJMas1e2CCLfUOI77qrj8AvLGc,5862
+methodazure/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+methodazure/resources/__init__.py,sha256=SmNJ_7nKq4qutN-NqQOUOFQuz8H86dL5kIcLqdJUACQ,1176
+methodazure/resources/azure/__init__.py,sha256=vTPO1ejDsUQRRFbZmO0cTUfQVhRvo79gn09l5zgUDRU,188
+methodazure/resources/azure/resource_group.py,sha256=kHAxbUOPOz8BOFy4HfGjU7q5B_bL-b9zGlu6a9Vu7rM,500
+methodazure/resources/azure/subresource.py,sha256=I29Cax4w2lYnUVnz6QtbVkG8iyCiKnNjlcXNuOSFHmk,484
+methodazure/resources/interface/__init__.py,sha256=diz5VELtHjyLjnJW1V0CCP8JNxFPCO-grj3jq1RVxjg,540
+methodazure/resources/interface/interface_ip_configuration.py,sha256=cmI01CgH78duZzQaKJeeMIyWhqYdcoWK4t65lq6hZwA,880
+methodazure/resources/interface/network_interface.py,sha256=PhozocKDh_cqcpiSAPH4XALGOoCKUd1cwtgLR59zlLU,707
+methodazure/resources/interface/public_ip_address.py,sha256=zPUgctXZl9URjLLeWvhrz7biJjrQvYd5xEAHZkQo2Lw,747
+methodazure/resources/interface/public_ip_address_dns_settings.py,sha256=iCggSXvPxZq2zGebPnt6oBE0HP_TLPL84Guw1hcjF8A,630
+methodazure/resources/interface/subnet.py,sha256=E3ZRBxhfF7Zt_9MrIc8lo3FEh3U8UqHSDZcDimfvmL4,853
+methodazure/resources/interface/transport_protocol.py,sha256=11XSRZv7fGUi0C7Qk7vUuvfUf66kvTjpZlMmyZ3QhG8,162
+methodazure/resources/loadbalancer/__init__.py,sha256=UoTC_jtPC4sOF8xCffke_08Lv5zGtVheRj3KhXqVgcs,978
+methodazure/resources/loadbalancer/backend_address_pool.py,sha256=tLWYgRkFNwUczmtYfD7BRxEOl9il6FPSlO8tmvCKD8s,1521
+methodazure/resources/loadbalancer/load_balancer.py,sha256=ZrVGDcQCtK2NEqdwbKSWtYl9SkqK2-ulxzfzT7Ekz6M,1577
+methodazure/resources/loadbalancer/load_balancer_backend_address.py,sha256=ZKBE6bdNcUonHQn7pU5OBrRMydQetbvn6hf3OJeS3Lc,1727
+methodazure/resources/loadbalancer/load_balancer_backend_address_admin_state.py,sha256=ghL22sLU9ql-ZbQ9-0USILMDaIUh7H8vow3lwmAfRJI,182
+methodazure/resources/loadbalancer/load_balancer_report.py,sha256=EWvuEBuxJET8XQCFTEUelYQOem__IOXewjp32dngz1w,778
+methodazure/resources/loadbalancer/load_balancer_sku.py,sha256=P6GOXZYv6_cvcfWQRMSq_myeq6KKdJIrID50h8Ufk3I,648
+methodazure/resources/loadbalancer/load_balancer_sku_name.py,sha256=1lFak71pVXAQOXtwbQXFPASGyD2X7oxKJIpAKqjxk30,186
+methodazure/resources/loadbalancer/load_balancer_sku_tier.py,sha256=dQ3AbZRVgubJcT0Vr_mBf7XEM8hfUMTgB6gI5gEi94c,176
+methodazure/resources/loadbalancer/load_balancing_rule.py,sha256=-yGizoKCEQVQp-PQfsGmAMUgannfQB29qLgUXszr4lg,1386
+methodazure/resources/loadbalancer/nat_rule_port_mapping.py,sha256=Kvg87hluVDORDjrqd5LI9tWPmCSiYuyms_b8iTm2WiY,677
+methodazure/resources/loadbalancer/sync_mode.py,sha256=rJdFVB2zTYCgaEDrHoSO9yEe9xl1CjtCtGXj_8UjDAI,155
+methodazure-0.0.12.dist-info/METADATA,sha256=pEK04p1DcSi-kjciS7KqPRW7X9kFMK8mqxVUH_Hkrnw,929
+methodazure-0.0.12.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+methodazure-0.0.12.dist-info/RECORD,,

methodazure-0.0.12.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