@autorest/python 6.1.11 → 6.2.0

package/autorest/codegen/serializers/builder_serializer.py

@@ -12,7 +12,7 @@ from typing import Any, Generic, List, Type, TypeVar, Dict, Union, Optional, cas
 
 from ..models import (
     Operation,
-    CodeModel,
+    NamespaceModel,
     PagingOperation,
     LROOperation,
     LROPagingOperation,
@@ -190,8 +190,8 @@ def _api_version_validation(builder: OperationType) -> str:
 
 
 class _BuilderBaseSerializer(Generic[BuilderType]):  # pylint: disable=abstract-method
-    def __init__(self, code_model: CodeModel, async_mode: bool) -> None:
-        self.code_model = code_model
+    def __init__(self, namespace_model: NamespaceModel, async_mode: bool) -> None:
+        self.namespace_model = namespace_model
         self.async_mode = async_mode
         self.parameter_serializer = ParameterSerializer()
 
@@ -227,7 +227,7 @@ class _BuilderBaseSerializer(Generic[BuilderType]):  # pylint: disable=abstract-
         retval: List[str] = []
         if builder.is_overload:
             return ["@overload"]
-        if self.code_model.options["tracing"] and builder.want_tracing:
+        if self.namespace_model.options["tracing"] and builder.want_tracing:
             retval.append(f"@distributed_trace{'_async' if self.async_mode else ''}")
         return retval
 
@@ -315,7 +315,7 @@ class _BuilderBaseSerializer(Generic[BuilderType]):  # pylint: disable=abstract-
 
     def _json_input_example_template(self, builder: BuilderType) -> List[str]:
         template: List[str] = []
-        if self.code_model.options["models_mode"]:
+        if self.namespace_model.options["models_mode"]:
             # No input template if we have models
             return template
         if (
@@ -345,7 +345,7 @@ class _BuilderBaseSerializer(Generic[BuilderType]):  # pylint: disable=abstract-
             )
             for idx in range(
                 min(
-                    self.code_model.options["polymorphic_examples"],
+                    self.namespace_model.options["polymorphic_examples"],
                     len(polymorphic_subtypes),
                 )
             ):
@@ -513,7 +513,7 @@ class RequestBuilderSerializer(
         if any(
             o
             for o in ["low_level_client", "version_tolerant"]
-            if self.code_model.options.get(o)
+            if self.namespace_model.options.get(o)
         ):
             url_value = _escape_str(builder.url)
         else:
@@ -541,7 +541,7 @@ class _OperationSerializer(
 
     def example_template(self, builder: OperationType) -> List[str]:
         retval = super().example_template(builder)
-        if self.code_model.options["models_mode"]:
+        if self.namespace_model.options["models_mode"]:
             return retval
         for response in builder.responses:
             polymorphic_subtypes: List[ModelType] = []
@@ -559,7 +559,7 @@ class _OperationSerializer(
                 )
                 for idx in range(
                     min(
-                        self.code_model.options["polymorphic_examples"],
+                        self.namespace_model.options["polymorphic_examples"],
                         len(polymorphic_subtypes),
                     )
                 ):
@@ -615,7 +615,7 @@ class _OperationSerializer(
         self, builder: OperationType
     ) -> List[str]:  # pylint: disable=no-self-use
         description_list = super().param_description(builder)
-        if not self.code_model.options["version_tolerant"]:
+        if not self.namespace_model.options["version_tolerant"]:
             description_list.append(
                 ":keyword callable cls: A custom type or function that will be passed the direct response"
             )
@@ -636,7 +636,7 @@ class _OperationSerializer(
                 kwargs_to_pop, ParameterLocation.QUERY
             )
             else PopKwargType.SIMPLE,
-            check_client_input=not self.code_model.options["multiapi"],
+            check_client_input=not self.namespace_model.options["multiapi"],
         )
         kwargs.append(
             f"cls = kwargs.pop('cls', None)  {self.cls_type_annotation(builder)}"
@@ -672,9 +672,9 @@ class _OperationSerializer(
             body_param.type.xml_serialization_ctxt if send_xml else None
         )
         ser_ctxt_name = "serialization_ctxt"
-        if xml_serialization_ctxt and self.code_model.options["models_mode"]:
+        if xml_serialization_ctxt and self.namespace_model.options["models_mode"]:
             retval.append(f'{ser_ctxt_name} = {{"xml": {{{xml_serialization_ctxt}}}}}')
-        if self.code_model.options["models_mode"] == "msrest":
+        if self.namespace_model.options["models_mode"] == "msrest":
             is_xml_cmd = ", is_xml=True" if send_xml else ""
             serialization_ctxt_cmd = (
                 f", {ser_ctxt_name}={ser_ctxt_name}" if xml_serialization_ctxt else ""
@@ -683,7 +683,7 @@ class _OperationSerializer(
                 f"_{body_kwarg_name} = self._serialize.body({body_param.client_name}, "
                 f"'{body_param.type.serialization_type}'{is_xml_cmd}{serialization_ctxt_cmd})"
             )
-        elif self.code_model.options["models_mode"] == "dpg":
+        elif self.namespace_model.options["models_mode"] == "dpg":
             create_body_call = f"_{body_kwarg_name} = json.dumps({body_param.client_name}, cls=AzureJSONEncoder)"
         else:
             create_body_call = f"_{body_kwarg_name} = {body_param.client_name}"
@@ -825,7 +825,7 @@ class _OperationSerializer(
         is_next_request: bool = False,
     ) -> List[str]:
         retval: List[str] = []
-        if self.code_model.options["builders_visibility"] == "embedded":
+        if self.namespace_model.options["builders_visibility"] == "embedded":
             request_path_name = request_builder.name
         else:
             group_name = request_builder.group_name
@@ -871,7 +871,7 @@ class _OperationSerializer(
             retval.append(
                 f"    {body_param.client_name}={body_param.name_in_high_level_operation},"
             )
-        if not self.code_model.options["version_tolerant"]:
+        if not self.namespace_model.options["version_tolerant"]:
             template_url = template_url or f"self.{builder.name}.metadata['url']"
             retval.append(f"    template_url={template_url},")
         retval.append("    headers=_headers,")
@@ -883,7 +883,7 @@ class _OperationSerializer(
         self, builder: OperationType, template_url: Optional[str] = None
     ) -> List[str]:
         retval: List[str] = []
-        if not self.code_model.options["version_tolerant"]:
+        if not self.namespace_model.options["version_tolerant"]:
             pass_files = ""
             if (
                 builder.parameters.has_body
@@ -894,7 +894,7 @@ class _OperationSerializer(
         if builder.parameters.path:
             retval.extend(self.serialize_path(builder))
         url_to_format = "request.url"
-        if self.code_model.options["version_tolerant"] and template_url:
+        if self.namespace_model.options["version_tolerant"] and template_url:
             url_to_format = template_url
         retval.append(
             "request.url = self._client.format_url({}{})  # type: ignore".format(
@@ -958,16 +958,16 @@ class _OperationSerializer(
             retval.append(
                 "deserialized = {}".format(
                     "response.iter_bytes()"
-                    if self.code_model.options["version_tolerant"]
+                    if self.namespace_model.options["version_tolerant"]
                     else "response.stream_download(self._client._pipeline)"
                 )
             )
         elif response.type:
-            if self.code_model.options["models_mode"] == "msrest":
+            if self.namespace_model.options["models_mode"] == "msrest":
                 retval.append(
                     f"deserialized = self._deserialize('{response.serialization_type}', pipeline_response)"
                 )
-            elif self.code_model.options["models_mode"] == "dpg" and isinstance(
+            elif self.namespace_model.options["models_mode"] == "dpg" and isinstance(
                 response.type, ModelType
             ):
                 retval.append(
@@ -995,9 +995,9 @@ class _OperationSerializer(
         error_model = ""
         if (
             builder.default_error_deserialization
-            and self.code_model.options["models_mode"]
+            and self.namespace_model.options["models_mode"]
         ):
-            if self.code_model.options["models_mode"] == "dpg":
+            if self.namespace_model.options["models_mode"] == "dpg":
                 retval.append(
                     f"    error = _deserialize({builder.default_error_deserialization},  response.json())"
                 )
@@ -1011,7 +1011,7 @@ class _OperationSerializer(
             "    raise HttpResponseError(response=response{}{})".format(
                 error_model,
                 ", error_format=ARMErrorFormat"
-                if self.code_model.options["azure_arm"]
+                if self.namespace_model.options["azure_arm"]
                 else "",
             )
         )
@@ -1046,7 +1046,10 @@ class _OperationSerializer(
                     self.response_headers_and_deserialization(builder.responses[0])
                 )
                 retval.append("")
-        if builder.has_optional_return_type or self.code_model.options["models_mode"]:
+        if (
+            builder.has_optional_return_type
+            or self.namespace_model.options["models_mode"]
+        ):
             deserialized = "deserialized"
         else:
             deserialized = f"cast({builder.response_type_annotation(async_mode=self.async_mode)}, deserialized)"
@@ -1062,7 +1065,7 @@ class _OperationSerializer(
             retval.append(f"return {deserialized}")
         if (
             builder.request_builder.method == "HEAD"
-            and self.code_model.options["head_as_boolean"]
+            and self.namespace_model.options["head_as_boolean"]
         ):
             retval.append("return 200 <= response.status_code <= 299")
         return retval
@@ -1081,16 +1084,16 @@ class _OperationSerializer(
             for excep in builder.non_default_errors:
                 error_model_str = ""
                 if isinstance(excep.type, ModelType):
-                    if self.code_model.options["models_mode"] == "msrest":
+                    if self.namespace_model.options["models_mode"] == "msrest":
                         error_model_str = (
                             f", model=self._deserialize("
                             f"_models.{excep.type.serialization_type}, response)"
                         )
-                    elif self.code_model.options["models_mode"] == "dpg":
+                    elif self.namespace_model.options["models_mode"] == "dpg":
                         error_model_str = f", model=_deserialize(_models.{excep.type.name}, response.json())"
                 error_format_str = (
                     ", error_format=ARMErrorFormat"
-                    if self.code_model.options["azure_arm"]
+                    if self.namespace_model.options["azure_arm"]
                     else ""
                 )
                 for status_code in excep.status_codes:
@@ -1154,11 +1157,11 @@ PagingOperationType = TypeVar(
 class _PagingOperationSerializer(
     _OperationSerializer[PagingOperationType]
 ):  # pylint: disable=abstract-method
-    def __init__(self, code_model: CodeModel, async_mode: bool) -> None:
+    def __init__(self, namespace_model: NamespaceModel, async_mode: bool) -> None:
         # for pylint reasons need to redefine init
         # probably because inheritance is going too deep
-        super().__init__(code_model, async_mode)
-        self.code_model = code_model
+        super().__init__(namespace_model, async_mode)
+        self.namespace_model = namespace_model
         self.async_mode = async_mode
         self.parameter_serializer = ParameterSerializer()
 
@@ -1172,7 +1175,7 @@ class _PagingOperationSerializer(
         retval: List[str] = []
         if builder.is_overload:
             return ["@overload"]
-        if self.code_model.options["tracing"] and builder.want_tracing:
+        if self.namespace_model.options["tracing"] and builder.want_tracing:
             retval.append("@distributed_trace")
         if _api_version_validation(builder):
             retval.append(_api_version_validation(builder))
@@ -1183,7 +1186,7 @@ class _PagingOperationSerializer(
             request_builder = builder.next_request_builder
             template_url = (
                 None
-                if self.code_model.options["version_tolerant"]
+                if self.namespace_model.options["version_tolerant"]
                 else f"'{request_builder.url}'"
             )
         else:
@@ -1203,9 +1206,7 @@ class _PagingOperationSerializer(
         next_link_str = "next_link"
         try:
             api_version_param = next(
-                p
-                for p in self.code_model.client.parameters
-                if p.rest_api_name == "api-version"
+                p for p in builder.client.parameters if p.rest_api_name == "api-version"
             )
             retval.append("# make call to next link with the client's api-version")
             retval.append("_parsed_next_link = urllib.parse.urlparse(next_link)")
@@ -1245,7 +1246,7 @@ class _PagingOperationSerializer(
         retval.extend(
             [f"        {line}" for line in self.call_next_link_request_builder(builder)]
         )
-        if not builder.next_request_builder and self.code_model.is_legacy:
+        if not builder.next_request_builder and self.namespace_model.is_legacy:
             retval.append('        request.method = "GET"')
         else:
             retval.append("")
@@ -1262,14 +1263,14 @@ class _PagingOperationSerializer(
         ]
         response = builder.responses[0]
         deserialized = "pipeline_response.http_response.json()"
-        if self.code_model.options["models_mode"] == "msrest":
+        if self.namespace_model.options["models_mode"] == "msrest":
             deserialize_type = response.serialization_type
             pylint_disable = "  # pylint: disable=protected-access"
             if isinstance(response.type, ModelType) and response.type.is_public:
                 deserialize_type = f'"{response.serialization_type}"'
                 pylint_disable = ""
             deserialized = f"self._deserialize(\n    {deserialize_type}, pipeline_response{pylint_disable}\n)"
-        elif self.code_model.options["models_mode"] == "dpg":
+        elif self.namespace_model.options["models_mode"] == "dpg":
             deserialized = (
                 f"_deserialize({response.serialization_type}, pipeline_response)"
             )
@@ -1277,7 +1278,7 @@ class _PagingOperationSerializer(
         item_name = builder.item_name
         list_of_elem = (
             f".{item_name}"
-            if self.code_model.options["models_mode"]
+            if self.namespace_model.options["models_mode"]
             else f'["{item_name}"]'
         )
         retval.append(f"    list_of_elem = deserialized{list_of_elem}")
@@ -1287,7 +1288,7 @@ class _PagingOperationSerializer(
         continuation_token_name = builder.continuation_token_name
         if not continuation_token_name:
             cont_token_property = "None"
-        elif self.code_model.options["models_mode"]:
+        elif self.namespace_model.options["models_mode"]:
             cont_token_property = f"deserialized.{continuation_token_name} or None"
         else:
             cont_token_property = f'deserialized.get("{continuation_token_name}", None)'
@@ -1330,11 +1331,11 @@ LROOperationType = TypeVar(
 
 
 class _LROOperationSerializer(_OperationSerializer[LROOperationType]):
-    def __init__(self, code_model: CodeModel, async_mode: bool) -> None:
+    def __init__(self, namespace_model: NamespaceModel, async_mode: bool) -> None:
         # for pylint reasons need to redefine init
         # probably because inheritance is going too deep
-        super().__init__(code_model, async_mode)
-        self.code_model = code_model
+        super().__init__(namespace_model, async_mode)
+        self.namespace_model = namespace_model
         self.async_mode = async_mode
         self.parameter_serializer = ParameterSerializer()
 
@@ -1447,8 +1448,8 @@ class _LROOperationSerializer(_OperationSerializer[LROOperationType]):
             if builder.lro_response.headers:
                 retval.append("    response_headers = {}")
             if (
-                not self.code_model.options["models_mode"]
-                or self.code_model.options["models_mode"] == "dpg"
+                not self.namespace_model.options["models_mode"]
+                or self.namespace_model.options["models_mode"] == "dpg"
                 or builder.lro_response.headers
             ):
                 retval.append("    response = pipeline_response.http_response")
@@ -1514,7 +1515,7 @@ class LROPagingOperationSerializer(
 
 def get_operation_serializer(
     builder: Operation,
-    code_model,
+    namespace_model,
     async_mode: bool,
 ) -> Union[
     OperationSerializer,
@@ -1534,4 +1535,4 @@ def get_operation_serializer(
         retcls = LROOperationSerializer
     elif builder.operation_type == "paging":
         retcls = PagingOperationSerializer
-    return retcls(code_model, async_mode)
+    return retcls(namespace_model, async_mode)

package/autorest/codegen/serializers/client_serializer.py

@@ -6,18 +6,18 @@
 from typing import List
 
 from . import utils
-from ..models import CodeModel, ParameterMethodLocation
+from ..models import Client, ParameterMethodLocation
 from .parameter_serializer import ParameterSerializer, PopKwargType
 
 
 class ClientSerializer:
-    def __init__(self, code_model: CodeModel) -> None:
-        self.code_model = code_model
+    def __init__(self, client: Client) -> None:
+        self.client = client
         self.parameter_serializer = ParameterSerializer()
 
     def _init_signature(self, async_mode: bool) -> str:
         pylint_disable = ""
-        if not self.code_model.client.parameters.credential:
+        if not self.client.parameters.credential:
             pylint_disable = (
                 "  # pylint: disable=missing-client-constructor-parameter-credential"
             )
@@ -25,9 +25,7 @@ class ClientSerializer:
             function_def="def",
             method_name="__init__",
             need_self_param=True,
-            method_param_signatures=self.code_model.client.parameters.method_signature(
-                async_mode
-            ),
+            method_param_signatures=self.client.parameters.method_signature(async_mode),
             pylint_disable=pylint_disable,
         )
 
@@ -40,7 +38,7 @@ class ClientSerializer:
 
     def pop_kwargs_from_signature(self) -> List[str]:
         return self.parameter_serializer.pop_kwargs_from_signature(
-            self.code_model.client.parameters.kwargs_to_pop,
+            self.client.parameters.kwargs_to_pop,
             check_kwarg_dict=False,
             pop_headers_kwarg=PopKwargType.NO,
             pop_params_kwarg=PopKwargType.NO,
@@ -48,12 +46,12 @@ class ClientSerializer:
 
     @property
     def class_definition(self) -> str:
-        class_name = self.code_model.client.name
-        has_mixin_og = any(og for og in self.code_model.operation_groups if og.is_mixin)
+        class_name = self.client.name
+        has_mixin_og = any(og for og in self.client.operation_groups if og.is_mixin)
         base_class = ""
         if has_mixin_og:
             base_class = f"{class_name}OperationsMixin"
-        pylint_disable = self.code_model.client.pylint_disable
+        pylint_disable = self.client.pylint_disable
         if base_class:
             return f"class {class_name}({base_class}):{pylint_disable}"
         return f"class {class_name}:{pylint_disable}"
@@ -61,19 +59,18 @@ class ClientSerializer:
     def property_descriptions(self, async_mode: bool) -> List[str]:
         retval: List[str] = []
         operations_folder = ".aio.operations." if async_mode else ".operations."
-        for og in [og for og in self.code_model.operation_groups if not og.is_mixin]:
+        for og in [og for og in self.client.operation_groups if not og.is_mixin]:
             retval.append(f":ivar {og.property_name}: {og.class_name} operations")
-            retval.append(
-                f":vartype {og.property_name}: {self.code_model.namespace}{operations_folder}{og.class_name}"
-            )
-        for param in self.code_model.client.parameters.method:
+            property_type = f"{self.client.namespace_model.namespace}{operations_folder}{og.class_name}"
+            retval.append(f":vartype {og.property_name}: {property_type}")
+        for param in self.client.parameters.method:
             retval.append(
                 f":{param.description_keyword} {param.client_name}: {param.description}"
             )
             retval.append(
                 f":{param.docstring_type_keyword} {param.client_name}: {param.docstring_type(async_mode=async_mode)}"
             )
-        if self.code_model.has_lro_operations:
+        if self.client.has_lro_operations:
             retval.append(
                 ":keyword int polling_interval: Default waiting time between two polls for LRO operations "
                 "if no Retry-After header is present."
@@ -82,11 +79,11 @@ class ClientSerializer:
         return retval
 
     def initialize_config(self) -> str:
-        config_name = f"{self.code_model.client.name}Configuration"
+        config_name = f"{self.client.name}Configuration"
         config_call = ", ".join(
             [
                 f"{p.client_name}={p.client_name}"
-                for p in self.code_model.config.parameters.method
+                for p in self.client.config.parameters.method
                 if p.method_location != ParameterMethodLocation.KWARG
             ]
             + ["**kwargs"]
@@ -96,9 +93,7 @@ class ClientSerializer:
     @property
     def host_variable_name(self) -> str:
         try:
-            return next(
-                p for p in self.code_model.client.parameters if p.is_host
-            ).client_name
+            return next(p for p in self.client.parameters if p.is_host).client_name
         except StopIteration:
             return "_endpoint"
 
@@ -106,12 +101,12 @@ class ClientSerializer:
     def should_init_super(self) -> bool:
         return any(
             og
-            for og in self.code_model.operation_groups
+            for og in self.client.operation_groups
             if og.is_mixin and og.has_abstract_operations
         )
 
     def initialize_pipeline_client(self, async_mode: bool) -> str:
-        pipeline_client_name = self.code_model.client.pipeline_class(async_mode)
+        pipeline_client_name = self.client.pipeline_class(async_mode)
         return (
             f"self._client = {pipeline_client_name}(base_url={self.host_variable_name}, "
             "config=self._config, **kwargs)"
@@ -119,22 +114,22 @@ class ClientSerializer:
 
     def serializers_and_operation_groups_properties(self) -> List[str]:
         retval = []
-        if self.code_model.model_types:
+        if self.client.namespace_model.model_types:
             client_models_value = (
                 "{k: v for k, v in models.__dict__.items() if isinstance(v, type)}"
             )
         else:
             client_models_value = "{}  # type: Dict[str, Any]"
-        is_msrest_model = self.code_model.options["models_mode"] == "msrest"
+        is_msrest_model = self.client.namespace_model.options["models_mode"] == "msrest"
         if is_msrest_model:
             retval.append(f"client_models = {client_models_value}")
         client_models_str = "client_models" if is_msrest_model else ""
         retval.append(f"self._serialize = Serializer({client_models_str})")
         retval.append(f"self._deserialize = Deserializer({client_models_str})")
-        if not self.code_model.options["client_side_validation"]:
+        if not self.client.namespace_model.options["client_side_validation"]:
             retval.append("self._serialize.client_side_validation = False")
         operation_groups = [
-            og for og in self.code_model.operation_groups if not og.is_mixin
+            og for og in self.client.operation_groups if not og.is_mixin
         ]
         for og in operation_groups:
             retval.extend(
@@ -149,10 +144,10 @@ class ClientSerializer:
     def _send_request_signature(self) -> str:
         send_request_signature = [
             "request: HttpRequest,"
-        ] + self.code_model.client.parameters.method_signature_kwargs
+        ] + self.client.parameters.method_signature_kwargs
         return self.parameter_serializer.serialize_method(
             function_def="def",
-            method_name=self.code_model.client.send_request_name,
+            method_name=self.client.send_request_name,
             need_self_param=True,
             method_param_signatures=send_request_signature,
         )
@@ -171,7 +166,7 @@ class ClientSerializer:
     def _example_make_call(self, async_mode: bool) -> List[str]:
         http_response = "AsyncHttpResponse" if async_mode else "HttpResponse"
         retval = [
-            f">>> response = {'await ' if async_mode else ''}client.{self.code_model.client.send_request_name}(request)"
+            f">>> response = {'await ' if async_mode else ''}client.{self.client.send_request_name}(request)"
         ]
         retval.append(f"<{http_response}: 200 OK>")
         return retval
@@ -179,14 +174,14 @@ class ClientSerializer:
     def _request_builder_example(self, async_mode: bool) -> List[str]:
         retval = [
             "We have helper methods to create requests specific to this service in "
-            + f"`{self.code_model.namespace}.{self.code_model.rest_layer_name}`."
+            + f"`{self.client.namespace_model.namespace}.{self.client.namespace_model.rest_layer_name}`."
         ]
         retval.append(
             "Use these helper methods to create the request you pass to this method."
         )
         retval.append("")
 
-        request_builder = self.code_model.request_builders[0]
+        request_builder = self.client.request_builders[0]
         request_builder_signature = ", ".join(request_builder.parameters.call)
         if request_builder.group_name:
             rest_imported = request_builder.group_name
@@ -196,9 +191,8 @@ class ClientSerializer:
         else:
             rest_imported = request_builder.name
             request_builder_name = request_builder.name
-        retval.append(
-            f">>> from {self.code_model.namespace}.{self.code_model.rest_layer_name} import {rest_imported}"
-        )
+        full_path = f"{self.client.namespace_model.namespace}.{self.client.namespace_model.rest_layer_name}"
+        retval.append(f">>> from {full_path} import {rest_imported}")
         retval.append(
             f">>> request = {request_builder_name}({request_builder_signature})"
         )
@@ -218,7 +212,7 @@ class ClientSerializer:
     def send_request_description(self, async_mode: bool) -> List[str]:
         retval = ['"""Runs the network request through the client\'s chained policies.']
         retval.append("")
-        if self.code_model.options["builders_visibility"] != "embedded":
+        if self.client.namespace_model.options["builders_visibility"] != "embedded":
             retval.extend(self._request_builder_example(async_mode))
         else:
             retval.extend(self._rest_request_example(async_mode))
@@ -242,13 +236,13 @@ class ClientSerializer:
 
     def serialize_path(self) -> List[str]:
         return self.parameter_serializer.serialize_path(
-            self.code_model.client.parameters.path, "self._serialize"
+            self.client.parameters.path, "self._serialize"
         )
 
 
 class ConfigSerializer:
-    def __init__(self, code_model: CodeModel) -> None:
-        self.code_model = code_model
+    def __init__(self, client: Client) -> None:
+        self.client = client
         self.parameter_serializer = ParameterSerializer()
 
     def _init_signature(self, async_mode: bool) -> str:
@@ -256,7 +250,7 @@ class ConfigSerializer:
             function_def="def",
             method_name="__init__",
             need_self_param=True,
-            method_param_signatures=self.code_model.config.parameters.method_signature(
+            method_param_signatures=self.client.config.parameters.method_signature(
                 async_mode
             ),
         )
@@ -270,7 +264,7 @@ class ConfigSerializer:
 
     def pop_kwargs_from_signature(self) -> List[str]:
         return self.parameter_serializer.pop_kwargs_from_signature(
-            self.code_model.config.parameters.kwargs_to_pop,
+            self.client.config.parameters.kwargs_to_pop,
             check_kwarg_dict=False,
             pop_headers_kwarg=PopKwargType.NO,
             pop_params_kwarg=PopKwargType.NO,
@@ -279,21 +273,21 @@ class ConfigSerializer:
     def set_constants(self) -> List[str]:
         return [
             f"self.{p.client_name} = {p.client_default_value_declaration}"
-            for p in self.code_model.config.parameters.constant
-            if p not in self.code_model.config.parameters.method
+            for p in self.client.config.parameters.constant
+            if p not in self.client.config.parameters.method
         ]
 
     def check_required_parameters(self) -> List[str]:
         return [
             f"if {p.client_name} is None:\n"
             f"    raise ValueError(\"Parameter '{p.client_name}' must not be None.\")"
-            for p in self.code_model.config.parameters.method
+            for p in self.client.config.parameters.method
             if not (p.optional or p.constant)
         ]
 
     def property_descriptions(self, async_mode: bool) -> List[str]:
         retval: List[str] = []
-        for p in self.code_model.config.parameters.method:
+        for p in self.client.config.parameters.method:
             retval.append(f":{p.description_keyword} {p.client_name}: {p.description}")
             retval.append(
                 f":{p.docstring_type_keyword} {p.client_name}: {p.docstring_type(async_mode=async_mode)}"

package/autorest/codegen/serializers/enum_serializer.py

@@ -5,15 +5,15 @@
 # --------------------------------------------------------------------------
 
 from jinja2 import Environment
-from ..models import CodeModel
+from ..models import NamespaceModel
 
 
 class EnumSerializer:
-    def __init__(self, code_model: CodeModel, env: Environment) -> None:
-        self.code_model = code_model
+    def __init__(self, namespace_model: NamespaceModel, env: Environment) -> None:
+        self.namespace_model = namespace_model
         self.env = env
 
     def serialize(self) -> str:
         # Generate the enum file
         template = self.env.get_template("enum_container.py.jinja2")
-        return template.render(code_model=self.code_model)
+        return template.render(namespace_model=self.namespace_model)