@typespec/http-client-python 0.5.1 → 0.6.0

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

@@ -4,7 +4,8 @@
 # license information.
 # --------------------------------------------------------------------------
 import logging
-from typing import List, Optional, Any, Union
+from collections import namedtuple
+from typing import List, Any, Union
 from pathlib import Path
 from jinja2 import PackageLoader, Environment, FileSystemLoader, StrictUndefined
 
@@ -15,6 +16,8 @@ from ..models import (
     OverloadedRequestBuilder,
     CodeModel,
     Client,
+    ModelType,
+    EnumType,
 )
 from .enum_serializer import EnumSerializer
 from .general_serializer import GeneralSerializer
@@ -34,7 +37,6 @@ from .utils import (
     extract_sample_name,
     get_namespace_from_package_name,
     get_namespace_config,
-    get_all_operation_groups_recursively,
 )
 
 _LOGGER = logging.getLogger(__name__)
@@ -53,6 +55,7 @@ _PACKAGE_FILES = [
 ]
 
 _REGENERATE_FILES = {"setup.py", "MANIFEST.in"}
+AsyncInfo = namedtuple("AsyncInfo", ["async_mode", "async_path"])
 
 
 # extract sub folders. For example, source_file_path is like:
@@ -85,54 +88,11 @@ class JinjaSerializer(ReaderAndWriter):
     def has_operations_folder(self) -> bool:
         return self.code_model.options["show_operations"] and bool(self.code_model.has_operations)
 
-    def _serialize_namespace_level(self, env: Environment, namespace_path: Path, clients: List[Client]) -> None:
-        # if there was a patch file before, we keep it
-        self._keep_patch_file(namespace_path / Path("_patch.py"), env)
-        if self.has_aio_folder:
-            self._keep_patch_file(namespace_path / Path("aio") / Path("_patch.py"), env)
-
-        if self.has_operations_folder:
-            self._keep_patch_file(
-                namespace_path / Path(self.code_model.operations_folder_name) / Path("_patch.py"),
-                env,
-            )
-            if self.has_aio_folder:
-                self._keep_patch_file(
-                    namespace_path / Path("aio") / Path(self.code_model.operations_folder_name) / Path("_patch.py"),
-                    env,
-                )
-        self._serialize_and_write_top_level_folder(env=env, namespace_path=namespace_path, clients=clients)
-
-        if any(c for c in self.code_model.clients if c.operation_groups):
-            if self.code_model.options["builders_visibility"] != "embedded":
-                self._serialize_and_write_rest_layer(env=env, namespace_path=namespace_path)
-            if self.has_aio_folder:
-                self._serialize_and_write_aio_top_level_folder(
-                    env=env,
-                    namespace_path=namespace_path,
-                    clients=clients,
-                )
-
-        if self.has_operations_folder:
-            self._serialize_and_write_operations_folder(clients, env=env, namespace_path=namespace_path)
-            if self.code_model.options["multiapi"]:
-                self._serialize_and_write_metadata(env=env, namespace_path=namespace_path)
-        if self.code_model.options["package_mode"]:
-            self._serialize_and_write_package_files(namespace_path=namespace_path)
-
-        if (
-            self.code_model.options["show_operations"]
-            and self.code_model.has_operations
-            and self.code_model.options["generate_sample"]
-        ):
-            self._serialize_and_write_sample(env, namespace_path)
-
-        if (
-            self.code_model.options["show_operations"]
-            and self.code_model.has_operations
-            and self.code_model.options["generate_test"]
-        ):
-            self._serialize_and_write_test(env, namespace_path)
+    @property
+    def serialize_loop(self) -> List[AsyncInfo]:
+        sync_loop = AsyncInfo(async_mode=False, async_path="")
+        async_loop = AsyncInfo(async_mode=True, async_path="aio/")
+        return [sync_loop, async_loop] if self.has_aio_folder else [sync_loop]
 
     def serialize(self) -> None:
         env = Environment(
@@ -144,54 +104,71 @@ class JinjaSerializer(ReaderAndWriter):
             lstrip_blocks=True,
         )
 
-        namespace_path = (
-            Path(".") if self.code_model.options["no_namespace_folders"] else Path(*self._name_space().split("."))
-        )
-
-        p = namespace_path.parent
         general_serializer = GeneralSerializer(code_model=self.code_model, env=env, async_mode=False)
-        while p != Path("."):
-            # write pkgutil init file
-            self.write_file(
-                p / Path("__init__.py"),
-                general_serializer.serialize_pkgutil_init_file(),
-            )
-            p = p.parent
-
-        # serialize main module
-        self._serialize_namespace_level(
-            env,
-            namespace_path,
-            [c for c in self.code_model.clients if c.has_operations],
-        )
-        # serialize sub modules
-        for (
-            subnamespace,
-            clients,
-        ) in self.code_model.subnamespace_to_clients.items():
-            subnamespace_path = namespace_path / Path(subnamespace)
-            self._serialize_namespace_level(env, subnamespace_path, [c for c in clients if c.has_operations])
-
-        if self.code_model.options["models_mode"] and (self.code_model.model_types or self.code_model.enums):
-            self._keep_patch_file(namespace_path / Path("models") / Path("_patch.py"), env)
-
-        if self.code_model.options["models_mode"] and (self.code_model.model_types or self.code_model.enums):
-            self._serialize_and_write_models_folder(env=env, namespace_path=namespace_path)
-        if not self.code_model.options["models_mode"]:
-            # keep models file if users ended up just writing a models file
-            if self.read_file(namespace_path / Path("models.py")):
+        for client_namespace, client_namespace_type in self.code_model.client_namespace_types.items():
+            exec_path = self.exec_path(client_namespace)
+            if client_namespace == "":
+                # Write the setup file
+                if self.code_model.options["basic_setup_py"]:
+                    self.write_file(exec_path / Path("setup.py"), general_serializer.serialize_setup_file())
+
+                # add packaging files in root namespace (e.g. setup.py, README.md, etc.)
+                if self.code_model.options["package_mode"]:
+                    self._serialize_and_write_package_files(client_namespace)
+
+                # write apiview_mapping_python.json
+                if self.code_model.options.get("emit_cross_language_definition_file"):
+                    self.write_file(
+                        exec_path / Path("apiview_mapping_python.json"),
+                        general_serializer.serialize_cross_language_definition_file(),
+                    )
+
+                # add generated samples and generated tests
+                if self.code_model.options["show_operations"] and self.code_model.has_operations:
+                    if self.code_model.options["generate_sample"]:
+                        self._serialize_and_write_sample(env, namespace=client_namespace)
+                    if self.code_model.options["generate_test"]:
+                        self._serialize_and_write_test(env, namespace=client_namespace)
+            elif client_namespace_type.clients:
+                # add clients folder if there are clients in this namespace
+                self._serialize_client_and_config_files(client_namespace, client_namespace_type.clients, env)
+            else:
+                # add pkgutil init file if no clients in this namespace
                 self.write_file(
-                    namespace_path / Path("models.py"),
-                    self.read_file(namespace_path / Path("models.py")),
+                    exec_path / Path("__init__.py"),
+                    general_serializer.serialize_pkgutil_init_file(),
                 )
-        if self.code_model.named_unions:
-            self.write_file(
-                namespace_path / Path("_types.py"),
-                TypesSerializer(code_model=self.code_model, env=env).serialize(),
-            )
 
-    def _serialize_and_write_package_files(self, namespace_path: Path) -> None:
-        root_of_sdk = self._package_root_folder(namespace_path)
+            # _model_base.py/_serialization.py/_vendor.py/py.typed/_types.py/_validation.py
+            # is always put in top level namespace
+            if self.code_model.is_top_namespace(client_namespace):
+                self._serialize_and_write_top_level_folder(env=env, namespace=client_namespace)
+
+            # add models folder if there are models in this namespace
+            if (client_namespace_type.models or client_namespace_type.enums) and self.code_model.options["models_mode"]:
+                self._serialize_and_write_models_folder(
+                    env=env,
+                    namespace=client_namespace,
+                    models=client_namespace_type.models,
+                    enums=client_namespace_type.enums,
+                )
+
+            if not self.code_model.options["models_mode"]:
+                # keep models file if users ended up just writing a models file
+                model_path = exec_path / Path("models.py")
+                if self.read_file(model_path):
+                    self.write_file(model_path, self.read_file(model_path))
+
+            # add operations folder if there are operations in this namespace
+            if client_namespace_type.operation_groups:
+                self._serialize_and_write_operations_folder(
+                    client_namespace_type.operation_groups, env=env, namespace=client_namespace
+                )
+                if self.code_model.options["multiapi"]:
+                    self._serialize_and_write_metadata(env=env, namespace=client_namespace)
+
+    def _serialize_and_write_package_files(self, client_namespace: str) -> None:
+        root_of_sdk = self.exec_path(client_namespace)
         if self.code_model.options["package_mode"] in VALID_PACKAGE_MODE:
             env = Environment(
                 loader=PackageLoader("pygen.codegen", "templates/packaging_templates"),
@@ -230,25 +207,31 @@ class JinjaSerializer(ReaderAndWriter):
                 PatchSerializer(env=env, code_model=self.code_model).serialize(),
             )
 
-    def _serialize_and_write_models_folder(self, env: Environment, namespace_path: Path) -> None:
+    def _serialize_and_write_models_folder(
+        self, env: Environment, namespace: str, models: List[ModelType], enums: List[EnumType]
+    ) -> None:
         # Write the models folder
-        models_path = namespace_path / Path("models")
+        models_path = self.exec_path(namespace + ".models")
         serializer = DpgModelSerializer if self.code_model.options["models_mode"] == "dpg" else MsrestModelSerializer
-        if self.code_model.model_types:
+        if models:
             self.write_file(
                 models_path / Path(f"{self.code_model.models_filename}.py"),
-                serializer(code_model=self.code_model, env=env).serialize(),
+                serializer(code_model=self.code_model, env=env, client_namespace=namespace, models=models).serialize(),
             )
-        if self.code_model.enums:
+        if enums:
             self.write_file(
                 models_path / Path(f"{self.code_model.enums_filename}.py"),
-                EnumSerializer(code_model=self.code_model, env=env).serialize(),
+                EnumSerializer(
+                    code_model=self.code_model, env=env, client_namespace=namespace, enums=enums
+                ).serialize(),
             )
         self.write_file(
             models_path / Path("__init__.py"),
-            ModelInitSerializer(code_model=self.code_model, env=env).serialize(),
+            ModelInitSerializer(code_model=self.code_model, env=env, models=models, enums=enums).serialize(),
         )
 
+        self._keep_patch_file(models_path / Path("_patch.py"), env)
+
     def _serialize_and_write_rest_layer(self, env: Environment, namespace_path: Path) -> None:
         rest_path = namespace_path / Path(self.code_model.rest_layer_name)
         group_names = {rb.group_name for c in self.code_model.clients for rb in c.request_builders}
@@ -292,89 +275,57 @@ class JinjaSerializer(ReaderAndWriter):
             ).serialize_init(),
         )
 
-    def _serialize_and_write_operations_file(
-        self,
-        env: Environment,
-        clients: List[Client],
-        namespace_path: Path,
-        operation_group: Optional[OperationGroup] = None,
-    ) -> None:
-        filename = operation_group.filename if operation_group else "_operations"
-        # write first sync file
-        operation_group_serializer = OperationGroupsSerializer(
-            code_model=self.code_model,
-            clients=clients,
-            env=env,
-            async_mode=False,
-            operation_group=operation_group,
-        )
-        self.write_file(
-            namespace_path / Path(self.code_model.operations_folder_name) / Path(f"{filename}.py"),
-            operation_group_serializer.serialize(),
-        )
-
-        if self.has_aio_folder:
-            # write async operation group and operation files
-            operation_group_async_serializer = OperationGroupsSerializer(
-                code_model=self.code_model,
-                clients=clients,
-                env=env,
-                async_mode=True,
-                operation_group=operation_group,
-            )
-            self.write_file(
-                (namespace_path / Path("aio") / Path(self.code_model.operations_folder_name) / Path(f"{filename}.py")),
-                operation_group_async_serializer.serialize(),
-            )
-
     def _serialize_and_write_operations_folder(
-        self, clients: List[Client], env: Environment, namespace_path: Path
+        self, operation_groups: List[OperationGroup], env: Environment, namespace: str
     ) -> None:
-        # write sync operations init file
-        operations_init_serializer = OperationsInitSerializer(
-            code_model=self.code_model, clients=clients, env=env, async_mode=False
-        )
-        self.write_file(
-            namespace_path / Path(self.code_model.operations_folder_name) / Path("__init__.py"),
-            operations_init_serializer.serialize(),
-        )
-
-        # write async operations init file
-        if self.has_aio_folder:
-            operations_async_init_serializer = OperationsInitSerializer(
-                code_model=self.code_model, clients=clients, env=env, async_mode=True
+        operations_folder_name = self.code_model.operations_folder_name(namespace)
+        exec_path = self.exec_path(namespace)
+        for async_mode, async_path in self.serialize_loop:
+            prefix_path = f"{async_path}{operations_folder_name}"
+            # write init file
+            operations_init_serializer = OperationsInitSerializer(
+                code_model=self.code_model, operation_groups=operation_groups, env=env, async_mode=async_mode
             )
             self.write_file(
-                namespace_path / Path("aio") / Path(self.code_model.operations_folder_name) / Path("__init__.py"),
-                operations_async_init_serializer.serialize(),
+                exec_path / Path(f"{prefix_path}/__init__.py"),
+                operations_init_serializer.serialize(),
             )
 
-        if self.code_model.options["combine_operation_files"]:
-            self._serialize_and_write_operations_file(
-                env=env,
-                namespace_path=namespace_path,
-                clients=clients,
-            )
-        else:
-            for operation_group in get_all_operation_groups_recursively(self.code_model.clients):
-                self._serialize_and_write_operations_file(
+            # write operations file
+            OgLoop = namedtuple("OgLoop", ["operation_groups", "filename"])
+            if self.code_model.options["combine_operation_files"]:
+                loops = [OgLoop(operation_groups, "_operations")]
+            else:
+                loops = [OgLoop([og], og.filename) for og in operation_groups]
+            for ogs, filename in loops:
+                operation_group_serializer = OperationGroupsSerializer(
+                    code_model=self.code_model,
+                    operation_groups=ogs,
                     env=env,
-                    namespace_path=namespace_path,
-                    operation_group=operation_group,
-                    clients=clients,
+                    async_mode=async_mode,
+                    client_namespace=namespace,
                 )
+                self.write_file(
+                    exec_path / Path(f"{prefix_path}/{filename}.py"),
+                    operation_group_serializer.serialize(),
+                )
+
+            # if there was a patch file before, we keep it
+            self._keep_patch_file(exec_path / Path(f"{prefix_path}/_patch.py"), env)
 
     def _serialize_and_write_version_file(
         self,
-        namespace_path: Path,
+        namespace: str,
         general_serializer: GeneralSerializer,
     ):
+        exec_path = self.exec_path(namespace)
+
         def _read_version_file(original_version_file_name: str) -> str:
-            return self.read_file(namespace_path / original_version_file_name)
+            return self.read_file(exec_path / original_version_file_name)
 
         def _write_version_file(original_version_file_name: str) -> None:
             self.write_file(
-                namespace_path / Path("_version.py"),
+                exec_path / Path("_version.py"),
                 _read_version_file(original_version_file_name),
             )
 
@@ -385,103 +336,103 @@ class JinjaSerializer(ReaderAndWriter):
             _write_version_file(original_version_file_name="version.py")
         elif self.code_model.options["package_version"]:
             self.write_file(
-                namespace_path / Path("_version.py"),
+                exec_path / Path("_version.py"),
                 general_serializer.serialize_version_file(),
             )
 
     def _serialize_client_and_config_files(
         self,
-        namespace_path: Path,
-        general_serializer: GeneralSerializer,
-        async_mode: bool,
+        namespace: str,
         clients: List[Client],
+        env: Environment,
     ) -> None:
-        if self.code_model.has_operations:
-            namespace_path = namespace_path / Path("aio") if async_mode else namespace_path
-            self.write_file(
-                namespace_path / Path(f"{self.code_model.client_filename}.py"),
-                general_serializer.serialize_service_client_file(clients),
+        exec_path = self.exec_path(namespace)
+        for async_mode, async_path in self.serialize_loop:
+            general_serializer = GeneralSerializer(
+                code_model=self.code_model, env=env, async_mode=async_mode, client_namespace=namespace
             )
+            # when there is client.py, there must be __init__.py
             self.write_file(
-                namespace_path / Path("_configuration.py"),
-                general_serializer.serialize_config_file(clients),
+                exec_path / Path(f"{async_path}__init__.py"),
+                general_serializer.serialize_init_file([c for c in clients if c.has_operations]),
             )
 
-    def _serialize_and_write_top_level_folder(
-        self, env: Environment, namespace_path: Path, clients: List[Client]
-    ) -> None:
-        general_serializer = GeneralSerializer(code_model=self.code_model, env=env, async_mode=False)
+            # if there was a patch file before, we keep it
+            self._keep_patch_file(exec_path / Path(f"{async_path}_patch.py"), env)
 
-        self.write_file(
-            namespace_path / Path("__init__.py"),
-            general_serializer.serialize_init_file(clients),
-        )
+            if self.code_model.clients_has_operations(clients):
 
-        # Write the service client
-        self._serialize_client_and_config_files(namespace_path, general_serializer, async_mode=False, clients=clients)
-        if self.code_model.need_vendored_code(async_mode=False):
-            self.write_file(
-                namespace_path / Path("_vendor.py"),
-                general_serializer.serialize_vendor_file(clients),
-            )
+                # write client file
+                self.write_file(
+                    exec_path / Path(f"{async_path}{self.code_model.client_filename}.py"),
+                    general_serializer.serialize_service_client_file(clients),
+                )
+
+                # write config file
+                self.write_file(
+                    exec_path / Path(f"{async_path}_configuration.py"),
+                    general_serializer.serialize_config_file(clients),
+                )
+
+                # sometimes we need define additional Mixin class for client in _vendor.py
+                self._serialize_and_write_vendor_file(env, namespace)
 
-        self._serialize_and_write_version_file(namespace_path, general_serializer)
+    def _serialize_and_write_vendor_file(self, env: Environment, namespace: str) -> None:
+        exec_path = self.exec_path(namespace)
+        # write _vendor.py
+        for async_mode, async_path in self.serialize_loop:
+            if self.code_model.need_vendored_code(async_mode=async_mode, client_namespace=namespace):
+                self.write_file(
+                    exec_path / Path(f"{async_path}_vendor.py"),
+                    GeneralSerializer(
+                        code_model=self.code_model, env=env, async_mode=async_mode, client_namespace=namespace
+                    ).serialize_vendor_file(),
+                )
+
+    def _serialize_and_write_top_level_folder(self, env: Environment, namespace: str) -> None:
+        exec_path = self.exec_path(namespace)
+        # write _vendor.py
+        self._serialize_and_write_vendor_file(env, namespace)
+
+        general_serializer = GeneralSerializer(code_model=self.code_model, env=env, async_mode=False)
+
+        # write _version.py
+        self._serialize_and_write_version_file(namespace, general_serializer)
 
         # write the empty py.typed file
-        self.write_file(namespace_path / Path("py.typed"), "# Marker file for PEP 561.")
+        self.write_file(exec_path / Path("py.typed"), "# Marker file for PEP 561.")
 
+        # write _serialization.py
         if not self.code_model.options["client_side_validation"] and not self.code_model.options["multiapi"]:
             self.write_file(
-                namespace_path / Path("_serialization.py"),
+                exec_path / Path("_serialization.py"),
                 general_serializer.serialize_serialization_file(),
             )
+
+        # write _model_base.py
         if self.code_model.options["models_mode"] == "dpg":
             self.write_file(
-                namespace_path / Path("_model_base.py"),
+                exec_path / Path("_model_base.py"),
                 general_serializer.serialize_model_base_file(),
             )
 
+        # write _validation.py
         if any(og for client in self.code_model.clients for og in client.operation_groups if og.need_validation):
             self.write_file(
-                namespace_path / Path("_validation.py"),
+                exec_path / Path("_validation.py"),
                 general_serializer.serialize_validation_file(),
             )
-        if self.code_model.options.get("emit_cross_language_definition_file"):
-            self.write_file(
-                Path("./apiview_mapping_python.json"),
-                general_serializer.serialize_cross_language_definition_file(),
-            )
-
-        # Write the setup file
-        if self.code_model.options["basic_setup_py"]:
-            self.write_file(Path("setup.py"), general_serializer.serialize_setup_file())
-
-    def _serialize_and_write_aio_top_level_folder(
-        self, env: Environment, namespace_path: Path, clients: List[Client]
-    ) -> None:
-        aio_general_serializer = GeneralSerializer(code_model=self.code_model, env=env, async_mode=True)
-
-        aio_path = namespace_path / Path("aio")
-
-        # Write the __init__ file
-        self.write_file(
-            aio_path / Path("__init__.py"),
-            aio_general_serializer.serialize_init_file(clients),
-        )
 
-        # Write the service client
-        self._serialize_client_and_config_files(
-            namespace_path, aio_general_serializer, async_mode=True, clients=clients
-        )
-        if self.code_model.need_vendored_code(async_mode=True):
+        # write _types.py
+        if self.code_model.named_unions:
             self.write_file(
-                aio_path / Path("_vendor.py"),
-                aio_general_serializer.serialize_vendor_file(clients),
+                exec_path / Path("_types.py"),
+                TypesSerializer(code_model=self.code_model, env=env).serialize(),
             )
 
-    def _serialize_and_write_metadata(self, env: Environment, namespace_path: Path) -> None:
-        metadata_serializer = MetadataSerializer(self.code_model, env)
-        self.write_file(namespace_path / Path("_metadata.json"), metadata_serializer.serialize())
+    def _serialize_and_write_metadata(self, env: Environment, namespace: str) -> None:
+        metadata_serializer = MetadataSerializer(self.code_model, env, client_namespace=namespace)
+        self.write_file(self.exec_path(namespace) / Path("_metadata.json"), metadata_serializer.serialize())
 
     @property
     def _namespace_from_package_name(self) -> str:
@@ -493,9 +444,17 @@ class JinjaSerializer(ReaderAndWriter):
 
         return self._namespace_from_package_name
 
-    # find root folder where "setup.py" is
-    def _package_root_folder(self, namespace_path: Path) -> Path:
-        return namespace_path / Path("../" * (self._name_space().count(".") + 1))
+    @property
+    def exec_path_compensation(self) -> Path:
+        """Assume the process is running in the root folder of the package. If not, we need the path compensation."""
+        return (
+            Path("../" * (self._name_space().count(".") + 1))
+            if self.code_model.options["no_namespace_folders"]
+            else Path(".")
+        )
+
+    def exec_path(self, namespace: str) -> Path:
+        return self.exec_path_compensation / Path(*namespace.split("."))
 
     @property
     def _additional_folder(self) -> Path:
@@ -506,8 +465,8 @@ class JinjaSerializer(ReaderAndWriter):
             return Path("/".join(namespace_config.split(".")[num_of_package_namespace:]))
         return Path("")
 
-    def _serialize_and_write_sample(self, env: Environment, namespace_path: Path):
-        out_path = self._package_root_folder(namespace_path) / Path("generated_samples")
+    def _serialize_and_write_sample(self, env: Environment, namespace: str):
+        out_path = self.exec_path(namespace) / Path("generated_samples")
         for client in self.code_model.clients:
             for op_group in client.operation_groups:
                 for operation in op_group.operations:
@@ -539,15 +498,15 @@ class JinjaSerializer(ReaderAndWriter):
                             log_error = f"error happens in sample {file}: {e}"
                             _LOGGER.error(log_error)
 
-    def _serialize_and_write_test(self, env: Environment, namespace_path: Path):
+    def _serialize_and_write_test(self, env: Environment, namespace: str):
         self.code_model.for_test = True
-        out_path = self._package_root_folder(namespace_path) / Path("generated_tests")
+        out_path = self.exec_path(namespace) / Path("generated_tests")
         general_serializer = TestGeneralSerializer(code_model=self.code_model, env=env)
         self.write_file(out_path / "conftest.py", general_serializer.serialize_conftest())
         if not self.code_model.options["azure_arm"]:
-            for is_async in (True, False):
-                async_suffix = "_async" if is_async else ""
-                general_serializer.is_async = is_async
+            for async_mode in (True, False):
+                async_suffix = "_async" if async_mode else ""
+                general_serializer.async_mode = async_mode
                 self.write_file(
                     out_path / f"testpreparer{async_suffix}.py",
                     general_serializer.serialize_testpreparer(),
@@ -560,9 +519,9 @@ class JinjaSerializer(ReaderAndWriter):
                 ):
                     continue
                 test_serializer = TestSerializer(self.code_model, env, client=client, operation_group=og)
-                for is_async in (True, False):
+                for async_mode in (True, False):
                     try:
-                        test_serializer.is_async = is_async
+                        test_serializer.async_mode = async_mode
                         self.write_file(
                             out_path / f"{to_snake_case(test_serializer.test_class_name)}.py",
                             test_serializer.serialize_test(),

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

@@ -3,6 +3,7 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
+from typing import Optional
 from jinja2 import Environment
 from ..models import (
     FileImport,
@@ -13,9 +14,26 @@ from ..models import (
 class BaseSerializer:
     """Base 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 = False,
+        *,
+        client_namespace: Optional[str] = None
+    ):
         self.code_model = code_model
         self.env = env
+        self.async_mode = async_mode
+        self.client_namespace = code_model.namespace if client_namespace is None else client_namespace
 
     def init_file_import(self) -> FileImport:
         return FileImport(self.code_model)
+
+    # get namespace of serialize file from client namespace.
+    # For async API, serialize namespace will have additional suffix '.aio' compared with client namespace;
+    # For models, there will be additional '.models';
+    # For operations, there will be additional '.operations' or '._operations';
+    @property
+    def serialize_namespace(self) -> str:
+        return self.code_model.get_serialize_namespace(self.client_namespace, async_mode=self.async_mode)