@autorest/python 6.2.0 → 6.2.1

package/autorest/codegen/serializers/builder_serializer.py

@@ -12,8 +12,8 @@ from typing import Any, Generic, List, Type, TypeVar, Dict, Union, Optional, cas
 
 from ..models import (
     Operation,
-    NamespaceModel,
     PagingOperation,
+    CodeModel,
     LROOperation,
     LROPagingOperation,
     ModelType,
@@ -190,8 +190,8 @@ def _api_version_validation(builder: OperationType) -> str:
 
 
 class _BuilderBaseSerializer(Generic[BuilderType]):  # pylint: disable=abstract-method
-    def __init__(self, namespace_model: NamespaceModel, async_mode: bool) -> None:
-        self.namespace_model = namespace_model
+    def __init__(self, code_model: CodeModel, async_mode: bool) -> None:
+        self.code_model = code_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.namespace_model.options["tracing"] and builder.want_tracing:
+        if self.code_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.namespace_model.options["models_mode"]:
+        if self.code_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.namespace_model.options["polymorphic_examples"],
+                    self.code_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.namespace_model.options.get(o)
+            if self.code_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.namespace_model.options["models_mode"]:
+        if self.code_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.namespace_model.options["polymorphic_examples"],
+                        self.code_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.namespace_model.options["version_tolerant"]:
+        if not self.code_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.namespace_model.options["multiapi"],
+            check_client_input=not self.code_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.namespace_model.options["models_mode"]:
+        if xml_serialization_ctxt and self.code_model.options["models_mode"]:
             retval.append(f'{ser_ctxt_name} = {{"xml": {{{xml_serialization_ctxt}}}}}')
-        if self.namespace_model.options["models_mode"] == "msrest":
+        if self.code_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.namespace_model.options["models_mode"] == "dpg":
+        elif self.code_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.namespace_model.options["builders_visibility"] == "embedded":
+        if self.code_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.namespace_model.options["version_tolerant"]:
+        if not self.code_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.namespace_model.options["version_tolerant"]:
+        if not self.code_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.namespace_model.options["version_tolerant"] and template_url:
+        if self.code_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.namespace_model.options["version_tolerant"]
+                    if self.code_model.options["version_tolerant"]
                     else "response.stream_download(self._client._pipeline)"
                 )
             )
         elif response.type:
-            if self.namespace_model.options["models_mode"] == "msrest":
+            if self.code_model.options["models_mode"] == "msrest":
                 retval.append(
                     f"deserialized = self._deserialize('{response.serialization_type}', pipeline_response)"
                 )
-            elif self.namespace_model.options["models_mode"] == "dpg" and isinstance(
+            elif self.code_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.namespace_model.options["models_mode"]
+            and self.code_model.options["models_mode"]
         ):
-            if self.namespace_model.options["models_mode"] == "dpg":
+            if self.code_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.namespace_model.options["azure_arm"]
+                if self.code_model.options["azure_arm"]
                 else "",
             )
         )
@@ -1046,10 +1046,7 @@ class _OperationSerializer(
                     self.response_headers_and_deserialization(builder.responses[0])
                 )
                 retval.append("")
-        if (
-            builder.has_optional_return_type
-            or self.namespace_model.options["models_mode"]
-        ):
+        if builder.has_optional_return_type or self.code_model.options["models_mode"]:
             deserialized = "deserialized"
         else:
             deserialized = f"cast({builder.response_type_annotation(async_mode=self.async_mode)}, deserialized)"
@@ -1065,7 +1062,7 @@ class _OperationSerializer(
             retval.append(f"return {deserialized}")
         if (
             builder.request_builder.method == "HEAD"
-            and self.namespace_model.options["head_as_boolean"]
+            and self.code_model.options["head_as_boolean"]
         ):
             retval.append("return 200 <= response.status_code <= 299")
         return retval
@@ -1084,16 +1081,16 @@ class _OperationSerializer(
             for excep in builder.non_default_errors:
                 error_model_str = ""
                 if isinstance(excep.type, ModelType):
-                    if self.namespace_model.options["models_mode"] == "msrest":
+                    if self.code_model.options["models_mode"] == "msrest":
                         error_model_str = (
                             f", model=self._deserialize("
                             f"_models.{excep.type.serialization_type}, response)"
                         )
-                    elif self.namespace_model.options["models_mode"] == "dpg":
+                    elif self.code_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.namespace_model.options["azure_arm"]
+                    if self.code_model.options["azure_arm"]
                     else ""
                 )
                 for status_code in excep.status_codes:
@@ -1157,11 +1154,11 @@ PagingOperationType = TypeVar(
 class _PagingOperationSerializer(
     _OperationSerializer[PagingOperationType]
 ):  # pylint: disable=abstract-method
-    def __init__(self, namespace_model: NamespaceModel, async_mode: bool) -> None:
+    def __init__(self, code_model: CodeModel, async_mode: bool) -> None:
         # for pylint reasons need to redefine init
         # probably because inheritance is going too deep
-        super().__init__(namespace_model, async_mode)
-        self.namespace_model = namespace_model
+        super().__init__(code_model, async_mode)
+        self.code_model = code_model
         self.async_mode = async_mode
         self.parameter_serializer = ParameterSerializer()
 
@@ -1175,7 +1172,7 @@ class _PagingOperationSerializer(
         retval: List[str] = []
         if builder.is_overload:
             return ["@overload"]
-        if self.namespace_model.options["tracing"] and builder.want_tracing:
+        if self.code_model.options["tracing"] and builder.want_tracing:
             retval.append("@distributed_trace")
         if _api_version_validation(builder):
             retval.append(_api_version_validation(builder))
@@ -1186,7 +1183,7 @@ class _PagingOperationSerializer(
             request_builder = builder.next_request_builder
             template_url = (
                 None
-                if self.namespace_model.options["version_tolerant"]
+                if self.code_model.options["version_tolerant"]
                 else f"'{request_builder.url}'"
             )
         else:
@@ -1246,7 +1243,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.namespace_model.is_legacy:
+        if not builder.next_request_builder and self.code_model.is_legacy:
             retval.append('        request.method = "GET"')
         else:
             retval.append("")
@@ -1263,14 +1260,14 @@ class _PagingOperationSerializer(
         ]
         response = builder.responses[0]
         deserialized = "pipeline_response.http_response.json()"
-        if self.namespace_model.options["models_mode"] == "msrest":
+        if self.code_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.namespace_model.options["models_mode"] == "dpg":
+        elif self.code_model.options["models_mode"] == "dpg":
             deserialized = (
                 f"_deserialize({response.serialization_type}, pipeline_response)"
             )
@@ -1278,7 +1275,7 @@ class _PagingOperationSerializer(
         item_name = builder.item_name
         list_of_elem = (
             f".{item_name}"
-            if self.namespace_model.options["models_mode"]
+            if self.code_model.options["models_mode"]
             else f'["{item_name}"]'
         )
         retval.append(f"    list_of_elem = deserialized{list_of_elem}")
@@ -1288,7 +1285,7 @@ class _PagingOperationSerializer(
         continuation_token_name = builder.continuation_token_name
         if not continuation_token_name:
             cont_token_property = "None"
-        elif self.namespace_model.options["models_mode"]:
+        elif self.code_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)'
@@ -1331,11 +1328,11 @@ LROOperationType = TypeVar(
 
 
 class _LROOperationSerializer(_OperationSerializer[LROOperationType]):
-    def __init__(self, namespace_model: NamespaceModel, async_mode: bool) -> None:
+    def __init__(self, code_model: CodeModel, async_mode: bool) -> None:
         # for pylint reasons need to redefine init
         # probably because inheritance is going too deep
-        super().__init__(namespace_model, async_mode)
-        self.namespace_model = namespace_model
+        super().__init__(code_model, async_mode)
+        self.code_model = code_model
         self.async_mode = async_mode
         self.parameter_serializer = ParameterSerializer()
 
@@ -1448,8 +1445,8 @@ class _LROOperationSerializer(_OperationSerializer[LROOperationType]):
             if builder.lro_response.headers:
                 retval.append("    response_headers = {}")
             if (
-                not self.namespace_model.options["models_mode"]
-                or self.namespace_model.options["models_mode"] == "dpg"
+                not self.code_model.options["models_mode"]
+                or self.code_model.options["models_mode"] == "dpg"
                 or builder.lro_response.headers
             ):
                 retval.append("    response = pipeline_response.http_response")
@@ -1515,7 +1512,7 @@ class LROPagingOperationSerializer(
 
 def get_operation_serializer(
     builder: Operation,
-    namespace_model,
+    code_model,
     async_mode: bool,
 ) -> Union[
     OperationSerializer,
@@ -1535,4 +1532,4 @@ def get_operation_serializer(
         retcls = LROOperationSerializer
     elif builder.operation_type == "paging":
         retcls = PagingOperationSerializer
-    return retcls(namespace_model, async_mode)
+    return retcls(code_model, async_mode)

package/autorest/codegen/serializers/client_serializer.py

@@ -61,7 +61,9 @@ class ClientSerializer:
         operations_folder = ".aio.operations." if async_mode else ".operations."
         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")
-            property_type = f"{self.client.namespace_model.namespace}{operations_folder}{og.class_name}"
+            property_type = (
+                f"{self.client.code_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(
@@ -114,19 +116,19 @@ class ClientSerializer:
 
     def serializers_and_operation_groups_properties(self) -> List[str]:
         retval = []
-        if self.client.namespace_model.model_types:
+        if self.client.code_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.client.namespace_model.options["models_mode"] == "msrest"
+        is_msrest_model = self.client.code_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.client.namespace_model.options["client_side_validation"]:
+        if not self.client.code_model.options["client_side_validation"]:
             retval.append("self._serialize.client_side_validation = False")
         operation_groups = [
             og for og in self.client.operation_groups if not og.is_mixin
@@ -174,7 +176,7 @@ 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.client.namespace_model.namespace}.{self.client.namespace_model.rest_layer_name}`."
+            + f"`{self.client.code_model.namespace}.{self.client.code_model.rest_layer_name}`."
         ]
         retval.append(
             "Use these helper methods to create the request you pass to this method."
@@ -191,7 +193,7 @@ class ClientSerializer:
         else:
             rest_imported = request_builder.name
             request_builder_name = request_builder.name
-        full_path = f"{self.client.namespace_model.namespace}.{self.client.namespace_model.rest_layer_name}"
+        full_path = f"{self.client.code_model.namespace}.{self.client.code_model.rest_layer_name}"
         retval.append(f">>> from {full_path} import {rest_imported}")
         retval.append(
             f">>> request = {request_builder_name}({request_builder_signature})"
@@ -212,7 +214,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.client.namespace_model.options["builders_visibility"] != "embedded":
+        if self.client.code_model.options["builders_visibility"] != "embedded":
             retval.extend(self._request_builder_example(async_mode))
         else:
             retval.extend(self._rest_request_example(async_mode))

package/autorest/codegen/serializers/enum_serializer.py

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

package/autorest/codegen/serializers/general_serializer.py

@@ -3,16 +3,16 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
-from typing import Any
+from typing import Any, List
 from jinja2 import Environment
 from .import_serializer import FileImportSerializer, TypingSection
 from ..models.imports import MsrestImportType
 from ..models import (
     FileImport,
     ImportType,
-    NamespaceModel,
     CodeModel,
     TokenCredentialType,
+    Client,
 )
 from .client_serializer import ClientSerializer, ConfigSerializer
 
@@ -28,9 +28,10 @@ _PACKAGE_MODE_FILES = [
 class GeneralSerializer:
     """General serializer for SDK root level files"""
 
-    def __init__(self, code_model: CodeModel, env: Environment):
+    def __init__(self, code_model: CodeModel, env: Environment, async_mode: bool):
         self.code_model = code_model
         self.env = env
+        self.async_mode = async_mode
 
     def serialize_setup_file(self) -> str:
         template = self.env.get_template("packaging_templates/setup.py.jinja2")
@@ -43,8 +44,7 @@ class GeneralSerializer:
         package_parts = (self.code_model.options["package_name"] or "").split("-")[:-1]
         token_credential = any(
             c
-            for nm in self.code_model.namespace_models
-            for c in nm.clients
+            for c in self.code_model.clients
             if isinstance(getattr(c.credential, "type", None), TokenCredentialType)
         )
         version = self.code_model.options["package_version"]
@@ -63,47 +63,36 @@ class GeneralSerializer:
                 "/".join(package_parts[: i + 1]) + "/__init__.py"
                 for i in range(len(package_parts))
             ],
-            "client_name": self.code_model.namespace_models[0].clients[0].name,
-            "namespace": self.code_model.namespace_models[0],
+            "client_name": self.code_model.clients[0].name,
+            "namespace": self.code_model.namespace,
         }
         params.update(self.code_model.options)
         params.update(kwargs)
         return template.render(**params)
 
-
-class GeneralNamespaceSerializer:
-    """General serializer for namespace level files"""
-
-    def __init__(
-        self, namespace_model: NamespaceModel, env: Environment, async_mode: bool
-    ) -> None:
-        self.namespace_model = namespace_model
-        self.env = env
-        self.async_mode = async_mode
-
     def serialize_pkgutil_init_file(self) -> str:
         template = self.env.get_template("pkgutil_init.py.jinja2")
         return template.render()
 
-    def serialize_init_file(self) -> str:
+    def serialize_init_file(self, clients: List[Client]) -> str:
         template = self.env.get_template("init.py.jinja2")
-        clients = [c for c in self.namespace_model.clients if c.request_builders]
         return template.render(
-            namespace_model=self.namespace_model,
+            code_model=self.code_model,
             clients=clients,
             async_mode=self.async_mode,
         )
 
-    def serialize_service_client_file(self) -> str:
+    def serialize_service_client_file(self, clients: List[Client]) -> str:
 
         template = self.env.get_template("client_container.py.jinja2")
 
         imports = FileImport()
-        for client in self.namespace_model.clients:
+        for client in clients:
             imports.merge(client.imports(self.async_mode))
 
         return template.render(
-            namespace_model=self.namespace_model,
+            code_model=self.code_model,
+            clients=clients,
             async_mode=self.async_mode,
             get_serializer=ClientSerializer,
             imports=FileImportSerializer(imports),
@@ -114,14 +103,14 @@ class GeneralNamespaceSerializer:
 
         # configure imports
         file_import = FileImport()
-        if self.namespace_model.need_request_converter:
+        if self.code_model.need_request_converter:
             file_import.add_submodule_import(
                 "azure.core.pipeline.transport",
                 "HttpRequest",
                 ImportType.AZURECORE,
             )
 
-        if self.namespace_model.need_mixin_abc:
+        if self.code_model.need_mixin_abc:
             file_import.add_submodule_import(
                 "abc",
                 "ABC",
@@ -134,12 +123,12 @@ class GeneralNamespaceSerializer:
                 TypingSection.TYPING,
             )
             file_import.add_msrest_import(
-                self.namespace_model,
+                self.code_model,
                 ".." if self.async_mode else ".",
                 MsrestImportType.SerializerDeserializer,
                 TypingSection.TYPING,
             )
-            for client in self.namespace_model.clients:
+            for client in self.code_model.clients:
                 file_import.add_submodule_import(
                     "._configuration",
                     f"{client.name}Configuration",
@@ -147,37 +136,38 @@ class GeneralNamespaceSerializer:
                 )
 
         return template.render(
-            namespace_model=self.namespace_model,
+            code_model=self.code_model,
             imports=FileImportSerializer(
                 file_import,
             ),
             async_mode=self.async_mode,
         )
 
-    def serialize_config_file(self) -> str:
+    def serialize_config_file(self, clients: List[Client]) -> str:
         template = self.env.get_template("config_container.py.jinja2")
         imports = FileImport()
-        for client in self.namespace_model.clients:
+        for client in self.code_model.clients:
             imports.merge(client.config.imports(self.async_mode))
         return template.render(
-            namespace_model=self.namespace_model,
+            code_model=self.code_model,
             async_mode=self.async_mode,
             imports=FileImportSerializer(imports),
             get_serializer=ConfigSerializer,
+            clients=clients,
         )
 
     def serialize_version_file(self) -> str:
         template = self.env.get_template("version.py.jinja2")
-        return template.render(namespace_model=self.namespace_model)
+        return template.render(code_model=self.code_model)
 
     def serialize_serialization_file(self) -> str:
         template = self.env.get_template("serialization.py.jinja2")
-        return template.render(namespace_model=self.namespace_model)
+        return template.render(code_model=self.code_model)
 
     def serialize_model_base_file(self) -> str:
         template = self.env.get_template("model_base.py.jinja2")
-        return template.render(namespace_model=self.namespace_model)
+        return template.render(code_model=self.code_model)
 
     def serialize_validation_file(self) -> str:
         template = self.env.get_template("validation.py.jinja2")
-        return template.render(namespace_model=self.namespace_model)
+        return template.render(code_model=self.code_model)