@autorest/python 6.1.10 → 6.2.0

package/autorest/codegen/serializers/sample_serializer.py

@@ -0,0 +1,146 @@
+# 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 NamespaceModel
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class SampleSerializer:
+    def __init__(
+        self,
+        namespace_model: NamespaceModel,
+        env: Environment,
+        operation_group: OperationGroup,
+        operation: OperationBase[Any],
+        sample: Dict[str, Any],
+        file_name: str,
+        sample_origin_name: str,
+    ) -> None:
+        self.namespace_model = namespace_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.namespace_model.options["package_name"] or "").replace(
+            "-", "."
+        ) or self.namespace_model.namespace
+        client = self.namespace_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.namespace_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.namespace_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 {%s} in example file {%s}"'
+        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(
+            namespace_model=self.namespace_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
+{{ namespace_model.options['license_header'] }}
+
+{{ imports }}
+
+{% for client in namespace_model.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.namespace_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
+{{ namespace_model.options['license_header'] }}
+
+{{ imports }}
+
+{% if not namespace_model.options['package_version'] %}
+VERSION = "unknown"
+{% endif %}
+
+{% for client in namespace_model.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
-{{ code_model.options['license_header'] }}
+{{ namespace_model.options['license_header'] }}
 
 from enum import Enum
 from azure.core import CaseInsensitiveEnumMeta
 
-{% for enum in code_model.enums | sort %}
+{% for enum in namespace_model.enums | sort %}
 {% include "enum.py.jinja2" %}
-{% endfor %}
+{% endfor %}

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

@@ -1,18 +1,24 @@
 {% import 'keywords.jinja2' as keywords %}
 # coding=utf-8
-{{ code_model.options['license_header'] }}
+{{ namespace_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']%}
+{% if not async_mode and namespace_model.options['package_version']%}
 from ._version import VERSION
 
 __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

@@ -14,6 +14,6 @@
 
     {{ op_tools.serialize(operation_serializer.return_lro_poller(operation)) | indent }}
     {% endif %}
-{% if not code_model.options["version_tolerant"] %}
+{% if not namespace_model.options["version_tolerant"] %}
 {{ operation_serializer.get_metadata_url(operation) -}}
-{% endif %}
+{% 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 code_model.options["version_tolerant"] %}
+{% if not namespace_model.options["version_tolerant"] %}
 {{ operation_serializer.get_metadata_url(operation) }}
 {% 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.namespace_model.options["azure_arm"]  | tojson }},
+        "has_lro_operations": {{ client.has_lro_operations | tojson }},
+        "client_side_validation": {{ client.namespace_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_container.py.jinja2

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

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

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

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 code_model.options["version_tolerant"] %}
+{% if not namespace_model.options["version_tolerant"] %}
 {{ operation_serializer.get_metadata_url(operation) }}
-{% endif %}
+{% 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:`{{ "~" + code_model.namespace + (".aio." if async_mode else ".") + code_model.client.name }}`'s
+        :class:`{{ "~" + namespace_model.namespace + (".aio." if async_mode else ".") + operation_group.client.name }}`'s
         :attr:`{{ operation_group.property_name }}` attribute.
     """
 
-{% if code_model.public_model_types and code_model.options["models_mode"] == "msrest" %}
+{% if namespace_model.public_model_types and namespace_model.options["models_mode"] == "msrest" %}
     models = _models
 
 {% endif %}
@@ -50,4 +50,4 @@ class {{ operation_group.class_name }}{{ base_class }}:{{ disable }}
     {% macro someop() %}{% include "operation.py.jinja2" %}{% endmacro %}
     {% endif %}
     {{ someop()|indent }}
-{% endfor %}
+{% endfor %}

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

@@ -3,17 +3,17 @@
 {% set return_none_type_annotation = " -> None" if async_mode else "" %}
 # pylint: disable=too-many-lines
 # coding=utf-8
-{{ code_model.options['license_header'] }}
+{{ namespace_model.options['license_header'] }}
 {{ imports }}
 
-{% if code_model.options["builders_visibility"] == "embedded" and not async_mode %}
-{{ op_tools.declare_serializer(code_model, request_builders) }}
-{% for operation_group in operation_groups %}
-    {% for request_builder in request_builders | selectattr("group_name", "equalto", operation_group.property_name) | rejectattr("is_overload") %}
+{% if namespace_model.options["builders_visibility"] == "embedded" and not async_mode %}
+{{ op_tools.declare_serializer(namespace_model) }}
+    {% for operation_group in operation_groups %}
+        {% for request_builder in get_request_builders(operation_group) %}
 
-        {% include "request_builder.py.jinja2" %}
+{% include "request_builder.py.jinja2" %}
+        {% endfor %}
     {% endfor %}
-{% endfor %}
 {% endif %}
 {% for operation_group in operation_groups %}
     {% include "operation_group.py.jinja2" %}

package/autorest/codegen/templates/operation_tools.jinja2

@@ -50,10 +50,10 @@ Example:
     {% endif %}
 {% endfor %}{% endmacro %}
 
-{% macro declare_serializer(code_model, request_builders) %}
-{% if request_builders %}
+{% macro declare_serializer(namespace_model) %}
+{% if namespace_model.request_builders | rejectattr("abstract") | first %}
 _SERIALIZER = Serializer()
-    {% if not code_model.options["client_side_validation"] %}
+    {% if not namespace_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
-{{ code_model.options['license_header'] }}
+{{ namespace_model.options['license_header'] }}
 
 {{ op_tools.serialize(operation_group_imports()) }}
 {{ keywords.patch_imports() }}
-{% if operation_groups %}
+{% if namespace_model.operation_groups %}
 __all__ = [
-    {% for operation_group in operation_groups %}
+    {% for operation_group in namespace_model.operation_groups %}
     '{{ operation_group.class_name }}',
     {% endfor %}
 ]
 {% endif %}
 {{ keywords.extend_all }}
-_patch_sdk()
+_patch_sdk()

package/autorest/codegen/templates/{setup.py.jinja2 → packaging_templates/setup.py.jinja2}

@@ -7,9 +7,9 @@ import re
 {% endif -%}
 from setuptools import setup, find_packages
 
-{% set package_name_render = package_name or code_model.client.name %}
+{% set package_name = package_name or code_model.namespace_models[0].clients[0].name %}
 
-PACKAGE_NAME = "{{ package_name_render|lower }}"
+PACKAGE_NAME = "{{ package_name|lower }}"
 {% if package_mode -%}
 PACKAGE_PPRINT_NAME = "{{ package_pprint_name }}"
 
@@ -28,9 +28,9 @@ if not version:
 {% set author_email = "azpysdkhelp@microsoft.com" %}
 {% set url = "https://github.com/Azure/azure-sdk-for-python/tree/main/sdk" %}
 {% else %}
-version = "{{ code_model.options['package_version'] }}"
-{% set description = "%s"|format(package_name_render) %}
-{% set long_description = code_model.client.description %}
+version = "{{ package_version }}"
+{% set description = "%s"|format(package_name) %}
+{% set long_description = code_model.description %}
 {% set author_email = "" %}
 {% set url = "" %}
 {% endif -%}
@@ -82,21 +82,21 @@ setup(
     {% endif %}
     install_requires=[
         {% if code_model.is_legacy %}
-        "{{ dependency_msrest }}",
+        "msrest>=0.7.1",
         {% else %}
         "isodate<1.0.0,>=0.6.1",
         {% endif %}
         {% if azure_arm %}
-        "{{ dependency_azure_mgmt_core }}",
+        "azure-mgmt-core<2.0.0,>=1.3.2",
         {% else %}
-        "{{ dependency_azure_core }}",
+        "azure-core<2.0.0,>=1.24.0",
         {% endif %}
     ],
     {% if package_mode %}
     python_requires=">=3.7",
     {% else %}
     long_description="""\
-    {{ code_model.client.description }}
+    {{ code_model.description }}
     """
     {% endif %}
 )

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

@@ -19,6 +19,6 @@
         get_next, extract_data
     )
     {% endif %}
-{% if not code_model.options["version_tolerant"] %}
+{% if not namespace_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 code_model.options["builders_visibility"] == "public" %}
+{% if namespace_model.options["builders_visibility"] == "public" %}
     {{ op_tools.description(request_builder, request_builder_serializer) | indent }}
 {% endif %}
 {% if not request_builder.is_overload %}