@autorest/python 6.27.4 → 6.28.0

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

@@ -4,7 +4,9 @@
 # license information.
 # --------------------------------------------------------------------------
 import logging
-from typing import List, Optional, Any, Union
+from collections import namedtuple
+import re
+from typing import List, Any, Union
 from pathlib import Path
 from jinja2 import PackageLoader, Environment, FileSystemLoader, StrictUndefined
 
@@ -15,6 +17,8 @@ from ..models import (
     OverloadedRequestBuilder,
     CodeModel,
     Client,
+    ModelType,
+    EnumType,
 )
 from .enum_serializer import EnumSerializer
 from .general_serializer import GeneralSerializer
@@ -34,7 +38,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 +56,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 +89,24 @@ 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,
-                )
+    @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]
 
-        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 keep_version_file(self) -> bool:
+        if self.options.get("keep_version_file"):
+            return True
+        # If the version file is already there and the version is greater than the current version, keep it.
+        try:
+            serialized_version_file = self.read_file(self.exec_path(self.code_model.namespace) / "_version.py")
+            match = re.search(r'VERSION\s*=\s*"([^"]+)"', str(serialized_version_file))
+            serialized_version = match.group(1) if match else ""
+        except (FileNotFoundError, IndexError):
+            serialized_version = ""
+        return serialized_version > self.code_model.options["package_version"]
 
     def serialize(self) -> None:
         env = Environment(
@@ -144,54 +118,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"),
@@ -216,6 +207,9 @@ class JinjaSerializer(ReaderAndWriter):
             file = template_name.replace(".jinja2", "")
             output_name = root_of_sdk / file
             if not self.read_file(output_name) or file in _REGENERATE_FILES:
+                if self.keep_version_file and file == "setup.py":
+                    # don't regenerate setup.py file if the version file is more up to date
+                    continue
                 self.write_file(
                     output_name,
                     serializer.serialize_package_file(template_name, **params),
@@ -230,25 +224,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,196 +292,163 @@ 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),
             )
 
-        keep_version_file = self.code_model.options["keep_version_file"]
-        if keep_version_file and _read_version_file("_version.py"):
+        if self.keep_version_file and _read_version_file("_version.py"):
             _write_version_file(original_version_file_name="_version.py")
-        elif keep_version_file and _read_version_file("version.py"):
+        elif self.keep_version_file and _read_version_file("version.py"):
             _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),
+                )
 
-        self._serialize_and_write_version_file(namespace_path, general_serializer)
+                # 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)
+
+    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 +460,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 +481,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 +514,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 +535,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(),