@autorest/python 5.12.5 → 5.12.6

package/ChangeLog.md

@@ -1,5 +1,21 @@
 # Change Log
 
+### 2022-02-09 - 5.12.6
+
+| Library | Min Version
+| --------------- | -------
+|`@autorest/core` |  `3.6.2`
+|`@autorest/modelerfour` | `4.19.1`
+|`azure-core` dep of generated code | `1.20.1`
+|`msrest` dep of generated code | `0.6.21`
+|`azure-mgmt-core` dep of generated code (If generating mgmt plane code) | `1.3.0`
+
+**Bug Fixes**
+
+- Remove unused `metadata` value for paging and long running operations with `version-tolerant` generations #1131
+- Remove name conflicts with parameters called `url`, `header_parameters`, and `query_parameters` #1143
+- Make `--version-tolerant` generated code pylint compatible in the `azure-sdk-for-python` repo when generated with the `--black` flag #1147, #1144, #1130
+
 ### 2022-01-26 - 5.12.5
 
 | Library | Min Version

package/autorest/codegen/models/client.py

@@ -33,13 +33,14 @@ class Client:
     def _imports_shared(self, async_mode: bool) -> FileImport:
         file_import = FileImport()
 
-        file_import.add_submodule_import("msrest", "Serializer", ImportType.AZURECORE)
-        file_import.add_submodule_import("msrest", "Deserializer", ImportType.AZURECORE)
+        file_import.add_submodule_import("msrest", "Serializer", ImportType.THIRDPARTY)
+        file_import.add_submodule_import("msrest", "Deserializer", ImportType.THIRDPARTY)
         file_import.add_submodule_import("typing", "Any", ImportType.STDLIB, TypingSection.CONDITIONAL)
 
         any_optional_gp = any(not gp.required for gp in self.parameters)
 
-        if any_optional_gp or self.code_model.service_client.parameters.host:
+        legacy = not any(g for g in ["low_level_client", "version_tolerant"] if g in self.code_model.options)
+        if any_optional_gp or (legacy and self.code_model.service_client.parameters.host):
             file_import.add_submodule_import("typing", "Optional", ImportType.STDLIB, TypingSection.CONDITIONAL)
 
         if self.code_model.options["azure_arm"]:
@@ -98,6 +99,6 @@ class Client:
             pass
         return file_import
 
-    def send_request_signature(self, async_mode: bool, is_python3_file: bool) -> List[str]:
-        request_signature = ["request: HttpRequest," if async_mode else "request,  # type: HttpRequest"]
+    def send_request_signature(self, is_python3_file: bool) -> List[str]:
+        request_signature = ["request: HttpRequest," if is_python3_file else "request,  # type: HttpRequest"]
         return request_signature + self.parameters.method_signature_kwargs(is_python3_file)

package/autorest/codegen/models/lro_operation.py

@@ -175,6 +175,10 @@ class LROOperation(Operation):
 
         if async_mode:
             file_import.add_submodule_import("typing", "Optional", ImportType.STDLIB, TypingSection.CONDITIONAL)
-        if self.lro_response and self.lro_response.has_body and not self.code_model.options["models_mode"]:
-            file_import.add_submodule_import("json", "loads", import_type=ImportType.STDLIB, alias="_loads")
+        if self.code_model.options["tracing"] and self.want_tracing:
+            file_import.add_submodule_import(
+                f"azure.core.tracing.decorator{'_async' if async_mode else ''}",
+                f"distributed_trace{'_async' if async_mode else ''}",
+                ImportType.AZURECORE,
+            )
         return file_import

package/autorest/codegen/models/operation.py

@@ -159,7 +159,8 @@ class Operation(BaseBuilder):  # pylint: disable=too-many-public-methods, too-ma
             if response.has_body:
                 file_import.merge(cast(BaseSchema, response.schema).imports())
 
-        if len([r for r in self.responses if r.has_body]) > 1:
+        response_types = [r.operation_type_annotation for r in self.responses if r.has_body]
+        if len(set(response_types)) > 1:
             file_import.add_submodule_import("typing", "Union", ImportType.STDLIB, TypingSection.CONDITIONAL)
 
         if self.is_stream_response:
@@ -179,13 +180,10 @@ class Operation(BaseBuilder):  # pylint: disable=too-many-public-methods, too-ma
             file_import.add_submodule_import("azure.mgmt.core.exceptions", "ARMErrorFormat", ImportType.AZURECORE)
         file_import.add_submodule_import("azure.core.exceptions", "HttpResponseError", ImportType.AZURECORE)
 
-
-        file_import.add_import("functools", ImportType.STDLIB)
         file_import.add_submodule_import("typing", "Callable", ImportType.STDLIB, TypingSection.CONDITIONAL)
         file_import.add_submodule_import("typing", "Optional", ImportType.STDLIB, TypingSection.CONDITIONAL)
         file_import.add_submodule_import("typing", "Dict", ImportType.STDLIB, TypingSection.CONDITIONAL)
         file_import.add_submodule_import("typing", "TypeVar", ImportType.STDLIB, TypingSection.CONDITIONAL)
-        file_import.add_submodule_import("typing", "Generic", ImportType.STDLIB, TypingSection.CONDITIONAL)
         file_import.add_submodule_import("azure.core.pipeline", "PipelineResponse", ImportType.AZURECORE)
         file_import.add_submodule_import("azure.core.rest", "HttpRequest", ImportType.AZURECORE)
         if async_mode:
@@ -193,9 +191,7 @@ class Operation(BaseBuilder):  # pylint: disable=too-many-public-methods, too-ma
         else:
             file_import.add_submodule_import("azure.core.pipeline.transport", "HttpResponse", ImportType.AZURECORE)
 
-        # Deprecation
-        # FIXME: Replace with "the YAML contains deprecated:true"
-        if True:  # pylint: disable=using-constant-test
+        if self.deprecated:
             file_import.add_import("warnings", ImportType.STDLIB)
 
         if self.code_model.options["builders_visibility"] != "embedded":
@@ -227,6 +223,12 @@ class Operation(BaseBuilder):  # pylint: disable=too-many-public-methods, too-ma
             any(r for r in self.responses if r.has_body)
         ):
             file_import.define_mypy_type("JSONType", "Any")
+        if self.code_model.options["tracing"] and self.want_tracing:
+            file_import.add_submodule_import(
+                f"azure.core.tracing.decorator{'_async' if async_mode else ''}",
+                f"distributed_trace{'_async' if async_mode else ''}",
+                ImportType.AZURECORE,
+            )
         return file_import
 
     def _get_body_param_from_body_kwarg(self, body_kwarg: Parameter) -> Parameter:

package/autorest/codegen/models/operation_group.py

@@ -63,15 +63,6 @@ class OperationGroup(BaseModel):
         file_import.add_submodule_import("azure.core.exceptions", "ResourceExistsError", ImportType.AZURECORE)
         for operation in self.operations:
             file_import.merge(operation.imports(async_mode))
-        if self.code_model.options["tracing"]:
-            if async_mode:
-                file_import.add_submodule_import(
-                    "azure.core.tracing.decorator_async", "distributed_trace_async", ImportType.AZURECORE,
-                )
-            else:
-                file_import.add_submodule_import(
-                    "azure.core.tracing.decorator", "distributed_trace", ImportType.AZURECORE,
-                )
         local_path = "..." if async_mode else ".."
         if self.code_model.has_schemas and self.code_model.options["models_mode"]:
             file_import.add_submodule_import(local_path, "models", ImportType.LOCAL, alias="_models")

package/autorest/codegen/models/paging_operation.py

@@ -147,6 +147,8 @@ class PagingOperation(Operation):
 
     def imports(self, async_mode: bool) -> FileImport:
         file_import = super(PagingOperation, self).imports(async_mode)
+        # operation adds an import for distributed_trace_async, we don't want it
+        file_import.imports = [i for i in file_import.imports if not i.submodule_name == "distributed_trace_async"]
 
         pager_import_path = ".".join(self.get_pager_path(async_mode).split(".")[:-1])
         pager = self.get_pager(async_mode)
@@ -156,11 +158,9 @@ class PagingOperation(Operation):
         if async_mode:
             file_import.add_submodule_import("azure.core.async_paging", "AsyncList", ImportType.AZURECORE)
 
-        if self.code_model.options["tracing"]:
+        if self.code_model.options["tracing"] and self.want_tracing:
             file_import.add_submodule_import(
                 "azure.core.tracing.decorator", "distributed_trace", ImportType.AZURECORE,
             )
-        if not self.code_model.options["models_mode"]:
-            file_import.add_submodule_import("json", "loads", ImportType.STDLIB, alias="_loads")
 
         return file_import

package/autorest/codegen/models/parameter.py

@@ -98,6 +98,7 @@ class Parameter(BaseModel):  # pylint: disable=too-many-instance-attributes, too
         self.content_types = content_types or []
         self.body_kwargs: List[Parameter] = []
         self.is_body_kwarg = False
+        self.need_import = True
 
     def __hash__(self) -> int:
         return hash(self.serialized_name)

package/autorest/codegen/models/parameter_list.py

@@ -275,6 +275,7 @@ class ParameterList(MutableSequence):  # pylint: disable=too-many-public-methods
 def _create_files_or_data_param(
     params: List[Parameter], serialized_name: str, description: str
 ) -> Parameter:
+    params[0].need_import = False
     param = copy(params[0])
     param.serialized_name = serialized_name
     param.schema = DictionarySchema(

package/autorest/codegen/models/request_builder.py

@@ -66,7 +66,8 @@ class RequestBuilder(BaseBuilder):
     def imports(self) -> FileImport:
         file_import = FileImport()
         for parameter in self.parameters:
-            file_import.merge(parameter.imports())
+            if parameter.need_import:
+                file_import.merge(parameter.imports())
 
         file_import.add_submodule_import(
             "azure.core.rest",
@@ -87,7 +88,7 @@ class RequestBuilder(BaseBuilder):
         file_import.add_submodule_import(
             "typing", "Any", ImportType.STDLIB, typing_section=TypingSection.CONDITIONAL
         )
-        file_import.add_submodule_import("msrest", "Serializer", ImportType.AZURECORE)
+        file_import.add_submodule_import("msrest", "Serializer", ImportType.THIRDPARTY)
         if self.parameters.has_body and (
             self.code_model.options["builders_visibility"] != "embedded" or
             self.code_model.options["add_python3_operation_files"]

package/autorest/codegen/models/request_builder_parameter_list.py

@@ -198,6 +198,7 @@ class RequestBuilderParameterList(ParameterList):
         else:
             for kwarg in body_kwargs_added:
                 kwarg.required = False
+        first_body_param.need_import = False
         self.parameters = body_kwargs_added + self.parameters
 
     @property

package/autorest/codegen/serializers/builder_serializer.py

@@ -33,6 +33,9 @@ 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 +113,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] = []
@@ -180,11 +183,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 +264,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)
@@ -402,7 +402,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 +499,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 +533,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 +718,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,
@@ -986,7 +993,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
@@ -1114,7 +1122,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 +1145,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 +1243,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 +1296,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 +1343,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 +1376,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 +1391,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/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,8 +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 }}
 {% if not code_model.options["version_tolerant"] %}
-{{ operation.python_name }}.metadata = {'url': {{ keywords.escape_str(request_builder.url) }}}  # type: ignore
+{{ 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 }}

package/autorest/codegen/templates/operation_tools.jinja2

@@ -1,4 +1,4 @@
-{% macro wrap_string(string, wrapstring) %}{{ string | wordwrap(width=95, break_long_words=False, break_on_hyphens=False, wrapstring=wrapstring)}}{% endmacro %}
+{% macro wrap_string(string, wrapstring, width=95) %}{{ string | wordwrap(width=width, break_long_words=False, break_on_hyphens=False, wrapstring=wrapstring)}}{% endmacro %}
 
 {% macro description(builder, serializer) %}
     {% for description in serializer.description_and_summary(builder) %}
@@ -22,7 +22,8 @@ Example:
     .. code-block:: python
     {% for template_line in serializer.get_example_template(builder) %}
         {% if template_line %}
-        {{ template_line }}
+            {% set wrap_amount = (template_line | length) - (template_line.lstrip() | length) + 10 %}
+        {{  wrap_string(template_line, wrapstring='\n' + " " * wrap_amount, width=(95 - wrap_amount)) }}
         {% else %}
 
         {% endif %}

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

@@ -17,6 +17,6 @@
     return {{ operation.get_pager(async_mode) }}(
         get_next, extract_data
     )
-{% if not code_model.options["metadata"] %}
-{{ operation.python_name }}.metadata = {'url': '{{ request_builder.url|replace("'", "\\'") }}'}  # type: ignore
+{% if not code_model.options["version_tolerant"] %}
+{{ operation_serializer.get_metadata_url(operation) -}}
 {% endif %}

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

@@ -13,15 +13,10 @@
     {% endfor %}
 {% endif %}
     # Construct URL
-{% if code_model.options["version_tolerant"] or code_model.options["low_level_client"] %}
-    {% set url_value = keywords.escape_str(request_builder.url) %}
-{% else %}
-    {% set url_value = 'kwargs.pop("template_url", ' + keywords.escape_str(request_builder.url) + ')' %}
-{% endif %}
-    url = {{ url_value }}
+    {{ request_builder_serializer.construct_url(request_builder) }}
 {% if request_builder.parameters.path %}
     {{ op_tools.serialize(request_builder_serializer.serialize_path(request_builder)) | indent }}
-    url = _format_url_section(url, **path_format_arguments)
+    _url = _format_url_section(_url, **path_format_arguments)
 {% endif %}
 
 {% if request_builder.parameters.query %}

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

@@ -7,7 +7,7 @@
 {{ imports }}
 
 {{ serializer.class_definition(async_mode) }}
-    """{{ code_model.description }}
+    """{{ op_tools.wrap_string(code_model.description, "\n") | indent }}
 
     {{ op_tools.serialize_with_wrap(serializer.property_descriptions(async_mode), "\n ") | indent }}
     {{ serializer.init_signature_and_response_type_annotation(async_mode) | indent }}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@autorest/python",
-    "version": "5.12.5",
+    "version": "5.12.6",
     "description": "The Python extension for generators in AutoRest.",
     "scripts": {
         "prepare": "node run-python3.js prepare.py",
@@ -27,7 +27,7 @@
         "@azure-tools/extension": "~3.2.1"
     },
     "devDependencies": {
-        "@microsoft.azure/autorest.testserver": "^3.1.11"
+        "@microsoft.azure/autorest.testserver": "^3.1.13"
     },
     "files": [
         "autorest/**/*.py",