@typespec/http-client-python 0.5.1 → 0.6.1

package/generator/build/lib/pygen/codegen/models/base.py

@@ -87,8 +87,7 @@ class BaseType(BaseModel, ABC):  # pylint: disable=too-many-public-methods
             attrs_list.append("'text': True")
         return ", ".join(attrs_list)
 
-    @property
-    def serialization_type(self) -> str:
+    def serialization_type(self, **kwargs: Any) -> str:
         """The tag recognized by 'msrest' as a serialization/deserialization.
 
         'str', 'int', 'float', 'bool' or
@@ -103,7 +102,7 @@ class BaseType(BaseModel, ABC):  # pylint: disable=too-many-public-methods
 
     @property
     def msrest_deserialization_key(self) -> str:
-        return self.serialization_type
+        return self.serialization_type()
 
     @property
     def client_default_value(self) -> Any:

package/generator/build/lib/pygen/codegen/models/base_builder.py

@@ -14,6 +14,7 @@ from typing import (
     Union,
     TYPE_CHECKING,
     cast,
+    Sequence,
 )
 from abc import abstractmethod
 
@@ -39,7 +40,7 @@ if TYPE_CHECKING:
     from .request_builder import RequestBuilder
 
 
-OverloadListType = TypeVar("OverloadListType", bound=Union[List["Operation"], List["RequestBuilder"]])
+OverloadListType = TypeVar("OverloadListType", bound=Union[Sequence["Operation"], Sequence["RequestBuilder"]])
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -72,6 +73,7 @@ class BaseBuilder(
         self.api_versions: List[str] = yaml_data["apiVersions"]
         self.added_on: Optional[str] = yaml_data.get("addedOn")
         self.external_docs: Optional[Dict[str, Any]] = yaml_data.get("externalDocs")
+        self.client_namespace: str = yaml_data.get("clientNamespace", code_model.namespace)
 
         if code_model.options["version_tolerant"] and yaml_data.get("abstract"):
             _LOGGER.warning(
@@ -112,7 +114,7 @@ class BaseBuilder(
             )
         return self._description or self.name
 
-    def method_signature(self, async_mode: bool) -> List[str]:
+    def method_signature(self, async_mode: bool, **kwargs: Any) -> List[str]:
         if self.abstract:
             return ["*args,", "**kwargs"]
-        return self.parameters.method_signature(async_mode)
+        return self.parameters.method_signature(async_mode, **kwargs)

package/generator/build/lib/pygen/codegen/models/client.py

@@ -43,6 +43,7 @@ class _ClientConfigBase(Generic[ParameterListType], BaseModel):
         self.parameters = parameters
         self.url: str = self.yaml_data["url"]  # the base endpoint of the client. Can be parameterized or not
         self.legacy_filename: str = self.yaml_data.get("legacyFilename", "client")
+        self.client_namespace: str = self.yaml_data.get("clientNamespace", code_model.namespace)
 
     @property
     def description(self) -> str:
@@ -188,7 +189,7 @@ class Client(_ClientConfigBase[ClientGlobalParameterList]):
         except StopIteration as exc:
             raise KeyError(f"No operation with id {operation_id} found.") from exc
 
-    def _imports_shared(self, async_mode: bool) -> FileImport:
+    def _imports_shared(self, async_mode: bool, **kwargs) -> FileImport:
         file_import = FileImport(self.code_model)
         file_import.add_submodule_import("typing", "Any", ImportType.STDLIB, TypingSection.CONDITIONAL)
         if self.code_model.options["azure_arm"]:
@@ -206,8 +207,8 @@ class Client(_ClientConfigBase[ClientGlobalParameterList]):
             file_import.merge(
                 gp.imports(
                     async_mode,
-                    relative_path=".." if async_mode else ".",
-                    operation=True,
+                    is_operation_file=True,
+                    **kwargs,
                 )
             )
         file_import.add_submodule_import(
@@ -215,8 +216,9 @@ class Client(_ClientConfigBase[ClientGlobalParameterList]):
             f"{self.name}Configuration",
             ImportType.LOCAL,
         )
+        serialize_namespace = kwargs.get("serialize_namespace", self.code_model.namespace)
         file_import.add_msrest_import(
-            relative_path=".." if async_mode else ".",
+            serialize_namespace=serialize_namespace,
             msrest_import_type=MsrestImportType.SerializerDeserializer,
             typing_section=TypingSection.REGULAR,
         )
@@ -277,8 +279,8 @@ class Client(_ClientConfigBase[ClientGlobalParameterList]):
         """Whether there is non-abstract operation in any operation group."""
         return any(og.has_non_abstract_operations for og in self.operation_groups)
 
-    def imports(self, async_mode: bool) -> FileImport:
-        file_import = self._imports_shared(async_mode)
+    def imports(self, async_mode: bool, **kwargs) -> FileImport:
+        file_import = self._imports_shared(async_mode, **kwargs)
         if async_mode:
             file_import.add_submodule_import("typing", "Awaitable", ImportType.STDLIB)
             file_import.add_submodule_import(
@@ -300,9 +302,13 @@ class Client(_ClientConfigBase[ClientGlobalParameterList]):
             ImportType.SDKCORE,
             TypingSection.CONDITIONAL,
         )
+        serialize_namespace = kwargs.get("serialize_namespace", self.code_model.namespace)
         for og in self.operation_groups:
             file_import.add_submodule_import(
-                f".{self.code_model.operations_folder_name}",
+                self.code_model.get_relative_import_path(
+                    serialize_namespace,
+                    self.code_model.get_imported_namespace_for_operation(og.client_namespace, async_mode),
+                ),
                 og.class_name,
                 ImportType.LOCAL,
             )
@@ -317,8 +323,8 @@ class Client(_ClientConfigBase[ClientGlobalParameterList]):
         file_import.add_submodule_import("copy", "deepcopy", ImportType.STDLIB)
         return file_import
 
-    def imports_for_multiapi(self, async_mode: bool) -> FileImport:
-        file_import = self._imports_shared(async_mode)
+    def imports_for_multiapi(self, async_mode: bool, **kwargs) -> FileImport:
+        file_import = self._imports_shared(async_mode, **kwargs)
         file_import.add_submodule_import("typing", "Optional", ImportType.STDLIB, TypingSection.CONDITIONAL)
         try:
             mixin_operation = next(og for og in self.operation_groups if og.is_mixin)
@@ -377,7 +383,7 @@ class Config(_ClientConfigBase[ConfigGlobalParameterList]):
     def name(self) -> str:
         return f"{super().name}Configuration"
 
-    def _imports_shared(self, async_mode: bool) -> FileImport:
+    def _imports_shared(self, async_mode: bool, **kwargs: Any) -> FileImport:
         file_import = FileImport(self.code_model)
         file_import.add_submodule_import(
             "pipeline" if self.code_model.is_azure_flavor else "runtime",
@@ -386,7 +392,12 @@ class Config(_ClientConfigBase[ConfigGlobalParameterList]):
         )
         file_import.add_submodule_import("typing", "Any", ImportType.STDLIB, TypingSection.CONDITIONAL)
         if self.code_model.options["package_version"]:
-            file_import.add_submodule_import(".._version" if async_mode else "._version", "VERSION", ImportType.LOCAL)
+            serialize_namespace = kwargs.get("serialize_namespace", self.code_model.namespace)
+            file_import.add_submodule_import(
+                self.code_model.get_relative_import_path(serialize_namespace, module_name="_version"),
+                "VERSION",
+                ImportType.LOCAL,
+            )
         if self.code_model.options["azure_arm"]:
             policy = "AsyncARMChallengeAuthenticationPolicy" if async_mode else "ARMChallengeAuthenticationPolicy"
             file_import.add_submodule_import("azure.mgmt.core.policies", "ARMHttpLoggingPolicy", ImportType.SDKCORE)
@@ -394,22 +405,21 @@ class Config(_ClientConfigBase[ConfigGlobalParameterList]):
 
         return file_import
 
-    def imports(self, async_mode: bool) -> FileImport:
-        file_import = self._imports_shared(async_mode)
+    def imports(self, async_mode: bool, **kwargs) -> FileImport:
+        file_import = self._imports_shared(async_mode, **kwargs)
         for gp in self.parameters:
             if gp.method_location == ParameterMethodLocation.KWARG and gp not in self.parameters.kwargs_to_pop:
                 continue
             file_import.merge(
                 gp.imports(
                     async_mode=async_mode,
-                    relative_path=".." if async_mode else ".",
-                    operation=True,
+                    **kwargs,
                 )
             )
         return file_import
 
-    def imports_for_multiapi(self, async_mode: bool) -> FileImport:
-        file_import = self._imports_shared(async_mode)
+    def imports_for_multiapi(self, async_mode: bool, **kwargs: Any) -> FileImport:
+        file_import = self._imports_shared(async_mode, **kwargs)
         for gp in self.parameters:
             if (
                 gp.method_location == ParameterMethodLocation.KWARG
@@ -420,8 +430,7 @@ class Config(_ClientConfigBase[ConfigGlobalParameterList]):
             file_import.merge(
                 gp.imports_for_multiapi(
                     async_mode=async_mode,
-                    relative_path=".." if async_mode else ".",
-                    operation=True,
+                    **kwargs,
                 )
             )
         return file_import

package/generator/build/lib/pygen/codegen/models/code_model.py

@@ -3,7 +3,7 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
-from typing import List, Dict, Any, Set, Union, Literal
+from typing import List, Dict, Any, Set, Union, Literal, Optional, cast
 
 from .base import BaseType
 from .enum_type import EnumType
@@ -11,12 +11,40 @@ from .model_type import ModelType, UsageFlags
 from .combined_type import CombinedType
 from .client import Client
 from .request_builder import RequestBuilder, OverloadedRequestBuilder
+from .operation_group import OperationGroup
+from .utils import NamespaceType
 
 
 def _is_legacy(options) -> bool:
     return not (options.get("version_tolerant") or options.get("low_level_client"))
 
 
+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
+
+
+class ClientNamespaceType:
+    def __init__(
+        self,
+        clients: Optional[List[Client]] = None,
+        models: Optional[List[ModelType]] = None,
+        enums: Optional[List[EnumType]] = None,
+        operation_groups: Optional[List[OperationGroup]] = None,
+    ):
+        self.clients = clients or []
+        self.models = models or []
+        self.enums = enums or []
+        self.operation_groups = operation_groups or []
+
+
 class CodeModel:  # pylint: disable=too-many-public-methods, disable=too-many-instance-attributes
     """Top level code model
 
@@ -44,8 +72,6 @@ class CodeModel:  # pylint: disable=too-many-public-methods, disable=too-many-in
         self,
         yaml_data: Dict[str, Any],
         options: Dict[str, Any],
-        *,
-        is_subnamespace: bool = False,
     ) -> None:
         self.yaml_data = yaml_data
         self.options = options
@@ -59,18 +85,113 @@ class CodeModel:  # pylint: disable=too-many-public-methods, disable=too-many-in
         self.clients: List[Client] = [
             Client.from_yaml(client_yaml_data, self) for client_yaml_data in yaml_data["clients"]
         ]
-        self.subnamespace_to_clients: Dict[str, List[Client]] = {
-            subnamespace: [Client.from_yaml(client_yaml, self, is_subclient=True) for client_yaml in client_yamls]
-            for subnamespace, client_yamls in yaml_data.get("subnamespaceToClients", {}).items()
-        }
         if self.options["models_mode"] and self.model_types:
             self.sort_model_types()
-        self.is_subnamespace = is_subnamespace
         self.named_unions: List[CombinedType] = [
             t for t in self.types_map.values() if isinstance(t, CombinedType) and t.name
         ]
         self.cross_language_package_id = self.yaml_data.get("crossLanguagePackageId")
         self.for_test: bool = False
+        # key is typespec namespace, value is models/clients/opeartion_groups/enums cache in the namespace
+        self._client_namespace_types: Dict[str, ClientNamespaceType] = {}
+        self.has_subnamespace = False
+        self._operations_folder_name: Dict[str, str] = {}
+        self._relative_import_path: Dict[str, str] = {}
+
+    @staticmethod
+    def get_imported_namespace_for_client(imported_namespace: str, async_mode: bool = False) -> str:
+        return imported_namespace + (".aio" if async_mode else "")
+
+    @staticmethod
+    def get_imported_namespace_for_model(imported_namespace: str) -> str:
+        return imported_namespace + ".models"
+
+    def get_imported_namespace_for_operation(self, imported_namespace: str, async_mode: bool = False) -> str:
+        module_namespace = f".{self.operations_folder_name(imported_namespace)}"
+        return self.get_imported_namespace_for_client(imported_namespace, async_mode) + module_namespace
+
+    # | serialize_namespace  | imported_namespace   | relative_import_path |
+    # |----------------------|----------------------|----------------------|
+    # |azure.test.operations | azure.test.operations| .                    |
+    # |azure.test.operations | azure.test           | ..                   |
+    # |azure.test.operations | azure.test.subtest   | ..subtest            |
+    # |azure.test.operations | azure                | ...                  |
+    # |azure.test.aio.operations | azure.test       | ...                  |
+    # |azure.test.subtest.aio.operations|azure.test | ....                 |
+    # |azure.test            |azure.test.subtest    | .subtest             |
+    def get_relative_import_path(
+        self,
+        serialize_namespace: str,
+        imported_namespace: Optional[str] = None,
+        module_name: Optional[str] = None,
+    ) -> str:
+        if imported_namespace is None:
+            imported_namespace = self.namespace
+
+        key = f"{serialize_namespace}-{imported_namespace}"
+        if key not in self._relative_import_path:
+            idx = 0
+            serialize_namespace_split = serialize_namespace.split(".")
+            imported_namespace_split = cast(str, imported_namespace).split(".")
+            while idx < min(len(serialize_namespace_split), len(imported_namespace_split)):
+                if serialize_namespace_split[idx] != imported_namespace_split[idx]:
+                    break
+                idx += 1
+            self._relative_import_path[key] = "." * (len(serialize_namespace_split[idx:]) + 1) + ".".join(
+                imported_namespace_split[idx:]
+            )
+        result = self._relative_import_path[key]
+        if module_name is None:
+            return result
+        return f"{result}{module_name}" if result.endswith(".") else f"{result}.{module_name}"
+
+    @property
+    def need_unique_model_alias(self) -> bool:
+        return self.has_subnamespace and self.options["enable_typespec_namespace"]
+
+    def get_unique_models_alias(self, serialize_namespace: str, imported_namespace: str) -> str:
+        if not self.need_unique_model_alias:
+            return "_models"
+        relative_path = self.get_relative_import_path(
+            serialize_namespace, self.get_imported_namespace_for_model(imported_namespace)
+        )
+        dot_num = max(relative_path.count(".") - 1, 0)
+        parts = [""] + ([p for p in relative_path.split(".") if p] or ["models"])
+        return "_".join(parts) + (str(dot_num) if dot_num > 0 else "")
+
+    @property
+    def client_namespace_types(self) -> Dict[str, ClientNamespaceType]:
+        if not self._client_namespace_types:
+            # calculate client namespace types for each kind of client namespace
+            for client in self.clients:
+                if client.client_namespace not in self._client_namespace_types:
+                    self._client_namespace_types[client.client_namespace] = ClientNamespaceType()
+                self._client_namespace_types[client.client_namespace].clients.append(client)
+            for model in self.model_types:
+                if model.client_namespace not in self._client_namespace_types:
+                    self._client_namespace_types[model.client_namespace] = ClientNamespaceType()
+                self._client_namespace_types[model.client_namespace].models.append(model)
+            for enum in self.enums:
+                if enum.client_namespace not in self._client_namespace_types:
+                    self._client_namespace_types[enum.client_namespace] = ClientNamespaceType()
+                self._client_namespace_types[enum.client_namespace].enums.append(enum)
+            for operation_group in get_all_operation_groups_recursively(self.clients):
+                if operation_group.client_namespace not in self._client_namespace_types:
+                    self._client_namespace_types[operation_group.client_namespace] = ClientNamespaceType()
+                self._client_namespace_types[operation_group.client_namespace].operation_groups.append(operation_group)
+
+            # here we can check and record whether there are multi kinds of client namespace
+            if len(self._client_namespace_types.keys()) > 1:
+                self.has_subnamespace = True
+
+            # insert namespace to make sure it is continuous(e.g. ("", "azure", "azure.mgmt", "azure.mgmt.service"))
+            longest_namespace = sorted(self._client_namespace_types.keys())[-1]
+            namespace_parts = longest_namespace.split(".")
+            for idx in range(len(namespace_parts) + 1):
+                namespace = ".".join(namespace_parts[:idx])
+                if namespace not in self._client_namespace_types:
+                    self._client_namespace_types[namespace] = ClientNamespaceType()
+        return self._client_namespace_types
 
     @property
     def has_form_data(self) -> bool:
@@ -80,17 +201,17 @@ class CodeModel:  # pylint: disable=too-many-public-methods, disable=too-many-in
     def has_etag(self) -> bool:
         return any(client.has_etag for client in self.clients)
 
+    @staticmethod
+    def clients_has_operations(clients: List[Client]) -> bool:
+        return any(c for c in clients if c.has_operations)
+
     @property
     def has_operations(self) -> bool:
-        if any(c for c in self.clients if c.has_operations):
-            return True
-        return any(c for clients in self.subnamespace_to_clients.values() for c in clients if c.has_operations)
+        return self.clients_has_operations(self.clients)
 
     @property
     def has_non_abstract_operations(self) -> bool:
-        return any(c for c in self.clients if c.has_non_abstract_operations) or any(
-            c for cs in self.subnamespace_to_clients.values() for c in cs if c.has_non_abstract_operations
-        )
+        return any(c for c in self.clients if c.has_non_abstract_operations)
 
     def lookup_request_builder(self, request_builder_id: int) -> Union[RequestBuilder, OverloadedRequestBuilder]:
         """Find the request builder based off of id"""
@@ -114,31 +235,73 @@ class CodeModel:  # pylint: disable=too-many-public-methods, disable=too-many-in
     def client_filename(self) -> str:
         return self.clients[0].filename
 
-    def need_vendored_code(self, async_mode: bool) -> bool:
-        """Whether we need to vendor code in the _vendor.py file for this SDK"""
-        if self.has_abstract_operations:
-            return True
-        if async_mode:
-            return self.need_mixin_abc
-        return self.need_mixin_abc or self.has_etag or self.has_form_data
+    def get_clients(self, client_namespace: str) -> List[Client]:
+        """Get all clients in specific namespace"""
+        return self.client_namespace_types.get(client_namespace, ClientNamespaceType()).clients
 
-    @property
-    def need_mixin_abc(self) -> bool:
-        return any(c for c in self.clients if c.has_mixin)
+    def is_top_namespace(self, client_namespace: str) -> bool:
+        """Whether the namespace is the top namespace. For example, a package named 'azure-mgmt-service',
+        'azure.mgmt.service' is the top namespace.
+        """
+        return client_namespace == self.namespace
+
+    def need_vendored_code(self, async_mode: bool, client_namespace: str) -> bool:
+        """Whether we need to vendor code in the _vendor.py in specific namespace"""
+        return (
+            self.need_vendored_form_data(async_mode, client_namespace)
+            or self.need_vendored_etag(client_namespace)
+            or self.need_vendored_abstract(client_namespace)
+            or self.need_vendored_mixin(client_namespace)
+        )
+
+    def need_vendored_form_data(self, async_mode: bool, client_namespace: str) -> bool:
+        return (
+            (not async_mode)
+            and self.is_top_namespace(client_namespace)
+            and self.has_form_data
+            and self.options["models_mode"] == "dpg"
+        )
+
+    def need_vendored_etag(self, client_namespace: str) -> bool:
+        return self.is_top_namespace(client_namespace) and self.has_etag
+
+    def need_vendored_abstract(self, client_namespace: str) -> bool:
+        return self.is_top_namespace(client_namespace) and self.has_abstract_operations
+
+    def need_vendored_mixin(self, client_namespace: str) -> bool:
+        return self.has_mixin(client_namespace)
+
+    def has_mixin(self, client_namespace: str) -> bool:
+        return any(c for c in self.get_clients(client_namespace) if c.has_mixin)
 
     @property
     def has_abstract_operations(self) -> bool:
         return any(c for c in self.clients if c.has_abstract_operations)
 
-    @property
-    def operations_folder_name(self) -> str:
+    def operations_folder_name(self, client_namespace: str) -> str:
         """Get the name of the operations folder that holds operations."""
-        name = "operations"
-        if self.options["version_tolerant"] and not any(
-            og for client in self.clients for og in client.operation_groups if not og.is_mixin
-        ):
-            name = f"_{name}"
-        return name
+        if client_namespace not in self._operations_folder_name:
+            name = "operations"
+            operation_groups = self.client_namespace_types.get(client_namespace, ClientNamespaceType()).operation_groups
+            if self.options["version_tolerant"] and all(og.is_mixin for og in operation_groups):
+                name = f"_{name}"
+            self._operations_folder_name[client_namespace] = name
+        return self._operations_folder_name[client_namespace]
+
+    def get_serialize_namespace(
+        self,
+        client_namespace: str,
+        async_mode: bool = False,
+        client_namespace_type: NamespaceType = NamespaceType.CLIENT,
+    ) -> str:
+        """calculate the namespace for serialization from client namespace"""
+        if client_namespace_type == NamespaceType.CLIENT:
+            return client_namespace + (".aio" if async_mode else "")
+        if client_namespace_type == NamespaceType.MODEL:
+            return client_namespace + ".models"
+
+        operations_folder_name = self.operations_folder_name(client_namespace)
+        return client_namespace + (".aio." if async_mode else ".") + operations_folder_name
 
     @property
     def description(self) -> str:
@@ -170,9 +333,13 @@ class CodeModel:  # pylint: disable=too-many-public-methods, disable=too-many-in
     def model_types(self, val: List[ModelType]) -> None:
         self._model_types = val
 
+    @staticmethod
+    def get_public_model_types(models: List[ModelType]) -> List[ModelType]:
+        return [m for m in models if not m.internal and not m.base == "json"]
+
     @property
     def public_model_types(self) -> List[ModelType]:
-        return [m for m in self.model_types if not m.internal and not m.base == "json"]
+        return self.get_public_model_types(self.model_types)
 
     @property
     def enums(self) -> List[EnumType]:

package/generator/build/lib/pygen/codegen/models/combined_type.py

@@ -8,6 +8,7 @@ import re
 from .imports import FileImport, ImportType, TypingSection
 from .base import BaseType
 from .model_type import ModelType
+from .utils import NamespaceType
 
 if TYPE_CHECKING:
     from .code_model import CodeModel
@@ -30,9 +31,9 @@ class CombinedType(BaseType):
         self.types = types  # the types that this type is combining
         self.name = yaml_data.get("name")
         self._is_union_of_literals = all(i.type == "constant" for i in self.types)
+        self.client_namespace: str = self.yaml_data.get("clientNamespace", code_model.namespace)
 
-    @property
-    def serialization_type(self) -> str:
+    def serialization_type(self, **kwargs: Any) -> str:
         """The tag recognized by 'msrest' as a serialization/deserialization.
 
         'str', 'int', 'float', 'bool' or
@@ -45,7 +46,7 @@ class CombinedType(BaseType):
         """
         if not all(t for t in self.types if t.type == "constant"):
             raise ValueError("Shouldn't get serialization type of a combinedtype")
-        return self.types[0].serialization_type
+        return self.types[0].serialization_type(**kwargs)
 
     @property
     def client_default_value(self) -> Any:
@@ -112,9 +113,11 @@ class CombinedType(BaseType):
 
     def imports(self, **kwargs: Any) -> FileImport:
         file_import = FileImport(self.code_model)
-        if self.name and not kwargs.get("is_types_file"):
+        serialize_namespace = kwargs.get("serialize_namespace", self.code_model.namespace)
+        serialize_namespace_type = kwargs.get("serialize_namespace_type")
+        if self.name and serialize_namespace_type != NamespaceType.TYPES_FILE:
             file_import.add_submodule_import(
-                kwargs.pop("relative_path"),
+                self.code_model.get_relative_import_path(serialize_namespace),
                 "_types",
                 ImportType.LOCAL,
                 TypingSection.TYPING,

package/generator/build/lib/pygen/codegen/models/constant_type.py

@@ -56,14 +56,13 @@ class ConstantType(BaseType):
             f"Default value is {self.get_declaration()}.",
         )
 
-    @property
-    def serialization_type(self) -> str:
+    def serialization_type(self, **kwargs: Any) -> str:
         """Returns the serialization value for msrest.
 
         :return: The serialization value for msrest
         :rtype: str
         """
-        return self.value_type.serialization_type
+        return self.value_type.serialization_type(**kwargs)
 
     def docstring_text(self, **kwargs: Any) -> str:
         return "constant"

package/generator/build/lib/pygen/codegen/models/credential_types.py

@@ -131,8 +131,7 @@ class CredentialType(Generic[CredentialPolicyType], BaseType):
     def docstring_text(self, **kwargs: Any) -> str:
         return "credential"
 
-    @property
-    def serialization_type(self) -> str:
+    def serialization_type(self, **kwargs: Any) -> str:
         return self.docstring_type()
 
     @classmethod
@@ -156,7 +155,7 @@ class TokenCredentialType(CredentialType[Union[BearerTokenCredentialPolicyType,
 
     @property
     def type_description(self) -> str:
-        return "TokenCredential"
+        return "token credential"
 
     @property
     def credentials_subfolder(self) -> str:

package/generator/build/lib/pygen/codegen/models/dictionary_type.py

@@ -34,14 +34,13 @@ class DictionaryType(BaseType):
     def encode(self) -> Optional[str]:
         return self.element_type.encode if hasattr(self.element_type, "encode") else None  # type: ignore
 
-    @property
-    def serialization_type(self) -> str:
+    def serialization_type(self, **kwargs: Any) -> str:
         """Returns the serialization value for msrest.
 
         :return: The serialization value for msrest
         :rtype: str
         """
-        return f"{{{self.element_type.serialization_type}}}"
+        return f"{{{self.element_type.serialization_type(**kwargs)}}}"
 
     def type_annotation(self, **kwargs: Any) -> str:
         """The python type used for type annotation