@autorest/python 6.38.1 → 6.39.0

package/autorest/multiapi/serializers/__init__.py

@@ -1,145 +0,0 @@
-# -------------------------------------------------------------------------
-# Copyright (c) Microsoft Corporation. All rights reserved.
-# Licensed under the MIT License. See License.txt in the project root for
-# license information.
-# --------------------------------------------------------------------------
-from pathlib import Path
-from typing import Any, Optional, Union, List
-from jinja2 import PackageLoader, Environment
-from pygen import ReaderAndWriter
-from pygen.utils import build_policies
-
-from .import_serializer import FileImportSerializer
-
-from ...jsonrpc import AutorestAPI
-from ..models import CodeModel, GlobalParameter
-from ... import ReaderAndWriterAutorest
-
-
-__all__ = [
-    "MultiAPISerializer",
-]
-
-_FILE_TO_TEMPLATE = {
-    "init": "multiapi_init.py.jinja2",
-    "client": "multiapi_service_client.py.jinja2",
-    "config": "multiapi_config.py.jinja2",
-    "models": "multiapi_models.py.jinja2",
-    "operations_mixin": "multiapi_operations_mixin.py.jinja2",
-}
-
-
-def _method_signature_helper(parameters: List[GlobalParameter], async_mode: bool) -> List[str]:
-    return [p.signature(async_mode) for p in sorted(parameters, key=lambda p: p.required, reverse=True)]
-
-
-def _get_file_path(filename: str, async_mode: bool) -> Path:
-    filename += ".py"
-    if async_mode:
-        return Path("aio") / filename
-    return Path(filename)
-
-
-class MultiAPISerializer(ReaderAndWriter):  # pylint: disable=abstract-method
-    def __init__(self, **kwargs: Any) -> None:
-        super().__init__(**kwargs)
-        self.env = Environment(
-            loader=PackageLoader("autorest.multiapi", "templates"),
-            keep_trailing_newline=True,
-            line_statement_prefix="##",
-            line_comment_prefix="###",
-            trim_blocks=True,
-            lstrip_blocks=True,
-        )
-
-    def _serialize_helper(self, code_model: CodeModel, async_mode: bool) -> None:
-        def _render_template(file: str, **kwargs: Any) -> str:
-            template = self.env.get_template(_FILE_TO_TEMPLATE[file])
-            all_params = (
-                code_model.global_parameters.parameters
-                + code_model.global_parameters.service_client_specific_global_parameters
-            )
-            positional_params = [p for p in all_params if p.method_location == "positional"]
-            keyword_only_params = [p for p in all_params if p.method_location == "keywordOnly"]
-            return template.render(
-                code_model=code_model,
-                async_mode=async_mode,
-                positional_params=_method_signature_helper(positional_params, async_mode),
-                keyword_only_params=_method_signature_helper(keyword_only_params, async_mode),
-                **kwargs
-            )
-
-        # serialize init file
-        self.write_file(_get_file_path("__init__", async_mode), _render_template("init"))
-
-        # serialize service client file
-        imports = FileImportSerializer(code_model.client.imports(async_mode))
-        config_policies = build_policies(code_model.azure_arm, async_mode, is_azure_flavor=True)
-        self.write_file(
-            _get_file_path(code_model.client.filename, async_mode),
-            _render_template("client", imports=imports, config_policies=config_policies),
-        )
-
-        # serialize config file
-        imports = FileImportSerializer(code_model.config.imports(async_mode))
-        self.write_file(
-            _get_file_path("_configuration", async_mode),
-            _render_template("config", imports=imports),
-        )
-
-        # serialize mixins
-        if code_model.operation_mixin_group.mixin_operations:
-            imports = FileImportSerializer(
-                code_model.operation_mixin_group.imports(async_mode),
-                code_model.operation_mixin_group.typing_definitions(async_mode),
-            )
-            self.write_file(
-                _get_file_path("_operations_mixin", async_mode),
-                _render_template("operations_mixin", imports=imports),
-            )
-
-        # serialize models
-        self.write_file(Path("models.py"), _render_template("models"))
-
-    def _serialize_version_file(self) -> None:
-        if self.read_file("_version.py"):
-            self.write_file("_version.py", self.read_file("_version.py"))
-        elif self.read_file("version.py"):
-            self.write_file("_version.py", self.read_file("version.py"))
-        else:
-            template = self.env.get_template("multiapi_version.py.jinja2")
-            self.write_file(Path("_version.py"), template.render())
-
-    def serialize(self, code_model: CodeModel, no_async: Optional[bool]) -> None:
-        self._serialize_helper(code_model, async_mode=False)
-        if not no_async:
-            self._serialize_helper(code_model, async_mode=True)
-
-        self._serialize_version_file()
-
-        # don't erase patch file
-        if self.read_file("_patch.py"):
-            self.write_file("_patch.py", self.read_file("_patch.py"))
-
-        self.write_file(Path("py.typed"), "# Marker file for PEP 561.")
-
-        if not code_model.client.client_side_validation:
-            codegen_env = Environment(
-                loader=PackageLoader("pygen.codegen", "templates"),
-                keep_trailing_newline=True,
-                line_statement_prefix="##",
-                line_comment_prefix="###",
-                trim_blocks=True,
-                lstrip_blocks=True,
-            )
-            self.write_file(
-                Path("_serialization.py"),
-                codegen_env.get_template("serialization.py.jinja2").render(
-                    code_model=code_model,
-                ),
-            )
-
-
-class MultiAPISerializerAutorest(MultiAPISerializer, ReaderAndWriterAutorest):
-    def __init__(self, autorestapi: AutorestAPI, *, output_folder: Union[str, Path]) -> None:
-        super().__init__(autorestapi=autorestapi, output_folder=output_folder)

package/autorest/multiapi/serializers/import_serializer.py

@@ -1,181 +0,0 @@
-# -------------------------------------------------------------------------
-# Copyright (c) Microsoft Corporation. All rights reserved.
-# Licensed under the MIT License. See License.txt in the project root for
-# license information.
-# --------------------------------------------------------------------------
-from copy import deepcopy
-from typing import Dict, Set, Optional, List, Tuple, Union
-from ..models import ImportType, FileImport, TypingSection
-from ..utils import convert_list_to_tuple
-
-
-def _serialize_package(
-    package_name: str,
-    module_list: Set[
-        Optional[
-            Union[
-                str,
-                Tuple[
-                    str,
-                    str,
-                ],
-                Tuple[
-                    str,
-                    Optional[str],
-                    Tuple[Tuple[Tuple[int, int], str, Optional[str]]],
-                ],
-            ]
-        ]
-    ],
-    delimiter: str,
-) -> str:
-    buffer = []
-
-    versioned_modules = set()
-    normal_modules = set()
-    for m in module_list:
-        if m and isinstance(m, (tuple, list)) and len(m) > 2:
-            versioned_modules.add(convert_list_to_tuple(m))
-        else:
-            normal_modules.add(m)
-    if None in normal_modules:
-        buffer.append(f"import {package_name}")
-    if normal_modules != {None} and len(normal_modules) > 0:
-        buffer.append(
-            "from {} import {}".format(
-                package_name,
-                ", ".join(
-                    sorted(
-                        [
-                            mod if isinstance(mod, str) else f"{mod[0]} as {mod[1]}"
-                            for mod in normal_modules
-                            if mod is not None
-                        ]
-                    )
-                ),
-            )
-        )
-    for submodule_name, alias, version_modules in versioned_modules:
-        for n, (version, module_name, comment) in enumerate(version_modules):
-            buffer.append("{} sys.version_info >= {}:".format("if" if n == 0 else "elif", version))
-            buffer.append(
-                f"    from {module_name} import {submodule_name}{f' as {alias}' if alias else ''}"
-                f"{f' # {comment}' if comment else ''}"
-            )
-        buffer.append("else:")
-        buffer.append(
-            f"    from {package_name} import {submodule_name}{f' as {alias}' if alias else ''}"
-            "  # type: ignore  # pylint: disable=ungrouped-imports"
-        )
-    return delimiter.join(buffer)
-
-
-def _serialize_type(
-    import_type_dict: Dict[
-        str,
-        Set[
-            Optional[
-                Union[
-                    str,
-                    Tuple[
-                        str,
-                        str,
-                    ],
-                    Tuple[
-                        str,
-                        Optional[str],
-                        Tuple[Tuple[Tuple[int, int], str, Optional[str]]],
-                    ],
-                ]
-            ]
-        ],
-    ],
-    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))
-    return delimiter.join(import_list)
-
-
-def _get_import_clauses(
-    imports: Dict[
-        ImportType,
-        Dict[
-            str,
-            Set[
-                Optional[
-                    Union[
-                        str,
-                        Tuple[
-                            str,
-                            str,
-                        ],
-                        Tuple[
-                            str,
-                            Optional[str],
-                            Tuple[Tuple[Tuple[int, int], str, Optional[str]]],
-                        ],
-                    ]
-                ]
-            ],
-        ],
-    ],
-    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))
-    return import_clause
-
-
-class FileImportSerializer:
-    def __init__(self, file_import: FileImport, typing_definitions: str = "") -> None:
-        self._file_import = file_import
-        self._typing_definitions = typing_definitions
-
-    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):
-        # 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):
-            # 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, {})
-
-    def _add_type_checking_import(self):
-        if self._file_import.imports.get(TypingSection.TYPING):
-            self._file_import.add_submodule_import("typing", "TYPE_CHECKING", ImportType.STDLIB)
-
-    def __str__(self) -> str:
-        self._add_type_checking_import()
-        regular_imports = ""
-        regular_imports_dict = self._get_imports_dict(
-            baseline_typing_section=TypingSection.REGULAR,
-            add_conditional_typing=True,
-        )
-
-        if regular_imports_dict:
-            regular_imports = "\n\n".join(_get_import_clauses(regular_imports_dict, "\n"))
-
-        typing_imports = ""
-        typing_imports_dict = self._get_imports_dict(
-            baseline_typing_section=TypingSection.TYPING,
-            add_conditional_typing=False,
-        )
-        if typing_imports_dict:
-            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    "))
-
-        return regular_imports + typing_imports + self._typing_definitions

package/autorest/multiapi/templates/multiapi_config.py.jinja2

@@ -1,89 +0,0 @@
-{% macro method_signature() %}
-def __init__(
-    self,
-    {% for parameter in code_model.global_parameters.parameters %}
-        {% if parameter.required %}
-    {{ parameter.signature(async_mode) }}
-        {% endif %}
-    {% endfor %}
-    {% for parameter in code_model.global_parameters.parameters %}
-        {% if not parameter.required %}
-    {{ parameter.signature(async_mode) }}
-        {% endif %}
-    {% endfor %}
-    **kwargs: Any
-){{" -> None" if async_mode else "" }}:{% endmacro %}
-{% set version_import = ".._version" if async_mode else "._version" %}
-{% set async_prefix = "Async" if async_mode else "" %}
-{# actual template starts here #}
-# coding=utf-8
-# --------------------------------------------------------------------------
-# Copyright (c) Microsoft Corporation. All rights reserved.
-# Licensed under the MIT License. See License.txt in the project root for
-# license information.
-#
-# Code generated by Microsoft (R) AutoRest Code Generator.
-# Changes may cause incorrect behavior and will be lost if the code is
-# regenerated.
-# --------------------------------------------------------------------------
-{{ imports }}
-
-class {{ code_model.client.name }}Configuration:
-    """Configuration for {{ code_model.client.name }}.
-
-    Note that all parameters used to create this instance are saved as instance
-    attributes.
-{% if code_model.global_parameters.parameters %}
-
-{% endif %}
-{% for parameter in code_model.global_parameters.parameters %}
-    :param {{ parameter.name }}: {{ parameter.description(async_mode) }}
-    :type {{ parameter.name }}: {{ parameter.docstring_type(async_mode) }}
-{% endfor %}
-    """
-
-    {{ method_signature()|indent }}
-{% for parameter in code_model.global_parameters.parameters %}
-    {% if parameter.required %}
-        if {{ parameter.name }} is None:
-            raise ValueError("Parameter '{{ parameter.name }}' must not be None.")
-    {% endif %}
-{% endfor %}
-
-{% for parameter in code_model.global_parameters.parameters %}
-        self.{{ parameter.name }} = {{ parameter.name }}
-{% endfor %}
-{% if code_model.global_parameters.constant_parameters %}
-    {% for constant_parameter in code_model.global_parameters.constant_parameters %}
-        self.{{ constant_parameter.name }} = {{ constant_parameter.value }}
-    {% endfor %}
-{% endif %}
-{% if code_model.config.credential_scopes is not none %}
-        self.credential_scopes = kwargs.pop('credential_scopes', {{ code_model.config.credential_scopes }})
-{% endif %}
-        kwargs.setdefault('sdk_moniker', '{{ code_model.package_name|lower }}/{}'.format(VERSION))
-        self.polling_interval = kwargs.get("polling_interval", 30)
-        self._configure(**kwargs)
-
-    def _configure(
-        self,
-        **kwargs: Any
-    ){{ " -> None" if async_mode else "" }}:
-        self.user_agent_policy = kwargs.get('user_agent_policy') or policies.UserAgentPolicy(**kwargs)
-        self.headers_policy = kwargs.get('headers_policy') or policies.HeadersPolicy(**kwargs)
-        self.proxy_policy = kwargs.get('proxy_policy') or policies.ProxyPolicy(**kwargs)
-        self.logging_policy = kwargs.get('logging_policy') or policies.NetworkTraceLoggingPolicy(**kwargs)
-        self.http_logging_policy = kwargs.get('http_logging_policy') or {{ "ARM" if code_model.azure_arm else "policies." }}HttpLoggingPolicy(**kwargs)
-        self.retry_policy = kwargs.get('retry_policy') or policies.{{ async_prefix }}RetryPolicy(**kwargs)
-        self.custom_hook_policy = kwargs.get('custom_hook_policy') or policies.CustomHookPolicy(**kwargs)
-        self.redirect_policy = kwargs.get('redirect_policy') or policies.{{ async_prefix }}RedirectPolicy(**kwargs)
-        self.authentication_policy = kwargs.get('authentication_policy')
-        {% if code_model.config.credential %}
-        {# only adding this if credential_scopes is not passed during code generation #}
-        {% if code_model.config.credential_scopes is not none and code_model.config.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.config.credential_call(async_mode) }}
-        {% endif %}

package/autorest/multiapi/templates/multiapi_init.py.jinja2

@@ -1,22 +0,0 @@
-# coding=utf-8
-# --------------------------------------------------------------------------
-# Copyright (c) Microsoft Corporation. All rights reserved.
-# Licensed under the MIT License. See License.txt in the project root for license information.
-# Code generated by Microsoft (R) AutoRest Code Generator.
-# Changes may cause incorrect behavior and will be lost if the code is regenerated.
-# --------------------------------------------------------------------------
-
-from .{{ code_model.client.filename }} import {{ code_model.client.name }}
-__all__ = ['{{ code_model.client.name }}']
-{% if not async_mode %}
-
-try:
-    from ._patch import patch_sdk  # type: ignore
-    patch_sdk()
-except ImportError:
-    pass
-
-from ._version import VERSION
-
-__version__ = VERSION
-{% endif %}

package/autorest/multiapi/templates/multiapi_models.py.jinja2

@@ -1,9 +0,0 @@
-# coding=utf-8
-# --------------------------------------------------------------------------
-# Copyright (c) Microsoft Corporation. All rights reserved.
-# Licensed under the MIT License. See License.txt in the project root for
-# license information.
-# --------------------------------------------------------------------------
-{% for mod_api_version in code_model.default_models %}
-from .{{ mod_api_version }}.models import *
-{% endfor %}

package/autorest/multiapi/templates/multiapi_operations_mixin.py.jinja2

@@ -1,39 +0,0 @@
-# coding=utf-8
-# --------------------------------------------------------------------------
-# Copyright (c) Microsoft Corporation. All rights reserved.
-# Licensed under the MIT License. See License.txt in the project root for
-# license information.
-#
-# Code generated by Microsoft (R) AutoRest Code Generator.
-# Changes may cause incorrect behavior and will be lost if the code is
-# regenerated.
-# --------------------------------------------------------------------------
-from {{ ".." if async_mode else "." }}_serialization import Serializer, Deserializer
-{% if imports %}
-{{ imports }}
-{% endif %}
-
-
-class {{ code_model.client.name }}OperationsMixin(object):
-{% for mixin_operation in code_model.operation_mixin_group.mixin_operations %}
-
-    {{ mixin_operation.signature(async_mode) | indent }}        {{ mixin_operation.description(async_mode) | indent(8) }}
-        api_version = self._get_api_version('{{ mixin_operation.name }}')
-        {% for api in mixin_operation.available_apis|sort %}
-        {% set if_statement = "if" if loop.first else "elif" %}
-        {{ if_statement }} api_version == '{{ code_model.mod_to_api_version[api] }}':
-            from {{ ".." if async_mode else "." }}{{ api }}{{ ".aio" if async_mode else "" }}.operations import {{ code_model.client.name }}OperationsMixin as OperationClass
-        {% endfor %}
-        else:
-            raise ValueError("API version {} does not have operation '{{ mixin_operation.name }}'".format(api_version))
-        mixin_instance = OperationClass()
-        mixin_instance._client = self._client
-        mixin_instance._config = self._config
-        mixin_instance._config.api_version = api_version
-        mixin_instance._serialize = Serializer(self._models_dict(api_version))
-        {% if not code_model.client.client_side_validation %}
-        mixin_instance._serialize.client_side_validation = False
-        {% endif %}
-        mixin_instance._deserialize = Deserializer(self._models_dict(api_version))
-        return {{ "await " if mixin_operation.coroutine(async_mode) }}mixin_instance.{{ mixin_operation.name }}({{ mixin_operation.call(async_mode) }})
-{% endfor %}

package/autorest/multiapi/templates/multiapi_service_client.py.jinja2

@@ -1,163 +0,0 @@
-{% macro method_signature() %}
-def __init__(
-    self,
-    {% for pos in positional_params %}
-    {{ pos }}
-    {% endfor %}
-    {% if keyword_only_params %}
-    *,
-    {% endif %}
-    {% for ko in keyword_only_params %}
-    {{ ko }}
-    {% endfor %}
-    **kwargs: Any
-){{" -> None" if async_mode else "" }}:{% endmacro %}
-{# actual template starts here #}
-{% set relative_path = ".." if async_mode else "." %}
-{% set def = "async def" if async_mode else "def" %}
-{% set async_prefix = "Async" if async_mode else "" %}
-{% set a_prefix = "a" if async_mode else "" %}
-{% set await = "await " if async_mode else "" %}
-{% set credential_scopes = "credential_scopes=credential_scopes, " if code_model.config.credential_scopes is not none and code_model.azure_arm else "" %}
-# coding=utf-8
-# --------------------------------------------------------------------------
-# Copyright (c) Microsoft Corporation. All rights reserved.
-# Licensed under the MIT License. See License.txt in the project root for
-# license information.
-#
-# Code generated by Microsoft (R) AutoRest Code Generator.
-# Changes may cause incorrect behavior and will be lost if the code is
-# regenerated.
-# --------------------------------------------------------------------------
-
-{{ imports }}
-
-class _SDKClient(object):
-    def __init__(self, *args, **kwargs):
-        """This is a fake class to support current implementation of MultiApiClientMixin."
-        Will be removed in final version of multiapi azure-core based client
-        """
-        pass
-
-class {{ code_model.client.name }}({% if code_model.operation_mixin_group.mixin_operations %}{{ code_model.client.name }}OperationsMixin, {% endif %}MultiApiClientMixin, _SDKClient):
-    """{{ code_model.client.description }}
-
-    This ready contains multiple API versions, to help you deal with all of the Azure clouds
-    (Azure Stack, Azure Government, Azure China, etc.).
-    By default, it uses the latest API version available on public Azure.
-    For production, you should stick to a particular api-version and/or profile.
-    The profile sets a mapping between an operation group and its API version.
-    The api-version parameter sets the default API version if the operation
-    group is not described in the profile.
-{% if code_model.global_parameters.parameters %}
-
-{% endif %}
-{% for parameter in code_model.global_parameters.parameters %}
-    :param {{ parameter.name }}: {{ parameter.description(async_mode) }}
-    :type {{ parameter.name }}: {{ parameter.docstring_type(async_mode) }}
-{% endfor %}
-{% for parameter in code_model.global_parameters.service_client_specific_global_parameters %}
-    :param {{ parameter.name }}: {{ parameter.description(async_mode) }}
-    :type {{ parameter.name }}: {{ parameter.docstring_type(async_mode) }}
-{% endfor %}
-    {% if code_model.client.has_public_lro_operations %}
-    :keyword int polling_interval: Default waiting time between two polls for LRO operations if no Retry-After header is present.
-    {% endif %}
-    """
-
-    DEFAULT_API_VERSION = '{{ code_model.mod_to_api_version[code_model.default_api_version] }}'
-    _PROFILE_TAG = "{{ code_model.module_name }}.{{ code_model.client.name }}"
-    LATEST_PROFILE = ProfileDefinition({
-        _PROFILE_TAG: {
-            None: DEFAULT_API_VERSION,
-{% for rt_name, api_version in code_model.last_rt_list|dictsort %}
-            '{{ rt_name }}': '{{ code_model.mod_to_api_version[api_version] }}',
-{% endfor %}
-        }},
-        _PROFILE_TAG + " latest"
-    )
-
-    {{ method_signature()|indent }}
-        {% if not code_model.azure_arm %}
-        {% if not code_model.client.host_value %}
-        {% for parameterized_host_template, api_versions in code_model.client.parameterized_host_template_to_api_version|dictsort %}
-        {% set if_statement = "if" if loop.first else "elif" %}
-        {{ if_statement ~ " api_version == '" ~ api_versions|join("' or api_version == '") ~ "'" }}:
-            base_url = {{ parameterized_host_template }}
-        {% endfor %}
-        else:
-            raise ValueError("API version {} is not available".format(api_version))
-        {% endif %}
-        {% endif %}
-        if api_version:
-            kwargs.setdefault('api_version', api_version)
-        {% if credential_scopes %}
-        _cloud = kwargs.pop("cloud_setting", None) or settings.current.azure_cloud  # type: ignore
-        _endpoints = get_arm_endpoints(_cloud)
-        if not base_url:
-            base_url = _endpoints["resource_manager"]
-        credential_scopes = kwargs.pop("credential_scopes", _endpoints["credential_scopes"])
-        {% endif %}
-        self._config = {{ code_model.client.name }}Configuration({{ code_model.global_parameters.call }}{{ ", " if code_model.global_parameters.call }}{{ credential_scopes }}**kwargs)
-        _policies = kwargs.pop("policies", None)
-        if _policies is None:
-            _policies = [
-                {% for p in config_policies %}
-                {{ p }},
-                {% endfor %}
-            ]
-        {% set host_variable_name = "cast(str, " + code_model.host_variable_name + ")" if credential_scopes else code_model.host_variable_name %}
-        self._client: {{ async_prefix }}{{ code_model.client.pipeline_client }} = {{ async_prefix }}{{ code_model.client.pipeline_client }}(base_url={{ host_variable_name }}, policies=_policies, **kwargs)
-        super({{ code_model.client.name }}, self).__init__(
-            api_version=api_version,
-            profile=profile
-        )
-
-    @classmethod
-    def _models_dict(cls, api_version):
-        return {k: v for k, v in cls.models(api_version).__dict__.items() if isinstance(v, type)}
-
-    @classmethod
-    def models(cls, api_version=DEFAULT_API_VERSION):
-        """Module depends on the API version:
-
-        {% for mod_api_version, api_version in code_model.mod_to_api_version|dictsort %}
-           * {{ api_version }}: :mod:`{{ mod_api_version }}.models<{{ code_model.module_name }}.{{ mod_api_version }}.models>`
-        {% endfor %}
-        """
-        {% for mod_api_version, api_version in code_model.mod_to_api_version|dictsort %}
-        {% set if_statement = "if" if loop.first else "elif" %}
-        {{if_statement }} api_version == '{{ api_version }}':
-            from {{ relative_path }}{{ mod_api_version }} import models
-            return models
-        {% endfor %}
-        raise ValueError("API version {} is not available".format(api_version))
-    {% for operation_group in code_model.operation_groups %}
-
-    @property
-    def {{ operation_group.name }}(self):
-        """Instance depends on the API version:
-
-        {% for api in operation_group.available_apis | sort %}
-           * {{ code_model.mod_to_api_version[api] }}: :class:`{{ operation_group.class_name(api) }}<{{ code_model.module_name }}.{{ api }}{{ ".aio" if async_mode else "" }}.operations.{{ operation_group.class_name(api) }}>`
-        {% endfor %}
-        """
-        api_version = self._get_api_version('{{ operation_group.name }}')
-        {% for api in operation_group.available_apis | sort %}
-        {% set if_statement = "if" if loop.first else "elif" %}
-        {{ if_statement }} api_version == '{{ code_model.mod_to_api_version[api] }}':
-            from {{ relative_path }}{{ api }}.{{ "aio." if async_mode else "" }}operations import {{ operation_group.class_name(api) }} as OperationClass
-        {% endfor %}
-        else:
-            raise ValueError("API version {} does not have operation group '{{ operation_group.name }}'".format(api_version))
-        self._config.api_version = api_version
-        return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)), api_version)
-    {% endfor %}
-
-    {{ def }} close(self):
-        {{ await }}self._client.close()
-    {{ def }} __{{ a_prefix }}enter__(self):
-        {{ await }}self._client.__{{ a_prefix }}enter__()
-        return self
-    {{ def }} __{{ a_prefix }}exit__(self, *exc_details):
-        {{ await }}self._client.__{{ a_prefix }}exit__(*exc_details)

package/autorest/multiapi/templates/multiapi_version.py.jinja2

@@ -1,8 +0,0 @@
-# coding=utf-8
-# --------------------------------------------------------------------------
-# Copyright (c) Microsoft Corporation. All rights reserved.
-# Licensed under the MIT License. See License.txt in the project root for
-# license information.
-# --------------------------------------------------------------------------
-
-VERSION = "0.1.0"