@autorest/python 6.2.11 → 6.2.15

package/autorest/codegen/models/parameter.py

@@ -4,7 +4,7 @@
 # license information.
 # --------------------------------------------------------------------------
 import abc
-from enum import Enum, auto
+from enum import Enum
 
 from typing import (
     Dict,
@@ -22,6 +22,8 @@ from .base import BaseModel
 from .base import BaseType
 from .constant_type import ConstantType
 from .utils import add_to_description
+from .combined_type import CombinedType
+from .model_type import JSONModelType
 
 if TYPE_CHECKING:
     from .code_model import CodeModel
@@ -37,10 +39,10 @@ class ParameterLocation(str, Enum):
     OTHER = "other"
 
 
-class ParameterMethodLocation(Enum):
-    POSITIONAL = auto()
-    KEYWORD_ONLY = auto()
-    KWARG = auto()
+class ParameterMethodLocation(str, Enum):
+    POSITIONAL = "positional"
+    KEYWORD_ONLY = "keywordOnly"
+    KWARG = "kwarg"
 
 
 class ParameterDelimeter(str, Enum):
@@ -241,6 +243,20 @@ class BodyParameter(_BodyParameterBase):
     def default_content_type(self) -> str:
         return self.yaml_data["defaultContentType"]
 
+    @staticmethod
+    def _has_json_model_type(t: BaseType) -> bool:
+        if isinstance(t, JSONModelType):
+            return True
+        if isinstance(t, CombinedType):
+            for sub_t in t.types:
+                if BodyParameter._has_json_model_type(sub_t):
+                    return True
+        return False
+
+    @property
+    def has_json_model_type(self) -> bool:
+        return BodyParameter._has_json_model_type(self.type)
+
     @classmethod
     def from_yaml(
         cls, yaml_data: Dict[str, Any], code_model: "CodeModel"
@@ -314,6 +330,7 @@ class Parameter(_ParameterBase):
         self.in_overload: bool = self.yaml_data["inOverload"]
         self.in_overriden: bool = self.yaml_data.get("inOverriden", False)
         self.delimiter: Optional[ParameterDelimeter] = self.yaml_data.get("delimiter")
+        self.in_flattened_body: bool = self.yaml_data.get("inFlattenedBody", False)
 
     @property
     def in_method_signature(self) -> bool:
@@ -334,9 +351,13 @@ class Parameter(_ParameterBase):
         return bool(self.rest_api_name) and self.rest_api_name.lower() == "content-type"
 
     @property
-    def method_location(self) -> ParameterMethodLocation:
+    def method_location(  # pylint: disable=too-many-return-statements
+        self,
+    ) -> ParameterMethodLocation:
         if not self.in_method_signature:
             raise ValueError(f"Parameter '{self.client_name}' is not in the method.")
+        if self.code_model.options["models_mode"] == "dpg" and self.in_flattened_body:
+            return ParameterMethodLocation.KEYWORD_ONLY
         if self.grouper:
             return ParameterMethodLocation.POSITIONAL
         if self.constant:

package/autorest/codegen/models/parameter_list.py

@@ -115,7 +115,6 @@ class _ParameterListBase(
     @abstractmethod
     def parameter_creator() -> Callable[[Dict[str, Any], "CodeModel"], ParameterType]:
         """Callable for creating parameters"""
-        ...
 
     @staticmethod
     @abstractmethod
@@ -123,7 +122,6 @@ class _ParameterListBase(
         [Dict[str, Any], "CodeModel"], BodyParameterType
     ]:
         """Callable for creating body parameters"""
-        ...
 
     @property
     def grouped(self) -> List[Union[ParameterType, BodyParameterType]]:
@@ -208,7 +206,6 @@ class _ParameterListBase(
     @abstractmethod
     def implementation(self) -> str:
         """Whether this is a client or a method parameter"""
-        ...
 
     @property
     def unsorted_method_params(self) -> List[Union[ParameterType, BodyParameterType]]:
@@ -339,8 +336,6 @@ class _ParameterList(
 class ParameterList(_ParameterList):
     """ParameterList is the parameter list for Operation classes"""
 
-    ...
-
 
 class _RequestBuilderParameterList(
     _ParameterListBase[  # pylint: disable=unsubscriptable-object
@@ -406,8 +401,6 @@ class _RequestBuilderParameterList(
 class RequestBuilderParameterList(_RequestBuilderParameterList):
     """Parameter list for Request Builder"""
 
-    ...
-
 
 class OverloadedRequestBuilderParameterList(_RequestBuilderParameterList):
     """Parameter list for OverloadedRequestBuilder"""
@@ -423,8 +416,7 @@ class OverloadedRequestBuilderParameterList(_RequestBuilderParameterList):
         ]
 
 
-class _ClientGlobalParameterList(
-    # pylint: disable=unsubscriptable-object
+class _ClientGlobalParameterList(  # pylint: disable=abstract-method
     _ParameterListBase[ParameterType, BodyParameter]
 ):
     """Base parameter list for client and config classes"""

package/autorest/codegen/models/primitive_types.py

@@ -133,7 +133,7 @@ class BinaryIteratorType(PrimitiveType):
 
     @property
     def default_template_representation_declaration(self) -> str:
-        return self.get_declaration(f"Iterator[bytes]")
+        return self.get_declaration("Iterator[bytes]")
 
     def imports(self, **kwargs: Any) -> FileImport:
         file_import = FileImport()

package/autorest/codegen/models/property.py

@@ -129,13 +129,25 @@ class Property(BaseModel):  # pylint: disable=too-many-instance-attributes
         retval.update(self.type.validation or {})
         return retval or None
 
-    def imports(self, **kwargs) -> FileImport:
-        from .model_type import ModelType
+    @staticmethod
+    def contain_model_type(t: BaseType) -> bool:
+        from . import ListType, DictionaryType, ModelType
+
+        if isinstance(t, ModelType):
+            return True
+        if isinstance(t, ListType):
+            return Property.contain_model_type(t.element_type)
+        if isinstance(t, DictionaryType):
+            return Property.contain_model_type(t.element_type)
+        if isinstance(t, ConstantType):
+            return Property.contain_model_type(t.value_type)
+        return False
 
+    def imports(self, **kwargs) -> FileImport:
         file_import = self.type.imports(**kwargs, is_operation_file=False)
         if self.optional and self.client_default_value is None:
             file_import.add_submodule_import("typing", "Optional", ImportType.STDLIB)
-        if isinstance(self.type, ModelType):
+        if self.contain_model_type(self.type):
             file_import.add_submodule_import(
                 "..",
                 "models",

package/autorest/codegen/models/response.py

@@ -49,12 +49,12 @@ class Response(BaseModel):
         yaml_data: Dict[str, Any],
         code_model: "CodeModel",
         *,
-        headers: List[ResponseHeader] = [],
+        headers: Optional[List[ResponseHeader]] = None,
         type: Optional[BaseType] = None,
     ) -> None:
         super().__init__(yaml_data=yaml_data, code_model=code_model)
         self.status_codes: List[Union[int, str]] = yaml_data["statusCodes"]
-        self.headers = headers
+        self.headers = headers or []
         self.type = type
         self.nullable = yaml_data.get("nullable")
 

package/autorest/codegen/serializers/__init__.py

@@ -462,7 +462,7 @@ class JinjaSerializer(ReaderAndWriter):  # pylint: disable=abstract-method
         if self.code_model.need_vendored_code(async_mode=False):
             self.write_file(
                 namespace_path / Path("_vendor.py"),
-                general_serializer.serialize_vendor_file(),
+                general_serializer.serialize_vendor_file(clients),
             )
 
         self._serialize_and_write_version_file(namespace_path, general_serializer)
@@ -521,7 +521,7 @@ class JinjaSerializer(ReaderAndWriter):  # pylint: disable=abstract-method
         if self.code_model.need_vendored_code(async_mode=True):
             self.write_file(
                 aio_path / Path("_vendor.py"),
-                aio_general_serializer.serialize_vendor_file(),
+                aio_general_serializer.serialize_vendor_file(clients),
             )
 
     def _serialize_and_write_metadata(

package/autorest/codegen/serializers/builder_serializer.py

@@ -31,6 +31,8 @@ from ..models import (
     MultipartBodyParameter,
     Property,
     RequestBuilderType,
+    JSONModelType,
+    CombinedType,
 )
 from .parameter_serializer import ParameterSerializer, PopKwargType
 from . import utils
@@ -146,6 +148,25 @@ def _serialize_flattened_body(body_parameter: BodyParameter) -> List[str]:
     return retval
 
 
+def _serialize_json_model_body(body_parameter: BodyParameter) -> List[str]:
+    retval: List[str] = []
+    if not body_parameter.property_to_parameter_name:
+        raise ValueError(
+            "This method can't be called if the operation doesn't need parameter flattening"
+        )
+
+    retval.append(f"if {body_parameter.client_name} is None:")
+    parameter_string = ", \n".join(
+        f'"{property_name}": {parameter_name}'
+        for property_name, parameter_name in body_parameter.property_to_parameter_name.items()
+    )
+    model_type = cast(ModelType, body_parameter.type)
+    if isinstance(model_type, CombinedType):
+        model_type = next(t for t in model_type.types if isinstance(t, JSONModelType))
+    retval.append(f"    {body_parameter.client_name} = {{{parameter_string}}}")
+    return retval
+
+
 def _serialize_multipart_body(builder: BuilderType) -> List[str]:
     retval: List[str] = []
     body_param = cast(MultipartBodyParameter, builder.parameters.body_parameter)
@@ -184,7 +205,7 @@ def _api_version_validation(builder: OperationType) -> str:
         retval.append(f"    params_added_on={dict(params_added_on)},")
     if retval:
         retval_str = "\n".join(retval)
-        return f"@api_version_validation(\n{retval_str}\n)"
+        return f"@api_version_validation(\n{retval_str}\n){builder.pylint_disable}"
     return ""
 
 
@@ -203,23 +224,20 @@ class _BuilderBaseSerializer(Generic[BuilderType]):  # pylint: disable=abstract-
     @abstractmethod
     def _function_def(self) -> str:
         """The def keyword for the builder we're serializing, i.e. 'def' or 'async def'"""
-        ...
 
     @property
     @abstractmethod
     def _call_method(self) -> str:
         """How to call network calls. Await if we have to await network calls"""
-        ...
 
     @property
     @abstractmethod
     def serializer_name(self) -> str:
-        ...
+        """Name of serializer"""
 
     @abstractmethod
     def response_docstring(self, builder: BuilderType) -> List[str]:
         """Response portion of the docstring"""
-        ...
 
     def decorators(self, builder: BuilderType) -> List[str]:
         """Decorators for the method"""
@@ -258,9 +276,7 @@ class _BuilderBaseSerializer(Generic[BuilderType]):  # pylint: disable=abstract-
             )
         )
 
-    def description_and_summary(  # pylint: disable=no-self-use
-        self, builder: BuilderType
-    ) -> List[str]:
+    def description_and_summary(self, builder: BuilderType) -> List[str]:
         description_list: List[str] = []
         description_list.append(
             f"{ builder.summary.strip() if builder.summary else builder.description.strip() }"
@@ -280,9 +296,7 @@ class _BuilderBaseSerializer(Generic[BuilderType]):  # pylint: disable=abstract-
             template += self._json_input_example_template(builder)
         return template
 
-    def param_description(  # pylint: disable=no-self-use
-        self, builder: BuilderType
-    ) -> List[str]:
+    def param_description(self, builder: BuilderType) -> List[str]:
         description_list: List[str] = []
         for param in builder.parameters.method:
             if not param.in_docstring:
@@ -314,9 +328,6 @@ class _BuilderBaseSerializer(Generic[BuilderType]):  # pylint: disable=abstract-
 
     def _json_input_example_template(self, builder: BuilderType) -> List[str]:
         template: List[str] = []
-        if self.code_model.options["models_mode"]:
-            # No input template if we have models
-            return template
         if (
             not builder.parameters.has_body
             or builder.parameters.body_parameter.flattened
@@ -331,6 +342,15 @@ class _BuilderBaseSerializer(Generic[BuilderType]):  # pylint: disable=abstract-
         if not isinstance(body_param.type, (ListType, DictionaryType, ModelType)):
             return template
 
+        if (
+            isinstance(body_param.type, (ListType, DictionaryType))
+            and self.code_model.options["models_mode"]
+        ):
+            return template
+
+        if isinstance(body_param.type, ModelType) and body_param.type.base != "json":
+            return template
+
         polymorphic_subtypes: List[ModelType] = []
         body_param.type.get_polymorphic_subtypes(polymorphic_subtypes)
         if polymorphic_subtypes:
@@ -440,11 +460,11 @@ class RequestBuilderSerializer(
 
     def response_docstring(self, builder: RequestBuilderType) -> List[str]:
         response_str = (
-            f":return: Returns an :class:`~azure.core.rest.HttpRequest` that you will pass to the client's "
+            ":return: Returns an :class:`~azure.core.rest.HttpRequest` that you will pass to the client's "
             + "`send_request` method. See https://aka.ms/azsdk/dpcodegen/python/send_request for how to "
             + "incorporate this response into your code flow."
         )
-        rtype_str = f":rtype: ~azure.core.rest.HttpRequest"
+        rtype_str = ":rtype: ~azure.core.rest.HttpRequest"
         return [response_str, rtype_str]
 
     def pop_kwargs_from_signature(self, builder: RequestBuilderType) -> List[str]:
@@ -612,9 +632,7 @@ class _OperationSerializer(
             retval.append(_api_version_validation(builder))
         return retval
 
-    def param_description(
-        self, builder: OperationType
-    ) -> List[str]:  # pylint: disable=no-self-use
+    def param_description(self, builder: OperationType) -> List[str]:
         description_list = super().param_description(builder)
         if not self.code_model.options["version_tolerant"]:
             description_list.append(
@@ -683,7 +701,10 @@ class _OperationSerializer(
                 f"'{body_param.type.serialization_type}'{is_xml_cmd}{serialization_ctxt_cmd})"
             )
         elif self.code_model.options["models_mode"] == "dpg":
-            create_body_call = f"_{body_kwarg_name} = json.dumps({body_param.client_name}, cls=AzureJSONEncoder)"
+            create_body_call = (
+                f"_{body_kwarg_name} = json.dumps({body_param.client_name}, "
+                "cls=AzureJSONEncoder)  # type: ignore"
+            )
         else:
             create_body_call = f"_{body_kwarg_name} = {body_param.client_name}"
         if body_param.optional:
@@ -885,7 +906,7 @@ class _OperationSerializer(
             retval.append(f"    template_url={template_url},")
         retval.append("    headers=_headers,")
         retval.append("    params=_params,")
-        retval.append(f")")
+        retval.append(")")
         return retval
 
     def _postprocess_http_request(
@@ -928,6 +949,12 @@ class _OperationSerializer(
         if builder.parameters.has_body and builder.parameters.body_parameter.flattened:
             # unflatten before passing to request builder as well
             retval.extend(_serialize_flattened_body(builder.parameters.body_parameter))
+        if (
+            builder.parameters.has_body
+            and builder.parameters.body_parameter.has_json_model_type
+            and any(p.in_flattened_body for p in builder.parameters.parameters)
+        ):
+            retval.extend(_serialize_json_model_body(builder.parameters.body_parameter))
         if builder.overloads:
             # we are only dealing with two overloads. If there are three, we generate an abstract operation
             retval.extend(self._initialize_overloads(builder, is_paging=is_paging))
@@ -987,10 +1014,10 @@ class _OperationSerializer(
                     if response.type.is_xml
                     else "response.json()"
                 )
-                retval.append(f"if response.content:")
+                retval.append("if response.content:")
                 retval.append(f"    deserialized = {deserialized_value}")
                 retval.append("else:")
-                retval.append(f"    deserialized = None")
+                retval.append("    deserialized = None")
         return retval
 
     def handle_error_response(self, builder: OperationType) -> List[str]:
@@ -1298,11 +1325,20 @@ class _PagingOperationSerializer(
                 deserialize_type = f'"{response.serialization_type}"'
                 pylint_disable = ""
             deserialized = f"self._deserialize(\n    {deserialize_type}, pipeline_response{pylint_disable}\n)"
+            retval.append(f"    deserialized = {deserialized}")
         elif self.code_model.options["models_mode"] == "dpg":
-            deserialized = (
-                f"_deserialize({response.serialization_type}, pipeline_response)"
+            pylint_disable = (
+                "  # pylint: disable=protected-access\n"
+                if isinstance(response.type, ModelType) and not response.type.is_public
+                else ""
+            )
+            deserialized = f"_deserialize({response.serialization_type}{pylint_disable}, pipeline_response)"
+            retval.append(
+                f"    deserialized: {response.serialization_type} = ({pylint_disable}"
             )
-        retval.append(f"    deserialized = {deserialized}")
+            retval.append(f"        {deserialized})")
+        else:
+            retval.append(f"    deserialized = {deserialized}")
         item_name = builder.item_name
         list_of_elem = (
             f".{item_name}"
@@ -1447,7 +1483,7 @@ class _LROOperationSerializer(_OperationSerializer[LROOperationType]):
                 f"        {lro_options_str}",
                 f"        {path_format_arguments_str}",
                 "        **kwargs",
-                f"))",
+                "))",
             ]
         )
         retval.append(
@@ -1504,7 +1540,7 @@ class _LROOperationSerializer(_OperationSerializer[LROOperationType]):
                 " # type: ignore"
                 if builder.lro_response
                 and builder.lro_response.type
-                and not self.code_model.options["models_mode"]
+                and self.code_model.options["models_mode"] != "msrest"
                 else "",
             )
         )

package/autorest/codegen/serializers/client_serializer.py

@@ -137,7 +137,9 @@ class ClientSerializer:
                 f" = {_get_client_models_value(model_dict_name)}"
             )
             if add_private_models and self.client.code_model.model_types:
-                update_dict = f"{{k: v for k, v in _models.__dict__.items() if isinstance(v, type)}}"
+                update_dict = (
+                    "{k: v for k, v in _models.__dict__.items() if isinstance(v, type)}"
+                )
                 retval.append(f"client_models.update({update_dict})")
         client_models_str = "client_models" if is_msrest_model else ""
         retval.append(f"self._serialize = Serializer({client_models_str})")
@@ -221,7 +223,7 @@ class ClientSerializer:
     def _rest_request_example(self, async_mode: bool) -> List[str]:
         retval = [">>> from azure.core.rest import HttpRequest"]
         retval.append('>>> request = HttpRequest("GET", "https://www.example.org/")')
-        retval.append(f"<HttpRequest [GET], url: 'https://www.example.org/'>")
+        retval.append("<HttpRequest [GET], url: 'https://www.example.org/'>")
         retval.extend(self._example_make_call(async_mode))
         return retval
 
@@ -236,9 +238,9 @@ class ClientSerializer:
         retval.append(
             "For more information on this code flow, see https://aka.ms/azsdk/dpcodegen/python/send_request"
         )
-        retval.append(f"")
+        retval.append("")
         retval.append(":param request: The network request you want to make. Required.")
-        retval.append(f":type request: ~azure.core.rest.HttpRequest")
+        retval.append(":type request: ~azure.core.rest.HttpRequest")
         retval.append(
             ":keyword bool stream: Whether the response payload will be streamed. Defaults to False."
         )

package/autorest/codegen/serializers/general_serializer.py

@@ -98,7 +98,7 @@ class GeneralSerializer:
             imports=FileImportSerializer(imports),
         )
 
-    def serialize_vendor_file(self) -> str:
+    def serialize_vendor_file(self, clients: List[Client]) -> str:
         template = self.env.get_template("vendor.py.jinja2")
 
         # configure imports
@@ -110,6 +110,10 @@ class GeneralSerializer:
                 ImportType.AZURECORE,
             )
 
+        if self.code_model.need_format_url and not self.async_mode:
+            file_import.add_submodule_import("typing", "List", ImportType.STDLIB)
+            file_import.add_submodule_import("typing", "cast", ImportType.STDLIB)
+
         if self.code_model.need_mixin_abc:
             file_import.add_submodule_import(
                 "abc",
@@ -128,7 +132,7 @@ class GeneralSerializer:
                 MsrestImportType.SerializerDeserializer,
                 TypingSection.TYPING,
             )
-            for client in self.code_model.clients:
+            for client in clients:
                 file_import.add_submodule_import(
                     "._configuration",
                     f"{client.name}Configuration",
@@ -141,6 +145,7 @@ class GeneralSerializer:
                 file_import,
             ),
             async_mode=self.async_mode,
+            clients=clients,
         )
 
     def serialize_config_file(self, clients: List[Client]) -> str:

package/autorest/codegen/serializers/model_serializer.py

@@ -208,14 +208,19 @@ class DpgModelSerializer(_ModelSerializer):
             ImportType.LOCAL,
             TypingSection.REGULAR,
         )
-        file_import.add_submodule_import("typing", "overload", ImportType.STDLIB)
-        file_import.add_submodule_import("typing", "Mapping", ImportType.STDLIB)
-        file_import.add_submodule_import("typing", "Any", ImportType.STDLIB)
 
         for model in self.code_model.model_types:
             file_import.merge(model.imports(is_operation_file=False))
             for prop in model.properties:
                 file_import.merge(prop.imports())
+            if model.is_polymorphic:
+                file_import.add_submodule_import("typing", "Dict", ImportType.STDLIB)
+            if model.is_public and self.init_line(model):
+                file_import.add_submodule_import(
+                    "typing", "overload", ImportType.STDLIB
+                )
+                file_import.add_submodule_import("typing", "Mapping", ImportType.STDLIB)
+                file_import.add_submodule_import("typing", "Any", ImportType.STDLIB)
         return file_import
 
     def declare_model(self, model: ModelType) -> str:
@@ -256,9 +261,14 @@ class DpgModelSerializer(_ModelSerializer):
             args.append(f"default={prop.client_default_value_declaration}")
 
         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
+        )
         ret = [
             f"{prop.client_name}: {prop.type_annotation()} ="
-            f' {field}({", ".join(args)})'
+            f' {field}({", ".join(args)}){"  # type: ignore" if type_ignore else ""}'
         ]
         comment = prop.description(is_operation_file=False).replace('"', '\\"')
         if comment:

package/autorest/codegen/serializers/sample_serializer.py

@@ -65,7 +65,7 @@ class SampleSerializer:
 
     def _client_params(self) -> Dict[str, Any]:
         # client params
-        special_param = dict()
+        special_param = {}
         credential_type = getattr(self.code_model.clients[0].credential, "type", None)
         if isinstance(credential_type, TokenCredentialType):
             special_param.update({"credential": "DefaultAzureCredential()"})
@@ -79,14 +79,10 @@ class SampleSerializer:
             for p in self.code_model.clients[0].parameters.positional
             if not (p.optional or p.client_default_value)
         ]
-        cls = lambda x: f'"{x}"'
         client_params = {
             p.client_name: special_param.get(
                 p.client_name,
-                cls(
-                    self.sample["parameters"].get(p.rest_api_name)
-                    or p.client_name.upper()
-                ),
+                f'"{self.sample["parameters"].get(p.rest_api_name) or p.client_name.upper()}"',
             )
             for p in params_positional
         }

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

@@ -22,12 +22,27 @@ class {{ client.name }}Configuration(Configuration):  # pylint: disable=too-many
 {% if serializer.set_constants() %}
         {{ op_tools.serialize(serializer.set_constants()) | indent(8) -}}
 {% endif %}
-{% if client.credential and client.credential.type.policy.credential_scopes is defined %}
-        self.credential_scopes = kwargs.pop('credential_scopes', {{ client.credential.type.policy.credential_scopes }})
+{% if client.credential %}
+    {% set cred_scopes = client.credential.type if client.credential.type.policy is defined and client.credential.type.policy.credential_scopes is defined %}
+    {% if not cred_scopes %}
+        {% set cred_scopes = client.credential.type.types | selectattr("policy.credential_scopes") | first if client.credential.type.types is defined %}
+    {% endif %}
+    {% if cred_scopes %}
+        self.credential_scopes = kwargs.pop('credential_scopes', {{ cred_scopes.policy.credential_scopes }})
+    {% endif %}
 {% endif %}
         kwargs.setdefault('sdk_moniker', '{{ client.config.sdk_moniker }}/{}'.format(VERSION))
         self._configure(**kwargs)
 
+{% if client.credential and client.credential.type.types is defined %}
+    def _infer_policy(self, **kwargs):
+    {% for cred_type in client.credential.type.types %}
+        if {{ cred_type.instance_check_template.format("self.credential") }}:
+            return {{ cred_type.policy.call(async_mode) }}
+    {% endfor %}
+        raise TypeError(f"Unsupported credential: {self.credential}")
+{% endif %}
+
     def _configure(
         self,
         **kwargs: Any
@@ -41,12 +56,16 @@ class {{ client.name }}Configuration(Configuration):  # pylint: disable=too-many
         self.custom_hook_policy = kwargs.get('custom_hook_policy') or policies.CustomHookPolicy(**kwargs)
         self.redirect_policy = kwargs.get('redirect_policy') or policies.{{ keywords.async_class }}RedirectPolicy(**kwargs)
         self.authentication_policy = kwargs.get('authentication_policy')
-        {% if client.credential %}
-        {# only adding this if credential_scopes is not passed during code generation #}
-        {% if client.credential.type.policy.credential_scopes is defined and client.credential.type.policy.credential_scopes | length == 0 %}
+        {% if client.credential and client.credential.type.policy is defined %}
+            {# only adding this if credential_scopes is not passed during code generation #}
+            {% if client.credential.type.policy.credential_scopes is defined and client.credential.type.policy.credential_scopes | length == 0 %}
         if not self.credential_scopes and not self.authentication_policy:
             raise ValueError("You must provide either credential_scopes or authentication_policy as kwargs")
-        {% endif %}
+            {% endif %}
         if self.credential and not self.authentication_policy:
             self.authentication_policy = {{ client.credential.type.policy.call(async_mode) }}
         {% endif %}
+        {% if client.credential and client.credential.type.types is defined %}
+        if self.credential and not self.authentication_policy:
+            self.authentication_policy = self._infer_policy(**kwargs)
+        {% endif %}

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

@@ -6,8 +6,8 @@ class {{ enum.name }}({{ enum.value_type.type_annotation(is_operation_file=False
     {% endif %}
 
     {% 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    #: ') }}
+    """{{ value.description | wordwrap(width=95, break_long_words=False, break_on_hyphens=False, wrapstring='\n    #: ') }}"""
     {% endif %}
-    {{ value.name }} = {{ enum.value_type.get_declaration(value.value) }}
     {% endfor %}