@autorest/python 6.2.0 → 6.2.2

package/autorest/codegen/serializers/__init__.py

@@ -14,11 +14,11 @@ from ..models import (
     OperationGroup,
     RequestBuilder,
     OverloadedRequestBuilder,
-    NamespaceModel,
     CodeModel,
+    Client,
 )
 from .enum_serializer import EnumSerializer
-from .general_serializer import GeneralNamespaceSerializer, GeneralSerializer
+from .general_serializer import GeneralSerializer
 from .model_init_serializer import ModelInitSerializer
 from .model_serializer import DpgModelSerializer, MsrestModelSerializer
 from .operations_init_serializer import OperationsInitSerializer
@@ -51,57 +51,37 @@ class JinjaSerializer(ReaderAndWriter):  # pylint: disable=abstract-method
     def __init__(
         self,
         code_model: CodeModel,
-        namespace_model: NamespaceModel,
         *,
         output_folder: Union[str, Path],
         **kwargs: Any,
     ) -> None:
         super().__init__(output_folder=output_folder, **kwargs)
         self.code_model = code_model
-        self.namespace_model = namespace_model
 
     @property
     def has_aio_folder(self) -> bool:
-        return not self.namespace_model.options["no_async"] and bool(
-            self.namespace_model.operation_groups
+        return not self.code_model.options["no_async"] and bool(
+            self.code_model.has_operations
         )
 
     @property
     def has_operations_folder(self) -> bool:
-        return self.namespace_model.options["show_operations"] and bool(
-            self.namespace_model.operation_groups
+        return self.code_model.options["show_operations"] and bool(
+            self.code_model.has_operations
         )
 
-    def serialize(self) -> None:
-        env = Environment(
-            loader=PackageLoader("autorest.codegen", "templates"),
-            keep_trailing_newline=True,
-            line_statement_prefix="##",
-            line_comment_prefix="###",
-            trim_blocks=True,
-            lstrip_blocks=True,
-        )
-
-        namespace_path = (
-            Path(".")
-            if self.namespace_model.options["no_namespace_folders"]
-            else Path(*(self.namespace_model.namespace.split(".")))
-        )
+    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.namespace_model.options["models_mode"] and (
-            self.namespace_model.model_types or self.namespace_model.enums
-        ):
-            self._keep_patch_file(
-                namespace_path / Path("models") / Path("_patch.py"), env
-            )
         if self.has_operations_folder:
             self._keep_patch_file(
                 namespace_path
-                / Path(self.namespace_model.operations_folder_name)
+                / Path(self.code_model.operations_folder_name)
                 / Path("_patch.py"),
                 env,
             )
@@ -109,17 +89,16 @@ class JinjaSerializer(ReaderAndWriter):  # pylint: disable=abstract-method
                 self._keep_patch_file(
                     namespace_path
                     / Path("aio")
-                    / Path(self.namespace_model.operations_folder_name)
+                    / Path(self.code_model.operations_folder_name)
                     / Path("_patch.py"),
                     env,
                 )
-
         self._serialize_and_write_top_level_folder(
-            env=env, namespace_path=namespace_path
+            env=env, namespace_path=namespace_path, clients=clients
         )
 
-        if self.namespace_model.operation_groups:
-            if self.namespace_model.options["builders_visibility"] != "embedded":
+        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
                 )
@@ -127,24 +106,86 @@ class JinjaSerializer(ReaderAndWriter):  # pylint: disable=abstract-method
                 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(
-                env=env, namespace_path=namespace_path
+                clients, env=env, namespace_path=namespace_path
             )
-            if self.namespace_model.options["multiapi"]:
+            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"]
+            and not self.code_model.options["multiapi"]
+        ):
+            self._serialize_and_write_sample(env, namespace_path)
+
+    def serialize(self) -> None:
+        env = Environment(
+            loader=PackageLoader("autorest.codegen", "templates"),
+            keep_trailing_newline=True,
+            line_statement_prefix="##",
+            line_comment_prefix="###",
+            trim_blocks=True,
+            lstrip_blocks=True,
+        )
+
+        namespace_path = (
+            Path(".")
+            if self.code_model.options["no_namespace_folders"]
+            else Path(*(self.code_model.namespace.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.namespace_model.options["models_mode"] and (
-            self.namespace_model.model_types or self.namespace_model.enums
+        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.namespace_model.options["models_mode"]:
+        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")):
                 self.write_file(
@@ -152,20 +193,9 @@ class JinjaSerializer(ReaderAndWriter):  # pylint: disable=abstract-method
                     cast(str, self.read_file(namespace_path / Path("models.py"))),
                 )
 
-        if self.namespace_model.options["package_mode"]:
-            self._serialize_and_write_package_files(namespace_path=namespace_path)
-
-        if (
-            self.namespace_model.options["show_operations"]
-            and self.namespace_model.operation_groups
-            and self.namespace_model.options["generate_sample"]
-            and not self.namespace_model.options["multiapi"]
-        ):
-            self._serialize_and_write_sample(env, namespace_path)
-
     def _serialize_and_write_package_files(self, namespace_path: Path) -> None:
         root_of_sdk = self._package_root_folder(namespace_path)
-        if self.namespace_model.options["package_mode"] in ("dataplane", "mgmtplane"):
+        if self.code_model.options["package_mode"] in ("dataplane", "mgmtplane"):
             env = Environment(
                 loader=PackageLoader(
                     "autorest.codegen", "templates/packaging_templates"
@@ -174,10 +204,10 @@ class JinjaSerializer(ReaderAndWriter):  # pylint: disable=abstract-method
             )
 
             package_files = _PACKAGE_FILES
-        elif Path(self.namespace_model.options["package_mode"]).exists():
+        elif Path(self.code_model.options["package_mode"]).exists():
             env = Environment(
                 loader=FileSystemLoader(
-                    str(Path(self.namespace_model.options["package_mode"]))
+                    str(Path(self.code_model.options["package_mode"]))
                 ),
                 keep_trailing_newline=True,
                 undefined=StrictUndefined,
@@ -185,8 +215,8 @@ class JinjaSerializer(ReaderAndWriter):  # pylint: disable=abstract-method
             package_files = env.list_templates()
         else:
             return
-        serializer = GeneralSerializer(self.code_model, env)
-        params = self.namespace_model.options["package_configuration"] or {}
+        serializer = GeneralSerializer(self.code_model, env, async_mode=False)
+        params = self.code_model.options["package_configuration"] or {}
         for template_name in package_files:
             file = template_name.replace(".jinja2", "")
             output_name = root_of_sdk / file
@@ -202,9 +232,7 @@ class JinjaSerializer(ReaderAndWriter):  # pylint: disable=abstract-method
         else:
             self.write_file(
                 path_file,
-                PatchSerializer(
-                    env=env, namespace_model=self.namespace_model
-                ).serialize(),
+                PatchSerializer(env=env, code_model=self.code_model).serialize(),
             )
 
     def _serialize_and_write_models_folder(
@@ -214,42 +242,36 @@ class JinjaSerializer(ReaderAndWriter):  # pylint: disable=abstract-method
         models_path = namespace_path / Path("models")
         serializer = (
             DpgModelSerializer
-            if self.namespace_model.options["models_mode"] == "dpg"
+            if self.code_model.options["models_mode"] == "dpg"
             else MsrestModelSerializer
         )
-        if self.namespace_model.model_types:
+        if self.code_model.model_types:
             self.write_file(
-                models_path / Path(f"{self.namespace_model.models_filename}.py"),
-                serializer(namespace_model=self.namespace_model, env=env).serialize(),
+                models_path / Path(f"{self.code_model.models_filename}.py"),
+                serializer(code_model=self.code_model, env=env).serialize(),
             )
-        if self.namespace_model.enums:
+        if self.code_model.enums:
             self.write_file(
-                models_path / Path(f"{self.namespace_model.enums_filename}.py"),
-                EnumSerializer(
-                    namespace_model=self.namespace_model, env=env
-                ).serialize(),
+                models_path / Path(f"{self.code_model.enums_filename}.py"),
+                EnumSerializer(code_model=self.code_model, env=env).serialize(),
             )
         self.write_file(
             models_path / Path("__init__.py"),
-            ModelInitSerializer(
-                namespace_model=self.namespace_model, env=env
-            ).serialize(),
+            ModelInitSerializer(code_model=self.code_model, env=env).serialize(),
         )
 
     def _serialize_and_write_rest_layer(
         self, env: Environment, namespace_path: Path
     ) -> None:
-        rest_path = namespace_path / Path(self.namespace_model.rest_layer_name)
+        rest_path = namespace_path / Path(self.code_model.rest_layer_name)
         group_names = {
-            rb.group_name
-            for c in self.namespace_model.clients
-            for rb in c.request_builders
+            rb.group_name for c in self.code_model.clients for rb in c.request_builders
         }
 
         for group_name in group_names:
             request_builders = [
                 r
-                for c in self.namespace_model.clients
+                for c in self.code_model.clients
                 for r in c.request_builders
                 if r.group_name == group_name
             ]
@@ -259,7 +281,7 @@ class JinjaSerializer(ReaderAndWriter):  # pylint: disable=abstract-method
         if not "" in group_names:
             self.write_file(
                 rest_path / Path("__init__.py"),
-                self.namespace_model.options["license_header"],
+                self.code_model.options["license_header"],
             )
 
     def _serialize_and_write_single_rest_layer(
@@ -274,7 +296,7 @@ class JinjaSerializer(ReaderAndWriter):  # pylint: disable=abstract-method
         self.write_file(
             output_path / Path("_request_builders.py"),
             RequestBuildersSerializer(
-                namespace_model=self.namespace_model,
+                code_model=self.code_model,
                 env=env,
                 request_builders=request_builders,
             ).serialize_request_builders(),
@@ -284,7 +306,7 @@ class JinjaSerializer(ReaderAndWriter):  # pylint: disable=abstract-method
         self.write_file(
             output_path / Path("__init__.py"),
             RequestBuildersSerializer(
-                namespace_model=self.namespace_model,
+                code_model=self.code_model,
                 env=env,
                 request_builders=request_builders,
             ).serialize_init(),
@@ -293,20 +315,22 @@ class JinjaSerializer(ReaderAndWriter):  # pylint: disable=abstract-method
     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(
-            namespace_model=self.namespace_model,
+            code_model=self.code_model,
+            clients=clients,
             env=env,
             async_mode=False,
             operation_group=operation_group,
         )
         self.write_file(
             namespace_path
-            / Path(self.namespace_model.operations_folder_name)
+            / Path(self.code_model.operations_folder_name)
             / Path(f"{filename}.py"),
             operation_group_serializer.serialize(),
         )
@@ -314,7 +338,8 @@ class JinjaSerializer(ReaderAndWriter):  # pylint: disable=abstract-method
         if self.has_aio_folder:
             # write async operation group and operation files
             operation_group_async_serializer = OperationGroupsSerializer(
-                namespace_model=self.namespace_model,
+                code_model=self.code_model,
+                clients=clients,
                 env=env,
                 async_mode=True,
                 operation_group=operation_group,
@@ -323,22 +348,22 @@ class JinjaSerializer(ReaderAndWriter):  # pylint: disable=abstract-method
                 (
                     namespace_path
                     / Path("aio")
-                    / Path(self.namespace_model.operations_folder_name)
+                    / Path(self.code_model.operations_folder_name)
                     / Path(f"{filename}.py")
                 ),
                 operation_group_async_serializer.serialize(),
             )
 
     def _serialize_and_write_operations_folder(
-        self, env: Environment, namespace_path: Path
+        self, clients: List[Client], env: Environment, namespace_path: Path
     ) -> None:
         # write sync operations init file
         operations_init_serializer = OperationsInitSerializer(
-            namespace_model=self.namespace_model, env=env, async_mode=False
+            code_model=self.code_model, clients=clients, env=env, async_mode=False
         )
         self.write_file(
             namespace_path
-            / Path(self.namespace_model.operations_folder_name)
+            / Path(self.code_model.operations_folder_name)
             / Path("__init__.py"),
             operations_init_serializer.serialize(),
         )
@@ -346,33 +371,36 @@ class JinjaSerializer(ReaderAndWriter):  # pylint: disable=abstract-method
         # write async operations init file
         if self.has_aio_folder:
             operations_async_init_serializer = OperationsInitSerializer(
-                namespace_model=self.namespace_model, env=env, async_mode=True
+                code_model=self.code_model, clients=clients, env=env, async_mode=True
             )
             self.write_file(
                 namespace_path
                 / Path("aio")
-                / Path(self.namespace_model.operations_folder_name)
+                / Path(self.code_model.operations_folder_name)
                 / Path("__init__.py"),
                 operations_async_init_serializer.serialize(),
             )
 
-        if self.namespace_model.options["combine_operation_files"]:
+        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 self.namespace_model.operation_groups:
-                self._serialize_and_write_operations_file(
-                    env=env,
-                    namespace_path=namespace_path,
-                    operation_group=operation_group,
-                )
+            for client in self.code_model.clients:
+                for operation_group in client.operation_groups:
+                    self._serialize_and_write_operations_file(
+                        env=env,
+                        namespace_path=namespace_path,
+                        operation_group=operation_group,
+                        clients=self.code_model.clients,
+                    )
 
     def _serialize_and_write_version_file(
         self,
         namespace_path: Path,
-        general_namespace_serializer: GeneralNamespaceSerializer,
+        general_serializer: GeneralSerializer,
     ):
         def _read_version_file(original_version_file_name: str) -> str:
             return self.read_file(namespace_path / original_version_file_name)
@@ -383,99 +411,98 @@ class JinjaSerializer(ReaderAndWriter):  # pylint: disable=abstract-method
                 _read_version_file(original_version_file_name),
             )
 
-        keep_version_file = self.namespace_model.options["keep_version_file"]
+        keep_version_file = self.code_model.options["keep_version_file"]
         if 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"):
             _write_version_file(original_version_file_name="version.py")
-        elif self.namespace_model.options["package_version"]:
+        elif self.code_model.options["package_version"]:
             self.write_file(
                 namespace_path / Path("_version.py"),
-                general_namespace_serializer.serialize_version_file(),
+                general_serializer.serialize_version_file(),
+            )
+
+    def _serialize_client_and_config_files(
+        self,
+        namespace_path: Path,
+        general_serializer: GeneralSerializer,
+        async_mode: bool,
+        clients: List[Client],
+    ) -> 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),
+            )
+            self.write_file(
+                namespace_path / Path("_configuration.py"),
+                general_serializer.serialize_config_file(clients),
             )
 
     def _serialize_and_write_top_level_folder(
-        self, env: Environment, namespace_path: Path
+        self, env: Environment, namespace_path: Path, clients: List[Client]
     ) -> None:
-        general_namespace_serializer = GeneralNamespaceSerializer(
-            namespace_model=self.namespace_model, env=env, async_mode=False
-        )
         general_serializer = GeneralSerializer(
-            code_model=self.code_model,
-            env=env,
+            code_model=self.code_model, env=env, async_mode=False
         )
 
         self.write_file(
             namespace_path / Path("__init__.py"),
-            general_namespace_serializer.serialize_init_file(),
+            general_serializer.serialize_init_file(clients),
         )
-        p = namespace_path.parent
-        while p != Path("."):
-            # write pkgutil init file
-            self.write_file(
-                p / Path("__init__.py"),
-                general_namespace_serializer.serialize_pkgutil_init_file(),
-            )
-            p = p.parent
 
         # Write the service client
-        if self.namespace_model.operation_groups:
-            self.write_file(
-                namespace_path / Path(f"{self.namespace_model.client_filename}.py"),
-                general_namespace_serializer.serialize_service_client_file(),
-            )
-
-        if self.namespace_model.need_vendored_code(async_mode=False):
+        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_namespace_serializer.serialize_vendor_file(),
+                general_serializer.serialize_vendor_file(),
             )
 
-        self._serialize_and_write_version_file(
-            namespace_path, general_namespace_serializer
-        )
+        self._serialize_and_write_version_file(namespace_path, general_serializer)
 
         # write the empty py.typed file
         self.write_file(namespace_path / Path("py.typed"), "# Marker file for PEP 561.")
 
         if (
-            not self.namespace_model.options["client_side_validation"]
-            and not self.namespace_model.options["multiapi"]
+            not self.code_model.options["client_side_validation"]
+            and not self.code_model.options["multiapi"]
         ):
             self.write_file(
                 namespace_path / Path("_serialization.py"),
-                general_namespace_serializer.serialize_serialization_file(),
+                general_serializer.serialize_serialization_file(),
             )
-        if self.namespace_model.options["models_mode"] == "dpg":
+        if self.code_model.options["models_mode"] == "dpg":
             self.write_file(
                 namespace_path / Path("_model_base.py"),
-                general_namespace_serializer.serialize_model_base_file(),
+                general_serializer.serialize_model_base_file(),
             )
 
         if any(
-            og for og in self.namespace_model.operation_groups if og.need_validation
+            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"),
-                general_namespace_serializer.serialize_validation_file(),
-            )
-
-        # Write the config file
-        if self.namespace_model.request_builders:
-            self.write_file(
-                namespace_path / Path("_configuration.py"),
-                general_namespace_serializer.serialize_config_file(),
+                general_serializer.serialize_validation_file(),
             )
 
         # Write the setup file
-        if self.namespace_model.options["basic_setup_py"]:
+        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
+        self, env: Environment, namespace_path: Path, clients: List[Client]
     ) -> None:
-        aio_general_namespace_serializer = GeneralNamespaceSerializer(
-            namespace_model=self.namespace_model, env=env, async_mode=True
+        aio_general_serializer = GeneralSerializer(
+            code_model=self.code_model, env=env, async_mode=True
         )
 
         aio_path = namespace_path / Path("aio")
@@ -483,68 +510,58 @@ class JinjaSerializer(ReaderAndWriter):  # pylint: disable=abstract-method
         # Write the __init__ file
         self.write_file(
             aio_path / Path("__init__.py"),
-            aio_general_namespace_serializer.serialize_init_file(),
+            aio_general_serializer.serialize_init_file(clients),
         )
 
         # Write the service client
-        if self.namespace_model.request_builders:
-            self.write_file(
-                aio_path / Path(f"{self.namespace_model.client_filename}.py"),
-                aio_general_namespace_serializer.serialize_service_client_file(),
-            )
-
-        # Write the config file
-        self.write_file(
-            aio_path / Path("_configuration.py"),
-            aio_general_namespace_serializer.serialize_config_file(),
+        self._serialize_client_and_config_files(
+            namespace_path, aio_general_serializer, async_mode=True, clients=clients
         )
-        if self.namespace_model.need_vendored_code(async_mode=True):
+        if self.code_model.need_vendored_code(async_mode=True):
             self.write_file(
                 aio_path / Path("_vendor.py"),
-                aio_general_namespace_serializer.serialize_vendor_file(),
+                aio_general_serializer.serialize_vendor_file(),
             )
 
     def _serialize_and_write_metadata(
         self, env: Environment, namespace_path: Path
     ) -> None:
-        metadata_serializer = MetadataSerializer(self.namespace_model, env)
+        metadata_serializer = MetadataSerializer(self.code_model, env)
         self.write_file(
             namespace_path / Path("_metadata.json"), metadata_serializer.serialize()
         )
 
     # find root folder where "setup.py" is
     def _package_root_folder(self, namespace_path: Path) -> Path:
-        return namespace_path / Path(
-            "../" * (self.namespace_model.namespace.count(".") + 1)
-        )
+        return namespace_path / Path("../" * (self.code_model.namespace.count(".") + 1))
 
     def _serialize_and_write_sample(self, env: Environment, namespace_path: Path):
         out_path = self._package_root_folder(namespace_path) / Path("generated_samples")
-        for op_group in self.namespace_model.operation_groups:
-            for operation in op_group.operations:
-                samples = operation.yaml_data["samples"]
-                if not samples:
-                    continue
-                for key, value in samples.items():
-                    file_name = to_snake_case(key) + ".py"
-                    try:
-                        self.write_file(
-                            out_path / file_name,
-                            SampleSerializer(
-                                namespace_model=self.namespace_model,
-                                env=env,
-                                operation_group=op_group,
-                                operation=operation,
-                                sample=value,
-                                file_name=file_name,
-                                sample_origin_name=key,
-                            ).serialize(),
-                        )
-                    except Exception as e:  # pylint: disable=broad-except
-                        # sample generation shall not block code generation, so just log error
-                        _LOGGER.error(
-                            "error happens when generate sample with {%s}: {%s}", key, e
-                        )
+        for client in self.code_model.clients:
+            for op_group in client.operation_groups:
+                for operation in op_group.operations:
+                    samples = operation.yaml_data["samples"]
+                    if not samples or operation.name.startswith("_"):
+                        continue
+                    for key, value in samples.items():
+                        file_name = to_snake_case(key) + ".py"
+                        try:
+                            self.write_file(
+                                out_path / file_name,
+                                SampleSerializer(
+                                    code_model=self.code_model,
+                                    env=env,
+                                    operation_group=op_group,
+                                    operation=operation,
+                                    sample=value,
+                                    file_name=file_name,
+                                    sample_origin_name=key,
+                                ).serialize(),
+                            )
+                        except Exception as e:  # pylint: disable=broad-except
+                            # sample generation shall not block code generation, so just log error
+                            log_error = f"error happens in sample {key}: {e}"
+                            _LOGGER.error(log_error)
 
 
 class JinjaSerializerAutorest(JinjaSerializer, ReaderAndWriterAutorest):
@@ -552,7 +569,6 @@ class JinjaSerializerAutorest(JinjaSerializer, ReaderAndWriterAutorest):
         self,
         autorestapi: AutorestAPI,
         code_model: CodeModel,
-        namespace_model: NamespaceModel,
         *,
         output_folder: Union[str, Path],
         **kwargs: Any,
@@ -560,7 +576,6 @@ class JinjaSerializerAutorest(JinjaSerializer, ReaderAndWriterAutorest):
         super().__init__(
             autorestapi=autorestapi,
             code_model=code_model,
-            namespace_model=namespace_model,
             output_folder=output_folder,
             **kwargs,
         )