@autorest/python 6.1.11 → 6.2.1

package/autorest/codegen/serializers/model_serializer.py

@@ -5,10 +5,12 @@
 # --------------------------------------------------------------------------
 from typing import cast, List
 from abc import ABC, abstractmethod
+
 from jinja2 import Environment
 from ..models import ModelType, CodeModel, Property
 from ..models.imports import FileImport, TypingSection, MsrestImportType, ImportType
 from .import_serializer import FileImportSerializer
+from ..models.constant_type import ConstantType
 
 
 def _documentation_string(
@@ -93,13 +95,17 @@ class _ModelSerializer(ABC):
             f"Known sub-classes are: {', '.join(v.name for v in model.discriminated_subtypes.values())}"
         )
 
-    def init_line(self, model: ModelType) -> List[str]:
-        init_properties_declaration = []
-        init_line_parameters = [
+    @staticmethod
+    def _init_line_parameters(model: ModelType):
+        return [
             p
             for p in model.properties
             if not p.readonly and not p.is_discriminator and not p.constant
         ]
+
+    def init_line(self, model: ModelType) -> List[str]:
+        init_properties_declaration = []
+        init_line_parameters = self._init_line_parameters(model)
         init_line_parameters.sort(key=lambda x: x.optional)
         if init_line_parameters:
             init_properties_declaration.append("*,")
@@ -134,11 +140,9 @@ class MsrestModelSerializer(_ModelSerializer):
         )
         for model in self.code_model.model_types:
             file_import.merge(model.imports(is_operation_file=False))
-            init_line_parameters = [
-                p for p in model.properties if not p.readonly and not p.is_discriminator
-            ]
-            for param in init_line_parameters:
+            for param in self._init_line_parameters(model):
                 file_import.merge(param.imports())
+
         return file_import
 
     def declare_model(self, model: ModelType) -> str:
@@ -209,8 +213,8 @@ class DpgModelSerializer(_ModelSerializer):
 
         for model in self.code_model.model_types:
             file_import.merge(model.imports(is_operation_file=False))
-            for param in model.properties:
-                file_import.merge(param.imports())
+            for prop in model.properties:
+                file_import.merge(prop.imports())
         return file_import
 
     def declare_model(self, model: ModelType) -> str:
@@ -222,30 +226,31 @@ class DpgModelSerializer(_ModelSerializer):
         return f"class {model.name}({basename}):{model.pylint_disable}"
 
     @staticmethod
-    def get_properties_to_initialize(model: ModelType) -> List[Property]:
+    def get_properties_to_declare(model: ModelType) -> List[Property]:
         if model.parents:
+            parent_properties = [
+                p for bm in model.parents for p in cast(ModelType, bm).properties
+            ]
             properties_to_declare = [
                 p
-                for bm in model.parents
                 for p in model.properties
-                if p not in cast(ModelType, bm).properties
+                if not any(
+                    p.client_name == pp.client_name
+                    and p.type_annotation() == pp.type_annotation()
+                    for pp in parent_properties
+                )
             ]
-
         else:
             properties_to_declare = model.properties
         if any(p for p in properties_to_declare if p.client_name == "_"):
             raise ValueError("We do not generate anonymous properties")
-        return [
-            p
-            for p in properties_to_declare
-            if (not p.is_discriminator or p.is_polymorphic)
-        ]
+        return properties_to_declare
 
     @staticmethod
     def declare_property(prop: Property) -> List[str]:
         attribute_key = _ModelSerializer.escape_dot(prop.rest_api_name)
         args = []
-        if prop.client_name != attribute_key:
+        if prop.client_name != attribute_key or prop.is_discriminator:
             args.append(f'name="{attribute_key}"')
         if prop.readonly:
             args.append("readonly=True")
@@ -261,3 +266,13 @@ class DpgModelSerializer(_ModelSerializer):
         if comment:
             ret.append(f'"""{comment}"""')
         return ret
+
+    def initialize_properties(self, model: ModelType) -> List[str]:
+        init_args = []
+        for prop in self.get_properties_to_declare(model):
+            if prop.constant or prop.is_discriminator:
+                init_args.append(
+                    f"self.{prop.client_name} = {cast(ConstantType, prop.type).get_declaration()}   "
+                    f"# type: {prop.type_annotation()}"
+                )
+        return init_args

package/autorest/codegen/serializers/operation_groups_serializer.py

@@ -3,7 +3,7 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
-from typing import Optional
+from typing import Optional, List, Union
 import functools
 from jinja2 import Environment
 
@@ -11,6 +11,9 @@ from ..models import (
     CodeModel,
     OperationGroup,
     FileImport,
+    RequestBuilder,
+    OverloadedRequestBuilder,
+    Client,
 )
 from .import_serializer import FileImportSerializer
 from .builder_serializer import get_operation_serializer, RequestBuilderSerializer
@@ -20,20 +23,35 @@ class OperationGroupsSerializer:
     def __init__(
         self,
         code_model: CodeModel,
+        clients: List[Client],
         env: Environment,
         async_mode: bool,
         operation_group: Optional[OperationGroup] = None,
-    ) -> None:
+    ):
+        self.clients = clients
         self.code_model = code_model
         self.env = env
         self.async_mode = async_mode
         self.operation_group = operation_group
 
+    def _get_request_builders(
+        self, operation_group: OperationGroup
+    ) -> List[Union[OverloadedRequestBuilder, RequestBuilder]]:
+        return [
+            r
+            for client in self.clients
+            for r in client.request_builders
+            if r.client.name == operation_group.client.name
+            and r.group_name == operation_group.property_name
+            and not r.is_overload
+            and not r.abstract
+        ]
+
     def serialize(self) -> str:
         operation_groups = (
             [self.operation_group]
             if self.operation_group
-            else self.code_model.operation_groups
+            else [og for client in self.clients for og in client.operation_groups]
         )
         imports = FileImport()
         for operation_group in operation_groups:
@@ -63,7 +81,5 @@ class OperationGroupsSerializer:
                 self.code_model,
                 async_mode=False,
             ),
-            request_builders=[
-                rb for rb in self.code_model.request_builders if not rb.abstract
-            ],
+            get_request_builders=self._get_request_builders,
         )

package/autorest/codegen/serializers/operations_init_serializer.py

@@ -7,14 +7,19 @@ from typing import List
 from jinja2 import Environment
 
 from autorest.codegen.models.operation_group import OperationGroup
-from ..models import CodeModel
+from ..models import CodeModel, Client
 
 
 class OperationsInitSerializer:
     def __init__(
-        self, code_model: CodeModel, env: Environment, async_mode: bool
+        self,
+        code_model: CodeModel,
+        clients: List[Client],
+        env: Environment,
+        async_mode: bool,
     ) -> None:
         self.code_model = code_model
+        self.clients = clients
         self.env = env
         self.async_mode = async_mode
 
@@ -28,7 +33,8 @@ class OperationsInitSerializer:
 
         return [
             f"from .{_get_filename(og)} import {og.class_name}"
-            for og in self.code_model.operation_groups
+            for client in self.clients
+            for og in client.operation_groups
         ]
 
     def serialize(self) -> str:
@@ -38,7 +44,7 @@ class OperationsInitSerializer:
 
         return operation_group_init_template.render(
             code_model=self.code_model,
-            operation_groups=self.code_model.operation_groups,
             async_mode=self.async_mode,
             operation_group_imports=self.operation_group_imports,
+            clients=self.clients,
         )

package/autorest/codegen/serializers/sample_serializer.py

@@ -0,0 +1,144 @@
+# pylint: disable=too-many-lines
+# -------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for
+# license information.
+# --------------------------------------------------------------------------
+import logging
+from typing import Dict, Any
+from jinja2 import Environment
+
+from autorest.codegen.models.credential_types import AzureKeyCredentialType
+from autorest.codegen.models.credential_types import TokenCredentialType
+from autorest.codegen.models.imports import FileImport, ImportType
+from autorest.codegen.models.operation import OperationBase
+from autorest.codegen.models.operation_group import OperationGroup
+from autorest.codegen.serializers.import_serializer import FileImportSerializer
+from ..models import CodeModel
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class SampleSerializer:
+    def __init__(
+        self,
+        code_model: CodeModel,
+        env: Environment,
+        operation_group: OperationGroup,
+        operation: OperationBase[Any],
+        sample: Dict[str, Any],
+        file_name: str,
+        sample_origin_name: str,
+    ) -> None:
+        self.code_model = code_model
+        self.env = env
+        self.operation_group = operation_group
+        self.operation = operation
+        self.sample = sample
+        self.file_name = file_name
+        self.sample_origin_name = sample_origin_name
+
+    def _imports(self) -> FileImportSerializer:
+        imports = FileImport()
+        namespace = (self.code_model.options["package_name"] or "").replace(
+            "-", "."
+        ) or self.code_model.namespace
+        client = self.code_model.clients[0]
+        imports.add_submodule_import(namespace, client.name, ImportType.THIRDPARTY)
+        credential_type = getattr(client.credential, "type", None)
+        if isinstance(credential_type, TokenCredentialType):
+            imports.add_submodule_import(
+                "azure.identity", "DefaultAzureCredential", ImportType.THIRDPARTY
+            )
+        elif isinstance(credential_type, AzureKeyCredentialType):
+            imports.add_import("os", ImportType.STDLIB)
+            imports.add_submodule_import(
+                "azure.core.credentials", "AzureKeyCredential", ImportType.THIRDPARTY
+            )
+        return FileImportSerializer(imports, True)
+
+    def _client_params(self) -> Dict[str, Any]:
+        # client params
+        special_param = dict()
+        credential_type = getattr(self.code_model.clients[0].credential, "type", None)
+        if isinstance(credential_type, TokenCredentialType):
+            special_param.update({"credential": "DefaultAzureCredential()"})
+        elif isinstance(credential_type, AzureKeyCredentialType):
+            special_param.update(
+                {"credential": 'AzureKeyCredential(key=os.getenv("AZURE_KEY"))'}
+            )
+
+        params_positional = [
+            p
+            for p in self.code_model.clients[0].parameters.positional
+            if not (p.optional or p.client_default_value)
+        ]
+        cls = lambda x: f'"{x}"'
+        client_params = {
+            p.client_name: special_param.get(
+                p.client_name,
+                cls(
+                    self.sample["parameters"].get(p.rest_api_name)
+                    or p.client_name.upper()
+                ),
+            )
+            for p in params_positional
+        }
+
+        return client_params
+
+    # prepare operation parameters
+    def _operation_params(self) -> Dict[str, Any]:
+        params_positional = [
+            p
+            for p in self.operation.parameters.positional
+            if not p.client_default_value
+        ]
+        cls = lambda x: f'"{x}"' if isinstance(x, str) else str(x)
+        failure_info = "fail to find required param named {} in example file {}"
+        operation_params = {}
+        for param in params_positional:
+            name = param.rest_api_name
+            param_value = self.sample["parameters"].get(name)
+            if not param.optional:
+                if not param_value:
+                    raise Exception(failure_info.format(name, self.sample_origin_name))
+                operation_params[param.client_name] = cls(param_value)
+        return operation_params
+
+    def _operation_group_name(self) -> str:
+        if self.operation_group.is_mixin:
+            return ""
+        return f".{self.operation_group.property_name}"
+
+    def _operation_result(self) -> str:
+        lro = ".result()"
+        paging = "\n    for item in response:\n        print(item)"
+        normal_print = "\n    print(response)"
+        if self.operation.operation_type == "paging":
+            return paging
+        if self.operation.operation_type == "lro":
+            return lro + normal_print
+        if self.operation.operation_type == "lropaging":
+            return lro + paging
+        return normal_print
+
+    def _operation_name(self) -> str:
+        return f".{self.operation.name}"
+
+    def _origin_file(self) -> str:
+        name = self.sample.get("x-ms-original-file", "").split("specification")[-1]
+        return "specification" + name if name else name
+
+    def serialize(self) -> str:
+        return self.env.get_template("sample.py.jinja2").render(
+            code_model=self.code_model,
+            file_name=self.file_name,
+            operation_result=self._operation_result(),
+            operation_params=self._operation_params(),
+            operation_group_name=self._operation_group_name(),
+            operation_name=self._operation_name(),
+            imports=self._imports(),
+            client_params=self._client_params(),
+            origin_file=self._origin_file(),
+        )

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

@@ -1,24 +1,16 @@
-{% import 'keywords.jinja2' as keywords with context %}
-{% import 'operation_tools.jinja2' as op_tools %}
-{# actual template starts here #}
-# coding=utf-8
-{{ code_model.options['license_header'] }}
-
-{{ imports }}
-
 {{ serializer.class_definition }}
-    """{{ op_tools.wrap_string(code_model.client.description, "\n") | indent }}
+    """{{ op_tools.wrap_string(client.description, "\n") | indent }}
 
     {{ op_tools.serialize_with_wrap(serializer.property_descriptions(async_mode), "\n ") | indent }}
     {{ serializer.init_signature_and_response_type_annotation(async_mode) | indent }}
     {% if serializer.should_init_super %}
         super().__init__()
     {% endif %}
-    {% if code_model.client.parameters.kwargs_to_pop %}
+    {% if client.parameters.kwargs_to_pop %}
         {{ op_tools.serialize(serializer.pop_kwargs_from_signature()) | indent(8) }}
     {% endif %}
-        {% if code_model.client.has_parameterized_host %}
-        {{ serializer.host_variable_name }} = {{ keywords.escape_str(code_model.client.url) }}
+        {% if client.has_parameterized_host %}
+        {{ serializer.host_variable_name }} = {{ keywords.escape_str(client.url) }}
         {% endif %}
         {{ serializer.initialize_config() }}
         {{ serializer.initialize_pipeline_client(async_mode) }}
@@ -29,7 +21,7 @@
     {{ serializer.send_request_signature_and_response_type_annotation(async_mode) | indent }}
         {{ op_tools.serialize(serializer.send_request_description(async_mode)) | indent(8) }}
         request_copy = deepcopy(request)
-        {% if code_model.client.parameters.path %}
+        {% if client.parameters.path %}
         {{ op_tools.serialize(serializer.serialize_path()) | indent(8) }}
         request_copy.url = self._client.format_url(request_copy.url, **path_format_arguments)
         {% else %}
@@ -43,9 +35,9 @@
         {% endif %}
         {{ keywords.await }}self._client.close()
 
-    {{ keywords.def }} __{{ keywords.async_prefix }}enter__(self){{ (" -> \"" + code_model.client.name + "\"") if async_mode else "" }}:
+    {{ keywords.def }} __{{ keywords.async_prefix }}enter__(self){{ (" -> \"" + client.name + "\"") if async_mode else "" }}:
         {% if not async_mode %}
-        # type: () -> {{ code_model.client.name }}
+        # type: () -> {{ client.name }}
         {% endif %}
         {{ keywords.await }}self._client.__{{ keywords.async_prefix }}enter__()
         return self

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

@@ -0,0 +1,12 @@
+{% import 'keywords.jinja2' as keywords with context %}
+{% import 'operation_tools.jinja2' as op_tools %}
+{# actual template starts here #}
+# coding=utf-8
+{{ code_model.options['license_header'] }}
+
+{{ imports }}
+
+{% for client in clients %}
+    {% set serializer = get_serializer(client) %}
+{% include "client.py.jinja2" %}
+{% endfor %}

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

@@ -1,44 +1,31 @@
-{% import 'keywords.jinja2' as keywords with context %}
-{% import 'operation_tools.jinja2' as op_tools %}
-{% set version_import = ".._version" if async_mode else "._version" %}
-{# actual template starts here #}
-# coding=utf-8
-{{ code_model.options['license_header'] }}
-
-{{ imports }}
-
-{% if not code_model.options['package_version'] %}
-VERSION = "unknown"
-{% endif %}
-
-class {{ code_model.client.name }}Configuration(Configuration):  # pylint: disable=too-many-instance-attributes
-    """Configuration for {{ code_model.client.name }}.
+class {{ client.name }}Configuration(Configuration):  # pylint: disable=too-many-instance-attributes
+    """Configuration for {{ client.name }}.
 
     Note that all parameters used to create this instance are saved as instance
     attributes.
-{% if code_model.config.parameters.method | first %}
+{% if client.config.parameters.method | first %}
 
 {% endif %}
     {{ op_tools.serialize_with_wrap(serializer.property_descriptions(async_mode), "\n ") | indent }}
     {{ serializer.init_signature_and_response_type_annotation(async_mode) | indent }}
-        super({{ code_model.client.name }}Configuration, self).__init__(**kwargs)
-    {% if code_model.config.parameters.kwargs_to_pop %}
+        super({{ client.name }}Configuration, self).__init__(**kwargs)
+    {% if client.config.parameters.kwargs_to_pop %}
         {{ op_tools.serialize(serializer.pop_kwargs_from_signature()) | indent(8) }}
     {% endif %}
 {% if serializer.check_required_parameters() %}
         {{ op_tools.serialize(serializer.check_required_parameters()) | indent(8) -}}
 {% endif %}
 
-{% for parameter in code_model.config.parameters.method %}
+{% for parameter in client.config.parameters.method %}
         self.{{ parameter.client_name }} = {{ parameter.client_name }}
 {% endfor %}
 {% if serializer.set_constants() %}
         {{ op_tools.serialize(serializer.set_constants()) | indent(8) -}}
 {% endif %}
-{% if code_model.credential and code_model.credential.type.policy.credential_scopes is defined %}
-        self.credential_scopes = kwargs.pop('credential_scopes', {{ code_model.credential.type.policy.credential_scopes }})
+{% if client.credential and client.credential.type.policy.credential_scopes is defined %}
+        self.credential_scopes = kwargs.pop('credential_scopes', {{ client.credential.type.policy.credential_scopes }})
 {% endif %}
-        kwargs.setdefault('sdk_moniker', '{{ sdk_moniker }}/{}'.format(VERSION))
+        kwargs.setdefault('sdk_moniker', '{{ client.config.sdk_moniker }}/{}'.format(VERSION))
         self._configure(**kwargs)
 
     def _configure(
@@ -52,17 +39,17 @@ class {{ code_model.client.name }}Configuration(Configuration):  # pylint: disab
         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.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)
         self.authentication_policy = kwargs.get('authentication_policy')
-        {% if code_model.credential %}
+        {% if client.credential %}
         {# only adding this if credential_scopes is not passed during code generation #}
-        {% if code_model.credential.type.policy.credential_scopes is defined and code_model.credential.type.policy.credential_scopes | length == 0 %}
+        {% if client.credential.type.policy.credential_scopes is defined and client.credential.type.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.type.policy.call(async_mode) }}
+            self.authentication_policy = {{ client.credential.type.policy.call(async_mode) }}
         {% endif %}

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

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

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

@@ -6,4 +6,4 @@ from azure.core import CaseInsensitiveEnumMeta
 
 {% for enum in code_model.enums | sort %}
 {% include "enum.py.jinja2" %}
-{% endfor %}
+{% endfor %}

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

@@ -2,8 +2,10 @@
 # coding=utf-8
 {{ code_model.options['license_header'] }}
 
-{% if code_model.request_builders %}
-from .{{ code_model.client.filename }} import {{ code_model.client.name }}
+{% if clients %}
+    {% for client in clients %}
+from .{{ client.filename }} import {{ client.name }}
+    {% endfor %}
 {% endif %}
 {% if not async_mode and code_model.options['package_version']%}
 from ._version import VERSION
@@ -12,7 +14,11 @@ __version__ = VERSION
 {% endif %}
 
 {{ keywords.patch_imports(try_except=True) }}
-__all__ = [{{("'" + code_model.client.name + "'") if code_model.request_builders else ""}}]
+__all__ = [
+    {% for client in clients %}
+    {{ keywords.escape_str(client.name) }},
+    {% endfor %}
+]
 {{ keywords.extend_all }}
 
 _patch_sdk()

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

@@ -16,4 +16,4 @@
     {% endif %}
 {% if not code_model.options["version_tolerant"] %}
 {{ operation_serializer.get_metadata_url(operation) -}}
-{% endif %}
+{% endif %}

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

@@ -1,18 +1,17 @@
 {% import 'operation_tools.jinja2' as op_tools %}
 {% import 'keywords.jinja2' as keywords %}
-{% set client = code_model.client %}
 {
     "chosen_version": {{ chosen_version | tojson }},
     "total_api_version_list": {{ total_api_version_list | tojson }},
     "client": {
-        "name": {{ code_model.client.name | tojson }},
-        "filename": {{ ("_" + code_model.module_name) | tojson }},
-        "description": {{ code_model.client.description | tojson }},
+        "name": {{ client.name | tojson }},
+        "filename": {{ ("_" + client.legacy_filename) | tojson }},
+        "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": {{ code_model.options["azure_arm"]  | tojson }},
-        "has_lro_operations": {{ code_model.has_lro_operations | tojson }},
-        "client_side_validation": {{ code_model.options["client_side_validation"] | tojson }},
+        "azure_arm": {{ client.code_model.options["azure_arm"]  | tojson }},
+        "has_lro_operations": {{ client.has_lro_operations | tojson }},
+        "client_side_validation": {{ client.code_model.options["client_side_validation"] | tojson }},
         "sync_imports": {{ sync_client_imports | tojson }},
         "async_imports": {{ async_client_imports | tojson }}
     },
@@ -38,11 +37,11 @@
             {% endfor %}
         },
         "constant": {
-            {% for gp in code_model.client.parameters.constant | rejectattr("client_name", "equalto", "api_version") %}
+            {% for gp in client.parameters.constant | rejectattr("client_name", "equalto", "api_version") %}
             {{ gp.client_name | tojson }}: {{ gp.constant_declaration | tojson }}{{ "," if not loop.last else "" }}
             {% endfor %}
         },
-        "call": {{ code_model.client.parameters.method | rejectattr("client_name", "equalto", "api_version") | rejectattr("is_host") | map(attribute="client_name") | join(', ') | tojson }},
+        "call": {{ client.parameters.method | rejectattr("client_name", "equalto", "api_version") | rejectattr("is_host") | map(attribute="client_name") | join(', ') | tojson }},
         "service_client_specific": {
             "sync": {
                 "api_version": {
@@ -92,14 +91,14 @@
     },
     "config": {
         "credential": {{ has_credential | tojson }},
-        "credential_scopes": {{ (code_model.credential.type.policy.credential_scopes if has_credential and code_model.credential.type.policy.credential_scopes is defined else None)| tojson}},
-        "credential_call_sync": {{ (code_model.credential.type.policy.call(async_mode=False) if has_credential else None) | tojson }},
-        "credential_call_async": {{ (code_model.credential.type.policy.call(async_mode=True) if has_credential else None) | tojson }},
+        "credential_scopes": {{ (client.credential.type.policy.credential_scopes if has_credential and client.credential.type.policy.credential_scopes is defined else None)| tojson}},
+        "credential_call_sync": {{ (client.credential.type.policy.call(async_mode=False) if has_credential else None) | tojson }},
+        "credential_call_async": {{ (client.credential.type.policy.call(async_mode=True) if has_credential else None) | tojson }},
         "sync_imports": {{ sync_config_imports | tojson }},
         "async_imports": {{ async_config_imports | tojson }}
     },
     "operation_groups": {
-        {% for operation_group in code_model.operation_groups | rejectattr('is_mixin') %}
+        {% for operation_group in client.operation_groups | rejectattr('is_mixin') %}
         {{ operation_group.property_name | tojson }}: {{ operation_group.class_name | tojson }}{{ "," if not loop.last else "" }}
         {% endfor %}
     }{{ "," if mixin_operations }}
@@ -156,4 +155,4 @@
         }
     }
     {% endif %}
-}
+}

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

@@ -25,4 +25,4 @@ __all__ = [
 {% endif %}
 ]
 {{ keywords.extend_all }}
-_patch_sdk()
+_patch_sdk()

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

@@ -21,4 +21,4 @@
     {% endif %}
 {% if not code_model.options["version_tolerant"] %}
 {{ operation_serializer.get_metadata_url(operation) }}
-{% endif %}
+{% endif %}