@autorest/python 6.9.2 → 6.9.3

package/autorest/_utils.py

@@ -8,6 +8,19 @@ import re
 import argparse
 
 
+def update_enum_value(
+    name: str, value: Any, description: str, enum_type: Dict[str, Any]
+) -> Dict[str, Any]:
+    return {
+        "name": name,
+        "type": "enumvalue",
+        "value": value,
+        "description": description,
+        "enumType": enum_type,
+        "valueType": enum_type["valueType"],
+    }
+
+
 def to_snake_case(name: str) -> str:
     def replace_upper_characters(m) -> str:
         match_str = m.group().lower()

package/autorest/codegen/models/__init__.py

@@ -4,7 +4,7 @@
 # license information.
 # --------------------------------------------------------------------------
 import logging
-from typing import Any, Dict, Union
+from typing import Any, Dict, Union, Optional
 from .base import BaseModel
 from .base_builder import BaseBuilder, ParameterListType
 from .code_model import CodeModel
@@ -30,7 +30,7 @@ from .primitive_types import (
     UnixTimeType,
     AzureCoreType,
 )
-from .enum_type import EnumType
+from .enum_type import EnumType, EnumValue
 from .base import BaseType
 from .constant_type import ConstantType
 from .imports import FileImport, ImportType, TypingSection
@@ -86,6 +86,7 @@ __all__ = [
     "DictionaryType",
     "ListType",
     "EnumType",
+    "EnumValue",
     "FileImport",
     "ImportType",
     "TypingSection",
@@ -128,6 +129,7 @@ TYPE_TO_OBJECT = {
     "dict": DictionaryType,
     "constant": ConstantType,
     "enum": EnumType,
+    "enumvalue": EnumValue,
     "binary": BinaryType,
     "any": AnyType,
     "datetime": DatetimeType,
@@ -157,6 +159,7 @@ def build_type(yaml_data: Dict[str, Any], code_model: CodeModel) -> BaseType:
     except KeyError:
         # Not created yet, let's create it and add it to the index
         pass
+    response: Optional[BaseType] = None
     if yaml_data["type"] == "model":
         # need to special case model to avoid recursion
         if yaml_data["base"] == "json" or not code_model.options["models_mode"]:
@@ -168,6 +171,16 @@ def build_type(yaml_data: Dict[str, Any], code_model: CodeModel) -> BaseType:
         response = model_type(yaml_data, code_model)
         code_model.types_map[yaml_id] = response
         response.fill_instance_from_yaml(yaml_data, code_model)
+    elif yaml_data["type"] == "enum":
+        # avoid recursion because we add the parent enum type to the enum value
+        response = EnumType(
+            yaml_data,
+            code_model,
+            values=[],
+            value_type=build_type(yaml_data["valueType"], code_model),
+        )
+        code_model.types_map[yaml_id] = response
+        response.fill_instance_from_yaml(yaml_data, code_model)
     else:
         object_type = yaml_data.get("type")
         if object_type not in TYPE_TO_OBJECT:
@@ -177,6 +190,8 @@ def build_type(yaml_data: Dict[str, Any], code_model: CodeModel) -> BaseType:
             )
             object_type = "string"
         response = TYPE_TO_OBJECT[object_type].from_yaml(yaml_data, code_model)  # type: ignore
+    if response is None:
+        raise ValueError("response can not be None")
     code_model.types_map[yaml_id] = response
     return response
 

package/autorest/codegen/models/constant_type.py

@@ -6,7 +6,7 @@
 import logging
 from typing import Dict, Any, Optional, TYPE_CHECKING
 from .base import BaseType
-from .imports import FileImport, ImportType, TypingSection
+from .imports import FileImport
 from .primitive_types import IntegerType, BinaryType, StringType, BooleanType
 from .utils import add_to_description
 
@@ -134,21 +134,7 @@ class ConstantType(BaseType):
     def imports(self, **kwargs: Any) -> FileImport:
         file_import = self._imports_shared(**kwargs)
         if self._is_literal:
-            file_import.add_import("sys", ImportType.STDLIB)
-            file_import.add_submodule_import(
-                "typing_extensions",
-                "Literal",
-                ImportType.BYVERSION,
-                TypingSection.REGULAR,
-                None,
-                (
-                    (
-                        (3, 8),
-                        "typing",
-                        "pylint: disable=no-name-in-module, ungrouped-imports",
-                    ),
-                ),
-            )
+            file_import.add_literal_import()
         return file_import
 
     @property

package/autorest/codegen/models/enum_type.py

@@ -3,17 +3,16 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
-from typing import Any, Dict, List, TYPE_CHECKING, Optional
+from typing import Any, Dict, List, TYPE_CHECKING, Optional, cast
 
 from .base import BaseType
 from .imports import FileImport, ImportType, TypingSection
-from .base import BaseModel
 
 if TYPE_CHECKING:
     from .code_model import CodeModel
 
 
-class EnumValue(BaseModel):
+class EnumValue(BaseType):
     """Model containing necessary information for a single value of an enum.
 
     :param str name: The name of this enum value
@@ -21,11 +20,70 @@ class EnumValue(BaseModel):
     :param str description: Optional. The description for this enum value
     """
 
-    def __init__(self, yaml_data: Dict[str, Any], code_model: "CodeModel") -> None:
+    def __init__(
+        self,
+        yaml_data: Dict[str, Any],
+        code_model: "CodeModel",
+        enum_type: "EnumType",
+        value_type: BaseType,
+    ) -> None:
         super().__init__(yaml_data=yaml_data, code_model=code_model)
         self.name: str = self.yaml_data["name"]
         self.value: str = self.yaml_data["value"]
-        self.description: Optional[str] = self.yaml_data.get("description")
+        self.enum_type = enum_type
+        self.value_type = value_type
+
+    def description(self, *, is_operation_file: bool) -> str:
+        return self.yaml_data.get("description", "")
+
+    def type_annotation(self, **kwargs: Any) -> str:
+        """The python type used for type annotation"""
+        return f"Literal[{self.enum_type.name}.{self.name}]"
+
+    def get_declaration(self, value=None):
+        return self.enum_type.name + "." + self.name
+
+    def docstring_text(self, **kwargs: Any) -> str:
+        return self.enum_type.name + "." + self.name
+
+    def docstring_type(self, **kwargs: Any) -> str:
+        """The python type used for RST syntax input and type annotation."""
+
+        type_annotation = self.value_type.type_annotation(**kwargs)
+        enum_type_annotation = f"{self.code_model.namespace}.models.{self.name}"
+        return f"{type_annotation} or ~{enum_type_annotation}"
+
+    def get_json_template_representation(
+        self,
+        *,
+        optional: bool = True,
+        client_default_value_declaration: Optional[str] = None,
+        description: Optional[str] = None,
+    ) -> Any:
+        # for better display effect, use the only value instead of var type
+        return self.value_type.get_json_template_representation(
+            optional=optional,
+            client_default_value_declaration=client_default_value_declaration,
+            description=description,
+        )
+
+    @property
+    def serialization_type(self) -> str:
+        return self.value_type.serialization_type
+
+    @property
+    def instance_check_template(self) -> str:
+        return self.value_type.instance_check_template
+
+    def imports(self, **kwargs: Any) -> FileImport:
+        file_import = FileImport()
+        file_import.merge(self.value_type.imports(**kwargs))
+        file_import.add_literal_import()
+        file_import.add_submodule_import(
+            "._enums", self.enum_type.name, ImportType.LOCAL, TypingSection.REGULAR
+        )
+
+        return file_import
 
     @classmethod
     def from_yaml(
@@ -39,9 +97,14 @@ class EnumValue(BaseModel):
         :return: A created EnumValue
         :rtype: ~autorest.models.EnumValue
         """
+        from . import build_type
+
+        enum_type = cast(EnumType, code_model.lookup_type(id(yaml_data["enumType"])))
         return cls(
             yaml_data=yaml_data,
             code_model=code_model,
+            enum_type=enum_type,
+            value_type=build_type(yaml_data["valueType"], code_model),
         )
 
 
@@ -150,27 +213,19 @@ class EnumType(BaseType):
     def instance_check_template(self) -> str:
         return self.value_type.instance_check_template
 
+    def fill_instance_from_yaml(
+        self, yaml_data: Dict[str, Any], code_model: "CodeModel"
+    ) -> None:
+        for value in yaml_data["values"]:
+            self.values.append(EnumValue.from_yaml(value, code_model))
+
     @classmethod
     def from_yaml(
         cls, yaml_data: Dict[str, Any], code_model: "CodeModel"
     ) -> "EnumType":
-        """Constructs an EnumType from yaml data.
-
-        :param yaml_data: the yaml data from which we will construct this schema
-        :type yaml_data: dict[str, Any]
-
-        :return: A created EnumType
-        :rtype: ~autorest.models.EnumType
-        """
-        from . import build_type
-
-        return cls(
-            yaml_data=yaml_data,
-            code_model=code_model,
-            value_type=build_type(yaml_data["valueType"], code_model),
-            values=[
-                EnumValue.from_yaml(value, code_model) for value in yaml_data["values"]
-            ],
+        raise ValueError(
+            "You shouldn't call from_yaml for EnumType to avoid recursion. "
+            "Please initial a blank EnumType, then call .fill_instance_from_yaml on the created type."
         )
 
     def imports(self, **kwargs: Any) -> FileImport:

package/autorest/codegen/models/imports.py

@@ -183,6 +183,23 @@ class FileImport:
         )
         self.add_submodule_import("typing", "Any", ImportType.STDLIB)
 
+    def add_literal_import(self) -> None:
+        self.add_import("sys", ImportType.STDLIB)
+        self.add_submodule_import(
+            "typing_extensions",
+            "Literal",
+            ImportType.BYVERSION,
+            TypingSection.REGULAR,
+            None,
+            (
+                (
+                    (3, 8),
+                    "typing",
+                    "pylint: disable=no-name-in-module, ungrouped-imports",
+                ),
+            ),
+        )
+
     def to_dict(
         self,
     ) -> Dict[

package/autorest/codegen/models/parameter.py

@@ -92,6 +92,9 @@ class _ParameterBase(
         )
         self.hide_in_method: bool = self.yaml_data.get("hideInMethod", False)
 
+    def get_declaration(self, value: Any = None) -> Any:
+        return self.type.get_declaration(value)
+
     @property
     def hide_in_operation_signature(self) -> bool:
         return False
@@ -115,7 +118,7 @@ class _ParameterBase(
         if self.optional and isinstance(self.type, ConstantType):
             base_description = add_to_description(
                 base_description,
-                f"Known values are {self.type.get_declaration()} and None.",
+                f"Known values are {self.get_declaration()} and None.",
             )
         if not (self.optional or self.client_default_value):
             base_description = add_to_description(base_description, "Required.")
@@ -141,7 +144,7 @@ class _ParameterBase(
         """Declaration of parameter's client default value"""
         if self.client_default_value is None:
             return None
-        return self.type.get_declaration(self.client_default_value)
+        return self.get_declaration(self.client_default_value)
 
     def type_annotation(self, **kwargs: Any) -> str:
         kwargs["is_operation_file"] = True

package/autorest/codegen/models/property.py

@@ -7,6 +7,7 @@ from typing import Any, Dict, Optional, TYPE_CHECKING, List
 
 from .base import BaseModel
 from .constant_type import ConstantType
+from .enum_type import EnumType
 from .base import BaseType
 from .imports import FileImport, ImportType
 from .utils import add_to_description, add_to_pylint_disable
@@ -61,9 +62,9 @@ class Property(BaseModel):  # pylint: disable=too-many-instance-attributes
     @property
     def client_default_value_declaration(self) -> str:
         if self.client_default_value is not None:
-            return self.type.get_declaration(self.client_default_value)
+            return self.get_declaration(self.client_default_value)
         if self.type.client_default_value is not None:
-            return self.type.get_declaration(self.type.client_default_value)
+            return self.get_declaration(self.type.client_default_value)
         return "None"
 
     @property
@@ -88,11 +89,24 @@ class Property(BaseModel):  # pylint: disable=too-many-instance-attributes
     def msrest_deserialization_key(self) -> str:
         return self.type.msrest_deserialization_key
 
+    @property
+    def is_enum_discriminator(self) -> bool:
+        return self.is_discriminator and self.type.type == "enum"
+
     def type_annotation(self, *, is_operation_file: bool = False) -> str:
+        if self.is_enum_discriminator:
+            # here we are the enum discriminator property on the base model
+            return "Literal[None]"
         if self.optional and self.client_default_value is None:
             return f"Optional[{self.type.type_annotation(is_operation_file=is_operation_file)}]"
         return self.type.type_annotation(is_operation_file=is_operation_file)
 
+    def get_declaration(self, value: Any = None) -> Any:
+        if self.is_enum_discriminator:
+            # here we are the enum discriminator property on the base model
+            return None
+        return self.type.get_declaration(value)
+
     def get_json_template_representation(
         self,
         *,
@@ -101,7 +115,7 @@ class Property(BaseModel):  # pylint: disable=too-many-instance-attributes
         description: Optional[str] = None,
     ) -> Any:
         if self.client_default_value:
-            client_default_value_declaration = self.type.get_declaration(
+            client_default_value_declaration = self.get_declaration(
                 self.client_default_value
             )
         if self.description(is_operation_file=True):
@@ -131,7 +145,12 @@ class Property(BaseModel):  # pylint: disable=too-many-instance-attributes
         return retval or None
 
     def imports(self, **kwargs) -> FileImport:
-        file_import = self.type.imports(**kwargs, relative_path="..", model_typing=True)
+        file_import = FileImport()
+        if self.is_discriminator and isinstance(self.type, EnumType):
+            return file_import
+        file_import.merge(
+            self.type.imports(**kwargs, relative_path="..", model_typing=True)
+        )
         if self.optional and self.client_default_value is None:
             file_import.add_submodule_import("typing", "Optional", ImportType.STDLIB)
         if self.code_model.options["models_mode"] == "dpg":

package/autorest/codegen/serializers/builder_serializer.py

@@ -26,7 +26,6 @@ from ..models import (
     ParameterMethodLocation,
     RequestBuilderBodyParameter,
     OverloadedRequestBuilder,
-    ConstantType,
     MultipartBodyParameter,
     Property,
     RequestBuilderType,
@@ -458,15 +457,16 @@ class RequestBuilderSerializer(
     @staticmethod
     def declare_non_inputtable_constants(builder: RequestBuilderType) -> List[str]:
         def _get_value(param):
-            param_type = cast(ConstantType, param.type)
             if param.location in [ParameterLocation.HEADER, ParameterLocation.QUERY]:
                 kwarg_dict = (
                     "headers"
                     if param.location == ParameterLocation.HEADER
                     else "params"
                 )
-                return f"_{kwarg_dict}.pop('{param.wire_name}', {param_type.get_declaration()})"
-            return f"{param_type.get_declaration()}"
+                return (
+                    f"_{kwarg_dict}.pop('{param.wire_name}', {param.get_declaration()})"
+                )
+            return f"{param.get_declaration()}"
 
         return [
             f"{p.client_name} = {_get_value(p)}"
@@ -645,7 +645,7 @@ class _OperationSerializer(
             f"_stream = {stream_value}",
             f"pipeline_response: PipelineResponse = {self._call_method}self._client._pipeline.run(  "
             + f"{'# type: ignore' if type_ignore else ''} # pylint: disable=protected-access",
-            "    request,",
+            "    _request,",
             "    stream=_stream,",
             "    **kwargs",
             ")",
@@ -915,7 +915,7 @@ class _OperationSerializer(
                 ("_" + group_name) if group_name else "",
                 request_builder.name,
             )
-        retval.append(f"request = {request_path_name}(")
+        retval.append(f"_request = {request_path_name}(")
         for parameter in request_builder.parameters.method:
             if parameter.location == ParameterLocation.BODY:
                 # going to pass in body later based off of overloads
@@ -979,14 +979,14 @@ class _OperationSerializer(
                 and builder.parameters.body_parameter.client_name == "files"
             ):
                 pass_files = ", _files"
-            retval.append(f"request = _convert_request(request{pass_files})")
+            retval.append(f"_request = _convert_request(_request{pass_files})")
         if builder.parameters.path:
             retval.extend(self.serialize_path(builder))
-        url_to_format = "request.url"
+        url_to_format = "_request.url"
         if self.code_model.options["version_tolerant"] and template_url:
             url_to_format = template_url
         retval.append(
-            "request.url = self._client.format_url({}{})".format(
+            "_request.url = self._client.format_url({}{})".format(
                 url_to_format,
                 ", **path_format_arguments" if builder.parameters.path else "",
             )
@@ -1168,31 +1168,16 @@ class _OperationSerializer(
                     )
                 )
                 retval.append("")
-        type_ignore = (
-            builder.has_response_body
-            and not builder.has_optional_return_type
-            and not (
-                self.code_model.options["models_mode"] == "msrest"
-                and any(not resp.is_stream_response for resp in builder.responses)
-            )
-        )
         if builder.has_optional_return_type or self.code_model.options["models_mode"]:
             deserialized = "deserialized"
         else:
             deserialized = f"cast({builder.response_type_annotation(async_mode=self.async_mode)}, deserialized)"
-            type_ignore = False
-        if (
-            not builder.has_optional_return_type
-            and len(builder.responses) > 1
-            and any(resp.is_stream_response or resp.type for resp in builder.responses)
-        ):
-            type_ignore = True
         retval.append("if cls:")
         retval.append(
             "    return cls(pipeline_response, {}, {}){}".format(
                 deserialized if builder.has_response_body else "None",
                 "response_headers" if builder.any_response_has_headers else "{}",
-                " # type: ignore" if type_ignore else "",
+                " # type: ignore",
             )
         )
         if builder.has_response_body and any(
@@ -1200,9 +1185,7 @@ class _OperationSerializer(
             for response in builder.responses
         ):
             retval.append("")
-            retval.append(
-                f"return {deserialized}{' # type: ignore' if type_ignore else ''}"
-            )
+            retval.append(f"return {deserialized}  # type: ignore")
         if (
             builder.request_builder.method == "HEAD"
             and self.code_model.options["head_as_boolean"]
@@ -1370,8 +1353,8 @@ class _PagingOperationSerializer(
         except StopIteration:
             pass
 
-        retval.append(f'request = HttpRequest("GET", {next_link_str}{query_str})')
-        retval.extend(self._postprocess_http_request(builder, "request.url"))
+        retval.append(f'_request = HttpRequest("GET", {next_link_str}{query_str})')
+        retval.extend(self._postprocess_http_request(builder, "_request.url"))
 
         return retval
 
@@ -1391,10 +1374,10 @@ class _PagingOperationSerializer(
             [f"        {line}" for line in self.call_next_link_request_builder(builder)]
         )
         if not builder.next_request_builder and self.code_model.is_legacy:
-            retval.append('        request.method = "GET"')
+            retval.append('        _request.method = "GET"')
         else:
             retval.append("")
-        retval.append("    return request")
+        retval.append("    return _request")
         return retval
 
     @property
@@ -1453,7 +1436,7 @@ class _PagingOperationSerializer(
 
     def _get_next_callback(self, builder: PagingOperationType) -> List[str]:
         retval = [f"{'async ' if self.async_mode else ''}def get_next(next_link=None):"]
-        retval.append("    request = prepare_request(next_link)")
+        retval.append("    _request = prepare_request(next_link)")
         retval.append("")
         retval.extend([f"    {l}" for l in self.make_pipeline_call(builder)])
         retval.append("    response = pipeline_response.http_response")
@@ -1626,11 +1609,7 @@ class _LROOperationSerializer(_OperationSerializer[LROOperationType]):
                 "response_headers"
                 if builder.lro_response and builder.lro_response.headers
                 else "{}",
-                " # type: ignore"
-                if builder.lro_response
-                and builder.lro_response.type
-                and self.code_model.options["models_mode"] != "msrest"
-                else "",
+                " # type: ignore",
             )
         )
         if builder.lro_response and builder.lro_response.type:

package/autorest/codegen/serializers/model_serializer.py

@@ -3,14 +3,13 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
-from typing import List, cast
+from typing import List
 from abc import ABC, abstractmethod
 
 from jinja2 import Environment
-from ..models import ModelType, CodeModel, Property
+from ..models import ModelType, CodeModel, Property, ConstantType, EnumValue
 from ..models.imports import FileImport, TypingSection, MsrestImportType, ImportType
 from .import_serializer import FileImportSerializer
-from ..models.constant_type import ConstantType
 
 
 def _documentation_string(
@@ -266,8 +265,8 @@ class DpgModelSerializer(_ModelSerializer):
         field = "rest_discriminator" if prop.is_discriminator else "rest_field"
         type_ignore = (
             prop.is_discriminator
-            and prop.is_discriminator
-            and cast(ConstantType, prop.type).value
+            and isinstance(prop.type, (ConstantType, EnumValue))
+            and prop.type.value
         )
         return (
             f"{prop.client_name}: {prop.type_annotation()} ="
@@ -280,7 +279,7 @@ class DpgModelSerializer(_ModelSerializer):
             if prop.constant or prop.is_discriminator:
                 init_args.append(
                     f"self.{prop.client_name}: {prop.type_annotation()} = "
-                    f"{cast(ConstantType, prop.type).get_declaration()}"
+                    f"{prop.get_declaration()}"
                 )
         return init_args
 

package/autorest/codegen/templates/client.py.jinja2

@@ -24,7 +24,7 @@
         {% else %}
         request_copy.url = self._client.format_url(request_copy.url)
         {% endif %}
-        return self._client.send_request(request_copy, **kwargs)
+        return self._client.send_request(request_copy, **kwargs)  # type: ignore
 
     {{ keywords.def }} close(self) -> None:
         {{ keywords.await }}self._client.close()

package/autorest/codegen/templates/enum.py.jinja2

@@ -7,7 +7,7 @@ class {{ enum.name }}({{ enum.value_type.type_annotation(is_operation_file=False
 
     {% for value in enum.values %}
     {{ value.name }} = {{ enum.value_type.get_declaration(value.value) }}
-    {% if value.description %}
-    """{{ value.description | wordwrap(width=95, break_long_words=False, break_on_hyphens=False, wrapstring='\n    #: ') }}"""
+    {% if value.description(is_operation_file=False) %}
+    """{{ value.description(is_operation_file=False) | wordwrap(width=95, break_long_words=False, break_on_hyphens=False, wrapstring='\n    #: ') }}"""
     {% endif %}
-    {% endfor %}
+    {% endfor %}

package/autorest/codegen/templates/serialization.py.jinja2

@@ -295,7 +295,7 @@ class Model(object):
     _validation: Dict[str, Dict[str, Any]] = {}
 
     def __init__(self, **kwargs: Any) -> None:
-        self.additional_properties: Dict[str, Any] = {}
+        self.additional_properties: Optional[Dict[str, Any]] = {}
         for k in kwargs:
             if k not in self._attribute_map:
                 _LOGGER.warning("%s is not a known attribute of class %s and will be ignored", k, self.__class__)
@@ -351,7 +351,7 @@ class Model(object):
         :rtype: dict
         """
         serializer = Serializer(self._infer_class_models())
-        return serializer._serialize(self, keep_readonly=keep_readonly, **kwargs)
+        return serializer._serialize(self, keep_readonly=keep_readonly, **kwargs)  # type: ignore
 
     def as_dict(
         self,
@@ -392,7 +392,7 @@ class Model(object):
         :rtype: dict
         """
         serializer = Serializer(self._infer_class_models())
-        return serializer._serialize(self, key_transformer=key_transformer, keep_readonly=keep_readonly, **kwargs)
+        return serializer._serialize(self, key_transformer=key_transformer, keep_readonly=keep_readonly, **kwargs)  # type: ignore
 
     @classmethod
     def _infer_class_models(cls):
@@ -417,7 +417,7 @@ class Model(object):
         :raises: DeserializationError if something went wrong
         """
         deserializer = Deserializer(cls._infer_class_models())
-        return deserializer(cls.__name__, data, content_type=content_type)
+        return deserializer(cls.__name__, data, content_type=content_type)  # type: ignore
 
     @classmethod
     def from_dict(
@@ -447,7 +447,7 @@ class Model(object):
             if key_extractors is None
             else key_extractors
         )
-        return deserializer(cls.__name__, data, content_type=content_type)
+        return deserializer(cls.__name__, data, content_type=content_type)  # type: ignore
 
     @classmethod
     def _flatten_subtype(cls, key, objects):

package/autorest/m4reformatter/__init__.py

@@ -16,6 +16,7 @@ from .._utils import (
     KNOWN_TYPES,
     get_body_type_for_description,
     JSON_REGEXP,
+    update_enum_value,
 )
 from .. import YamlUpdatePluginAutorest
 
@@ -88,24 +89,25 @@ def update_constant(yaml_data: Dict[str, Any]) -> Dict[str, Any]:
     return base
 
 
-def update_enum_value(yaml_data: Dict[str, Any]) -> Dict[str, Any]:
-    return {
-        "name": yaml_data["language"]["default"]["name"],
-        "value": yaml_data["value"],
-        "description": yaml_data["language"]["default"]["description"],
-    }
-
-
 def update_enum(yaml_data: Dict[str, Any]) -> Dict[str, Any]:
     base = _update_type_base("enum", yaml_data)
     base.update(
         {
             "name": yaml_data["language"]["default"]["name"],
             "valueType": update_type(yaml_data["choiceType"]),
-            "values": [update_enum_value(v) for v in yaml_data["choices"]],
+            "values": [],
             "description": yaml_data["language"]["default"]["description"],
         }
     )
+    for v in yaml_data["choices"]:
+        base["values"].append(
+            update_enum_value(
+                name=v["language"]["default"]["name"],
+                value=v["value"],
+                description=v["language"]["default"]["description"],
+                enum_type=base,
+            )
+        )
     return base
 
 

package/autorest/preprocess/__init__.py

@@ -8,7 +8,7 @@
 import copy
 from typing import Callable, Dict, Any, List, Optional
 
-from .._utils import to_snake_case
+from .._utils import to_snake_case, update_enum_value
 from .helpers import (
     add_redefined_builtin_info,
     pad_builtin_namespaces,
@@ -264,11 +264,12 @@ class PreProcessPlugin(YamlUpdatePlugin):  # pylint: disable=abstract-method
                     ).upper()
                     if value["name"] != padded_name:
                         values_to_add.append(
-                            {
-                                "description": value["description"],
-                                "name": padded_name,
-                                "value": value["value"],
-                            }
+                            update_enum_value(
+                                name=padded_name,
+                                value=value["value"],
+                                description=value["description"],
+                                enum_type=value["enumType"],
+                            )
                         )
                 type["values"].extend(values_to_add)
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autorest/python",
-  "version": "6.9.2",
+  "version": "6.9.3",
   "description": "The Python extension for generators in AutoRest.",
   "main": "index.js",
   "repository": {