@autorest/python 6.2.0 → 6.2.1

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

@@ -39,7 +39,7 @@ class {{ client.name }}Configuration(Configuration):  # pylint: disable=too-many
         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 client.namespace_model.options['azure_arm'] else "policies." }}HttpLoggingPolicy(**kwargs)
+        self.http_logging_policy = kwargs.get('http_logging_policy') or {{ "ARM" if client.code_model.options['azure_arm'] else "policies." }}HttpLoggingPolicy(**kwargs)
         self.retry_policy = kwargs.get('retry_policy') or policies.{{ keywords.async_class }}RetryPolicy(**kwargs)
         self.custom_hook_policy = kwargs.get('custom_hook_policy') or policies.CustomHookPolicy(**kwargs)
         self.redirect_policy = kwargs.get('redirect_policy') or policies.{{ keywords.async_class }}RedirectPolicy(**kwargs)

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

@@ -2,15 +2,15 @@
 {% import 'operation_tools.jinja2' as op_tools %}
 {# actual template starts here #}
 # coding=utf-8
-{{ namespace_model.options['license_header'] }}
+{{ code_model.options['license_header'] }}
 
 {{ imports }}
 
-{% if not namespace_model.options['package_version'] %}
+{% if not code_model.options['package_version'] %}
 VERSION = "unknown"
 {% endif %}
 
-{% for client in namespace_model.clients %}
+{% for client in clients %}
     {% set serializer = get_serializer(client) %}
 {% include "config.py.jinja2" %}
 {% endfor %}

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

@@ -1,9 +1,9 @@
 # coding=utf-8
-{{ namespace_model.options['license_header'] }}
+{{ code_model.options['license_header'] }}
 
 from enum import Enum
 from azure.core import CaseInsensitiveEnumMeta
 
-{% for enum in namespace_model.enums | sort %}
+{% for enum in code_model.enums | sort %}
 {% include "enum.py.jinja2" %}
 {% endfor %}

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

@@ -1,13 +1,13 @@
 {% import 'keywords.jinja2' as keywords %}
 # coding=utf-8
-{{ namespace_model.options['license_header'] }}
+{{ code_model.options['license_header'] }}
 
 {% if clients %}
     {% for client in clients %}
 from .{{ client.filename }} import {{ client.name }}
     {% endfor %}
 {% endif %}
-{% if not async_mode and namespace_model.options['package_version']%}
+{% if not async_mode and code_model.options['package_version']%}
 from ._version import VERSION
 
 __version__ = VERSION

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

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

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

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

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

@@ -9,9 +9,9 @@
         "description": {{ client.description | tojson }},
         "host_value": {{ (client.parameters.host.client_default_value_declaration if not client.has_parameterized_host else None) | tojson }},
         "parameterized_host_template": {{ (keywords.escape_str(client.url) if client.has_parameterized_host else None) | tojson }},
-        "azure_arm": {{ client.namespace_model.options["azure_arm"]  | tojson }},
+        "azure_arm": {{ client.code_model.options["azure_arm"]  | tojson }},
         "has_lro_operations": {{ client.has_lro_operations | tojson }},
-        "client_side_validation": {{ client.namespace_model.options["client_side_validation"] | tojson }},
+        "client_side_validation": {{ client.code_model.options["client_side_validation"] | tojson }},
         "sync_imports": {{ sync_client_imports | tojson }},
         "async_imports": {{ async_client_imports | tojson }}
     },

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

@@ -1,10 +1,10 @@
 # coding=utf-8
 # pylint: disable=too-many-lines
-{{ namespace_model.options['license_header'] }}
+{{ code_model.options['license_header'] }}
 
 {{ imports }}
-{% for model in namespace_model.model_types %}
-{% if namespace_model.options["models_mode"] == "dpg" %}
+{% for model in code_model.model_types %}
+{% if code_model.options["models_mode"] == "dpg" %}
 {% include "model_dpg.py.jinja2" %}
 {% else %}
 {% include "model_msrest.py.jinja2" %}

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

@@ -30,7 +30,7 @@
     {% if model.is_polymorphic %}
     __mapping__ = {}
     {% endif %}
-    {% for p in serializer.get_properties_to_initialize(model)%}
+    {% for p in serializer.get_properties_to_declare(model)%}
         {% for line in serializer.declare_property(p) %}
     {{ line }}
         {% endfor %}
@@ -57,6 +57,6 @@
     {% endif %}
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
-    {% if model.discriminator_value %}
-        {{ serializer.initialize_discriminator_property(model, model.discriminator_property) }}
-    {% endif %}
+    {% for initialize_property in serializer.initialize_properties(model) %}
+        {{ initialize_property }}
+    {% endfor %}

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

@@ -1,16 +1,16 @@
 {% import 'keywords.jinja2' as keywords %}
 # coding=utf-8
-{{ namespace_model.options['license_header'] }}
+{{ code_model.options['license_header'] }}
 {% if schemas %}
 
     {% for schema in schemas %}
-from .{{ namespace_model.models_filename }} import {{ schema }}
+from .{{ code_model.models_filename }} import {{ schema }}
     {% endfor %}
 {% endif %}
 {% if enums %}
 
 {% for enum in enums %}
-from .{{ namespace_model.enums_filename }} import {{ enum }}
+from .{{ code_model.enums_filename }} import {{ enum }}
 {% endfor %}
 {% endif %}
 {{ keywords.patch_imports() }}

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

@@ -19,6 +19,6 @@
     {{ op_tools.serialize(operation_serializer.make_pipeline_call(operation)) | indent }}
     {{ op_tools.serialize(operation_serializer.handle_response(operation)) | indent }}
     {% endif %}
-{% if not namespace_model.options["version_tolerant"] %}
+{% if not code_model.options["version_tolerant"] %}
 {{ operation_serializer.get_metadata_url(operation) }}
 {% endif %}

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

@@ -16,11 +16,11 @@ class {{ operation_group.class_name }}{{ base_class }}:{{ disable }}
         **DO NOT** instantiate this class directly.
 
         Instead, you should access the following operations through
-        :class:`{{ "~" + namespace_model.namespace + (".aio." if async_mode else ".") + operation_group.client.name }}`'s
+        :class:`{{ "~" + code_model.namespace + (".aio." if async_mode else ".") + operation_group.client.name }}`'s
         :attr:`{{ operation_group.property_name }}` attribute.
     """
 
-{% if namespace_model.public_model_types and namespace_model.options["models_mode"] == "msrest" %}
+{% if code_model.public_model_types and code_model.options["models_mode"] == "msrest" %}
     models = _models
 
 {% endif %}

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

@@ -3,11 +3,11 @@
 {% set return_none_type_annotation = " -> None" if async_mode else "" %}
 # pylint: disable=too-many-lines
 # coding=utf-8
-{{ namespace_model.options['license_header'] }}
+{{ code_model.options['license_header'] }}
 {{ imports }}
 
-{% if namespace_model.options["builders_visibility"] == "embedded" and not async_mode %}
-{{ op_tools.declare_serializer(namespace_model) }}
+{% if code_model.options["builders_visibility"] == "embedded" and not async_mode %}
+{{ op_tools.declare_serializer(code_model) }}
     {% for operation_group in operation_groups %}
         {% for request_builder in get_request_builders(operation_group) %}
 

package/autorest/codegen/templates/operation_tools.jinja2

@@ -50,10 +50,10 @@ Example:
     {% endif %}
 {% endfor %}{% endmacro %}
 
-{% macro declare_serializer(namespace_model) %}
-{% if namespace_model.request_builders | rejectattr("abstract") | first %}
+{% macro declare_serializer(code_model) %}
+{% if code_model.has_non_abstract_operations %}
 _SERIALIZER = Serializer()
-    {% if not namespace_model.options["client_side_validation"] %}
+    {% if not code_model.options["client_side_validation"] %}
 _SERIALIZER.client_side_validation = False
     {% endif %}
 {% endif %}

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

@@ -2,16 +2,16 @@
 {% import 'keywords.jinja2' as keywords %}
 {# actual template starts here #}
 # coding=utf-8
-{{ namespace_model.options['license_header'] }}
+{{ code_model.options['license_header'] }}
 
 {{ op_tools.serialize(operation_group_imports()) }}
 {{ keywords.patch_imports() }}
-{% if namespace_model.operation_groups %}
 __all__ = [
-    {% for operation_group in namespace_model.operation_groups %}
+    {% for client in clients %}
+        {% for operation_group in client.operation_groups %}
     '{{ operation_group.class_name }}',
+        {% endfor %}
     {% endfor %}
 ]
-{% endif %}
 {{ keywords.extend_all }}
 _patch_sdk()

package/autorest/codegen/templates/packaging_templates/setup.py.jinja2

@@ -7,7 +7,7 @@ import re
 {% endif -%}
 from setuptools import setup, find_packages
 
-{% set package_name = package_name or code_model.namespace_models[0].clients[0].name %}
+{% set package_name = package_name or code_model.clients[0].name %}
 
 PACKAGE_NAME = "{{ package_name|lower }}"
 {% if package_mode -%}
@@ -91,6 +91,9 @@ setup(
         {% else %}
         "azure-core<2.0.0,>=1.24.0",
         {% endif %}
+        {% if code_model.need_typing_extensions %}
+        "typing_extensions>=4.3.0; python_version<'3.8.0'",
+        {% endif %}
     ],
     {% if package_mode %}
     python_requires=">=3.7",

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

@@ -19,6 +19,6 @@
         get_next, extract_data
     )
     {% endif %}
-{% if not namespace_model.options["version_tolerant"] %}
+{% if not code_model.options["version_tolerant"] %}
 {{ operation_serializer.get_metadata_url(operation) -}}
 {% endif %}

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

@@ -1,7 +1,7 @@
 {% import 'keywords.jinja2' as keywords with context %}
 {% import 'operation_tools.jinja2' as op_tools with context %}
 {{ request_builder_serializer.method_signature_and_response_type_annotation(request_builder) }}
-{% if namespace_model.options["builders_visibility"] == "public" %}
+{% if code_model.options["builders_visibility"] == "public" %}
     {{ op_tools.description(request_builder, request_builder_serializer) | indent }}
 {% endif %}
 {% if not request_builder.is_overload %}

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

@@ -1,9 +1,9 @@
 {% import 'operation_tools.jinja2' as op_tools %}
 # coding=utf-8
-{{ namespace_model.options['license_header'] }}
+{{ code_model.options['license_header'] }}
 {{ imports }}
 
-{{ op_tools.declare_serializer(namespace_model) }}
+{{ op_tools.declare_serializer(code_model) }}
 {% for request_builder in request_builders %}
 
 {% include "request_builder.py.jinja2" %}

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

@@ -1,5 +1,5 @@
 # coding=utf-8
-{{ client.namespace_model.options['license_header'] }}
+{{ code_model.options['license_header'] }}
 
 {% for request_builder in request_builders %}
 from ._request_builders import {{ request_builder.name }}

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

@@ -1,7 +1,7 @@
 # coding=utf-8
 {% set aad_token = "DefaultAzureCredential" %}
 {% set azure_key = "AzureKeyCredential" %}
-{{ namespace_model.options['license_header'] }}
+{{ code_model.options['license_header'] }}
 
 {{ imports }}
 """
@@ -9,23 +9,23 @@
 {% if "credential" in client_params and aad_token in client_params["credential"] %}
     pip install azure-identity
 {% endif %}
-    pip install {{ (namespace_model.options["package_name"] or namespace_model.clients[0].name)|lower }}
+    pip install {{ (code_model.options["package_name"] or code_model.clients[0].name)|lower }}
 # USAGE
     python {{ file_name }}
     {% if "credential" in client_params and aad_token in client_params["credential"] %}
 
-    Before run the sample, please set the values of the client ID, tenant ID and client secret 
+    Before run the sample, please 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. For more info about how to get the value, please see:
     https://docs.microsoft.com/azure/active-directory/develop/howto-create-service-principal-portal
     {% elif "credential" in client_params and azure_key in client_params["credential"] %}
-    
+
     Before run the sample, please set environment variables AZURE_KEY with real value
     which can access your service
     {% endif %}
 """
 def main():
-    client = {{ namespace_model.clients[0].name }}(
+    client = {{ code_model.clients[0].name }}(
         {% for key,value in client_params.items() %}
         {{ key }}={{ value }},
         {% endfor %}

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

@@ -1,4 +1,4 @@
-{{ namespace_model.options['license_header'] }}
+{{ code_model.options['license_header'] }}
 import functools
 
 def api_version_validation(**kwargs):

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

@@ -1,9 +1,9 @@
 {% import 'keywords.jinja2' as keywords with context %}
-{{ namespace_model.options['license_header'] }}
+{{ code_model.options['license_header'] }}
 
 {{ imports }}
 
-{% if namespace_model.need_request_converter and not async_mode %}
+{% if code_model.need_request_converter and not async_mode %}
 def _convert_request(request, files=None):
     data = request.content if not files else None
     request = HttpRequest(method=request.method, url=request.url, headers=request.headers, data=data)
@@ -11,7 +11,7 @@ def _convert_request(request, files=None):
         request.set_formdata_body(files)
     return request
 {% endif %}
-{% if namespace_model.need_format_url and not async_mode %}
+{% if code_model.need_format_url and not async_mode %}
 
 def _format_url_section(template, **kwargs):
     components = template.split("/")
@@ -25,8 +25,8 @@ def _format_url_section(template, **kwargs):
             ]
             template = "/".join(components)
 {% endif %}
-{% if namespace_model.need_mixin_abc %}
-    {% for client in namespace_model.clients | selectattr("has_mixin") %}
+{% if code_model.need_mixin_abc %}
+    {% for client in code_model.clients | selectattr("has_mixin") %}
 
 class {{ client.name }}MixinABC(ABC):
     """DO NOT use this class. It is for internal typing use only."""
@@ -36,7 +36,7 @@ class {{ client.name }}MixinABC(ABC):
     _deserialize: "Deserializer"
     {% endfor %}
 {% endif %}
-{% if namespace_model.has_abstract_operations %}
+{% if code_model.has_abstract_operations %}
 
 def raise_if_not_implemented(cls, abstract_methods):
     not_implemented = [f for f in abstract_methods if not callable(getattr(cls, f, None))]

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

@@ -1,4 +1,4 @@
 # coding=utf-8
-{{ namespace_model.options['license_header'] }}
+{{ code_model.options['license_header'] }}
 
-VERSION = "{{ namespace_model.options['package_version'] }}"
+VERSION = "{{ code_model.options['package_version'] }}"

package/autorest/m4reformatter/__init__.py

@@ -1108,14 +1108,15 @@ class M4Reformatter(
                     # we don't generate cloud error
                     continue
                 update_type(t)
-        yaml_data[namespace] = {}
-        yaml_data[namespace]["clients"] = [self.update_client(yaml_data)]
-        yaml_data[namespace]["clients"][0]["operationGroups"] = [
+        yaml_data["namespace"] = namespace
+        yaml_data["subnamespaceToClients"] = {}
+        yaml_data["clients"] = [self.update_client(yaml_data)]
+        yaml_data["clients"][0]["operationGroups"] = [
             self.update_operation_group(og) for og in yaml_data["operationGroups"]
         ]
-        yaml_data[namespace]["types"] = list(
-            ORIGINAL_ID_TO_UPDATED_TYPE.values()
-        ) + list(KNOWN_TYPES.values())
+        yaml_data["types"] = list(ORIGINAL_ID_TO_UPDATED_TYPE.values()) + list(
+            KNOWN_TYPES.values()
+        )
         if yaml_data.get("globalParameters"):
             del yaml_data["globalParameters"]
         del yaml_data["info"]

package/autorest/multiapi/models/imports.py

@@ -5,6 +5,7 @@
 # --------------------------------------------------------------------------
 from enum import Enum
 from typing import Dict, Optional, Set, Union, Tuple
+from ..utils import convert_list_to_tuple
 
 
 class ImportType(str, Enum):
@@ -12,6 +13,7 @@ class ImportType(str, Enum):
     THIRDPARTY = "thirdparty"
     AZURECORE = "azurecore"
     LOCAL = "local"
+    BYVERSION = "by_version"
 
 
 class TypingSection(str, Enum):
@@ -25,7 +27,28 @@ class FileImport:
         self,
         imports: Dict[
             TypingSection,
-            Dict[ImportType, Dict[str, Set[Optional[Union[str, Tuple[str, str]]]]]],
+            Dict[
+                ImportType,
+                Dict[
+                    str,
+                    Set[
+                        Optional[
+                            Union[
+                                str,
+                                Tuple[
+                                    str,
+                                    str,
+                                ],
+                                Tuple[
+                                    str,
+                                    str,
+                                    Tuple[Tuple[Tuple[int, int], str, Optional[str]]],
+                                ],
+                            ]
+                        ]
+                    ],
+                ],
+            ],
         ] = None,
     ) -> None:
         # Basic implementation
@@ -35,7 +58,28 @@ class FileImport:
         # Fourth level set: None if this import is a "import", the name to import if it's a "from"
         self._imports: Dict[
             TypingSection,
-            Dict[ImportType, Dict[str, Set[Optional[Union[str, Tuple[str, str]]]]]],
+            Dict[
+                ImportType,
+                Dict[
+                    str,
+                    Set[
+                        Optional[
+                            Union[
+                                str,
+                                Tuple[
+                                    str,
+                                    str,
+                                ],
+                                Tuple[
+                                    str,
+                                    str,
+                                    Tuple[Tuple[Tuple[int, int], str, Optional[str]]],
+                                ],
+                            ]
+                        ]
+                    ],
+                ],
+            ],
         ] = (
             imports or dict()
         )
@@ -44,14 +88,29 @@ class FileImport:
         self,
         from_section: str,
         import_type: ImportType,
-        name_import: Optional[Union[str, Tuple[str, str]]] = None,
+        name_import: Optional[
+            Union[
+                str,
+                Tuple[
+                    str,
+                    str,
+                ],
+                Tuple[str, str, Tuple[Tuple[Tuple[int, int], str, Optional[str]]]],
+            ]
+        ] = None,
         typing_section: TypingSection = TypingSection.REGULAR,
     ) -> None:
-        name_input: Optional[Union[str, Tuple[str, str]]] = None
-        if isinstance(name_import, list):
-            name_input = tuple(name_import)
-        else:
-            name_input = name_import
+        name_input: Optional[
+            Union[
+                str,
+                Tuple[
+                    str,
+                    str,
+                ],
+                Tuple[str, str, Tuple[Tuple[Tuple[int, int], str, Optional[str]]]],
+            ]
+        ] = None
+        name_input = convert_list_to_tuple(name_import)
         self._imports.setdefault(typing_section, dict()).setdefault(
             import_type, dict()
         ).setdefault(from_section, set()).add(name_input)
@@ -66,21 +125,33 @@ class FileImport:
         """Add an import to this import block."""
         self._add_import(from_section, import_type, name_import, typing_section)
 
-    def add_import(
-        self,
-        name_import: str,
-        import_type: ImportType,
-        typing_section: TypingSection = TypingSection.REGULAR,
-    ) -> None:
-        # Implementation detail: a regular import is just a "from" with no from
-        self._add_import(name_import, import_type, None, typing_section)
-
     @property
     def imports(
         self,
     ) -> Dict[
         TypingSection,
-        Dict[ImportType, Dict[str, Set[Optional[Union[str, Tuple[str, str]]]]]],
+        Dict[
+            ImportType,
+            Dict[
+                str,
+                Set[
+                    Optional[
+                        Union[
+                            str,
+                            Tuple[
+                                str,
+                                str,
+                            ],
+                            Tuple[
+                                str,
+                                str,
+                                Tuple[Tuple[Tuple[int, int], str, Optional[str]]],
+                            ],
+                        ]
+                    ]
+                ],
+            ],
+        ],
     ]:
         return self._imports