@typespec/http-client-python 0.5.1 → 0.6.0

package/generator/pygen/codegen/serializers/builder_serializer.py

@@ -32,6 +32,7 @@ from ..models import (
     ParameterListType,
     ByteArraySchema,
 )
+from ..models.utils import NamespaceType
 from .parameter_serializer import ParameterSerializer, PopKwargType
 from ..models.parameter_list import ParameterType
 from . import utils
@@ -188,10 +189,19 @@ def is_json_model_type(parameters: ParameterListType) -> bool:
 
 
 class _BuilderBaseSerializer(Generic[BuilderType]):
-    def __init__(self, code_model: CodeModel, async_mode: bool) -> None:
+    def __init__(self, code_model: CodeModel, async_mode: bool, client_namespace: str) -> None:
         self.code_model = code_model
         self.async_mode = async_mode
-        self.parameter_serializer = ParameterSerializer()
+        self.client_namespace = client_namespace
+        self.parameter_serializer = ParameterSerializer(self.serialize_namespace)
+
+    @property
+    def serialize_namespace(self) -> str:
+        return self.code_model.get_serialize_namespace(
+            self.client_namespace,
+            async_mode=self.async_mode,
+            client_namespace_type=NamespaceType.OPERATION,
+        )
 
     @property
     @abstractmethod
@@ -230,14 +240,18 @@ class _BuilderBaseSerializer(Generic[BuilderType]):
             function_def=self._function_def,
             method_name=builder.name,
             need_self_param=self._need_self_param,
-            method_param_signatures=builder.method_signature(self.async_mode),
+            method_param_signatures=builder.method_signature(
+                self.async_mode, serialize_namespace=self.serialize_namespace
+            ),
             pylint_disable=builder.pylint_disable(self.async_mode),
         )
 
     def method_signature_and_response_type_annotation(
         self, builder: BuilderType, *, want_decorators: Optional[bool] = True
     ) -> str:
-        response_type_annotation = builder.response_type_annotation(async_mode=self.async_mode)
+        response_type_annotation = builder.response_type_annotation(
+            async_mode=self.async_mode, serialize_namespace=self.serialize_namespace
+        )
         method_signature = self._method_signature(builder)
         decorators = self.decorators(builder)
         decorators_str = ""
@@ -286,6 +300,7 @@ class _BuilderBaseSerializer(Generic[BuilderType]):
             )
             docstring_type = param.docstring_type(
                 async_mode=self.async_mode,
+                serialize_namespace=self.serialize_namespace,
             )
             description_list.append(f":{param.docstring_type_keyword} {param.client_name}: {docstring_type}")
         return description_list
@@ -361,6 +376,7 @@ class _BuilderBaseSerializer(Generic[BuilderType]):
 
 
 class RequestBuilderSerializer(_BuilderBaseSerializer[RequestBuilderType]):
+
     def description_and_summary(self, builder: RequestBuilderType) -> List[str]:
         retval = super().description_and_summary(builder)
         retval += [
@@ -616,13 +632,18 @@ class _OperationSerializer(_BuilderBaseSerializer[OperationType]):
         for p in builder.parameters.parameters:
             if p.hide_in_operation_signature:
                 kwargs.append(f'{p.client_name} = kwargs.pop("{p.client_name}", None)')
-        cls_annotation = builder.cls_type_annotation(async_mode=self.async_mode)
+        cls_annotation = builder.cls_type_annotation(
+            async_mode=self.async_mode, serialize_namespace=self.serialize_namespace
+        )
         kwargs.append(f"cls: {cls_annotation} = kwargs.pop(\n    'cls', None\n)")
         return kwargs
 
     def response_docstring(self, builder: OperationType) -> List[str]:
         response_str = f":return: {builder.response_docstring_text(async_mode=self.async_mode)}"
-        rtype_str = f":rtype: {builder.response_docstring_type(async_mode=self.async_mode)}"
+        response_docstring_type = builder.response_docstring_type(
+            async_mode=self.async_mode, serialize_namespace=self.serialize_namespace
+        )
+        rtype_str = f":rtype: {response_docstring_type}"
         return [
             response_str,
             rtype_str,
@@ -670,9 +691,10 @@ class _OperationSerializer(_BuilderBaseSerializer[OperationType]):
         if self.code_model.options["models_mode"] == "msrest":
             is_xml_cmd = _xml_config(send_xml, builder.parameters.body_parameter.content_types)
             serialization_ctxt_cmd = f", {ser_ctxt_name}={ser_ctxt_name}" if xml_serialization_ctxt else ""
+            serialization_type = body_param.type.serialization_type(serialize_namespace=self.serialize_namespace)
             create_body_call = (
                 f"_{body_kwarg_name} = self._serialize.body({body_param.client_name}, "
-                f"'{body_param.type.serialization_type}'{is_xml_cmd}{serialization_ctxt_cmd})"
+                f"'{serialization_type}'{is_xml_cmd}{serialization_ctxt_cmd})"
             )
         elif self.code_model.options["models_mode"] == "dpg":
             if json_serializable(body_param.default_content_type):
@@ -903,7 +925,7 @@ class _OperationSerializer(_BuilderBaseSerializer[OperationType]):
         retval: List[str] = [
             (
                 f"response_headers['{response_header.wire_name}']=self._deserialize("
-                f"'{response_header.serialization_type}', response.headers.get('{response_header.wire_name}'))"
+                f"'{response_header.serialization_type(serialize_namespace=self.serialize_namespace)}', response.headers.get('{response_header.wire_name}'))"  # pylint: disable=line-too-long
             )
             for response_header in response.headers
         ]
@@ -911,7 +933,7 @@ class _OperationSerializer(_BuilderBaseSerializer[OperationType]):
             retval.append("")
         return retval
 
-    def response_deserialization(
+    def response_deserialization(  # pylint: disable=too-many-statements
         self,
         builder: OperationType,
         response: Response,
@@ -937,7 +959,8 @@ class _OperationSerializer(_BuilderBaseSerializer[OperationType]):
                 pylint_disable = "  # pylint: disable=protected-access"
             if self.code_model.options["models_mode"] == "msrest":
                 deserialize_code.append("deserialized = self._deserialize(")
-                deserialize_code.append(f"    '{response.serialization_type}',{pylint_disable}")
+                serialization_type = response.serialization_type(serialize_namespace=self.serialize_namespace)
+                deserialize_code.append(f"    '{serialization_type}',{pylint_disable}")
                 deserialize_code.append(" pipeline_response.http_response")
                 deserialize_code.append(")")
             elif self.code_model.options["models_mode"] == "dpg":
@@ -955,9 +978,10 @@ class _OperationSerializer(_BuilderBaseSerializer[OperationType]):
                     if xml_serializable(str(response.default_content_type)):
                         deserialize_func = "_deserialize_xml"
                     deserialize_code.append(f"deserialized = {deserialize_func}(")
-                    deserialize_code.append(
-                        f"    {response.type.type_annotation(is_operation_file=True)},{pylint_disable}"
+                    type_annotation = response.type.type_annotation(
+                        is_operation_file=True, serialize_namespace=self.serialize_namespace
                     )
+                    deserialize_code.append(f"    {type_annotation},{pylint_disable}")
                     deserialize_code.append(f"    response.{response_attr}(){response.result_property}{format_filed}")
                     deserialize_code.append(")")
 
@@ -1002,11 +1026,14 @@ class _OperationSerializer(_BuilderBaseSerializer[OperationType]):
                 if isinstance(e.status_codes[0], int):
                     for status_code in e.status_codes:
                         retval.append(f"    {condition} response.status_code == {status_code}:")
+                        type_annotation = e.type.type_annotation(  # type: ignore
+                            is_operation_file=True, skip_quote=True, serialize_namespace=self.serialize_namespace
+                        )
                         if self.code_model.options["models_mode"] == "dpg":
-                            retval.append(f"        error = _failsafe_deserialize({e.type.type_annotation(is_operation_file=True, skip_quote=True)},  response.json())")  # type: ignore # pylint: disable=line-too-long
+                            retval.append(f"        error = _failsafe_deserialize({type_annotation},  response.json())")
                         else:
                             retval.append(
-                                f"        error = self._deserialize.failsafe_deserialize({e.type.type_annotation(is_operation_file=True, skip_quote=True)}, "  # type: ignore # pylint: disable=line-too-long
+                                f"        error = self._deserialize.failsafe_deserialize({type_annotation}, "
                                 "pipeline_response)"
                             )
                         # add build-in error type
@@ -1044,11 +1071,14 @@ class _OperationSerializer(_BuilderBaseSerializer[OperationType]):
                     retval.append(
                         f"    {condition} {e.status_codes[0][0]} <= response.status_code <= {e.status_codes[0][1]}:"
                     )
+                    type_annotation = e.type.type_annotation(  # type: ignore
+                        is_operation_file=True, skip_quote=True, serialize_namespace=self.serialize_namespace
+                    )
                     if self.code_model.options["models_mode"] == "dpg":
-                        retval.append(f"        error = _failsafe_deserialize({e.type.type_annotation(is_operation_file=True, skip_quote=True)},  response.json())")  # type: ignore  # pylint: disable=line-too-long
+                        retval.append(f"        error = _failsafe_deserialize({type_annotation},  response.json())")
                     else:
                         retval.append(
-                            f"        error = self._deserialize.failsafe_deserialize({e.type.type_annotation(is_operation_file=True, skip_quote=True)}, "  # type: ignore  # pylint: disable=line-too-long
+                            f"        error = self._deserialize.failsafe_deserialize({type_annotation}, "
                             "pipeline_response)"
                         )
                 condition = "elif"
@@ -1198,13 +1228,6 @@ PagingOperationType = TypeVar("PagingOperationType", bound=Union[PagingOperation
 
 
 class _PagingOperationSerializer(_OperationSerializer[PagingOperationType]):
-    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__(code_model, async_mode)
-        self.code_model = code_model
-        self.async_mode = async_mode
-        self.parameter_serializer = ParameterSerializer()
 
     def serialize_path(self, builder: PagingOperationType) -> List[str]:
         return self.parameter_serializer.serialize_path(builder.parameters.path, self.serializer_name)
@@ -1294,10 +1317,10 @@ class _PagingOperationSerializer(_OperationSerializer[PagingOperationType]):
         deserialized = "pipeline_response.http_response.json()"
         if self.code_model.options["models_mode"] == "msrest":
             suffix = ".http_response" if hasattr(builder, "initial_operation") else ""
-            deserialize_type = response.serialization_type
+            deserialize_type = response.serialization_type(serialize_namespace=self.serialize_namespace)
             pylint_disable = "  # pylint: disable=protected-access"
             if isinstance(response.type, ModelType) and not response.type.internal:
-                deserialize_type = f'"{response.serialization_type}"'
+                deserialize_type = f'"{response.serialization_type(serialize_namespace=self.serialize_namespace)}"'
                 pylint_disable = ""
             deserialized = (
                 f"self._deserialize(\n    {deserialize_type},{pylint_disable}\n    pipeline_response{suffix}\n)"
@@ -1312,7 +1335,9 @@ class _PagingOperationSerializer(_OperationSerializer[PagingOperationType]):
         access = f".{item_name}" if self.code_model.options["models_mode"] == "msrest" else f'["{item_name}"]'
         list_of_elem_deserialized = ""
         if self.code_model.options["models_mode"] == "dpg":
-            item_type = builder.item_type.type_annotation(is_operation_file=True)
+            item_type = builder.item_type.type_annotation(
+                is_operation_file=True, serialize_namespace=self.serialize_namespace
+            )
             list_of_elem_deserialized = f"_deserialize({item_type}, deserialized{access})"
         else:
             list_of_elem_deserialized = f"deserialized{access}"
@@ -1363,14 +1388,6 @@ LROOperationType = TypeVar("LROOperationType", bound=Union[LROOperation, LROPagi
 
 
 class _LROOperationSerializer(_OperationSerializer[LROOperationType]):
-    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__(code_model, async_mode)
-        self.code_model = code_model
-        self.async_mode = async_mode
-        self.parameter_serializer = ParameterSerializer()
-
     def serialize_path(self, builder: LROOperationType) -> List[str]:
         return self.parameter_serializer.serialize_path(builder.parameters.path, self.serializer_name)
 
@@ -1512,6 +1529,7 @@ def get_operation_serializer(
     builder: Operation,
     code_model,
     async_mode: bool,
+    client_namespace: str,
 ) -> Union[
     OperationSerializer,
     PagingOperationSerializer,
@@ -1530,4 +1548,4 @@ def get_operation_serializer(
         ret_cls = LROOperationSerializer
     elif builder.operation_type == "paging":
         ret_cls = PagingOperationSerializer
-    return ret_cls(code_model, async_mode)
+    return ret_cls(code_model, async_mode, client_namespace)

package/generator/pygen/codegen/serializers/client_serializer.py

@@ -12,9 +12,10 @@ from ...utils import build_policies
 
 
 class ClientSerializer:
-    def __init__(self, client: Client) -> None:
+    def __init__(self, client: Client, serialize_namespace: str) -> None:
         self.client = client
-        self.parameter_serializer = ParameterSerializer()
+        self.parameter_serializer = ParameterSerializer(serialize_namespace)
+        self.serialize_namespace = serialize_namespace
 
     def _init_signature(self, async_mode: bool) -> str:
         pylint_disable = ""
@@ -24,7 +25,9 @@ class ClientSerializer:
             function_def="def",
             method_name="__init__",
             need_self_param=True,
-            method_param_signatures=self.client.parameters.method_signature(async_mode),
+            method_param_signatures=self.client.parameters.method_signature(
+                async_mode, serialize_namespace=self.serialize_namespace
+            ),
             pylint_disable=pylint_disable,
         )
 
@@ -244,9 +247,10 @@ class ClientSerializer:
 
 
 class ConfigSerializer:
-    def __init__(self, client: Client) -> None:
+    def __init__(self, client: Client, serialize_namespace: str) -> None:
         self.client = client
-        self.parameter_serializer = ParameterSerializer()
+        self.parameter_serializer = ParameterSerializer(serialize_namespace)
+        self.serialize_namespace = serialize_namespace
 
     def _init_signature(self, async_mode: bool) -> str:
         return self.parameter_serializer.serialize_method(

package/generator/pygen/codegen/serializers/enum_serializer.py

@@ -3,13 +3,27 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
-
+from typing import Optional, List
+from jinja2 import Environment
 from .base_serializer import BaseSerializer
-from ..models import FileImport
+from ..models import FileImport, CodeModel, EnumType
 
 
 class EnumSerializer(BaseSerializer):
+
+    def __init__(
+        self,
+        code_model: CodeModel,
+        env: Environment,
+        async_mode: bool = False,
+        *,
+        enums: List[EnumType],
+        client_namespace: Optional[str] = None
+    ):
+        super().__init__(code_model, env, async_mode=async_mode, client_namespace=client_namespace)
+        self.enums = enums
+
     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, file_import=FileImport(self.code_model))
+        return template.render(code_model=self.code_model, file_import=FileImport(self.code_model), enums=self.enums)

package/generator/pygen/codegen/serializers/general_serializer.py

@@ -5,15 +5,14 @@
 # --------------------------------------------------------------------------
 import json
 from typing import Any, List
-from jinja2 import Environment
 from .import_serializer import FileImportSerializer, TypingSection
 from ..models.imports import MsrestImportType, FileImport
 from ..models import (
     ImportType,
-    CodeModel,
     TokenCredentialType,
     Client,
 )
+from ..models.utils import NamespaceType
 from .client_serializer import ClientSerializer, ConfigSerializer
 from .base_serializer import BaseSerializer
 
@@ -21,10 +20,6 @@ from .base_serializer import BaseSerializer
 class GeneralSerializer(BaseSerializer):
     """General serializer for SDK root level files"""
 
-    def __init__(self, code_model: CodeModel, env: Environment, async_mode: bool):
-        super().__init__(code_model, env)
-        self.async_mode = async_mode
-
     def serialize_setup_file(self) -> str:
         template = self.env.get_template("packaging_templates/setup.py.jinja2")
         params = {}
@@ -65,6 +60,7 @@ class GeneralSerializer(BaseSerializer):
             code_model=self.code_model,
             clients=clients,
             async_mode=self.async_mode,
+            serialize_namespace=self.serialize_namespace,
         )
 
     def serialize_service_client_file(self, clients: List[Client]) -> str:
@@ -72,7 +68,13 @@ class GeneralSerializer(BaseSerializer):
 
         imports = FileImport(self.code_model)
         for client in clients:
-            imports.merge(client.imports(self.async_mode))
+            imports.merge(
+                client.imports(
+                    self.async_mode,
+                    serialize_namespace=self.serialize_namespace,
+                    serialize_namespace_type=NamespaceType.CLIENT,
+                )
+            )
 
         return template.render(
             code_model=self.code_model,
@@ -80,14 +82,16 @@ class GeneralSerializer(BaseSerializer):
             async_mode=self.async_mode,
             get_serializer=ClientSerializer,
             imports=FileImportSerializer(imports),
+            serialize_namespace=self.serialize_namespace,
         )
 
-    def serialize_vendor_file(self, clients: List[Client]) -> str:
+    def serialize_vendor_file(self) -> str:
         template = self.env.get_template("vendor.py.jinja2")
+        clients = self.code_model.get_clients(self.client_namespace)
 
         # configure imports
         file_import = FileImport(self.code_model)
-        if self.code_model.need_mixin_abc:
+        if self.code_model.need_vendored_mixin(self.client_namespace):
             file_import.add_submodule_import(
                 "abc",
                 "ABC",
@@ -100,7 +104,7 @@ class GeneralSerializer(BaseSerializer):
                 TypingSection.TYPING,
             )
             file_import.add_msrest_import(
-                relative_path=".." if self.async_mode else ".",
+                serialize_namespace=self.serialize_namespace,
                 msrest_import_type=MsrestImportType.SerializerDeserializer,
                 typing_section=TypingSection.TYPING,
             )
@@ -111,14 +115,14 @@ class GeneralSerializer(BaseSerializer):
                         f"{client.name}Configuration",
                         ImportType.LOCAL,
                     )
-        if self.code_model.has_etag:
+        if self.code_model.need_vendored_etag(self.client_namespace):
             file_import.add_submodule_import("typing", "Optional", ImportType.STDLIB)
             file_import.add_submodule_import(
                 "",
                 "MatchConditions",
                 ImportType.SDKCORE,
             )
-        if self.code_model.has_form_data and self.code_model.options["models_mode"] == "dpg" and not self.async_mode:
+        if self.code_model.need_vendored_form_data(self.async_mode, self.client_namespace):
             file_import.add_submodule_import("typing", "IO", ImportType.STDLIB)
             file_import.add_submodule_import("typing", "Tuple", ImportType.STDLIB)
             file_import.add_submodule_import("typing", "Union", ImportType.STDLIB)
@@ -146,19 +150,27 @@ class GeneralSerializer(BaseSerializer):
             ),
             async_mode=self.async_mode,
             clients=clients,
+            client_namespace=self.client_namespace,
         )
 
     def serialize_config_file(self, clients: List[Client]) -> str:
         template = self.env.get_template("config_container.py.jinja2")
         imports = FileImport(self.code_model)
         for client in self.code_model.clients:
-            imports.merge(client.config.imports(self.async_mode))
+            imports.merge(
+                client.config.imports(
+                    self.async_mode,
+                    serialize_namespace=self.serialize_namespace,
+                    serialize_namespace_type=NamespaceType.CLIENT,
+                )
+            )
         return template.render(
             code_model=self.code_model,
             async_mode=self.async_mode,
             imports=FileImportSerializer(imports),
             get_serializer=ConfigSerializer,
             clients=clients,
+            serialize_namespace=self.serialize_namespace,
         )
 
     def serialize_version_file(self) -> str:
@@ -181,7 +193,7 @@ class GeneralSerializer(BaseSerializer):
 
     def serialize_cross_language_definition_file(self) -> str:
         cross_langauge_def_dict = {
-            f"{self.code_model.namespace}.models.{model.name}": model.cross_language_definition_id
+            f"{model.client_namespace}.models.{model.name}": model.cross_language_definition_id
             for model in self.code_model.public_model_types
         }
         cross_langauge_def_dict.update(

package/generator/pygen/codegen/serializers/metadata_serializer.py

@@ -16,6 +16,7 @@ from ..models import (
     CodeModel,
 )
 from .builder_serializer import get_operation_serializer
+from .base_serializer import BaseSerializer
 from .import_serializer import FileImportSerializer
 
 
@@ -104,11 +105,10 @@ def _mixin_typing_definitions(
     return sync_mixin_typing_definitions, async_mixin_typing_definitions
 
 
-class MetadataSerializer:
-    def __init__(self, code_model: CodeModel, env: Environment) -> None:
-        self.code_model = code_model
+class MetadataSerializer(BaseSerializer):
+    def __init__(self, code_model: CodeModel, env: Environment, *, client_namespace: Optional[str] = None):
+        super().__init__(code_model, env, client_namespace=client_namespace)
         self.client = self.code_model.clients[0]  # we only do one client for multiapi
-        self.env = env
 
     def _choose_api_version(self) -> Tuple[str, List[str]]:
         chosen_version = ""
@@ -161,6 +161,10 @@ class MetadataSerializer:
         self.code_model.options["package_version"] = "0.1.0"
         template = self.env.get_template("metadata.json.jinja2")
 
+        client_serialize_namespace = self.code_model.get_serialize_namespace(self.client_namespace, async_mode=False)
+        client_serialize_namespace_async = self.code_model.get_serialize_namespace(
+            self.client_namespace, async_mode=True
+        )
         return template.render(
             code_model=self.code_model,
             chosen_version=chosen_version,
@@ -176,23 +180,37 @@ class MetadataSerializer:
             async_mixin_imports=async_mixin_imports,
             sync_mixin_typing_definitions=sync_mixin_typing_definitions,
             async_mixin_typing_definitions=async_mixin_typing_definitions,
-            sync_client_imports=_json_serialize_imports(self.client.imports_for_multiapi(async_mode=False).to_dict()),
-            async_client_imports=_json_serialize_imports(self.client.imports_for_multiapi(async_mode=True).to_dict()),
+            sync_client_imports=_json_serialize_imports(
+                self.client.imports_for_multiapi(
+                    async_mode=False, serialize_namespace=client_serialize_namespace
+                ).to_dict()
+            ),
+            async_client_imports=_json_serialize_imports(
+                self.client.imports_for_multiapi(
+                    async_mode=True, serialize_namespace=client_serialize_namespace_async
+                ).to_dict()
+            ),
             sync_config_imports=_json_serialize_imports(
-                self.client.config.imports_for_multiapi(async_mode=False).to_dict()
+                self.client.config.imports_for_multiapi(
+                    async_mode=False, serialize_namespace=client_serialize_namespace
+                ).to_dict()
             ),
             async_config_imports=_json_serialize_imports(
-                self.client.config.imports_for_multiapi(async_mode=True).to_dict()
+                self.client.config.imports_for_multiapi(
+                    async_mode=True, serialize_namespace=client_serialize_namespace_async
+                ).to_dict()
             ),
             get_async_operation_serializer=functools.partial(
                 get_operation_serializer,
                 code_model=self.client.code_model,
                 async_mode=True,
+                client_namespace=self.client_namespace,
             ),
             get_sync_operation_serializer=functools.partial(
                 get_operation_serializer,
                 code_model=self.client.code_model,
                 async_mode=False,
+                client_namespace=self.client_namespace,
             ),
             has_credential=bool(self.client.credential),
         )

package/generator/pygen/codegen/serializers/model_init_serializer.py

@@ -3,19 +3,24 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
+from typing import List
 from jinja2 import Environment
-from ..models import CodeModel
+from ..models import CodeModel, ModelType, EnumType
 
 
 class ModelInitSerializer:
-    def __init__(self, code_model: CodeModel, env: Environment) -> None:
+    def __init__(
+        self, code_model: CodeModel, env: Environment, *, models: List[ModelType], enums: List[EnumType]
+    ) -> None:
         self.code_model = code_model
         self.env = env
+        self.models = models
+        self.enums = enums
 
     def serialize(self) -> str:
-        schemas = [s.name for s in self.code_model.public_model_types]
+        schemas = [s.name for s in self.code_model.get_public_model_types(self.models)]
         schemas.sort()
-        enums = [e.name for e in self.code_model.enums if not e.internal] if self.code_model.enums else None
+        enums = [e.name for e in self.enums if not e.internal] if self.enums else None
 
         if enums:
             enums.sort()