@typespec/http-client-python 0.21.0 → 0.22.0

package/generator/pygen/codegen/serializers/general_serializer.py

@@ -23,7 +23,7 @@ VERSION_MAP = {
     "msrest": "0.7.1",
     "isodate": "0.6.1",
     "azure-mgmt-core": "1.6.0",
-    "azure-core": "1.35.0",
+    "azure-core": "1.36.0",
     "typing-extensions": "4.6.0",
     "corehttp": "1.0.0b6",
 }
@@ -57,7 +57,16 @@ class GeneralSerializer(BaseSerializer):
         m = re.search(r"[>=]=?([\d.]+(?:[a-z]+\d+)?)", s)
         return parse_version(m.group(1)) if m else parse_version("0")
 
-    def _keep_pyproject_fields(self, file_content: str) -> dict:
+    def _update_version_map(self, version_map: dict[str, str], dep_name: str, dep: str) -> None:
+        # For tracked dependencies, check if the version is higher than our default
+        default_version = parse_version(version_map[dep_name])
+        dep_version = self._extract_min_dependency(dep)
+        # If the version is higher than the default, update VERSION_MAP
+        # with higher min dependency version
+        if dep_version > default_version:
+            version_map[dep_name] = str(dep_version)
+
+    def external_lib_version_map(self, file_content: str, additional_version_map: dict[str, str]) -> dict:
         # Load the pyproject.toml file if it exists and extract fields to keep.
         result: dict = {"KEEP_FIELDS": {}}
         try:
@@ -80,15 +89,11 @@ class GeneralSerializer(BaseSerializer):
                 for dep in loaded_pyproject_toml["project"]["dependencies"]:
                     dep_name = re.split(r"[<>=\[]", dep)[0].strip()
 
-                    # Check if dependency is one we track in VERSION_MAP
+                    # Check if dependency is one we track in version map
                     if dep_name in VERSION_MAP:
-                        # For tracked dependencies, check if the version is higher than our default
-                        default_version = parse_version(VERSION_MAP[dep_name])
-                        dep_version = self._extract_min_dependency(dep)
-                        # If the version is higher than the default, update VERSION_MAP
-                        # with higher min dependency version
-                        if dep_version > default_version:
-                            VERSION_MAP[dep_name] = str(dep_version)
+                        self._update_version_map(VERSION_MAP, dep_name, dep)
+                    elif dep_name in additional_version_map:
+                        self._update_version_map(additional_version_map, dep_name, dep)
                     else:
                         # Keep non-default dependencies
                         kept_deps.append(dep)
@@ -107,9 +112,20 @@ class GeneralSerializer(BaseSerializer):
     def serialize_package_file(self, template_name: str, file_content: str, **kwargs: Any) -> str:
         template = self.env.get_template(template_name)
 
+        additional_version_map = {}
+        if self.code_model.has_external_type:
+            for item in self.code_model.external_types:
+                if item.package_name:
+                    if item.min_version:
+                        additional_version_map[item.package_name] = item.min_version
+                    else:
+                        # Use "0" as a placeholder when min_version is not specified for external types.
+                        # This allows the dependency to be included without a specific version constraint.
+                        additional_version_map[item.package_name] = "0"
+
         # Add fields to keep from an existing pyproject.toml
         if template_name == "pyproject.toml.jinja2":
-            params = self._keep_pyproject_fields(file_content)
+            params = self.external_lib_version_map(file_content, additional_version_map)
         else:
             params = {}
 
@@ -126,6 +142,7 @@ class GeneralSerializer(BaseSerializer):
             dev_status = "4 - Beta"
         else:
             dev_status = "5 - Production/Stable"
+
         params |= {
             "code_model": self.code_model,
             "dev_status": dev_status,
@@ -136,6 +153,7 @@ class GeneralSerializer(BaseSerializer):
             "VERSION_MAP": VERSION_MAP,
             "MIN_PYTHON_VERSION": MIN_PYTHON_VERSION,
             "MAX_PYTHON_VERSION": MAX_PYTHON_VERSION,
+            "ADDITIONAL_DEPENDENCIES": [f"{item[0]}>={item[1]}" for item in additional_version_map.items()],
         }
         params |= {"options": self.code_model.options}
         params |= kwargs

package/generator/pygen/codegen/serializers/model_serializer.py

@@ -333,6 +333,9 @@ class DpgModelSerializer(_ModelSerializer):
         if prop.xml_metadata:
             args.append(f"xml={prop.xml_metadata}")
 
+        if prop.original_tsp_name:
+            args.append(f'original_tsp_name="{prop.original_tsp_name}"')
+
         field = "rest_discriminator" if prop.is_discriminator else "rest_field"
         type_ignore = (
             "  # type: ignore"

package/generator/pygen/codegen/templates/model_base.py.jinja2

@@ -25,6 +25,9 @@ from {{ code_model.core_library }}.exceptions import DeserializationError
 from {{ code_model.core_library }}{{ "" if code_model.is_azure_flavor else ".utils" }} import CaseInsensitiveEnumMeta
 from {{ code_model.core_library }}.{{ "" if code_model.is_azure_flavor else "runtime." }}pipeline import PipelineResponse
 from {{ code_model.core_library }}.serialization import _Null
+{% if code_model.has_external_type %}
+from {{ code_model.core_library }}.serialization import TypeHandlerRegistry
+{% endif %}
 from {{ code_model.core_library }}.rest import HttpResponse
 
 _LOGGER = logging.getLogger(__name__)
@@ -34,6 +37,10 @@ __all__ = ["SdkJSONEncoder", "Model", "rest_field", "rest_discriminator"]
 TZ_UTC = timezone.utc
 _T = typing.TypeVar("_T")
 
+{% if code_model.has_external_type %}
+TYPE_HANDLER_REGISTRY = TypeHandlerRegistry()
+{% endif %}
+
 
 def _timedelta_as_isostr(td: timedelta) -> str:
     """Converts a datetime.timedelta object into an ISO 8601 formatted string, e.g. 'P4DT12H30M05S'
@@ -158,6 +165,11 @@ class SdkJSONEncoder(JSONEncoder):
             except AttributeError:
                 # This will be raised when it hits value.total_seconds in the method above
                 pass
+            {% if code_model.has_external_type %}
+            custom_serializer = TYPE_HANDLER_REGISTRY.get_serializer(o)
+            if custom_serializer:
+                return custom_serializer(o)
+            {% endif %}
             return super(SdkJSONEncoder, self).default(o)
 
 
@@ -313,7 +325,13 @@ def get_deserializer(annotation: typing.Any, rf: typing.Optional["_RestField"] =
         return _deserialize_int_as_str
     if rf and rf._format:
         return _DESERIALIZE_MAPPING_WITHFORMAT.get(rf._format)
+    {% if code_model.has_external_type %}
+    if _DESERIALIZE_MAPPING.get(annotation):  # pyright: ignore
+        return _DESERIALIZE_MAPPING.get(annotation)  # pyright: ignore
+    return TYPE_HANDLER_REGISTRY.get_deserializer(annotation)  # pyright: ignore
+    {% else %}
     return _DESERIALIZE_MAPPING.get(annotation)  # pyright: ignore
+    {% endif %}
 
 
 def _get_type_alias_type(module_name: str, alias_name: str):
@@ -507,6 +525,14 @@ def _serialize(o, format: typing.Optional[str] = None):  # pylint: disable=too-m
     except AttributeError:
         # This will be raised when it hits value.total_seconds in the method above
         pass
+    {% if code_model.has_external_type %}
+
+    # Check if there's a custom serializer for the type
+    custom_serializer = TYPE_HANDLER_REGISTRY.get_serializer(o)
+    if custom_serializer:
+        return custom_serializer(o)
+
+    {% endif %}
     return o
 
 
@@ -636,6 +662,12 @@ class Model(_MyMutableMapping):
                 if not rf._rest_name_input:
                     rf._rest_name_input = attr
             cls._attr_to_rest_field: dict[str, _RestField] = dict(attr_to_rest_field.items())
+            {% if code_model.has_padded_model_property %}
+            cls._backcompat_attr_to_rest_field: dict[str, _RestField] = {
+                Model._get_backcompat_attribute_name(cls._attr_to_rest_field, attr): rf for attr, rf in cls
+                ._attr_to_rest_field.items()
+            }
+            {% endif %}
             cls._calculated.add(f"{cls.__module__}.{cls.__qualname__}")
 
         return super().__new__(cls)
@@ -645,6 +677,18 @@ class Model(_MyMutableMapping):
             if hasattr(base, "__mapping__"):
                 base.__mapping__[discriminator or cls.__name__] = cls  # type: ignore
 
+    {% if code_model.has_padded_model_property %}
+    @classmethod
+    def _get_backcompat_attribute_name(cls, attr_to_rest_field: dict[str, "_RestField"], attr_name: str) -> str:
+        rest_field_obj = attr_to_rest_field.get(attr_name)  # pylint: disable=protected-access
+        if rest_field_obj is None:
+            return attr_name
+        original_tsp_name = getattr(rest_field_obj, "_original_tsp_name", None)  # pylint: disable=protected-access
+        if original_tsp_name:
+            return original_tsp_name
+        return attr_name
+    {% endif %}
+
     @classmethod
     def _get_discriminator(cls, exist_discriminators) -> typing.Optional["_RestField"]:
         for v in cls.__dict__.values():
@@ -971,6 +1015,9 @@ def _failsafe_deserialize_xml(
       return None
 
 
+{% if code_model.has_padded_model_property %}
+# pylint: disable=too-many-instance-attributes
+{% endif %}
 class _RestField:
     def __init__(
         self,
@@ -983,6 +1030,9 @@ class _RestField:
         format: typing.Optional[str] = None,
         is_multipart_file_input: bool = False,
         xml: typing.Optional[dict[str, typing.Any]] = None,
+        {% if code_model.has_padded_model_property %}
+        original_tsp_name: typing.Optional[str] = None,
+        {% endif %}
     ):
         self._type = type
         self._rest_name_input = name
@@ -994,10 +1044,17 @@ class _RestField:
         self._format = format
         self._is_multipart_file_input = is_multipart_file_input
         self._xml = xml if xml is not None else {}
+        {% if code_model.has_padded_model_property %}
+        self._original_tsp_name = original_tsp_name
+        {% endif %}
 
     @property
     def _class_type(self) -> typing.Any:
-        return getattr(self._type, "args", [None])[0]
+        result = getattr(self._type, "args", [None])[0]
+        # type may be wrapped by nested functools.partial so we need to check for that
+        if isinstance(result, functools.partial):
+            return getattr(result, "args", [None])[0]
+        return result
 
     @property
     def _rest_name(self) -> str:
@@ -1045,6 +1102,9 @@ def rest_field(
     format: typing.Optional[str] = None,
     is_multipart_file_input: bool = False,
     xml: typing.Optional[dict[str, typing.Any]] = None,
+    {% if code_model.has_padded_model_property %}
+    original_tsp_name: typing.Optional[str] = None,
+    {% endif %}
 ) -> typing.Any:
     return _RestField(
         name=name,
@@ -1054,6 +1114,9 @@ def rest_field(
         format=format,
         is_multipart_file_input=is_multipart_file_input,
         xml=xml,
+        {% if code_model.has_padded_model_property %}
+        original_tsp_name=original_tsp_name,
+        {% endif %}
     )
 
 

package/generator/pygen/codegen/templates/packaging_templates/pyproject.toml.jinja2

@@ -56,6 +56,9 @@ dependencies = [
     "{{ dep }}",
     {% endfor %}
     {% endif %}
+    {% for dep in ADDITIONAL_DEPENDENCIES %}
+    "{{ dep }}",
+    {% endfor %}
 ]
 dynamic = [
     {% if options.get('package-mode') %}"version", {% endif %}"readme"

package/generator/pygen/codegen/templates/packaging_templates/setup.py.jinja2

@@ -108,6 +108,9 @@ setup(
         "corehttp[requests]>={{ VERSION_MAP["corehttp"] }}",
         {% endif %}
         "typing-extensions>={{ VERSION_MAP['typing-extensions'] }}",
+        {% for dep in ADDITIONAL_DEPENDENCIES %}
+        {{ dep }},
+        {% endfor %}
     ],
     {% if options["package-mode"] %}
     python_requires=">={{  MIN_PYTHON_VERSION }}",

package/generator/pygen/codegen/templates/utils.py.jinja2

@@ -78,9 +78,8 @@ def serialize_multipart_data_entry(data_entry: Any) -> Any:
 
 def prepare_multipart_form_data(
     body: Mapping[str, Any], multipart_fields: list[str], data_fields: list[str]
-) -> tuple[list[FileType], dict[str, Any]]:
+) -> list[FileType]:
     files: list[FileType] = []
-    data: dict[str, Any] = {}
     for multipart_field in multipart_fields:
         multipart_entry = body.get(multipart_field)
         if isinstance(multipart_entry, list):
@@ -88,10 +87,12 @@ def prepare_multipart_form_data(
         elif multipart_entry:
             files.append((multipart_field, multipart_entry))
 
+    # if files is empty, sdk core library can't handle multipart/form-data correctly, so
+    # we put data fields into files with filename as None to avoid that scenario.
     for data_field in data_fields:
         data_entry = body.get(data_field)
         if data_entry:
-            data[data_field] = serialize_multipart_data_entry(data_entry)
+            files.append((data_field, str(serialize_multipart_data_entry(data_entry))))
 
-    return files, data
+    return files
 {% endif %}

package/generator/pygen/preprocess/__init__.py

@@ -236,7 +236,7 @@ class PreProcessPlugin(YamlUpdatePlugin):
                     body_parameter["type"]["types"].insert(1, any_obj_list_or_dict)
             code_model["types"].append(body_parameter["type"])
 
-    def pad_reserved_words(self, name: str, pad_type: PadType):
+    def pad_reserved_words(self, name: str, pad_type: PadType, yaml_type: dict[str, Any]) -> str:
         # we want to pad hidden variables as well
         if not name:
             # we'll pass in empty operation groups sometime etc.
@@ -250,6 +250,10 @@ class PreProcessPlugin(YamlUpdatePlugin):
         name_prefix = "_" if name[0] == "_" else ""
         name = name[1:] if name[0] == "_" else name
         if name.lower() in reserved_words[pad_type]:
+            if self.is_tsp and name.lower() in TSP_RESERVED_WORDS.get(pad_type, []):
+                # to maintain backcompat for cases where we pad in tsp but not in autorest,
+                # if we have a tsp reserved word, we also want to keep track of the original name for backcompat
+                yaml_type["originalTspName"] = name_prefix + name
             return name_prefix + name + pad_type
         return name_prefix + name
 
@@ -257,11 +261,13 @@ class PreProcessPlugin(YamlUpdatePlugin):
         for type in yaml_data:
             for property in type.get("properties", []):
                 property["description"] = update_description(property.get("description", ""))
-                property["clientName"] = self.pad_reserved_words(property["clientName"].lower(), PadType.PROPERTY)
+                property["clientName"] = self.pad_reserved_words(
+                    property["clientName"].lower(), PadType.PROPERTY, property
+                )
                 add_redefined_builtin_info(property["clientName"], property)
             if type.get("name"):
                 pad_type = PadType.MODEL if type["type"] == "model" else PadType.ENUM_CLASS
-                name = self.pad_reserved_words(type["name"], pad_type)
+                name = self.pad_reserved_words(type["name"], pad_type, type)
                 type["name"] = name[0].upper() + name[1:]
                 type["description"] = update_description(type.get("description", ""), type["name"])
                 type["snakeCaseName"] = to_snake_case(type["name"])
@@ -269,7 +275,7 @@ class PreProcessPlugin(YamlUpdatePlugin):
                 # we're enums
                 values_to_add = []
                 for value in type["values"]:
-                    padded_name = self.pad_reserved_words(value["name"].lower(), PadType.ENUM_VALUE).upper()
+                    padded_name = self.pad_reserved_words(value["name"].lower(), PadType.ENUM_VALUE, value).upper()
                     if self.version_tolerant:
                         if padded_name[0] in "0123456789":
                             padded_name = "ENUM_" + padded_name
@@ -364,12 +370,14 @@ class PreProcessPlugin(YamlUpdatePlugin):
     def update_parameter(self, yaml_data: dict[str, Any]) -> None:
         yaml_data["description"] = update_description(yaml_data.get("description", ""))
         if not (yaml_data["location"] == "header" and yaml_data["clientName"] in ("content_type", "accept")):
-            yaml_data["clientName"] = self.pad_reserved_words(yaml_data["clientName"].lower(), PadType.PARAMETER)
+            yaml_data["clientName"] = self.pad_reserved_words(
+                yaml_data["clientName"].lower(), PadType.PARAMETER, yaml_data
+            )
         if yaml_data.get("propertyToParameterName"):
             # need to create a new one with padded keys and values
             yaml_data["propertyToParameterName"] = {
-                self.pad_reserved_words(prop, PadType.PROPERTY): self.pad_reserved_words(
-                    param_name, PadType.PARAMETER
+                self.pad_reserved_words(prop, PadType.PROPERTY, yaml_data): self.pad_reserved_words(
+                    param_name, PadType.PARAMETER, yaml_data
                 ).lower()
                 for prop, param_name in yaml_data["propertyToParameterName"].items()
             }
@@ -390,15 +398,17 @@ class PreProcessPlugin(YamlUpdatePlugin):
         *,
         is_overload: bool = False,
     ) -> None:
-        yaml_data["groupName"] = self.pad_reserved_words(yaml_data["groupName"], PadType.OPERATION_GROUP)
+        yaml_data["groupName"] = self.pad_reserved_words(yaml_data["groupName"], PadType.OPERATION_GROUP, yaml_data)
         yaml_data["groupName"] = to_snake_case(yaml_data["groupName"])
         yaml_data["name"] = yaml_data["name"].lower()
         if yaml_data.get("isLroInitialOperation") is True:
             yaml_data["name"] = (
-                "_" + self.pad_reserved_words(extract_original_name(yaml_data["name"]), PadType.METHOD) + "_initial"
+                "_"
+                + self.pad_reserved_words(extract_original_name(yaml_data["name"]), PadType.METHOD, yaml_data)
+                + "_initial"
             )
         else:
-            yaml_data["name"] = self.pad_reserved_words(yaml_data["name"], PadType.METHOD)
+            yaml_data["name"] = self.pad_reserved_words(yaml_data["name"], PadType.METHOD, yaml_data)
         yaml_data["description"] = update_description(yaml_data["description"], yaml_data["name"])
         yaml_data["summary"] = update_description(yaml_data.get("summary", ""))
         body_parameter = yaml_data.get("bodyParameter")
@@ -485,7 +495,7 @@ class PreProcessPlugin(YamlUpdatePlugin):
         item_type = item_type or yaml_data["itemType"]["elementType"]
         if yaml_data.get("nextOperation"):
             yaml_data["nextOperation"]["groupName"] = self.pad_reserved_words(
-                yaml_data["nextOperation"]["groupName"], PadType.OPERATION_GROUP
+                yaml_data["nextOperation"]["groupName"], PadType.OPERATION_GROUP, yaml_data["nextOperation"]
             )
             yaml_data["nextOperation"]["groupName"] = to_snake_case(yaml_data["nextOperation"]["groupName"])
             for response in yaml_data["nextOperation"].get("responses", []):
@@ -503,10 +513,11 @@ class PreProcessPlugin(YamlUpdatePlugin):
             operation_group["identifyName"] = self.pad_reserved_words(
                 operation_group.get("name", operation_group["propertyName"]),
                 PadType.OPERATION_GROUP,
+                operation_group,
             )
             operation_group["identifyName"] = to_snake_case(operation_group["identifyName"])
             operation_group["propertyName"] = self.pad_reserved_words(
-                operation_group["propertyName"], PadType.OPERATION_GROUP
+                operation_group["propertyName"], PadType.OPERATION_GROUP, operation_group
             )
             operation_group["propertyName"] = to_snake_case(operation_group["propertyName"])
             operation_group["className"] = update_operation_group_class_name(

package/generator/test/azure/mock_api_tests/test_model_base_flatten_compatibility.py

@@ -0,0 +1,251 @@
+# ------------------------------------
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+# ------------------------------------
+import datetime
+from typing import (
+    Any,
+    Mapping,
+    Optional,
+    overload,
+)
+
+from specs.azure.clientgenerator.core.flattenproperty._utils.model_base import (
+    Model,
+    rest_field,
+)
+from azure.core.serialization import attribute_list
+
+
+class ModelProperty(Model):
+    """This is a test model."""
+
+    value: str = rest_field()
+    """Required."""
+
+    @overload
+    def __init__(
+        self,
+        *,
+        value: str,
+    ) -> None: ...
+
+    @overload
+    def __init__(self, mapping: Mapping[str, Any]) -> None:
+        """
+        :param mapping: raw JSON to initialize the model.
+        :type mapping: Mapping[str, Any]
+        """
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
+
+
+class ChildModel(Model):
+    """This is the child model to be flattened.
+
+    :ivar description: Required.
+    :vartype description: str
+    :ivar age: Required.
+    :vartype age: int
+    """
+
+    description: str = rest_field()
+    """Required."""
+    age: int = rest_field()
+    """Required."""
+    model_property: "ModelProperty" = rest_field(name="modelProperty")
+    """Required."""
+    datetime_default: datetime.datetime = rest_field(name="datetimeDefault")
+    datetime_rfc3339: datetime.datetime = rest_field(name="datetimeRfc3339", format="rfc3339")
+    datetime_rfc7231: datetime.datetime = rest_field(name="datetimeRfc7231", format="rfc7231")
+    datetime_unix_timestamp: datetime.datetime = rest_field(name="datetimeUnixTimestamp", format="unix-timestamp")
+
+    @overload
+    def __init__(
+        self,
+        *,
+        description: str,
+        age: int,
+        model_property: "ModelProperty",
+        datetime_default: datetime.datetime,
+        datetime_rfc3339: datetime.datetime,
+        datetime_rfc7231: datetime.datetime,
+        datetime_unix_timestamp: datetime.datetime,
+    ) -> None: ...
+
+    @overload
+    def __init__(self, mapping: Mapping[str, Any]) -> None:
+        """
+        :param mapping: raw JSON to initialize the model.
+        :type mapping: Mapping[str, Any]
+        """
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
+
+
+class FlattenModel(Model):
+    """This is the model with one level of flattening."""
+
+    name: str = rest_field()
+    """Required."""
+    properties: "ChildModel" = rest_field()
+    """Required."""
+
+    __flattened_items = [
+        "description",
+        "age",
+        "model_property",
+        "datetime_default",
+        "datetime_rfc3339",
+        "datetime_rfc7231",
+        "datetime_unix_timestamp",
+    ]
+
+    @overload
+    def __init__(
+        self,
+        *,
+        name: str,
+        properties: "ChildModel",
+    ) -> None: ...
+
+    @overload
+    def __init__(self, mapping: Mapping[str, Any]) -> None:
+        """
+        :param mapping: raw JSON to initialize the model.
+        :type mapping: Mapping[str, Any]
+        """
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        _flattened_input = {k: kwargs.pop(k) for k in kwargs.keys() & self.__flattened_items}
+        super().__init__(*args, **kwargs)
+        for k, v in _flattened_input.items():
+            setattr(self, k, v)
+
+    def __getattr__(self, name: str) -> Any:
+        if name in self.__flattened_items:
+            if self.properties is None:
+                return None
+            return getattr(self.properties, name)
+        raise AttributeError(f"'{self.__class__.__name__}' object has no attribute '{name}'")
+
+    def __setattr__(self, key: str, value: Any) -> None:
+        if key in self.__flattened_items:
+            if self.properties is None:
+                self.properties = self._attr_to_rest_field["properties"]._class_type()
+            setattr(self.properties, key, value)
+        else:
+            super().__setattr__(key, value)
+
+
+def test_model_initialization():
+    model = FlattenModel(
+        name="test",
+        description="a description",
+        age=30,
+        model_property=ModelProperty(value="test value"),
+        datetime_default=datetime.datetime(2023, 1, 12, 0, 0, 0, tzinfo=datetime.timezone.utc),
+        datetime_rfc3339=datetime.datetime(2023, 1, 12, 0, 0, 0, tzinfo=datetime.timezone.utc),
+        datetime_rfc7231=datetime.datetime(2023, 1, 12, 0, 0, 0, tzinfo=datetime.timezone.utc),
+        datetime_unix_timestamp=datetime.datetime(2023, 1, 12, 0, 0, 0, tzinfo=datetime.timezone.utc),
+    )
+
+    assert model.name == "test"
+
+    assert model.description == "a description"
+    assert model.properties.description == "a description"
+
+    assert model.age == 30
+    assert model.properties.age == 30
+
+    assert model.model_property.value == "test value"
+    assert model.properties.model_property == ModelProperty(value="test value")
+    assert model.properties.model_property.value == "test value"
+
+    assert model.datetime_default == datetime.datetime(2023, 1, 12, 0, 0, 0, tzinfo=datetime.timezone.utc)
+    assert model.properties.datetime_default == datetime.datetime(2023, 1, 12, 0, 0, 0, tzinfo=datetime.timezone.utc)
+    assert model.properties["datetimeDefault"] == "2023-01-12T00:00:00Z"
+
+    assert model.datetime_rfc3339 == datetime.datetime(2023, 1, 12, 0, 0, 0, tzinfo=datetime.timezone.utc)
+    assert model.properties.datetime_rfc3339 == datetime.datetime(2023, 1, 12, 0, 0, 0, tzinfo=datetime.timezone.utc)
+    assert model.properties["datetimeRfc3339"] == "2023-01-12T00:00:00Z"
+
+    assert model.datetime_rfc7231 == datetime.datetime(2023, 1, 12, 0, 0, 0, tzinfo=datetime.timezone.utc)
+    assert model.properties.datetime_rfc7231 == datetime.datetime(2023, 1, 12, 0, 0, 0, tzinfo=datetime.timezone.utc)
+    assert model.properties["datetimeRfc7231"] == "Thu, 12 Jan 2023 00:00:00 GMT"
+
+    assert model.datetime_unix_timestamp == datetime.datetime(2023, 1, 12, 0, 0, 0, tzinfo=datetime.timezone.utc)
+    assert model.properties.datetime_unix_timestamp == datetime.datetime(
+        2023, 1, 12, 0, 0, 0, tzinfo=datetime.timezone.utc
+    )
+    assert model.properties["datetimeUnixTimestamp"] == 1673481600
+
+
+class FlattenModelWithOptionalProperties(Model):
+    """This is the model with one level of flattening and optional properties."""
+
+    name: str = rest_field()
+    """Required."""
+    properties: Optional["ModelProperty"] = rest_field()
+    """Optional."""
+
+    __flattened_items = ["value"]
+
+    @overload
+    def __init__(
+        self,
+        *,
+        name: str,
+        properties: Optional["ModelProperty"],
+    ) -> None: ...
+
+    @overload
+    def __init__(self, mapping: Mapping[str, Any]) -> None:
+        """
+        :param mapping: raw JSON to initialize the model.
+        :type mapping: Mapping[str, Any]
+        """
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        _flattened_input = {k: kwargs.pop(k) for k in kwargs.keys() & self.__flattened_items}
+        super().__init__(*args, **kwargs)
+        for k, v in _flattened_input.items():
+            setattr(self, k, v)
+
+    def __getattr__(self, name: str) -> Any:
+        if name in self.__flattened_items:
+            if self.properties is None:
+                return None
+            return getattr(self.properties, name)
+        raise AttributeError(f"'{self.__class__.__name__}' object has no attribute '{name}'")
+
+    def __setattr__(self, key: str, value: Any) -> None:
+        if key in self.__flattened_items:
+            if self.properties is None:
+                self.properties = self._attr_to_rest_field["properties"]._class_type()
+            setattr(self.properties, key, value)
+        else:
+            super().__setattr__(key, value)
+
+
+def test_model_with_optional_properties_initialization():
+    model = FlattenModelWithOptionalProperties(
+        name="test",
+        value="test value",
+    )
+
+    assert model.name == "test"
+
+    assert model.value == "test value"
+    assert model.properties.value == "test value"
+
+
+def test_model_with_optional_properties_attribute_list():
+    model = FlattenModelWithOptionalProperties(
+        name="test",
+    )
+
+    attrs = attribute_list(model)
+    assert sorted(attrs) == sorted(["name", "value"])

package/generator/test/azure/requirements.txt

@@ -14,6 +14,7 @@ azure-mgmt-core==1.6.0
 -e ./generated/azure-client-generator-core-usage
 -e ./generated/azure-client-generator-core-override
 -e ./generated/azure-client-generator-core-client-location
+-e ./generated/azure-client-generator-core-alternate-type
 -e ./generated/azure-client-generator-core-next-link-verb
 -e ./generated/azure-core-basic
 -e ./generated/azure-core-scalar
@@ -53,6 +54,7 @@ azure-mgmt-core==1.6.0
 -e ./generated/setuppy-authentication-union
 -e ./generated/encode-duration
 -e ./generated/encode-numeric
+-e ./generated/encode-array
 -e ./generated/parameters-basic
 -e ./generated/parameters-collection-format
 -e ./generated/parameters-path

package/generator/test/unbranded/requirements.txt

@@ -9,6 +9,7 @@
 -e ./generated/setuppy-authentication-union
 -e ./generated/encode-duration
 -e ./generated/encode-numeric
+-e ./generated/encode-array
 -e ./generated/parameters-basic
 -e ./generated/parameters-collection-format
 -e ./generated/parameters-path