@typespec/http-client-python 0.5.1 → 0.6.1

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

@@ -3,13 +3,14 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
-from typing import List
+from typing import List, Optional
 from abc import ABC, abstractmethod
 
 from ..models import ModelType, Property, ConstantType, EnumValue
 from ..models.imports import FileImport, TypingSection, MsrestImportType, ImportType
 from .import_serializer import FileImportSerializer
 from .base_serializer import BaseSerializer
+from ..models.utils import NamespaceType
 
 
 def _documentation_string(prop: Property, description_keyword: str, docstring_type_keyword: str) -> List[str]:
@@ -22,6 +23,12 @@ def _documentation_string(prop: Property, description_keyword: str, docstring_ty
 
 
 class _ModelSerializer(BaseSerializer, ABC):
+    def __init__(
+        self, code_model, env, async_mode=False, *, models: List[ModelType], client_namespace: Optional[str] = None
+    ):
+        super().__init__(code_model, env, async_mode, client_namespace=client_namespace)
+        self.models = models
+
     @abstractmethod
     def imports(self) -> FileImport: ...
 
@@ -33,6 +40,7 @@ class _ModelSerializer(BaseSerializer, ABC):
             imports=FileImportSerializer(self.imports()),
             str=str,
             serializer=self,
+            models=self.models,
         )
 
     @abstractmethod
@@ -63,12 +71,12 @@ class _ModelSerializer(BaseSerializer, ABC):
             typing = "str"
         return f"self.{prop.client_name}: {typing}  = {discriminator_value}"
 
-    @staticmethod
-    def initialize_standard_property(prop: Property):
+    def initialize_standard_property(self, prop: Property):
         if not (prop.optional or prop.client_default_value is not None):
-            return f"{prop.client_name}: {prop.type_annotation()},{prop.pylint_disable()}"
+            type_annotation = prop.type_annotation(serialize_namespace=self.serialize_namespace)
+            return f"{prop.client_name}: {type_annotation},{prop.pylint_disable()}"
         return (
-            f"{prop.client_name}: {prop.type_annotation()} = "
+            f"{prop.client_name}: {prop.type_annotation(serialize_namespace=self.serialize_namespace)} = "
             f"{prop.client_default_value_declaration},{prop.pylint_disable()}"
         )
 
@@ -108,7 +116,7 @@ class _ModelSerializer(BaseSerializer, ABC):
     def initialize_properties(self, model: ModelType) -> List[str]: ...
 
     def need_init(self, model: ModelType) -> bool:
-        return (not model.internal) and bool(self.init_line(model) or model.discriminator)
+        return bool(self.init_line(model) or model.discriminator)
 
     def pylint_disable_items(self, model: ModelType) -> List[str]:
         if model.flattened_property or self.initialize_properties(model):
@@ -127,19 +135,29 @@ class _ModelSerializer(BaseSerializer, ABC):
     def global_pylint_disables(self) -> str:
         return ""
 
+    @property
+    def serialize_namespace(self) -> str:
+        return self.code_model.get_serialize_namespace(self.client_namespace, client_namespace_type=NamespaceType.MODEL)
+
 
 class MsrestModelSerializer(_ModelSerializer):
     def imports(self) -> FileImport:
         file_import = FileImport(self.code_model)
         file_import.add_msrest_import(
-            relative_path="..",
+            serialize_namespace=self.serialize_namespace,
             msrest_import_type=MsrestImportType.Module,
             typing_section=TypingSection.REGULAR,
         )
-        for model in self.code_model.model_types:
+        for model in self.models:
             file_import.merge(model.imports(is_operation_file=False))
             for param in self._init_line_parameters(model):
-                file_import.merge(param.imports())
+                file_import.merge(
+                    param.imports(
+                        serialize_namespace=self.serialize_namespace,
+                        serialize_namespace_type=NamespaceType.MODEL,
+                        called_by_property=True,
+                    )
+                )
 
         return file_import
 
@@ -209,19 +227,41 @@ class DpgModelSerializer(_ModelSerializer):
 
     def imports(self) -> FileImport:
         file_import = FileImport(self.code_model)
-        file_import.add_submodule_import(
-            "..",
-            "_model_base",
-            ImportType.LOCAL,
-            TypingSection.REGULAR,
-        )
-
-        for model in self.code_model.model_types:
+        if any(not m.parents for m in self.models):
+            file_import.add_submodule_import(
+                self.code_model.get_relative_import_path(self.serialize_namespace),
+                "_model_base",
+                ImportType.LOCAL,
+                TypingSection.REGULAR,
+            )
+        for model in self.models:
             if model.base == "json":
                 continue
-            file_import.merge(model.imports(is_operation_file=False))
+            file_import.merge(
+                model.imports(
+                    is_operation_file=False,
+                    serialize_namespace=self.serialize_namespace,
+                    serialize_namespace_type=NamespaceType.MODEL,
+                )
+            )
             for prop in model.properties:
-                file_import.merge(prop.imports())
+                file_import.merge(
+                    prop.imports(
+                        serialize_namespace=self.serialize_namespace,
+                        serialize_namespace_type=NamespaceType.MODEL,
+                        called_by_property=True,
+                    )
+                )
+            for parent in model.parents:
+                if parent.client_namespace != model.client_namespace:
+                    file_import.add_submodule_import(
+                        self.code_model.get_relative_import_path(
+                            self.serialize_namespace,
+                            self.code_model.get_imported_namespace_for_model(parent.client_namespace),
+                        ),
+                        parent.name,
+                        ImportType.LOCAL,
+                    )
             if model.is_polymorphic:
                 file_import.add_submodule_import("typing", "Dict", ImportType.STDLIB)
             if not model.internal and self.init_line(model):
@@ -258,8 +298,7 @@ class DpgModelSerializer(_ModelSerializer):
             raise ValueError("We do not generate anonymous properties")
         return properties_to_declare
 
-    @staticmethod
-    def declare_property(prop: Property) -> str:
+    def declare_property(self, prop: Property) -> str:
         args = []
         if prop.client_name != prop.wire_name or prop.is_discriminator:
             args.append(f'name="{prop.wire_name}"')
@@ -283,7 +322,8 @@ class DpgModelSerializer(_ModelSerializer):
             if prop.is_discriminator and isinstance(prop.type, (ConstantType, EnumValue)) and prop.type.value
             else ""
         )
-        generated_code = f'{prop.client_name}: {prop.type_annotation()} = {field}({", ".join(args)})'
+        type_annotation = prop.type_annotation(serialize_namespace=self.serialize_namespace)
+        generated_code = f'{prop.client_name}: {type_annotation} = {field}({", ".join(args)})'
         # there is 4 spaces indentation so original line length limit 120 - 4 = 116
         pylint_disable = (
             " # pylint: disable=line-too-long"
@@ -324,7 +364,7 @@ class DpgModelSerializer(_ModelSerializer):
 
     def global_pylint_disables(self) -> str:
         result = []
-        for model in self.code_model.model_types:
+        for model in self.models:
             if self.need_init(model):
                 for item in self.pylint_disable_items(model):
                     if item:

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

@@ -7,15 +7,14 @@ from typing import Optional, List, Union
 import functools
 from jinja2 import Environment
 
-from .utils import get_all_operation_groups_recursively
 from ..models import (
     CodeModel,
     OperationGroup,
     RequestBuilder,
     OverloadedRequestBuilder,
-    Client,
     FileImport,
 )
+from ..models.utils import NamespaceType
 from .import_serializer import FileImportSerializer
 from .builder_serializer import (
     get_operation_serializer,
@@ -28,23 +27,22 @@ class OperationGroupsSerializer(BaseSerializer):
     def __init__(
         self,
         code_model: CodeModel,
-        clients: List[Client],
+        operation_groups: List[OperationGroup],
         env: Environment,
         async_mode: bool,
-        operation_group: Optional[OperationGroup] = None,
+        *,
+        client_namespace: Optional[str] = None,
     ):
-        super().__init__(code_model, env)
-        self.clients = clients
+        super().__init__(code_model, env, async_mode, client_namespace=client_namespace)
+        self.operation_groups = operation_groups
         self.async_mode = async_mode
-        self.operation_group = operation_group
 
     def _get_request_builders(
         self, operation_group: OperationGroup
     ) -> List[Union[OverloadedRequestBuilder, RequestBuilder]]:
         return [
             r
-            for client in self.clients
-            for r in client.request_builders
+            for r in operation_group.client.request_builders
             if r.client.name == operation_group.client.name
             and r.group_name == operation_group.identify_name
             and not r.is_overload
@@ -52,17 +50,20 @@ class OperationGroupsSerializer(BaseSerializer):
             and not r.is_lro  # lro has already initial builder
         ]
 
-    def serialize(self) -> str:
-        if self.operation_group:
-            operation_groups = [self.operation_group]
-        else:
-            operation_groups = get_all_operation_groups_recursively(self.clients)
+    @property
+    def serialize_namespace(self) -> str:
+        return self.code_model.get_serialize_namespace(
+            self.client_namespace, async_mode=self.async_mode, client_namespace_type=NamespaceType.OPERATION
+        )
 
+    def serialize(self) -> str:
         imports = FileImport(self.code_model)
-        for operation_group in operation_groups:
+        for operation_group in self.operation_groups:
             imports.merge(
                 operation_group.imports(
                     async_mode=self.async_mode,
+                    serialize_namespace=self.serialize_namespace,
+                    serialize_namespace_type=NamespaceType.OPERATION,
                 )
             )
 
@@ -70,7 +71,7 @@ class OperationGroupsSerializer(BaseSerializer):
 
         return template.render(
             code_model=self.code_model,
-            operation_groups=operation_groups,
+            operation_groups=self.operation_groups,
             imports=FileImportSerializer(
                 imports,
                 async_mode=self.async_mode,
@@ -80,10 +81,12 @@ class OperationGroupsSerializer(BaseSerializer):
                 get_operation_serializer,
                 code_model=self.code_model,
                 async_mode=self.async_mode,
+                client_namespace=self.client_namespace,
             ),
             request_builder_serializer=RequestBuilderSerializer(
                 self.code_model,
                 async_mode=False,
+                client_namespace=self.client_namespace,
             ),
             get_request_builders=self._get_request_builders,
         )

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

@@ -6,20 +6,19 @@
 from typing import List
 from jinja2 import Environment
 
-from ..models.operation_group import OperationGroup
-from ..models import CodeModel, Client
+from ..models import CodeModel, OperationGroup
 
 
 class OperationsInitSerializer:
     def __init__(
         self,
         code_model: CodeModel,
-        clients: List[Client],
+        operation_groups: List[OperationGroup],
         env: Environment,
         async_mode: bool,
     ) -> None:
         self.code_model = code_model
-        self.clients = clients
+        self.operation_groups = [og for og in operation_groups if not og.has_parent_operation_group]
         self.env = env
         self.async_mode = async_mode
 
@@ -27,11 +26,7 @@ class OperationsInitSerializer:
         def _get_filename(operation_group: OperationGroup) -> str:
             return "_operations" if self.code_model.options["combine_operation_files"] else operation_group.filename
 
-        return [
-            f"from .{_get_filename(og)} import {og.class_name}  # type: ignore"
-            for client in self.clients
-            for og in client.operation_groups
-        ]
+        return [f"from .{_get_filename(og)} import {og.class_name}  # type: ignore" for og in self.operation_groups]
 
     def serialize(self) -> str:
         operation_group_init_template = self.env.get_template("operations_folder_init.py.jinja2")
@@ -40,5 +35,5 @@ class OperationsInitSerializer:
             code_model=self.code_model,
             async_mode=self.async_mode,
             operation_group_imports=self.operation_group_imports,
-            clients=self.clients,
+            operation_groups=self.operation_groups,
         )

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

@@ -52,8 +52,11 @@ SPECIAL_HEADER_SERIALIZATION: Dict[str, List[str]] = {
 
 
 class ParameterSerializer:
-    @staticmethod
-    def serialize_parameter(parameter: ParameterType, serializer_name: str) -> str:
+
+    def __init__(self, serialize_namespace: str) -> None:
+        self.serialize_namespace = serialize_namespace
+
+    def serialize_parameter(self, parameter: ParameterType, serializer_name: str) -> str:
         optional_parameters = []
 
         if parameter.skip_url_encoding:
@@ -88,7 +91,7 @@ class ParameterSerializer:
         parameters = [
             f'"{origin_name.lstrip("_")}"',
             "q" if parameter.explode else origin_name,
-            f"'{type.serialization_type}'",
+            f"'{type.serialization_type(serialize_namespace=self.serialize_namespace)}'",
             *optional_parameters,
         ]
         parameters_line = ", ".join(parameters)
@@ -106,8 +109,8 @@ class ParameterSerializer:
             return f"[{serialize_line} if q is not None else '' for q in {origin_name}]"
         return serialize_line
 
-    @staticmethod
     def serialize_path(
+        self,
         parameters: Union[
             List[Parameter],
             List[RequestBuilderParameter],
@@ -121,7 +124,7 @@ class ParameterSerializer:
             [
                 '    "{}": {},'.format(
                     path_parameter.wire_name,
-                    ParameterSerializer.serialize_parameter(path_parameter, serializer_name),
+                    self.serialize_parameter(path_parameter, serializer_name),
                 )
                 for path_parameter in parameters
             ]
@@ -129,8 +132,8 @@ class ParameterSerializer:
         retval.append("}")
         return retval
 
-    @staticmethod
     def serialize_query_header(
+        self,
         param: Parameter,
         kwarg_name: str,
         serializer_name: str,
@@ -146,7 +149,7 @@ class ParameterSerializer:
         set_parameter = "_{}['{}'] = {}".format(
             kwarg_name,
             param.wire_name,
-            ParameterSerializer.serialize_parameter(param, serializer_name),
+            self.serialize_parameter(param, serializer_name),
         )
         if not param.optional and (param.in_method_signature or param.constant):
             retval = [set_parameter]

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

@@ -7,6 +7,7 @@ from typing import List
 from jinja2 import Environment
 
 from ..models import FileImport
+from ..models.utils import NamespaceType
 from .import_serializer import FileImportSerializer
 from ..models import CodeModel, RequestBuilderType
 from .builder_serializer import RequestBuilderSerializer
@@ -39,6 +40,12 @@ class RequestBuildersSerializer(BaseSerializer):
             request_builders=[r for r in self.request_builders if not r.is_overload],
         )
 
+    @property
+    def serialize_namespace(self) -> str:
+        return self.code_model.get_serialize_namespace(
+            self.client_namespace, client_namespace_type=NamespaceType.OPERATION
+        )
+
     def serialize_request_builders(self) -> str:
         template = self.env.get_template("request_builders.py.jinja2")
 
@@ -48,5 +55,7 @@ class RequestBuildersSerializer(BaseSerializer):
             imports=FileImportSerializer(
                 self.imports,
             ),
-            request_builder_serializer=RequestBuilderSerializer(self.code_model, async_mode=False),
+            request_builder_serializer=RequestBuilderSerializer(
+                self.code_model, async_mode=False, client_namespace=self.client_namespace
+            ),
         )

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

@@ -20,7 +20,7 @@ from ..models import (
     BodyParameter,
     FileImport,
 )
-from .utils import get_namespace_config, get_namespace_from_package_name
+from .._utils import get_parent_namespace
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -44,15 +44,12 @@ class SampleSerializer(BaseSerializer):
 
     def _imports(self) -> FileImportSerializer:
         imports = FileImport(self.code_model)
-        namespace_from_package_name = get_namespace_from_package_name(self.code_model.options["package_name"])
-        namespace_config = get_namespace_config(self.code_model.namespace, self.code_model.options["multiapi"])
-        namespace = namespace_from_package_name or namespace_config
-        # mainly for "azure-mgmt-rdbms"
-        if not self.code_model.options["multiapi"] and namespace_config.count(".") > namespace_from_package_name.count(
-            "."
-        ):
-            namespace = namespace_config
-        client = self.code_model.clients[0]
+        client = self.operation_group.client
+        namespace = (
+            get_parent_namespace(client.client_namespace)
+            if self.code_model.options["multiapi"]
+            else client.client_namespace
+        )
         imports.add_submodule_import(namespace, client.name, ImportType.LOCAL)
         credential_type = getattr(client.credential, "type", None)
         if isinstance(credential_type, TokenCredentialType):

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

@@ -35,18 +35,18 @@ def is_common_operation(operation_type: str) -> bool:
 
 
 class TestName:
-    def __init__(self, code_model: CodeModel, client_name: str, *, is_async: bool = False) -> None:
+    def __init__(self, code_model: CodeModel, client_name: str, *, async_mode: bool = False) -> None:
         self.code_model = code_model
         self.client_name = client_name
-        self.is_async = is_async
+        self.async_mode = async_mode
 
     @property
     def async_suffix_capt(self) -> str:
-        return "Async" if self.is_async else ""
+        return "Async" if self.async_mode else ""
 
     @property
     def create_client_name(self) -> str:
-        return "create_async_client" if self.is_async else "create_client"
+        return "create_async_client" if self.async_mode else "create_client"
 
     @property
     def prefix(self) -> str:
@@ -72,12 +72,12 @@ class TestCase:
         params: Dict[str, Any],
         operation: OperationType,
         *,
-        is_async: bool = False,
+        async_mode: bool = False,
     ) -> None:
         self.operation_groups = operation_groups
         self.params = params
         self.operation = operation
-        self.is_async = is_async
+        self.async_mode = async_mode
 
     @property
     def name(self) -> str:
@@ -93,7 +93,7 @@ class TestCase:
 
     @property
     def response(self) -> str:
-        if self.is_async:
+        if self.async_mode:
             if is_lro(self.operation.operation_type):
                 return "response = await (await "
             if is_common_operation(self.operation.operation_type):
@@ -107,14 +107,14 @@ class TestCase:
     @property
     def operation_suffix(self) -> str:
         if is_lro(self.operation.operation_type):
-            extra = ")" if self.is_async else ""
+            extra = ")" if self.async_mode else ""
             return f"{extra}.result(){self.lro_comment}"
         return ""
 
     @property
     def extra_operation(self) -> str:
         if is_paging(self.operation.operation_type):
-            async_str = "async " if self.is_async else ""
+            async_str = "async " if self.async_mode else ""
             return f"result = [r {async_str}for r in response]"
         return ""
 
@@ -128,43 +128,39 @@ class Test(TestName):
         testcases: List[TestCase],
         test_class_name: str,
         *,
-        is_async: bool = False,
+        async_mode: bool = False,
     ) -> None:
-        super().__init__(code_model, client_name, is_async=is_async)
+        super().__init__(code_model, client_name, async_mode=async_mode)
         self.operation_group = operation_group
         self.testcases = testcases
         self.test_class_name = test_class_name
 
 
 class TestGeneralSerializer(BaseSerializer):
-    def __init__(self, code_model: CodeModel, env: Environment, *, is_async: bool = False) -> None:
-        super().__init__(code_model, env)
-        self.is_async = is_async
 
     @property
     def aio_str(self) -> str:
-        return ".aio" if self.is_async else ""
+        return ".aio" if self.async_mode else ""
 
     @property
     def test_names(self) -> List[TestName]:
-        return [TestName(self.code_model, c.name, is_async=self.is_async) for c in self.code_model.clients]
+        return [TestName(self.code_model, c.name, async_mode=self.async_mode) for c in self.code_model.clients]
 
     def add_import_client(self, imports: FileImport) -> None:
-        namespace = get_namespace_from_package_name(self.code_model.options["package_name"])
         for client in self.code_model.clients:
-            imports.add_submodule_import(namespace + self.aio_str, client.name, ImportType.STDLIB)
+            imports.add_submodule_import(client.client_namespace + self.aio_str, client.name, ImportType.STDLIB)
 
     @property
     def import_clients(self) -> FileImportSerializer:
         imports = self.init_file_import()
 
         imports.add_submodule_import("devtools_testutils", "AzureRecordedTestCase", ImportType.STDLIB)
-        if not self.is_async:
+        if not self.async_mode:
             imports.add_import("functools", ImportType.STDLIB)
             imports.add_submodule_import("devtools_testutils", "PowerShellPreparer", ImportType.STDLIB)
         self.add_import_client(imports)
 
-        return FileImportSerializer(imports, self.is_async)
+        return FileImportSerializer(imports, self.async_mode)
 
     def serialize_conftest(self) -> str:
         return self.env.get_template("conftest.py.jinja2").render(
@@ -188,17 +184,17 @@ class TestSerializer(TestGeneralSerializer):
         *,
         client: Client,
         operation_group: OperationGroup,
-        is_async: bool = False,
+        async_mode: bool = False,
     ) -> None:
-        super().__init__(code_model, env, is_async=is_async)
+        super().__init__(code_model, env, async_mode=async_mode)
         self.client = client
         self.operation_group = operation_group
 
     @property
     def import_test(self) -> FileImportSerializer:
         imports = self.init_file_import()
-        test_name = TestName(self.code_model, self.client.name, is_async=self.is_async)
-        async_suffix = "_async" if self.is_async else ""
+        test_name = TestName(self.code_model, self.client.name, async_mode=self.async_mode)
+        async_suffix = "_async" if self.async_mode else ""
         imports.add_submodule_import(
             "devtools_testutils" if self.code_model.options["azure_arm"] else "testpreparer" + async_suffix,
             test_name.base_test_class_name,
@@ -216,7 +212,7 @@ class TestSerializer(TestGeneralSerializer):
         )
         if self.code_model.options["azure_arm"]:
             self.add_import_client(imports)
-        return FileImportSerializer(imports, self.is_async)
+        return FileImportSerializer(imports, self.async_mode)
 
     @property
     def breadth_search_operation_group(self) -> List[List[OperationGroup]]:
@@ -263,7 +259,7 @@ class TestSerializer(TestGeneralSerializer):
                     operation_groups=operation_groups,
                     params=operation_params,
                     operation=operation,
-                    is_async=self.is_async,
+                    async_mode=self.async_mode,
                 )
                 testcases.append(testcase)
         if not testcases:
@@ -275,12 +271,12 @@ class TestSerializer(TestGeneralSerializer):
             operation_group=self.operation_group,
             testcases=testcases,
             test_class_name=self.test_class_name,
-            is_async=self.is_async,
+            async_mode=self.async_mode,
         )
 
     @property
     def test_class_name(self) -> str:
-        test_name = TestName(self.code_model, self.client.name, is_async=self.is_async)
+        test_name = TestName(self.code_model, self.client.name, async_mode=self.async_mode)
         class_name = "" if self.operation_group.is_mixin else self.operation_group.class_name
         return f"Test{test_name.prefix}{class_name}{test_name.async_suffix_capt}"
 

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

@@ -4,6 +4,7 @@
 # license information.
 # --------------------------------------------------------------------------
 from ..models.imports import FileImport, ImportType
+from ..models.utils import NamespaceType
 from .import_serializer import FileImportSerializer
 from .base_serializer import BaseSerializer
 
@@ -18,7 +19,11 @@ class TypesSerializer(BaseSerializer):
                 ImportType.STDLIB,
             )
         for nu in self.code_model.named_unions:
-            file_import.merge(nu.imports(relative_path=".", model_typing=True, is_types_file=True))
+            file_import.merge(
+                nu.imports(
+                    serialize_namespace=self.serialize_namespace, serialize_namespace_type=NamespaceType.TYPES_FILE
+                )
+            )
         return file_import
 
     def serialize(self) -> str:

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

@@ -4,11 +4,9 @@
 # license information.
 # --------------------------------------------------------------------------
 import json
-from typing import Optional, List, Any
+from typing import Optional, Any
 from pathlib import Path
 
-from ..models import Client, OperationGroup
-
 
 def method_signature_and_response_type_annotation_template(
     *,
@@ -35,18 +33,6 @@ def get_namespace_from_package_name(package_name: Optional[str]) -> str:
     return (package_name or "").replace("-", ".")
 
 
-def get_all_operation_groups_recursively(clients: List[Client]) -> List[OperationGroup]:
-    operation_groups = []
-    queue = []
-    for client in clients:
-        queue.extend(client.operation_groups)
-    while queue:
-        operation_groups.append(queue.pop(0))
-        if operation_groups[-1].operation_groups:
-            queue.extend(operation_groups[-1].operation_groups)
-    return operation_groups
-
-
 def _improve_json_string(template_representation: str) -> Any:
     origin = template_representation.split("\n")
     final = []

package/generator/pygen/codegen/templates/client_container.py.jinja2

@@ -7,6 +7,6 @@
 {{ imports }}
 
 {% for client in clients %}
-    {% set serializer = get_serializer(client) %}
+    {% set serializer = get_serializer(client, serialize_namespace) %}
 {% include "client.py.jinja2" %}
 {% endfor %}