@autorest/python 5.12.5 → 5.14.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

@@ -119,4 +119,7 @@ class GeneralSerializer:
 
     def serialize_setup_file(self) -> str:
         template = self.env.get_template("setup.py.jinja2")
-        return template.render(code_model=self.code_model)
+        params = {}
+        params.update(self.code_model.options)
+        params.update(self.code_model.package_dependency)
+        return template.render(code_model=self.code_model, **params)

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/CHANGELOG.md.jinja2

@@ -0,0 +1,6 @@
+# Release History
+
+## 1.0.0b1 (1970-01-01)
+
+- Initial version
+

package/autorest/codegen/templates/LICENSE.jinja2

@@ -0,0 +1,21 @@
+Copyright (c) Microsoft Corporation.
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED *AS IS*, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/autorest/codegen/templates/MANIFEST.in.jinja2

@@ -0,0 +1,7 @@
+include *.md
+include LICENSE
+recursive-include tests *.py
+recursive-include samples *.py *.md
+{%- for init_name in init_names %}
+include {{ init_name }}
+{%- endfor %}

package/autorest/codegen/templates/README.md.jinja2

@@ -0,0 +1,105 @@
+{% if package_mode == "mgmtplane" -%}
+# Microsoft Azure SDK for Python
+
+This is the Microsoft {{package_pprint_name}} Client Library.
+This package has been tested with Python 3.6+.
+For a more complete view of Azure libraries, see the [azure sdk python release](https://aka.ms/azsdk/python/all).
+
+# Usage
+
+To learn how to use this package, see the [quickstart guide](https://aka.ms/azsdk/python/mgmt)
+
+For docs and references, see [Python SDK References](https://docs.microsoft.com/python/api/overview/azure)
+Code samples for this package can be found at [{{package_pprint_name}}](https://docs.microsoft.com/samples/browse/?languages=python&term=Getting%20started%20-%20Managing&terms=Getting%20started%20-%20Managing) on docs.microsoft.com.
+Additional code samples for different Azure services are available at [Samples Repo](https://aka.ms/azsdk/python/mgmt/samples)
+
+# Provide Feedback
+
+If you encounter any bugs or have suggestions, please file an issue in the
+[Issues](https://github.com/Azure/azure-sdk-for-python/issues)
+section of the project. 
+
+
+![Impressions](https://azure-sdk-impressions.azurewebsites.net/api/impressions/azure-sdk-for-python%2F{{package_name}}%2FREADME.png)
+{% else %}
+# {{ package_pprint_name }} client library for Python
+<!-- write necessary description of service -->
+
+## Getting started
+
+### Installating the package
+
+```bash
+python -m pip install {{ package_name }}
+```
+
+#### Prequisites
+
+- Python 3.6 or later is required to use this package.
+- You need an [Azure subscription][azure_sub] to use this package.
+- An existing {{ package_pprint_name }} instance.
+
+{%- if token_credential %}
+#### Create with an Azure Active Directory Credential
+To use an [Azure Active Directory (AAD) token credential][authenticate_with_token],
+provide an instance of the desired credential type obtained from the
+[azure-identity][azure_identity_credentials] library.
+
+To authenticate with AAD, you must first [pip][pip] install [`azure-identity`][azure_identity_pip]
+
+After setup, you can choose which type of [credential][azure_identity_credentials] from azure.identity to use.
+As an example, [DefaultAzureCredential][default_azure_credential] can be used to authenticate the client:
+
+Set the values of the client ID, tenant ID, and client secret of the AAD application as environment variables:
+`AZURE_CLIENT_ID`, `AZURE_TENANT_ID`, `AZURE_CLIENT_SECRET`
+
+Use the returned token credential to authenticate the client:
+
+```python
+>>> from {{ namespace }} import {{ client_name }}
+>>> from azure.identity import DefaultAzureCredential
+>>> client = {{ client_name }}(endpoint='<endpoint>', credential=DefaultAzureCredential())
+```
+
+## Examples
+
+```python
+>>> from {{ namespace }} import {{ client_name }}
+>>> from azure.identity import DefaultAzureCredential
+>>> from azure.core.exceptions import HttpResponseError
+
+>>> client = {{ client_name }}(endpoint='<endpoint>', credential=DefaultAzureCredential())
+>>> try:
+        <!-- write test code here -->
+    except HttpResponseError as e:
+        print('service responds error: {}'.format(e.response.json()))
+
+```
+{%- endif %}
+
+## Contributing
+
+This project welcomes contributions and suggestions. Most contributions require
+you to agree to a Contributor License Agreement (CLA) declaring that you have
+the right to, and actually do, grant us the rights to use your contribution.
+For details, visit https://cla.microsoft.com.
+
+When you submit a pull request, a CLA-bot will automatically determine whether
+you need to provide a CLA and decorate the PR appropriately (e.g., label,
+comment). Simply follow the instructions provided by the bot. You will only
+need to do this once across all repos using our CLA.
+
+This project has adopted the
+[Microsoft Open Source Code of Conduct][code_of_conduct]. For more information,
+see the Code of Conduct FAQ or contact opencode@microsoft.com with any
+additional questions or comments.
+
+<!-- LINKS -->
+[code_of_conduct]: https://opensource.microsoft.com/codeofconduct/
+[authenticate_with_token]: https://docs.microsoft.com/azure/cognitive-services/authentication?tabs=powershell#authenticate-with-an-authentication-token
+[azure_identity_credentials]: https://github.com/Azure/azure-sdk-for-python/tree/main/sdk/identity/azure-identity#credentials
+[azure_identity_pip]: https://pypi.org/project/azure-identity/
+[default_azure_credential]: https://github.com/Azure/azure-sdk-for-python/tree/main/sdk/identity/azure-identity#defaultazurecredential
+[pip]: https://pypi.org/project/pip/
+[azure_sub]: https://azure.microsoft.com/free/
+{% endif %}

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/dev_requirements.txt.jinja2

@@ -0,0 +1,10 @@
+-e ../../../tools/azure-devtools
+-e ../../../tools/azure-sdk-tools
+../../core/azure-core
+{% if token_credential -%}
+../../identity/azure-identity
+{% endif -%}
+{% if azure_arm -%}
+../../core/azure-mgmt-core
+{% endif -%}
+aiohttp

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,29 +1,26 @@
-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 }}.
-
-    You should not instantiate this class directly. Instead, you should create a Client instance that
-    instantiates it for you and attaches it as an attribute.
+    """
+    .. warning::
+        **DO NOT** instantiate this class directly.
 
-{% if code_model.schemas and code_model.options["models_mode"] %}
-    :ivar models: Alias to model classes used in this operation group.
-    :type models: ~{{ code_model.namespace }}.models
-{% endif %}
-    :param client: Client for service requests.
-    :param config: Configuration of service client.
-    :param serializer: An object model serializer.
-    :param deserializer: An object model deserializer.
+        Instead, you should access the following operations through
+        :class:`{{ "~" + code_model.namespace + (".aio." if async_mode else ".") + code_model.class_name }}`'s
+        :attr:`{{ operation_group.name }}` attribute.
     """
 
 {% if code_model.schemas and code_model.options["models_mode"] %}
     models = _models
 
 {% endif %}
-    def __init__(self, client, config, serializer, deserializer){{ return_none_type_annotation }}:
-        self._client = client
-        self._serialize = serializer
-        self._deserialize = deserializer
-        self._config = config
+    def __init__(self, *args, **kwargs){{ return_none_type_annotation }}:
+        args = list(args)
+        self._client = args.pop(0) if args else kwargs.pop("client")
+        self._config = args.pop(0) if args else kwargs.pop("config")
+        self._serialize = args.pop(0) if args else kwargs.pop("serializer")
+        self._deserialize = args.pop(0) if args else kwargs.pop("deserializer")
+
 {% endif %}
 {% for operation in operation_group.operations %}
 

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 %}