@autorest/python 5.12.4 → 5.13.0

package/autorest/codegen/serializers/builder_serializer.py

@@ -27,12 +27,16 @@ from ..models import (
     SchemaResponse,
     IOSchema,
     ParameterStyle,
+    ParameterLocation
 )
 from . import utils
 
 T = TypeVar("T")
 OrderedSet = Dict[T, None]
 
+def _escape_str(input_str: str) -> str:
+    replace = input_str.replace("'", "\\'")
+    return f'"{replace}"'
 
 def _improve_json_string(template_representation: str) -> Any:
     origin = template_representation.split('\n')
@@ -110,7 +114,7 @@ def _pop_parameters_kwarg(
     function_name: str,
     kwarg_name: str,
 ) -> str:
-    return f'{function_name}_parameters = kwargs.pop("{kwarg_name}", {{}})  # type: Dict[str, Any]'
+    return f'_{function_name}_parameters = kwargs.pop("{kwarg_name}", {{}})  # type: Dict[str, Any]'
 
 def _serialize_grouped_body(builder) -> List[str]:
     retval: List[str] = []
@@ -149,12 +153,21 @@ def _serialize_flattened_body(builder) -> List[str]:
     return retval
 
 def _content_type_docstring(builder) -> str:
-    content_type_str = (
-        ":keyword str content_type: Media type of the body sent to the API. " +
-        f'Default value is "{builder.parameters.default_content_type}". ' +
-        'Allowed values are: "{}."'.format('", "'.join(builder.parameters.content_types))
+    content_types = [f'"{c}"' for c in builder.parameters.content_types]
+    if len(content_types) == 2:
+        possible_values_str = " or ".join(content_types)
+    else:
+        possible_values_str = ", ".join(
+            content_types[: len(content_types) - 1]
+        ) + f", and {content_types[-1]}"
+    default_value = next(
+        p for p in builder.parameters.method if p.rest_api_name == "Content-Type"
+    ).default_value_declaration
+    return (
+        ":keyword content_type: Media type of the body sent to the API. " +
+        f"Possible values are: {possible_values_str}. " +
+        f"Default value is {default_value}."
     )
-    return content_type_str
 
 class _BuilderSerializerProtocol(ABC):
     @property
@@ -180,11 +193,6 @@ class _BuilderSerializerProtocol(ABC):
         """Whether you want inline type hints. If false, your type hints will be commented'"""
         ...
 
-    @abstractmethod
-    def _method_signature(self, builder) -> str:
-        """Signature of the builder. Does not include return type annotation"""
-        ...
-
     @abstractmethod
     def _response_type_annotation(self, builder, modify_if_head_as_boolean: bool = True) -> str:
         """The mypy type annotation for the response"""
@@ -266,20 +274,22 @@ class _BuilderBaseSerializer(_BuilderSerializerProtocol):  # pylint: disable=abs
     def _cls_docstring_rtype(self) -> str:
         return "" if self.code_model.options["version_tolerant"] else " or the result of cls(response)"
 
-    def _method_signature(self, builder) -> str:
+    def _method_signature(self, builder: Operation, response_type_annotation: str) -> str:
         return utils.serialize_method(
             function_def=self._function_definition,
             method_name=builder.name,
             is_in_class=self._is_in_class,
             method_param_signatures=builder.parameters.method_signature(self._want_inline_type_hints),
+            ignore_inconsistent_return_statements=(response_type_annotation == "None")
         )
 
     def _response_type_annotation_wrapper(self, builder) -> List[str]:
         return []
 
     def method_signature_and_response_type_annotation(self, builder) -> str:
-        method_signature = self._method_signature(builder)
         response_type_annotation = self._response_type_annotation(builder)
+        # want pre-wrapped response type. As long as it's None, pylint will get mad about inconsistent return types
+        method_signature = self._method_signature(builder, response_type_annotation)
         for wrapper in self._response_type_annotation_wrapper(builder)[::-1]:
             response_type_annotation = f"{wrapper}[{response_type_annotation}]"
         return self._method_signature_and_response_type_annotation_template(method_signature, response_type_annotation)
@@ -304,13 +314,14 @@ class _BuilderBaseSerializer(_BuilderSerializerProtocol):  # pylint: disable=abs
             description_list.append(
                 f":{param.docstring_type_keyword} { param.serialized_name }: { param.docstring_type }"
             )
-        try:
-            request_builder: RequestBuilder = cast(Operation, builder).request_builder
-        except AttributeError:
-            request_builder = cast(RequestBuilder, builder)
 
-        if len(request_builder.schema_requests) > 1:
-            description_list.append(_content_type_docstring(builder))
+        if len(builder.parameters.content_types) > 1:
+            description_list = [
+                _content_type_docstring(builder) if l.startswith(":keyword content_type:") else l
+                for l in description_list
+            ]
+            if not any(l for l in description_list if l.startswith(":keyword content_type:")):
+                description_list.append(_content_type_docstring(builder))
         return description_list
 
     def param_description_and_response_docstring(self, builder) -> List[str]:
@@ -402,7 +413,7 @@ class _BuilderBaseSerializer(_BuilderSerializerProtocol):  # pylint: disable=abs
     def _serialize_parameter(
         self, param: Parameter, function_name: str
     ) -> List[str]:
-        set_parameter = "{}_parameters['{}'] = {}".format(
+        set_parameter = "_{}_parameters['{}'] = {}".format(
             function_name,
             param.rest_api_name,
             utils.build_serialize_data_call(param, function_name, self.serializer_name)
@@ -499,11 +510,11 @@ class _RequestBuilderBaseSerializer(_BuilderBaseSerializer):  # pylint: disable=
     def create_http_request(self, builder) -> List[str]:
         retval = ["return HttpRequest("]
         retval.append(f'    method="{builder.method}",')
-        retval.append("    url=url,")
+        retval.append("    url=_url,")
         if builder.parameters.query:
-            retval.append("    params=query_parameters,")
+            retval.append("    params=_query_parameters,")
         if builder.parameters.headers:
-            retval.append("    headers=header_parameters,")
+            retval.append("    headers=_header_parameters,")
         if builder.parameters.has_body:
             retval.extend([
                 f"    {body_kwarg}={body_kwarg},"
@@ -533,6 +544,13 @@ class _RequestBuilderBaseSerializer(_BuilderBaseSerializer):  # pylint: disable=
             ))
         return retval
 
+    def construct_url(self, builder) -> str:
+        if any(o for o in ["low_level_client", "version_tolerant"] if self.code_model.options.get(o)):
+            url_value = _escape_str(builder.url)
+        else:
+            url_value = f'kwargs.pop("template_url", {_escape_str(builder.url)})'
+        return f"_url = {url_value}{'  # pylint: disable=line-too-long' if len(url_value) > 114 else ''}"
+
 class RequestBuilderGenericSerializer(_RequestBuilderBaseSerializer):
     @property
     def _want_inline_type_hints(self) -> bool:
@@ -711,7 +729,7 @@ class _OperationBaseSerializer(_BuilderBaseSerializer):  # pylint: disable=abstr
         )
         ser_ctxt_name = "serialization_ctxt"
         ser_ctxt = builder.parameters.body[0].xml_serialization_ctxt if send_xml else None
-        if ser_ctxt:
+        if ser_ctxt and self.code_model.options["models_mode"]:
             retval.append(f'{ser_ctxt_name} = {{"xml": {{{ser_ctxt}}}}}')
         serialize_body_call = self._serialize_body_call(
             builder,
@@ -781,6 +799,7 @@ class _OperationBaseSerializer(_BuilderBaseSerializer):  # pylint: disable=abstr
         builder,
         request_builder: RequestBuilder,
         template_url: Optional[str] = None,
+        is_next_request: bool = False,
     ) -> List[str]:
         retval = []
         if len(builder.body_kwargs_to_pass_to_request_builder) > 1:
@@ -820,6 +839,16 @@ class _OperationBaseSerializer(_BuilderBaseSerializer):  # pylint: disable=abstr
                 parameter.serialized_name not in builder.body_kwargs_to_pass_to_request_builder
             ):
                 continue
+            if (
+                is_next_request and
+                not bool(builder.next_request_builder) and
+                not self.code_model.options["reformat_next_link"] and
+                parameter.location == ParameterLocation.Query
+            ):
+                # if we don't want to reformat query parameters for next link calls
+                # in paging operations with a single swagger operation defintion,
+                # we skip passing query params when building the next request
+                continue
             high_level_name = cast(RequestBuilderParameter, parameter).name_in_high_level_operation
             retval.append(f"    {parameter.serialized_name}={high_level_name},")
         if not self.code_model.options["version_tolerant"]:
@@ -986,7 +1015,8 @@ class _OperationBaseSerializer(_BuilderBaseSerializer):  # pylint: disable=abstr
 
     @staticmethod
     def get_metadata_url(builder) -> str:
-        return f"{builder.python_name}.metadata = {{'url': '{ builder.request_builder.url }'}}  # type: ignore"
+        url = _escape_str(builder.request_builder.url)
+        return f"{builder.python_name}.metadata = {{'url': { url }}}  # type: ignore"
 
 class _SyncOperationBaseSerializer(_OperationBaseSerializer):  # pylint: disable=abstract-method
     @property
@@ -1065,11 +1095,13 @@ class _PagingOperationBaseSerializer(_OperationBaseSerializer):  # pylint: disab
         else:
             request_builder = builder.request_builder
             template_url = "next_link"
+
         request_builder = builder.next_request_builder or builder.request_builder
         return self._call_request_builder_helper(
             builder,
             request_builder,
             template_url=template_url,
+            is_next_request=True
         )
 
     def _prepare_request_callback(self, builder) -> List[str]:
@@ -1114,7 +1146,7 @@ class _PagingOperationBaseSerializer(_OperationBaseSerializer):  # pylint: disab
         deserialized = (
             f'self._deserialize("{response.serialization_type}", pipeline_response)'
             if self.code_model.options["models_mode"] else
-            "_loads(pipeline_response.http_response.body())"
+            "pipeline_response.http_response.json()"
         )
         retval.append(f"    deserialized = {deserialized}")
         item_name = builder.item_name(self.code_model)
@@ -1137,10 +1169,11 @@ class _PagingOperationBaseSerializer(_OperationBaseSerializer):  # pylint: disab
         retval = [f"{self._def} get_next(next_link=None):"]
         retval.append("    request = prepare_request(next_link)")
         retval.append("")
-        retval.append(
-            f"    pipeline_response = {self._call_method}self._client._pipeline.run(request, "
-            f"stream={builder.is_stream_response}, **kwargs)"
-        )
+        retval.append(f"    pipeline_response = {self._call_method}self._client._pipeline.run(  # pylint: disable=protected-access")
+        retval.append("        request,")
+        retval.append(f"        stream={builder.is_stream_response},")
+        retval.append("        **kwargs")
+        retval.append("    )")
         retval.append("    response = pipeline_response.http_response")
         retval.append("")
         retval.extend([
@@ -1234,7 +1267,7 @@ class _LROOperationBaseSerializer(_OperationBaseSerializer):  # pylint: disable=
             "Pass in False for this operation to not poll, or pass in your own initialized polling object for a"
             " personal polling strategy."
         )
-        retval.append(f":paramtype polling: bool or ~{self._polling_method_type}")
+        retval.append(f":paramtype polling: bool or ~azure.core.polling.{self._polling_method_type}")
         retval.append(
             ":keyword int polling_interval: Default waiting time between two polls for LRO operations "
             "if no Retry-After header is present."
@@ -1287,9 +1320,8 @@ class _LROOperationBaseSerializer(_OperationBaseSerializer):  # pylint: disable=
         retval.append("        client=self._client,")
         retval.append("        deserialization_callback=get_long_running_output")
         retval.append("    )")
-        retval.append("else:")
         retval.append(
-            f"    return {self._poller(builder)}"
+            f"return {self._poller(builder)}"
             "(self._client, raw_result, get_long_running_output, polling_method)"
         )
         return retval
@@ -1335,7 +1367,7 @@ class _SyncLROOperationBaseSerializer(_LROOperationBaseSerializer, _SyncOperatio
 
     @property
     def _polling_method_type(self):
-        return "azure.core.polling.PollingMethod"
+        return "PollingMethod"
 
     def _poller(self, builder) -> str:
         return builder.get_poller(async_mode=False)
@@ -1368,7 +1400,7 @@ class AsyncLROOperationSerializer(_LROOperationBaseSerializer, AsyncOperationSer
 
     @property
     def _polling_method_type(self):
-        return "azure.core.polling.AsyncPollingMethod"
+        return "AsyncPollingMethod"
 
     def _poller(self, builder) -> str:
         return builder.get_poller(async_mode=True)
@@ -1383,8 +1415,7 @@ class _LROPagingOperationBaseSerializer(_LROOperationBaseSerializer, _PagingOper
         retval.append(f"    {self._def} internal_get_next(next_link=None):")
         retval.append("        if next_link is None:")
         retval.append("            return pipeline_response")
-        retval.append("        else:")
-        retval.append(f"            return {self._call_method}get_next(next_link)")
+        retval.append(f"        return {self._call_method}get_next(next_link)")
         retval.append("")
         retval.append(f"    return {self._pager(builder)}(")
         retval.append("        internal_get_next, extract_data")

package/autorest/codegen/serializers/client_serializer.py

@@ -44,9 +44,12 @@ class ClientSerializer:
             base_class = f"{class_name}OperationsMixin"
         elif not (async_mode or self.is_python3_file):
             base_class = "object"
+        disable = ""
+        if len(self.code_model.operation_groups) > 6:
+            disable = "    # pylint: disable=too-many-instance-attributes"
         if base_class:
-            return f"class {class_name}({base_class}):"
-        return f"class {class_name}:"
+            return f"class {class_name}({base_class}):{disable}"
+        return f"class {class_name}:{disable}"
 
     def property_descriptions(self, async_mode: bool) -> List[str]:
         retval: List[str] = []
@@ -113,7 +116,7 @@ class ClientSerializer:
             method_name=self.code_model.send_request_name,
             is_in_class=True,
             method_param_signatures=self.code_model.service_client.send_request_signature(
-                async_mode, async_mode or self.is_python3_file
+                async_mode or self.is_python3_file
             ),
         )
 
@@ -227,3 +230,11 @@ class ConfigSerializer:
             for p in self.code_model.global_parameters.config_method
             if p.required and not p.constant
         ]
+
+    def property_descriptions(self) -> List[str]:
+        retval: List[str] = []
+        for p in self.code_model.global_parameters.config_method:
+            retval.append(f":{p.description_keyword} {p.serialized_name}: {p.description}")
+            retval.append(f":{p.docstring_type_keyword} {p.serialized_name}: {p.docstring_type}")
+        retval.append('"""')
+        return retval

package/autorest/codegen/serializers/general_serializer.py

@@ -10,17 +10,17 @@ from .client_serializer import ClientSerializer, ConfigSerializer
 
 def config_imports(code_model, global_parameters: ParameterList, async_mode: bool) -> FileImport:
     file_import = FileImport()
-    file_import.add_from_import("azure.core.configuration", "Configuration", ImportType.AZURECORE)
-    file_import.add_from_import("azure.core.pipeline", "policies", ImportType.AZURECORE)
-    file_import.add_from_import("typing", "Any", ImportType.STDLIB, TypingSection.CONDITIONAL)
+    file_import.add_submodule_import("azure.core.configuration", "Configuration", ImportType.AZURECORE)
+    file_import.add_submodule_import("azure.core.pipeline", "policies", ImportType.AZURECORE)
+    file_import.add_submodule_import("typing", "Any", ImportType.STDLIB, TypingSection.CONDITIONAL)
     if code_model.options["package_version"]:
-        file_import.add_from_import(".._version" if async_mode else "._version", "VERSION", ImportType.LOCAL)
+        file_import.add_submodule_import(".._version" if async_mode else "._version", "VERSION", ImportType.LOCAL)
     for gp in global_parameters:
         file_import.merge(gp.imports())
     if code_model.options["azure_arm"]:
         policy = "AsyncARMChallengeAuthenticationPolicy" if async_mode else "ARMChallengeAuthenticationPolicy"
-        file_import.add_from_import("azure.mgmt.core.policies", "ARMHttpLoggingPolicy", ImportType.AZURECORE)
-        file_import.add_from_import("azure.mgmt.core.policies", policy, ImportType.AZURECORE)
+        file_import.add_submodule_import("azure.mgmt.core.policies", "ARMHttpLoggingPolicy", ImportType.AZURECORE)
+        file_import.add_submodule_import("azure.mgmt.core.policies", policy, ImportType.AZURECORE)
     return file_import
 
 
@@ -71,7 +71,7 @@ class GeneralSerializer:
         # configure imports
         file_import = FileImport()
         if self.code_model.need_request_converter:
-            file_import.add_from_import(
+            file_import.add_submodule_import(
                 "azure.core.pipeline.transport",
                 "HttpRequest",
                 ImportType.AZURECORE,

package/autorest/codegen/serializers/import_serializer.py

@@ -4,75 +4,73 @@
 # license information.
 # --------------------------------------------------------------------------
 from copy import deepcopy
-from typing import Dict, Set, Optional, List, Tuple, Union
-from ..models.imports import ImportType, FileImport, TypingSection
+from typing import List
+from ..models.imports import ImportType, FileImport, ImportModel, TypingSection
 
 def _serialize_package(
-    package_name: str, module_list: Set[Optional[Union[str, Tuple[str, str]]]], delimiter: str
+    imports: List[ImportModel], delimiter: str
 ) -> str:
     buffer = []
-    if None in module_list:
-        buffer.append(f"import {package_name}")
-    if module_list != {None}:
-        buffer.append(
-            "from {} import {}".format(
-                package_name, ", ".join(sorted([
-                    mod if isinstance(mod, str) else f"{mod[0]} as {mod[1]}" for mod in module_list if mod is not None
-                ]))
-            )
-        )
+    if any(i for i in imports if i.submodule_name is None):
+        buffer.append(f"import {imports[0].module_name}")
+    else:
+        import_str = ", ".join(sorted([
+            f"{i.submodule_name} as {i.alias}" if i.alias else i.submodule_name for i in imports # type: ignore
+        ]))
+        buffer.append(f"from {imports[0].module_name} import {import_str}")
     return delimiter.join(buffer)
 
-def _serialize_type(import_type_dict: Dict[str, Set[Optional[Union[str, Tuple[str, str]]]]], delimiter: str) -> str:
+def _serialize_import_type(imports: List[ImportModel], delimiter: str) -> str:
     """Serialize a given import type."""
     import_list = []
-    for package_name in sorted(list(import_type_dict.keys())):
-        module_list = import_type_dict[package_name]
-        import_list.append(_serialize_package(package_name, module_list, delimiter))
+    for module_name in sorted(set(i.module_name for i in imports)):
+
+        import_list.append(_serialize_package([
+            i for i in imports if i.module_name == module_name
+        ], delimiter))
     return delimiter.join(import_list)
 
 def _get_import_clauses(
-    imports: Dict[ImportType, Dict[str, Set[Optional[Union[str, Tuple[str, str]]]]]], delimiter: str
+    imports: List[ImportModel], delimiter: str
 ) -> List[str]:
     import_clause = []
     for import_type in ImportType:
-        if import_type in imports:
-            import_clause.append(_serialize_type(imports[import_type], delimiter))
+        imports_with_import_type = [i for i in imports if i.import_type == import_type]
+        if imports_with_import_type:
+            import_clause.append(_serialize_import_type(imports_with_import_type, delimiter))
     return import_clause
 
 
 class FileImportSerializer:
     def __init__(self, file_import: FileImport, is_python3_file: bool, async_mode: bool = False) -> None:
-        self._file_import = file_import
+        self.file_import = file_import
         self.is_python3_file = is_python3_file
         self.async_mode = async_mode
 
-    def _switch_typing_section_key(self, new_key: TypingSection):
-        switched_dictionary = {}
-        switched_dictionary[new_key] = self._file_import.imports[TypingSection.CONDITIONAL]
-        return switched_dictionary
-
-    def _get_imports_dict(self, baseline_typing_section: TypingSection, add_conditional_typing: bool):
+    def _get_imports_list(self, baseline_typing_section: TypingSection, add_conditional_typing: bool):
         # If this is a python 3 file, our regular imports include the CONDITIONAL category
         # If this is not a python 3 file, our typing imports include the CONDITIONAL category
-        file_import_copy = deepcopy(self._file_import)
-        if add_conditional_typing and self._file_import.imports.get(TypingSection.CONDITIONAL):
+        file_import_copy = deepcopy(self.file_import)
+        if add_conditional_typing and any(
+            self.file_import.get_imports_from_section(TypingSection.CONDITIONAL)
+        ):
             # we switch the TypingSection key for the CONDITIONAL typing imports so we can merge
             # the imports together
-            switched_imports_dictionary = self._switch_typing_section_key(baseline_typing_section)
-            switched_imports = FileImport(switched_imports_dictionary)
-            file_import_copy.merge(switched_imports)
-        return file_import_copy.imports.get(baseline_typing_section, {})
+            for i in file_import_copy.imports:
+                if i.typing_section == TypingSection.CONDITIONAL:
+                    i.typing_section = baseline_typing_section
+        return file_import_copy.get_imports_from_section(baseline_typing_section)
 
     def _add_type_checking_import(self):
-        if (
-            self._file_import.imports.get(TypingSection.TYPING) or
-            (not self.is_python3_file and self._file_import.imports.get(TypingSection.CONDITIONAL))
-        ):
-            self._file_import.add_from_import("typing", "TYPE_CHECKING", ImportType.STDLIB)
+        any_typing = any(self.file_import.get_imports_from_section(TypingSection.TYPING))
+        conditional_and_not_py3 = not self.is_python3_file and any(
+            self.file_import.get_imports_from_section(TypingSection.CONDITIONAL)
+        )
+        if any_typing or conditional_and_not_py3:
+            self.file_import.add_submodule_import("typing", "TYPE_CHECKING", ImportType.STDLIB)
 
     def _get_typing_definitions(self) -> str:
-        if not self._file_import.type_definitions:
+        if not self.file_import.type_definitions:
             return ""
         spacing = "" if self.is_python3_file else "    "
         declarations: List[str] = [f"\n{spacing}T = TypeVar('T')"]
@@ -82,27 +80,27 @@ class FileImportSerializer:
                 type_name,
                 values[1] if self.async_mode else values[0]
             )
-            for type_name, values in self._file_import.type_definitions.items()
+            for type_name, values in self.file_import.type_definitions.items()
         ])
         return "\n".join(declarations)
 
     def __str__(self) -> str:
         self._add_type_checking_import()
         regular_imports = ""
-        regular_imports_dict = self._get_imports_dict(
+        regular_imports_list = self._get_imports_list(
             baseline_typing_section=TypingSection.REGULAR, add_conditional_typing=self.is_python3_file
         )
 
-        if regular_imports_dict:
+        if regular_imports_list:
             regular_imports = "\n\n".join(
-                _get_import_clauses(regular_imports_dict, "\n")
+                _get_import_clauses(regular_imports_list, "\n")
             )
 
         typing_imports = ""
-        typing_imports_dict = self._get_imports_dict(
+        typing_imports_list = self._get_imports_list(
             baseline_typing_section=TypingSection.TYPING, add_conditional_typing=not self.is_python3_file
         )
-        if typing_imports_dict:
+        if typing_imports_list:
             typing_imports += "\n\nif TYPE_CHECKING:\n    # pylint: disable=unused-import,ungrouped-imports\n    "
-            typing_imports += "\n\n    ".join(_get_import_clauses(typing_imports_dict, "\n    "))
+            typing_imports += "\n\n    ".join(_get_import_clauses(typing_imports_list, "\n    "))
         return regular_imports + typing_imports + self._get_typing_definitions()

package/autorest/codegen/serializers/metadata_serializer.py

@@ -62,7 +62,7 @@ def _mixin_imports(mixin_operation_group: Optional[OperationGroup]) -> Tuple[Opt
     sync_mixin_imports = mixin_operation_group.imports_for_multiapi(async_mode=False)
     async_mixin_imports = mixin_operation_group.imports_for_multiapi(async_mode=True)
 
-    return _json_serialize_imports(sync_mixin_imports.imports), _json_serialize_imports(async_mixin_imports.imports)
+    return _json_serialize_imports(sync_mixin_imports.to_dict()), _json_serialize_imports(async_mixin_imports.to_dict())
 
 
 class MetadataSerializer:
@@ -102,20 +102,22 @@ class MetadataSerializer:
         file_import = FileImport()
         for gp in global_parameters:
             file_import.merge(gp.imports())
-        file_import.add_from_import("azure.profiles", "KnownProfiles", import_type=ImportType.AZURECORE)
-        file_import.add_from_import("azure.profiles", "ProfileDefinition", import_type=ImportType.AZURECORE)
-        file_import.add_from_import(
+        file_import.add_submodule_import("azure.profiles", "KnownProfiles", import_type=ImportType.AZURECORE)
+        file_import.add_submodule_import("azure.profiles", "ProfileDefinition", import_type=ImportType.AZURECORE)
+        file_import.add_submodule_import(
             "azure.profiles.multiapiclient", "MultiApiClientMixin", import_type=ImportType.AZURECORE
         )
-        file_import.add_from_import("._configuration", f"{self.code_model.class_name}Configuration", ImportType.LOCAL)
+        file_import.add_submodule_import(
+            "._configuration", f"{self.code_model.class_name}Configuration", ImportType.LOCAL
+        )
         # api_version and potentially endpoint require Optional typing
-        file_import.add_from_import("typing", "Optional", ImportType.STDLIB, TypingSection.CONDITIONAL)
+        file_import.add_submodule_import("typing", "Optional", ImportType.STDLIB, TypingSection.CONDITIONAL)
         if mixin_operation_group:
-            file_import.add_from_import(
+            file_import.add_submodule_import(
                 "._operations_mixin", f"{self.code_model.class_name}OperationsMixin", ImportType.LOCAL
             )
         file_import.merge(self.code_model.service_client.imports_for_multiapi(async_mode=async_mode))
-        return _json_serialize_imports(file_import.imports)
+        return _json_serialize_imports(file_import.to_dict())
 
     def serialize(self) -> str:
         def _is_lro(operation):
@@ -179,10 +181,10 @@ class MetadataSerializer:
             sync_client_imports=sync_client_imports,
             async_client_imports=async_client_imports,
             sync_config_imports=_json_serialize_imports(
-                config_imports(self.code_model, self.code_model.global_parameters, async_mode=False).imports
+                config_imports(self.code_model, self.code_model.global_parameters, async_mode=False).to_dict()
             ),
             async_config_imports=_json_serialize_imports(
-                config_imports(self.code_model, async_global_parameters, async_mode=True).imports
+                config_imports(self.code_model, async_global_parameters, async_mode=True).to_dict()
             ),
             get_async_operation_serializer=functools.partial(
                 get_operation_serializer, code_model=self.code_model, async_mode=True, is_python3_file=True

package/autorest/codegen/serializers/utils.py

@@ -13,9 +13,13 @@ def serialize_method(
     method_name: str,
     is_in_class: bool,
     method_param_signatures: List[str],
+    ignore_inconsistent_return_statements: bool = False,
 ):
     lines: List[str] = []
-    lines.append(f"{function_def} {method_name}(")
+    first_line = f"{function_def} {method_name}("
+    if ignore_inconsistent_return_statements:
+        first_line += "  # pylint: disable=inconsistent-return-statements"
+    lines.append(first_line)
     if is_in_class:
         lines.append("    self,")
     lines.extend([

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

@@ -11,7 +11,7 @@
 VERSION = "unknown"
 {% endif %}
 
-class {{ code_model.class_name }}Configuration(Configuration):
+class {{ code_model.class_name }}Configuration(Configuration):  # pylint: disable=too-many-instance-attributes
     """Configuration for {{ code_model.class_name }}.
 
     Note that all parameters used to create this instance are saved as instance
@@ -19,12 +19,7 @@ class {{ code_model.class_name }}Configuration(Configuration):
 {% if code_model.global_parameters.config_method | first %}
 
 {% endif %}
-{% for parameter in code_model.global_parameters.config_method %}
-    :{{ parameter.description_keyword }} {{ parameter.serialized_name }}: {{ parameter.description }}
-    :{{ parameter.docstring_type_keyword }} {{ parameter.serialized_name }}: {{ parameter.docstring_type }}
-{% endfor %}
-    """
-
+    {{ op_tools.serialize_with_wrap(serializer.property_descriptions(), "\n ") | indent }}
     {{ serializer.init_signature_and_response_type_annotation(async_mode) | indent }}
         super({{ code_model.class_name }}Configuration, self).__init__(**kwargs)
     {% if code_model.service_client.parameters.config_kwargs_to_pop(async_mode) %}

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

@@ -13,4 +13,6 @@
     {{ op_tools.serialize(operation_serializer.get_long_running_output(operation)) | indent }}
 
     {{ op_tools.serialize(operation_serializer.return_lro_poller(operation)) | indent }}
-{{ operation_serializer.get_metadata_url(operation) }}
+{% if not code_model.options["version_tolerant"] %}
+{{ operation_serializer.get_metadata_url(operation) -}}
+{% endif %}

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

@@ -15,4 +15,6 @@
     {{ op_tools.serialize(operation_serializer.initial_call(operation)) | indent }}
     {{ op_tools.serialize(operation_serializer.get_long_running_output(operation)) | indent }}
     {{ op_tools.serialize(operation_serializer.return_lro_poller(operation)) | indent }}
+{% if not code_model.options["version_tolerant"] %}
 {{ operation_serializer.get_metadata_url(operation) }}
+{% endif %}

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

@@ -18,6 +18,12 @@
     {{ op_tools.serialize(operation_serializer.pop_kwargs_from_signature(operation)) | indent }}
     {% endif %}
     {{ op_tools.serialize(operation_serializer.call_request_builder(operation)) | indent }}
-    pipeline_response = {{ keywords.await }}self._client._pipeline.run(request, {{ stream_request_parameter }}, **kwargs)
+    pipeline_response = {{ keywords.await }}self._client._pipeline.run(  # pylint: disable=protected-access
+        request,
+        {{ stream_request_parameter }},
+        **kwargs
+    )
     {{ op_tools.serialize(operation_serializer.handle_response(operation)) | indent }}
-{{ operation.python_name }}.metadata = {'url': {{ keywords.escape_str(request_builder.url) }}}  # type: ignore
+{% if not code_model.options["version_tolerant"] %}
+{{ operation_serializer.get_metadata_url(operation) }}
+{% endif %}

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

@@ -1,4 +1,5 @@
-class {{ operation_group.class_name }}{{ object_base_class }}:
+{% set disable = "  # pylint: disable=too-many-public-methods" if operation_group.operations | length > 20 else "" %}
+class {{ operation_group.class_name }}{{ object_base_class }}:{{ disable }}
 {% if not operation_group.is_empty_operation_group %}
     """{{ operation_group.class_name }} {{ operations_description }}.
 

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

@@ -2,6 +2,7 @@
 {% set object_base_class = "" if async_mode else "(object)" %}
 {% set operations_description = "async operations" if async_mode else "operations" %}
 {% set return_none_type_annotation = " -> None" if async_mode else "" %}
+# pylint: disable=too-many-lines
 # coding=utf-8
 {{ code_model.options['license_header'] }}
 {{ imports }}