@autorest/python 6.28.0 → 6.28.2

package/autorest/codegen.py

@@ -40,7 +40,7 @@ class JinjaSerializerAutorest(JinjaSerializer, ReaderAndWriterAutorest):
 class CodeGeneratorAutorest(CodeGenerator, PluginAutorest):
     def get_options(self) -> Dict[str, Any]:
         if self._autorestapi.get_boolean_value("python3-only") is False:
-            _LOGGER.warning("You have passed in --python3-only=False. We have force overriden this to True.")
+            _LOGGER.warning("You have passed in --python3-only=False. We have force overridden this to True.")
         if self._autorestapi.get_boolean_value("add-python3-operation-files"):
             _LOGGER.warning(
                 "You have passed in --add-python3-operation-files. "
@@ -48,7 +48,7 @@ class CodeGeneratorAutorest(CodeGenerator, PluginAutorest):
             )
         if self._autorestapi.get_boolean_value("reformat-next-link"):
             _LOGGER.warning(
-                "You have passed in --reformat-next-link. We have force overriden "
+                "You have passed in --reformat-next-link. We have force overridden "
                 "this to False because we no longer reformat initial query parameters into next "
                 "calls unless explicitly defined in the service definition."
             )

package/autorest/jsonrpc/__init__.py

@@ -12,7 +12,7 @@ from pathlib import Path
 
 
 class Channel(Enum):
-    # Information is considered the mildest of responses; not necesarily actionable.
+    # Information is considered the mildest of responses; not necessarily actionable.
     Information = "information"
 
     # Warnings are considered important for best practices, but not catastrophic in nature.
@@ -27,7 +27,7 @@ class Channel(Enum):
     # Verbose messages give the user additional clarity on the process.
     Verbose = "verbose"
 
-    # Catastrophic failure, likely abending the process.
+    # Catastrophic failure, likely ending the process.
     Fatal = "fatal"
 
 

package/autorest/m4reformatter/__init__.py

@@ -492,7 +492,7 @@ class M4Reformatter(YamlUpdatePluginAutorest):  # pylint: disable=too-many-publi
         *,
         is_overload: bool = False,
     ) -> Dict[str, Any]:
-        in_overriden = body_parameter["type"]["type"] == "combined" if body_parameter else False
+        in_overridden = body_parameter["type"]["type"] == "combined" if body_parameter else False
         abstract = False
         if body_parameter and (body_parameter.get("entries") or len(body_parameter["type"].get("types", [])) > 2):
             # this means it's formdata or urlencoded, or there are more than 2 types of body
@@ -507,7 +507,7 @@ class M4Reformatter(YamlUpdatePluginAutorest):  # pylint: disable=too-many-publi
                 yaml_data,
                 body_parameter,
                 in_overload=is_overload,
-                in_overriden=in_overriden,
+                in_overridden=in_overridden,
             ),
             "bodyParameter": body_parameter,
             "responses": [update_response(r) for r in yaml_data.get("responses", [])],
@@ -723,7 +723,7 @@ class M4Reformatter(YamlUpdatePluginAutorest):  # pylint: disable=too-many-publi
         request_media_types: List[str],
         *,
         in_overload: bool = False,
-        in_overriden: bool = False,
+        in_overridden: bool = False,
     ) -> Dict[str, Any]:
         # override content type type to string
         if not body_parameter:
@@ -737,14 +737,14 @@ class M4Reformatter(YamlUpdatePluginAutorest):  # pylint: disable=too-many-publi
         description = param["language"]["default"]["description"]
         if description and description[-1] != ".":
             description += "."
-        if not (in_overriden or in_overload):
+        if not (in_overridden or in_overload):
             param["inDocstring"] = False
         elif in_overload:
             description += " Content type parameter for " f"{get_body_type_for_description(body_parameter)} body."
         if not in_overload or (body_parameter["type"]["type"] == "binary" and len(request_media_types) > 1):
             content_types = "'" + "', '".join(request_media_types) + "'"
             description += f" Known values are: {content_types}."
-        if not in_overload and not in_overriden:
+        if not in_overload and not in_overridden:
             param["clientDefaultValue"] = body_parameter["defaultContentType"]
         param["language"]["default"]["description"] = description
         return param
@@ -758,7 +758,7 @@ class M4Reformatter(YamlUpdatePluginAutorest):  # pylint: disable=too-many-publi
         request_media_types: List[str],
         *,
         in_overload: bool = False,
-        in_overriden: bool = False,
+        in_overridden: bool = False,
     ) -> List[Dict[str, Any]]:
         retval: List[Dict[str, Any]] = []
         has_flattened_body = body_parameter and body_parameter.get("flattened")
@@ -785,9 +785,9 @@ class M4Reformatter(YamlUpdatePluginAutorest):  # pylint: disable=too-many-publi
                     body_parameter,
                     request_media_types,
                     in_overload=in_overload,
-                    in_overriden=in_overriden,
+                    in_overridden=in_overridden,
                 )
-            updated_param = self.update_parameter(param, in_overload=in_overload, in_overriden=in_overriden)
+            updated_param = self.update_parameter(param, in_overload=in_overload, in_overridden=in_overridden)
             retval.append(updated_param)
         return retval
 
@@ -797,7 +797,7 @@ class M4Reformatter(YamlUpdatePluginAutorest):  # pylint: disable=too-many-publi
         body_parameter: Optional[Dict[str, Any]],
         *,
         in_overload: bool = False,
-        in_overriden: bool = False,
+        in_overridden: bool = False,
     ) -> List[Dict[str, Any]]:
         retval: List[Dict[str, Any]] = []
         seen_client_names: Set[str] = set()
@@ -812,7 +812,7 @@ class M4Reformatter(YamlUpdatePluginAutorest):  # pylint: disable=too-many-publi
                 groupers,
                 request_media_types,
                 in_overload=in_overload,
-                in_overriden=in_overriden,
+                in_overridden=in_overridden,
             )
         )
         # now we handle content type and accept headers.
@@ -831,7 +831,7 @@ class M4Reformatter(YamlUpdatePluginAutorest):  # pylint: disable=too-many-publi
                     groupers,
                     request_media_types,
                     in_overload=in_overload,
-                    in_overriden=in_overriden,
+                    in_overridden=in_overridden,
                 )
             )
         all_params = (retval + [body_parameter]) if body_parameter else retval
@@ -853,7 +853,7 @@ class M4Reformatter(YamlUpdatePluginAutorest):  # pylint: disable=too-many-publi
         *,
         override_client_name: Optional[str] = None,
         in_overload: bool = False,
-        in_overriden: bool = False,
+        in_overridden: bool = False,
     ) -> Dict[str, Any]:
         param_base = self.update_parameter_base(yaml_data, override_client_name=override_client_name)
         type = get_type(yaml_data["schema"])
@@ -869,7 +869,7 @@ class M4Reformatter(YamlUpdatePluginAutorest):  # pylint: disable=too-many-publi
                 "inOverload": in_overload,
                 "skipUrlEncoding": yaml_data.get("extensions", {}).get("x-ms-skip-url-encoding", False),
                 "inDocstring": yaml_data.get("inDocstring", True),
-                "inOverriden": in_overriden,
+                "inOverridden": in_overridden,
                 "delimiter": update_parameter_delimiter(protocol_http.get("style")),
             }
         )

package/autorest/multiapi/templates/multiapi_service_client.py.jinja2

@@ -33,7 +33,7 @@ def __init__(
 
 class _SDKClient(object):
     def __init__(self, *args, **kwargs):
-        """This is a fake class to support current implemetation of MultiApiClientMixin."
+        """This is a fake class to support current implementation of MultiApiClientMixin."
         Will be removed in final version of multiapi azure-core based client
         """
         pass

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

@@ -313,7 +313,7 @@ class CodeModel:  # pylint: disable=too-many-public-methods, disable=too-many-in
         :param int schema_id: The yaml id of the schema
         :return: If created, we return the created schema, otherwise, we throw.
         :rtype: ~autorest.models.BaseType
-        :raises: KeyError if schema is not found
+        :raises KeyError: if schema is not found
         """
         try:
             return next(type for id, type in self.types_map.items() if id == schema_id)
@@ -402,3 +402,7 @@ class CodeModel:  # pylint: disable=too-many-public-methods, disable=too-many-in
     @property
     def is_legacy(self) -> bool:
         return _is_legacy(self.options)
+
+    @staticmethod
+    def has_non_json_models(models: List[ModelType]) -> bool:
+        return any(m for m in models if m.base != "json")

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

@@ -53,9 +53,10 @@ class CombinedType(BaseType):
         return self.yaml_data.get("clientDefaultValue")
 
     def description(self, *, is_operation_file: bool) -> str:
-        if len(self.types) == 2:
-            return f"Is either a {self.types[0].type_description} type or a {self.types[1].type_description} type."
-        return f"Is one of the following types: {', '.join([t.type_description for t in self.types])}"
+        type_descriptions = list({t.type_description: None for t in self.types}.keys())
+        if len(type_descriptions) == 2:
+            return f"Is either a {type_descriptions[0]} type or a {type_descriptions[1]} type."
+        return f"Is one of the following types: {', '.join(t for t in type_descriptions)}"
 
     def docstring_text(self, **kwargs: Any) -> str:
         return " or ".join(t.docstring_text(**kwargs) for t in self.types)

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

@@ -198,6 +198,10 @@ class KeyCredentialType(CredentialType[KeyCredentialPolicyType]):
     def type_annotation(self, **kwargs: Any) -> str:
         return self.policy.credential_name
 
+    @property
+    def type_description(self) -> str:
+        return "key credential"
+
     @property
     def instance_check_template(self) -> str:
         return "isinstance({}, " + f"{self.policy.credential_name})"

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

@@ -35,6 +35,7 @@ from .parameter import (
 )
 from .parameter_list import ParameterList
 from .model_type import ModelType
+from .primitive_types import BinaryIteratorType, BinaryType
 from .base import BaseType
 from .combined_type import CombinedType
 from .request_builder import OverloadedRequestBuilder, RequestBuilder
@@ -313,6 +314,10 @@ class OperationBase(  # pylint: disable=too-many-public-methods,too-many-instanc
             )
         return file_import
 
+    @property
+    def need_deserialize(self) -> bool:
+        return any(r.type and not isinstance(r.type, BinaryIteratorType) for r in self.responses)
+
     def imports(  # pylint: disable=too-many-branches, disable=too-many-statements
         self, async_mode: bool, **kwargs: Any
     ) -> FileImport:
@@ -432,7 +437,8 @@ class OperationBase(  # pylint: disable=too-many-public-methods,too-many-instanc
             file_import.add_submodule_import("typing", "overload", ImportType.STDLIB)
         if self.code_model.options["models_mode"] == "dpg":
             relative_path = self.code_model.get_relative_import_path(serialize_namespace, module_name="_model_base")
-            if self.parameters.has_body:
+            body_param = self.parameters.body_parameter if self.parameters.has_body else None
+            if body_param and not isinstance(body_param.type, BinaryType):
                 if self.has_form_data_body:
                     file_import.add_submodule_import(
                         self.code_model.get_relative_import_path(serialize_namespace), "_model_base", ImportType.LOCAL
@@ -450,9 +456,9 @@ class OperationBase(  # pylint: disable=too-many-public-methods,too-many-instanc
                         ImportType.LOCAL,
                     )
                     file_import.add_import("json", ImportType.STDLIB)
-            if any(xml_serializable(str(r.default_content_type)) for r in self.responses):
+            if any(xml_serializable(str(r.default_content_type)) for r in self.responses + self.exceptions):
                 file_import.add_submodule_import(relative_path, "_deserialize_xml", ImportType.LOCAL)
-            elif any(r.type for r in self.responses):
+            elif self.need_deserialize:
                 file_import.add_submodule_import(relative_path, "_deserialize", ImportType.LOCAL)
             if self.default_error_deserialization or self.non_default_errors:
                 file_import.add_submodule_import(relative_path, "_failsafe_deserialize", ImportType.LOCAL)

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

@@ -9,7 +9,7 @@ from .utils import OrderedSet
 
 from .base import BaseModel
 from .operation import get_operation
-from .imports import FileImport, ImportType, TypingSection
+from .imports import FileImport, ImportType, TypingSection, MsrestImportType
 from .utils import add_to_pylint_disable, NamespaceType
 from .lro_operation import LROOperation
 from .lro_paging_operation import LROPagingOperation
@@ -152,6 +152,31 @@ class OperationGroup(BaseModel):
                 f"{self.client.name}MixinABC",
                 ImportType.LOCAL,
             )
+        else:
+            file_import.add_submodule_import(
+                "" if self.code_model.is_azure_flavor else "runtime",
+                f"{'Async' if async_mode else ''}PipelineClient",
+                ImportType.SDKCORE,
+            )
+            file_import.add_submodule_import(
+                self.code_model.get_relative_import_path(
+                    serialize_namespace,
+                    self.code_model.get_imported_namespace_for_client(self.client.client_namespace, async_mode),
+                    module_name="_configuration",
+                ),
+                f"{self.client.name}Configuration",
+                ImportType.LOCAL,
+            )
+            file_import.add_msrest_import(
+                serialize_namespace=kwargs.get("serialize_namespace", self.code_model.namespace),
+                msrest_import_type=MsrestImportType.Serializer,
+                typing_section=TypingSection.REGULAR,
+            )
+            file_import.add_msrest_import(
+                serialize_namespace=kwargs.get("serialize_namespace", self.code_model.namespace),
+                msrest_import_type=MsrestImportType.SerializerDeserializer,
+                typing_section=TypingSection.REGULAR,
+            )
         if self.has_abstract_operations:
             file_import.add_submodule_import(
                 # raise_if_not_implemented is always defined in _vendor of top namespace

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

@@ -150,7 +150,7 @@ class PagingOperationBase(OperationBase[PagingResponseType]):
         if self.code_model.options["models_mode"] == "dpg":
             relative_path = self.code_model.get_relative_import_path(serialize_namespace, module_name="_model_base")
             file_import.merge(self.item_type.imports(**kwargs))
-            if self.default_error_deserialization or any(r.type for r in self.responses):
+            if self.default_error_deserialization or self.need_deserialize:
                 file_import.add_submodule_import(relative_path, "_deserialize", ImportType.LOCAL)
         return file_import
 

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

@@ -102,7 +102,7 @@ class Property(BaseModel):  # pylint: disable=too-many-instance-attributes
         if self.is_base_discriminator:
             return "str"
         types_type_annotation = self.type.type_annotation(is_operation_file=is_operation_file, **kwargs)
-        if self.optional and self.client_default_value is None:
+        if (self.optional and self.client_default_value is None) or self.readonly:
             return f"Optional[{types_type_annotation}]"
         return types_type_annotation
 
@@ -144,7 +144,7 @@ class Property(BaseModel):  # pylint: disable=too-many-instance-attributes
         if self.is_discriminator and isinstance(self.type, EnumType):
             return file_import
         file_import.merge(self.type.imports(**kwargs))
-        if self.optional and self.client_default_value is None:
+        if (self.optional and self.client_default_value is None) or self.readonly:
             file_import.add_submodule_import("typing", "Optional", ImportType.STDLIB)
         if self.code_model.options["models_mode"] == "dpg":
             serialize_namespace = kwargs.get("serialize_namespace", self.code_model.namespace)

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

@@ -130,10 +130,10 @@ class JinjaSerializer(ReaderAndWriter):
                 if self.code_model.options["package_mode"]:
                     self._serialize_and_write_package_files(client_namespace)
 
-                # write apiview_mapping_python.json
+                # write apiview-properties.json
                 if self.code_model.options.get("emit_cross_language_definition_file"):
                     self.write_file(
-                        exec_path / Path("apiview_mapping_python.json"),
+                        exec_path / Path("apiview-properties.json"),
                         general_serializer.serialize_cross_language_definition_file(),
                     )
 
@@ -159,7 +159,9 @@ class JinjaSerializer(ReaderAndWriter):
                 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"]:
+            if (
+                self.code_model.has_non_json_models(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,
@@ -181,6 +183,14 @@ class JinjaSerializer(ReaderAndWriter):
                 if self.code_model.options["multiapi"]:
                     self._serialize_and_write_metadata(env=env, namespace=client_namespace)
 
+            # if there are only operations under this namespace, we need to add general __init__.py into `aio` folder
+            # to make sure all generated files could be packed into .zip/.whl/.tgz package
+            if not client_namespace_type.clients and client_namespace_type.operation_groups and self.has_aio_folder:
+                self.write_file(
+                    exec_path / Path("aio/__init__.py"),
+                    general_serializer.serialize_pkgutil_init_file(),
+                )
+
     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:
@@ -228,9 +238,9 @@ class JinjaSerializer(ReaderAndWriter):
         self, env: Environment, namespace: str, models: List[ModelType], enums: List[EnumType]
     ) -> None:
         # Write the models folder
-        models_path = self.exec_path(namespace + ".models")
+        models_path = self.exec_path(namespace) / "models"
         serializer = DpgModelSerializer if self.code_model.options["models_mode"] == "dpg" else MsrestModelSerializer
-        if models:
+        if self.code_model.has_non_json_models(models):
             self.write_file(
                 models_path / Path(f"{self.code_model.models_filename}.py"),
                 serializer(code_model=self.code_model, env=env, client_namespace=namespace, models=models).serialize(),
@@ -469,7 +479,12 @@ class JinjaSerializer(ReaderAndWriter):
             else Path(".")
         )
 
+    def exec_path_for_test_sample(self, namespace: str) -> Path:
+        return self.exec_path_compensation / Path(*namespace.split("."))
+
     def exec_path(self, namespace: str) -> Path:
+        if self.code_model.options["no_namespace_folders"] and not self.code_model.options["multiapi"]:
+            return Path(".")
         return self.exec_path_compensation / Path(*namespace.split("."))
 
     @property
@@ -482,7 +497,7 @@ class JinjaSerializer(ReaderAndWriter):
         return Path("")
 
     def _serialize_and_write_sample(self, env: Environment, namespace: str):
-        out_path = self.exec_path(namespace) / Path("generated_samples")
+        out_path = self.exec_path_for_test_sample(namespace) / Path("generated_samples")
         for client in self.code_model.clients:
             for op_group in client.operation_groups:
                 for operation in op_group.operations:
@@ -516,7 +531,7 @@ class JinjaSerializer(ReaderAndWriter):
 
     def _serialize_and_write_test(self, env: Environment, namespace: str):
         self.code_model.for_test = True
-        out_path = self.exec_path(namespace) / Path("generated_tests")
+        out_path = self.exec_path_for_test_sample(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"]:

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

@@ -498,7 +498,11 @@ class RequestBuilderSerializer(_BuilderBaseSerializer[RequestBuilderType]):
             url_value = _escape_str(builder.url)
         else:
             url_value = f'kwargs.pop("template_url", {_escape_str(builder.url)})'
-        return f"_url = {url_value}{'  # pylint: disable=line-too-long' if len(url_value) > 114 else ''}"
+        result = "_url = " + url_value
+        # there will be always 4 spaces before the url
+        if len(result) + 4 > 120:
+            return result + "  # pylint: disable=line-too-long"
+        return result
 
 
 ############################## NORMAL OPERATIONS ##############################
@@ -1001,7 +1005,7 @@ class _OperationSerializer(_BuilderBaseSerializer[OperationType]):
                 retval.extend(deserialize_code)
         return retval
 
-    def handle_error_response(self, builder: OperationType) -> List[str]:
+    def handle_error_response(self, builder: OperationType) -> List[str]:   # pylint: disable=too-many-statements, too-many-branches
         async_await = "await " if self.async_mode else ""
         retval = [f"if response.status_code not in {str(builder.success_status_codes)}:"]
         response_read = [
@@ -1075,7 +1079,14 @@ class _OperationSerializer(_BuilderBaseSerializer[OperationType]):
                         is_operation_file=True, skip_quote=True, serialize_namespace=self.serialize_namespace
                     )
                     if self.code_model.options["models_mode"] == "dpg":
-                        retval.append(f"        error = _failsafe_deserialize({type_annotation},  response.json())")
+                        if xml_serializable(str(e.default_content_type)):
+                            retval.append(
+                                f"        error = _failsafe_deserialize_xml({type_annotation},  response.text())"
+                            )
+                        else:
+                            retval.append(
+                                f"        error = _failsafe_deserialize({type_annotation},  response.json())"
+                            )
                     else:
                         retval.append(
                             f"        error = self._deserialize.failsafe_deserialize({type_annotation}, "

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

@@ -192,7 +192,8 @@ class MsrestModelSerializer(_ModelSerializer):
             if prop.is_discriminator:
                 init_args.append(self.initialize_discriminator_property(model, prop))
             elif prop.readonly:
-                init_args.append(f"self.{prop.client_name} = None")
+                # we want typing for readonly since typing isn't provided from the command line
+                init_args.append(f"self.{prop.client_name}: {prop.type_annotation()} = None")
             elif not prop.constant:
                 init_args.append(f"self.{prop.client_name} = {prop.client_name}")
         return init_args

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

@@ -89,4 +89,5 @@ class OperationGroupsSerializer(BaseSerializer):
                 client_namespace=self.client_namespace,
             ),
             get_request_builders=self._get_request_builders,
+            need_declare_serializer=any(operation_group.operations for operation_group in self.operation_groups),
         )

package/generator/build/lib/pygen/codegen/templates/model_base.py.jinja2

@@ -372,15 +372,34 @@ class _MyMutableMapping(MutableMapping[str, typing.Any]):  # pylint: disable=uns
         return not self.__eq__(other)
 
     def keys(self) -> typing.KeysView[str]:
+        """
+        :returns: a set-like object providing a view on D's keys
+        :rtype: ~typing.KeysView
+        """
         return self._data.keys()
 
     def values(self) -> typing.ValuesView[typing.Any]:
+        """
+        :returns: an object providing a view on D's values
+        :rtype: ~typing.ValuesView
+        """
         return self._data.values()
 
     def items(self) -> typing.ItemsView[str, typing.Any]:
+        """
+        :returns: set-like object providing a view on D's items
+        :rtype: ~typing.ItemsView
+        """
         return self._data.items()
 
     def get(self, key: str, default: typing.Any = None) -> typing.Any:
+        """
+        Get the value for key if key is in the dictionary, else default.
+        :param str key: The key to look up.
+        :param any default: The value to return if key is not in the dictionary. Defaults to None
+        :returns: D[k] if k in D, else d.
+        :rtype: any
+        """
         try:
             return self[key]
         except KeyError:
@@ -396,17 +415,38 @@ class _MyMutableMapping(MutableMapping[str, typing.Any]):  # pylint: disable=uns
     def pop(self, key: str, default: typing.Any) -> typing.Any: ...
 
     def pop(self, key: str, default: typing.Any = _UNSET) -> typing.Any:
+        """
+        Removes specified key and return the corresponding value.
+        :param str key: The key to pop.
+        :param any default: The value to return if key is not in the dictionary
+        :returns: The value corresponding to the key.
+        :rtype: any
+        :raises KeyError: If key is not found and default is not given.
+        """
         if default is _UNSET:
             return self._data.pop(key)
         return self._data.pop(key, default)
 
     def popitem(self) -> typing.Tuple[str, typing.Any]:
+        """
+        Removes and returns some (key, value) pair
+        :returns: The (key, value) pair.
+        :rtype: tuple
+        :raises KeyError: if D is empty.
+        """
         return self._data.popitem()
 
     def clear(self) -> None:
+        """
+        Remove all items from D.
+        """
         self._data.clear()
 
     def update(self, *args: typing.Any, **kwargs: typing.Any) -> None:
+        """
+        Updates D from mapping/iterable E and F.
+        :param any args: Either a mapping object or an iterable of key-value pairs.
+        """
         self._data.update(*args, **kwargs)
 
     @typing.overload
@@ -416,6 +456,13 @@ class _MyMutableMapping(MutableMapping[str, typing.Any]):  # pylint: disable=uns
     def setdefault(self, key: str, default: typing.Any) -> typing.Any: ...
 
     def setdefault(self, key: str, default: typing.Any = _UNSET) -> typing.Any:
+        """
+        Same as calling D.get(k, d), and setting D[k]=d if k not found
+        :param str key: The key to look up.
+        :param any default: The value to set if key is not in the dictionary
+        :returns: D[k] if k in D, else d.
+        :rtype: any
+        """
         if default is _UNSET:
             return self._data.setdefault(key)
         return self._data.setdefault(key, default)
@@ -909,6 +956,20 @@ def _failsafe_deserialize(
       return None
 
 
+def _failsafe_deserialize_xml(
+  deserializer: typing.Any,
+  value: typing.Any,
+) -> typing.Any:
+  try:
+      return _deserialize_xml(deserializer, value)
+  except DeserializationError:
+      _LOGGER.warning(
+          "Ran into a deserialization error. Ignoring since this is failsafe deserialization",
+          exc_info=True
+      )
+      return None
+
+
 class _RestField:
     def __init__(
         self,

package/generator/build/lib/pygen/codegen/templates/operation_group.py.jinja2

@@ -31,10 +31,10 @@ class {{ operation_group.class_name }}: {{ operation_group.pylint_disable() }}
 {% endif %}
     def __init__(self, *args, **kwargs){{ return_none_type_annotation }}:
         input_args = list(args)
-        self._client = input_args.pop(0) if input_args else kwargs.pop("client")
-        self._config = input_args.pop(0) if input_args else kwargs.pop("config")
-        self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer")
-        self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer")
+        self._client: {{ 'Async' if async_mode else ''}}PipelineClient = input_args.pop(0) if input_args else kwargs.pop("client")
+        self._config: {{ operation_group.client.name }}Configuration = input_args.pop(0) if input_args else kwargs.pop("config")
+        self._serialize: Serializer = input_args.pop(0) if input_args else kwargs.pop("serializer")
+        self._deserialize: Deserializer = input_args.pop(0) if input_args else kwargs.pop("deserializer")
         {% if code_model.options["multiapi"] %}
         self._api_version = input_args.pop(0) if input_args else kwargs.pop("api_version")
         {% endif %}

package/generator/build/lib/pygen/codegen/templates/operation_groups_container.py.jinja2

@@ -6,7 +6,9 @@
 {{ imports }}
 {{ unset }}
 {% if code_model.options["builders_visibility"] == "embedded" and not async_mode %}
+  {% if need_declare_serializer %}
 {{ op_tools.declare_serializer(code_model) }}
+  {% endif %}
     {% for operation_group in operation_groups %}
         {% for request_builder in get_request_builders(operation_group) %}