@autorest/python 5.13.0 → 5.16.0

package/autorest/codegen/serializers/utils.py

@@ -3,8 +3,9 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
+from enum import Enum, auto
 from typing import List
-from ..models import ParameterStyle, ListSchema, Parameter
+from ..models import ParameterStyle, ListSchema, Parameter, ParameterLocation
 
 
 def serialize_method(
@@ -22,13 +23,11 @@ def serialize_method(
     lines.append(first_line)
     if is_in_class:
         lines.append("    self,")
-    lines.extend([
-        ("    " + line)
-        for line in method_param_signatures
-    ])
+    lines.extend([("    " + line) for line in method_param_signatures])
     lines.append(")")
     return "\n".join(lines)
 
+
 def build_serialize_data_call(
     parameter: Parameter, function_name: str, serializer_name: str
 ) -> str:
@@ -68,30 +67,32 @@ def build_serialize_data_call(
         f'"{origin_name.lstrip("_")}"',
         "q" if parameter.explode else origin_name,
         f"'{serialization_schema.serialization_type}'",
-        *optional_parameters
+        *optional_parameters,
     ]
-    parameters_line = ', '.join(parameters)
+    parameters_line = ", ".join(parameters)
 
-    serialize_line = f'{serializer_name}.{function_name}({parameters_line})'
+    serialize_line = f"{serializer_name}.{function_name}({parameters_line})"
 
     if parameter.explode:
         return f"[{serialize_line} if q is not None else '' for q in {origin_name}]"
     return serialize_line
 
-def serialize_path(
-    parameters: List[Parameter], serializer_name: str
-) -> List[str]:
+
+def serialize_path(parameters: List[Parameter], serializer_name: str) -> List[str]:
     retval = ["path_format_arguments = {"]
-    retval.extend([
-        "    \"{}\": {},".format(
-            path_parameter.rest_api_name,
-            build_serialize_data_call(path_parameter, "url", serializer_name)
-        )
-        for path_parameter in parameters
-    ])
+    retval.extend(
+        [
+            '    "{}": {},'.format(
+                path_parameter.rest_api_name,
+                build_serialize_data_call(path_parameter, "url", serializer_name),
+            )
+            for path_parameter in parameters
+        ]
+    )
     retval.append("}")
     return retval
 
+
 def method_signature_and_response_type_annotation_template(
     *,
     is_python3_file: bool,
@@ -102,16 +103,54 @@ def method_signature_and_response_type_annotation_template(
         return f"{method_signature} -> {response_type_annotation}:"
     return f"{method_signature}:\n    # type: (...) -> {response_type_annotation}"
 
-def pop_kwargs_from_signature(kwargs_to_pop: List[Parameter]) -> List[str]:
+
+class PopKwargType(Enum):
+    NO = auto()
+    SIMPLE = auto()
+    CASE_INSENSITIVE = auto()
+
+
+def pop_kwargs_from_signature(
+    kwargs_to_pop: List[Parameter],
+    check_kwarg_dict: bool,
+    pop_headers_kwarg: PopKwargType,
+    pop_params_kwarg: PopKwargType,
+) -> List[str]:
     retval = []
+
+    def append_pop_kwarg(key: str, pop_type: PopKwargType) -> None:
+        if PopKwargType.CASE_INSENSITIVE == pop_type:
+            retval.append(
+                f'_{key} = case_insensitive_dict(kwargs.pop("{key}", {{}}) or {{}})'
+            )
+        elif PopKwargType.SIMPLE == pop_type:
+            retval.append(f'_{key} = kwargs.pop("{key}", {{}}) or {{}}')
+
+    append_pop_kwarg("headers", pop_headers_kwarg)
+    append_pop_kwarg("params", pop_params_kwarg)
+    if pop_headers_kwarg != PopKwargType.NO or pop_params_kwarg != PopKwargType.NO:
+        retval.append("")
     for kwarg in kwargs_to_pop:
         if kwarg.has_default_value:
+            default_value = kwarg.default_value_declaration
+            if check_kwarg_dict and (
+                kwarg.location in [ParameterLocation.Header, ParameterLocation.Query]
+            ):
+                kwarg_dict = (
+                    "headers"
+                    if kwarg.location == ParameterLocation.Header
+                    else "params"
+                )
+                default_value = (
+                    f"_{kwarg_dict}.pop('{kwarg.rest_api_name}', {default_value})"
+                )
             retval.append(
                 f"{kwarg.serialized_name} = kwargs.pop('{kwarg.serialized_name}', "
-                + f"{kwarg.default_value_declaration})  # type: {kwarg.type_annotation}"
+                + f"{default_value})  # type: {kwarg.type_annotation(is_operation_file=True)}"
             )
         else:
+            type_annot = kwarg.type_annotation(is_operation_file=True)
             retval.append(
-                f"{kwarg.serialized_name} = kwargs.pop('{kwarg.serialized_name}')  # type: {kwarg.type_annotation}"
+                f"{kwarg.serialized_name} = kwargs.pop('{kwarg.serialized_name}')  # type: {type_annot}"
             )
     return retval

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

@@ -35,8 +35,8 @@ class {{ code_model.class_name }}Configuration(Configuration):  # pylint: disabl
 {% if serializer.set_constants() %}
         {{ op_tools.serialize(serializer.set_constants()) | indent(8) -}}
 {% endif %}
-{% if code_model.options['credential'] and code_model.credential_schema_policy.credential_scopes is defined %}
-        self.credential_scopes = kwargs.pop('credential_scopes', {{ code_model.credential_schema_policy.credential_scopes }})
+{% if code_model.options['credential'] and code_model.credential_model.credential_schema_policy.credential_scopes is defined %}
+        self.credential_scopes = kwargs.pop('credential_scopes', {{ code_model.credential_model.credential_schema_policy.credential_scopes }})
 {% endif %}
         kwargs.setdefault('sdk_moniker', '{{ sdk_moniker }}/{}'.format(VERSION))
         self._configure(**kwargs)
@@ -59,10 +59,10 @@ class {{ code_model.class_name }}Configuration(Configuration):  # pylint: disabl
         self.authentication_policy = kwargs.get('authentication_policy')
         {% if code_model.options['credential'] %}
         {# only adding this if credential_scopes is not passed during code generation #}
-        {% if code_model.credential_schema_policy.credential_scopes is defined and code_model.credential_schema_policy.credential_scopes|length == 0 %}
+        {% if code_model.credential_model.credential_schema_policy.credential_scopes is defined and code_model.credential_model.credential_schema_policy.credential_scopes|length == 0 %}
         if not self.credential_scopes and not self.authentication_policy:
             raise ValueError("You must provide either credential_scopes or authentication_policy as kwargs")
         {% endif %}
         if self.credential and not self.authentication_policy:
-            self.authentication_policy = {{ code_model.credential_schema_policy.call(async_mode) }}
+            self.authentication_policy = {{ code_model.credential_model.credential_schema_policy.call(async_mode) }}
         {% endif %}

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/enum.py.jinja2

@@ -1,5 +1,5 @@
 
-class {{ enum.name }}(with_metaclass(CaseInsensitiveEnumMeta, {{ enum.enum_type.type_annotation }}, Enum)):
+class {{ enum.name }}({{ enum.enum_type.type_annotation() }}, Enum, metaclass=CaseInsensitiveEnumMeta):
     {% if enum.description %}
     """{{ enum.description | wordwrap(width=95, break_long_words=False, break_on_hyphens=False, wrapstring='\n    ') }}
     """

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

@@ -2,7 +2,6 @@
 {{ code_model.options['license_header'] }}
 
 from enum import Enum
-from six import with_metaclass
 from azure.core import CaseInsensitiveEnumMeta
 
 {% for enum in code_model.enums.values() | sort %}

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

@@ -1,15 +1,18 @@
+{% import 'keywords.jinja2' as keywords %}
 # coding=utf-8
 {{ code_model.options['license_header'] }}
 
-from ._{{ code_model.module_name }} import {{ code_model.class_name }}
+{% if code_model.request_builders %}
+from .{{ code_model.service_client.filename }} import {{ code_model.class_name }}
+{% endif %}
 {% if not async_mode and code_model.options['package_version']%}
 from ._version import VERSION
 
 __version__ = VERSION
 {% endif %}
-__all__ = ['{{ code_model.class_name }}']
 
-# `._patch.py` is used for handwritten extensions to the generated code
-# Example: https://github.com/Azure/azure-sdk-for-python/blob/main/doc/dev/customize_code/how-to-patch-sdk-code.md
-from ._patch import patch_sdk
-patch_sdk()
+{{ keywords.patch_imports(try_except=True) }}
+__all__ = [{{("'" + code_model.class_name + "'") if code_model.request_builders else ""}}]
+{{ keywords.extend_all }}
+
+_patch_sdk()

package/autorest/codegen/templates/keywords.jinja2

@@ -3,4 +3,17 @@
 {% set await = "await " if async_mode else "" %}
 {% set async_class = "Async" if async_mode else "" %}
 {% macro escape_str(s) %}'{{ s|replace("'", "\\'") }}'{% endmacro %}
-{% set kwargs_declaration = "**kwargs: Any" if async_mode else "**kwargs  # type: Any" %}
+{% set kwargs_declaration = "**kwargs: Any" if async_mode else "**kwargs  # type: Any" %}
+{% set extend_all = "__all__.extend([p for p in _patch_all if p not in __all__])" %}
+{% macro patch_imports(try_except=False) %}
+{% set indentation = "    " if try_except else "" %}
+{% if try_except %}
+try:
+{% endif %}
+{{ indentation }}from ._patch import __all__ as _patch_all
+{{ indentation }}from ._patch import *  # type: ignore # pylint: disable=unused-wildcard-import
+{% if try_except %}
+except ImportError:
+    _patch_all = []
+{% endif %}
+from ._patch import patch_sdk as _patch_sdk{% endmacro %}

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

@@ -1,18 +1,16 @@
 {% import 'operation_tools.jinja2' as op_tools with context %}
-{% set trace_decorator = "@distributed_trace_async" if async_mode else "@distributed_trace" %}
 {# actual template starts here #}
-{% if code_model.options['tracing'] %}
-{{ trace_decorator }}
-{% endif %}
-{{ operation_serializer.method_signature_and_response_type_annotation(operation) }}
+{{ operation_serializer.method_signature_and_response_type_annotation(operation, async_mode) }}
     {{ op_tools.description(operation, operation_serializer) | indent -}}
-    {% if operation.parameters.kwargs_to_pop(async_mode) %}
+    {% if not operation.abstract %}
+        {% if operation_serializer.pop_kwargs_from_signature(operation) %}
     {{ op_tools.serialize(operation_serializer.pop_kwargs_from_signature(operation)) | indent }}
-    {%- endif %}
+        {%- endif %}
     {{ 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 }}
+    {% endif %}
 {% if not code_model.options["version_tolerant"] %}
 {{ operation_serializer.get_metadata_url(operation) -}}
 {% endif %}

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

@@ -1,20 +1,18 @@
 {% import 'operation_tools.jinja2' as op_tools with context %}
 {% import 'keywords.jinja2' as keywords with context %}
-{% set trace_decorator = "@distributed_trace_async" if async_mode else "@distributed_trace" %}
 {# actual template starts here #}
-{% if code_model.options['tracing'] %}
-{{ trace_decorator }}
-{% endif %}
-{{ operation_serializer.method_signature_and_response_type_annotation(operation) }}
+{{ operation_serializer.method_signature_and_response_type_annotation(operation, async_mode) }}
     {{ op_tools.description(operation, operation_serializer) | indent }}
-    {% if operation.parameters.kwargs_to_pop(async_mode) %}
+    {% if not operation.abstract %}
+        {% if operation_serializer.pop_kwargs_from_signature(operation) %}
     {{ op_tools.serialize(operation_serializer.pop_kwargs_from_signature(operation)) | indent }}
-    {% endif %}
+        {% endif %}
     {{ op_tools.serialize(operation_serializer.set_up_params_for_pager(operation)) | indent }}
 
     {{ 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 }}
+    {% endif %}
 {% if not code_model.options["version_tolerant"] %}
 {{ operation_serializer.get_metadata_url(operation) }}
 {% endif %}

package/autorest/codegen/templates/metadata.json.jinja2

@@ -92,9 +92,9 @@
     },
     "config": {
         "credential": {{ code_model.options['credential'] | tojson }},
-        "credential_scopes": {{ (code_model.credential_schema_policy.credential_scopes if code_model.options['credential'] and code_model.credential_schema_policy.credential_scopes is defined else None)| tojson}},
-        "credential_call_sync": {{ (code_model.credential_schema_policy.call(async_mode=False) if code_model.options['credential'] else None) | tojson }},
-        "credential_call_async": {{ (code_model.credential_schema_policy.call(async_mode=True) if code_model.options['credential'] else None) | tojson }},
+        "credential_scopes": {{ (code_model.credential_model.credential_schema_policy.credential_scopes if code_model.options['credential'] and code_model.credential_model.credential_schema_policy.credential_scopes is defined else None)| tojson}},
+        "credential_call_sync": {{ (code_model.credential_model.credential_schema_policy.call(async_mode=False) if code_model.options['credential'] else None) | tojson }},
+        "credential_call_async": {{ (code_model.credential_model.credential_schema_policy.call(async_mode=True) if code_model.options['credential'] else None) | tojson }},
         "sync_imports": {{ sync_config_imports | tojson }},
         "async_imports": {{ async_config_imports | tojson }}
     },
@@ -126,8 +126,9 @@
                         {% from "operation.py.jinja2" import operation_docstring with context %}
                         {% set sync_return_type_wrapper = "" %}
                     {% endif %}
-                    "signature": {{ (operation_serializer.method_signature_and_response_type_annotation(operation) + "\n") | tojson }},
-                    "doc": {{ op_tools.description(operation, operation_serializer).rstrip("\n") | tojson }}
+                    "signature": {{ (operation_serializer.method_signature_and_response_type_annotation(operation, False, want_decorators=False) + "\n") | tojson }},
+                    "doc": {{ op_tools.description(operation, operation_serializer).rstrip("\n") | tojson }},
+                    "call": {{ operation.parameters.call(is_python3_file=False) | join(', ') | tojson }}
                 },
                 "async": {
                     {% set coroutine = False if (is_paging(operation) and not is_lro(operation)) else True %}
@@ -146,10 +147,10 @@
                         {% from "operation.py.jinja2" import operation_docstring with context %}
                         {% set async_return_type_wrapper = "" %}
                     {% endif %}
-                    "signature": {{ (operation_serializer.method_signature_and_response_type_annotation(operation) + "\n") | tojson }},
-                    "doc": {{ op_tools.description(operation, operation_serializer).rstrip("\n") | tojson }}
-                },
-                "call": {{ operation.parameters.method | rejectattr("is_kwarg") | map(attribute="serialized_name") | rejectattr("is_kwarg") | join(', ') | tojson }}
+                    "signature": {{ (operation_serializer.method_signature_and_response_type_annotation(operation, True, want_decorators=False) + "\n") | tojson }},
+                    "doc": {{ op_tools.description(operation, operation_serializer).rstrip("\n") | tojson }},
+                    "call": {{ operation.parameters.call(is_python3_file=True) | join(', ') | tojson }}
+                }
             }{{ "," if not loop.last else "" }}
             {% endfor %}
         }

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

@@ -1,12 +1,7 @@
-{% set basename = model.base_models | join(', ', attribute='name') if model.base_models else "" %}
 {# actual template starts here #}
 
 
-{% if basename %}
-class {{ model.name }}({{ basename }}):
-{% else %}
-class {{ model.name }}(msrest.serialization.Model):
-{% endif %}
+{{ declare_model(model) }}
     """{{ model.description }}
     {% if model.discriminator_name %}
 

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

@@ -1,8 +1,9 @@
+{% import 'keywords.jinja2' as keywords %}
 # coding=utf-8
 {{ code_model.options['license_header'] }}
 {% macro iterate_models_py3() %}
     {% for schema in schemas %}
-from ._models_py3 import {{ schema }}
+from .{{ code_model.get_models_filename(is_python3_file=True) }} import {{ schema }}
     {% endfor %}
 {% endmacro %}
 
@@ -14,19 +15,19 @@ try:
     {{ iterate_models_py3() | indent-}}
 except (SyntaxError, ImportError):
         {% for schema in schemas %}
-    from ._models import {{ schema }}  # type: ignore
+    from .{{ code_model.get_models_filename(is_python3_file=False) }} import {{ schema }}  # type: ignore
         {% endfor %}
     {% endif %}
 {% endif %}
 {% if enums %}
 
-from ._{{ code_model.module_name }}_enums import (
+from .{{ code_model.enums_filename }} import (
     {% for enum in enums %}
     {{ enum }},
     {% endfor %}
 )
 {% endif %}
-
+{{ keywords.patch_imports() }}
 __all__ = [
     {% for schema in schemas %}
     '{{ schema }}',
@@ -37,3 +38,5 @@ __all__ = [
     {% endfor %}
 {% endif %}
 ]
+{{ keywords.extend_all }}
+_patch_sdk()

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

@@ -1,29 +1,26 @@
 {% import 'keywords.jinja2' as keywords with context %}
 {% import 'operation_tools.jinja2' as op_tools %}
-{% set trace_decorator = "@distributed_trace_async" if async_mode else "@distributed_trace" %}
 {% set stream_request_parameter = "stream=" ~ ("True" if operation.is_stream_response else "False") %}
 {# actual template starts here #}
-{%- if code_model.options['tracing'] and operation.want_tracing -%}
-{{ trace_decorator }}
-{% endif %}
-{{ operation_serializer.method_signature_and_response_type_annotation(operation) }}
+{{ operation_serializer.method_signature_and_response_type_annotation(operation, async_mode) }}
 {% if operation.want_description_docstring %}
     {{ op_tools.description(operation, operation_serializer) | indent }}{% endif %}
-    cls = kwargs.pop('cls', None)  {{ operation_serializer.cls_type_annotation(operation) }}
-{% if operation.deprecated %}
+    {% if not operation.abstract %}
+        {% if operation.deprecated %}
     warnings.warn('Method {{operation.name}} is deprecated', DeprecationWarning)
-{% endif %}
+        {% endif %}
     {{ op_tools.serialize(operation_serializer.error_map(operation)) | indent }}
-    {% if operation.parameters.kwargs_to_pop(async_mode) %}
+        {% if operation_serializer.pop_kwargs_from_signature(operation) %}
     {{ op_tools.serialize(operation_serializer.pop_kwargs_from_signature(operation)) | indent }}
-    {% endif %}
+        {% endif %}
     {{ op_tools.serialize(operation_serializer.call_request_builder(operation)) | indent }}
-    pipeline_response = {{ keywords.await }}self._client._pipeline.run(  # pylint: disable=protected-access
+    pipeline_response = {{ keywords.await }}self._client._pipeline.run(  # type: ignore # pylint: disable=protected-access
         request,
         {{ stream_request_parameter }},
         **kwargs
     )
     {{ op_tools.serialize(operation_serializer.handle_response(operation)) | indent }}
+    {% endif %}
 {% if not code_model.options["version_tolerant"] %}
 {{ operation_serializer.get_metadata_url(operation) }}
 {% endif %}

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

@@ -1,30 +1,27 @@
 {% set disable = "  # pylint: disable=too-many-public-methods" if operation_group.operations | length > 20 else "" %}
-class {{ operation_group.class_name }}{{ object_base_class }}:{{ disable }}
+{% set base_class = ("(" + operation_group.base_class(async_mode) + ")") if operation_group.base_class(async_mode) else "" %}
+class {{ operation_group.class_name }}{{ 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 }}:
+        input_args = list(args)
+        self._client = input_args.pop(0) if input_args else kwargs.pop("client")
+        self._config = input_args.pop(0) if input_args else kwargs.pop("config")
+        self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer")
+        self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer")
+
 {% endif %}
 {% for operation in operation_group.operations %}
 

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

@@ -1,5 +1,4 @@
 {% import 'operation_tools.jinja2' as op_tools %}
-{% 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
@@ -13,7 +12,7 @@
 # fmt: off
 {% endif %}
 {% for operation_group in operation_groups %}
-    {% for request_builder in code_model.rest.request_builders | selectattr("operation_group_name", "equalto", operation_group.name) %}
+    {% for request_builder in code_model.request_builders | selectattr("operation_group_name", "equalto", operation_group.name) %}
 
         {% include "request_builder.py.jinja2" %}
     {% endfor %}

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

@@ -1,9 +1,11 @@
 {% import 'operation_tools.jinja2' as op_tools %}
+{% import 'keywords.jinja2' as keywords %}
 {# actual template starts here #}
 # coding=utf-8
 {{ code_model.options['license_header'] }}
 
 {{ op_tools.serialize(operation_group_imports()) }}
+{{ keywords.patch_imports() }}
 {% if operation_groups %}
 __all__ = [
     {% for operation_group in operation_groups %}
@@ -11,3 +13,5 @@ __all__ = [
     {% endfor %}
 ]
 {% endif %}
+{{ keywords.extend_all }}
+_patch_sdk()