@autorest/python 6.28.0 → 6.28.2

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

@@ -47,9 +47,7 @@ from typing import (
     IO,
     Mapping,
     Callable,
-    TypeVar,
     MutableMapping,
-    Type,
     List,
 )
 
@@ -60,13 +58,13 @@ except ImportError:
 import xml.etree.ElementTree as ET
 
 import isodate  # type: ignore
+from typing_extensions import Self
 
 from {{ code_model.core_library }}.exceptions import DeserializationError, SerializationError
 from {{ code_model.core_library }}.serialization import NULL as CoreNull
 
 _BOM = codecs.BOM_UTF8.decode(encoding="utf-8")
 
-ModelType = TypeVar("ModelType", bound="Model")
 JSON = MutableMapping[str, Any]
 
 
@@ -184,73 +182,7 @@ try:
 except NameError:
     _long_type = int
 
-
-class UTC(datetime.tzinfo):
-    """Time Zone info for handling UTC"""
-
-    def utcoffset(self, dt):
-        """UTF offset for UTC is 0.
-
-        :param datetime.datetime dt: The datetime
-        :returns: The offset
-        :rtype: datetime.timedelta
-        """
-        return datetime.timedelta(0)
-
-    def tzname(self, dt):
-        """Timestamp representation.
-
-        :param datetime.datetime dt: The datetime
-        :returns: The timestamp representation
-        :rtype: str
-        """
-        return "Z"
-
-    def dst(self, dt):
-        """No daylight saving for UTC.
-
-        :param datetime.datetime dt: The datetime
-        :returns: The daylight saving time
-        :rtype: datetime.timedelta
-        """
-        return datetime.timedelta(hours=1)
-
-
-try:
-    from datetime import timezone as _FixedOffset  # type: ignore
-except ImportError:  # Python 2.7
-
-    class _FixedOffset(datetime.tzinfo):  # type: ignore
-        """Fixed offset in minutes east from UTC.
-        Copy/pasted from Python doc
-        :param datetime.timedelta offset: offset in timedelta format
-        """
-
-        def __init__(self, offset) -> None:
-            self.__offset = offset
-
-        def utcoffset(self, dt):
-            return self.__offset
-
-        def tzname(self, dt):
-            return str(self.__offset.total_seconds() / 3600)
-
-        def __repr__(self):
-            return "<FixedOffset {}>".format(self.tzname(None))
-
-        def dst(self, dt):
-            return datetime.timedelta(0)
-
-        def __getinitargs__(self):
-            return (self.__offset,)
-
-
-try:
-    from datetime import timezone
-
-    TZ_UTC = timezone.utc
-except ImportError:
-    TZ_UTC = UTC()  # type: ignore
+TZ_UTC = datetime.timezone.utc
 
 _FLATTEN = re.compile(r"(?<!\\)\.")
 
@@ -449,25 +381,25 @@ class Model:
         return client_models
 
     @classmethod
-    def deserialize(cls: Type[ModelType], data: Any, content_type: Optional[str] = None) -> ModelType:
+    def deserialize(cls, data: Any, content_type: Optional[str] = None) -> Self:
         """Parse a str using the RestAPI syntax and return a model.
 
         :param str data: A str using RestAPI structure. JSON by default.
         :param str content_type: JSON by default, set application/xml if XML.
         :returns: An instance of this model
-        :raises: DeserializationError if something went wrong
-        :rtype: ModelType
+        :raises DeserializationError: if something went wrong
+        :rtype: Self
         """
         deserializer = Deserializer(cls._infer_class_models())
         return deserializer(cls.__name__, data, content_type=content_type)  # type: ignore
 
     @classmethod
     def from_dict(
-        cls: Type[ModelType],
+        cls,
         data: Any,
         key_extractors: Optional[Callable[[str, Dict[str, Any], Any], Any]] = None,
         content_type: Optional[str] = None,
-    ) -> ModelType:
+    ) -> Self:
         """Parse a dict using given key extractor return a model.
 
         By default consider key
@@ -479,7 +411,7 @@ class Model:
         :param str content_type: JSON by default, set application/xml if XML.
         :returns: An instance of this model
         :raises: DeserializationError if something went wrong
-        :rtype: ModelType
+        :rtype: Self
         """
         deserializer = Deserializer(cls._infer_class_models())
         deserializer.key_extractors = (  # type: ignore
@@ -625,7 +557,7 @@ class Serializer:  # pylint: disable=too-many-public-methods
         :param object target_obj: The data to be serialized.
         :param str data_type: The type to be serialized from.
         :rtype: str, dict
-        :raises: SerializationError if serialization fails.
+        :raises SerializationError: if serialization fails.
         :returns: The serialized data.
         """
         key_transformer = kwargs.get("key_transformer", self.key_transformer)
@@ -735,8 +667,8 @@ class Serializer:  # pylint: disable=too-many-public-methods
         :param object data: The data to be serialized.
         :param str data_type: The type to be serialized from.
         :rtype: dict
-        :raises: SerializationError if serialization fails.
-        :raises: ValueError if data is None
+        :raises SerializationError: if serialization fails.
+        :raises ValueError: if data is None
         :returns: The serialized request body
         """
 
@@ -780,8 +712,8 @@ class Serializer:  # pylint: disable=too-many-public-methods
         :param str data_type: The type to be serialized from.
         :rtype: str
         :returns: The serialized URL path
-        :raises: TypeError if serialization fails.
-        :raises: ValueError if data is None
+        :raises TypeError: if serialization fails.
+        :raises ValueError: if data is None
         """
         try:
             output = self.serialize_data(data, data_type, **kwargs)
@@ -804,8 +736,8 @@ class Serializer:  # pylint: disable=too-many-public-methods
         :param object data: The data to be serialized.
         :param str data_type: The type to be serialized from.
         :rtype: str, list
-        :raises: TypeError if serialization fails.
-        :raises: ValueError if data is None
+        :raises TypeError: if serialization fails.
+        :raises ValueError: if data is None
         :returns: The serialized query parameter
         """
         try:
@@ -834,8 +766,8 @@ class Serializer:  # pylint: disable=too-many-public-methods
         :param object data: The data to be serialized.
         :param str data_type: The type to be serialized from.
         :rtype: str
-        :raises: TypeError if serialization fails.
-        :raises: ValueError if data is None
+        :raises TypeError: if serialization fails.
+        :raises ValueError: if data is None
         :returns: The serialized header
         """
         try:
@@ -854,9 +786,9 @@ class Serializer:  # pylint: disable=too-many-public-methods
 
         :param object data: The data to be serialized.
         :param str data_type: The type to be serialized from.
-        :raises: AttributeError if required data is None.
-        :raises: ValueError if data is None
-        :raises: SerializationError if serialization fails.
+        :raises AttributeError: if required data is None.
+        :raises ValueError: if data is None
+        :raises SerializationError: if serialization fails.
         :returns: The serialized data.
         :rtype: str, int, float, bool, dict, list
         """
@@ -1191,7 +1123,7 @@ class Serializer:  # pylint: disable=too-many-public-methods
 
         :param Datetime attr: Object to be serialized.
         :rtype: str
-        :raises: TypeError if format invalid.
+        :raises TypeError: if format invalid.
         :return: serialized rfc
         """
         try:
@@ -1217,7 +1149,7 @@ class Serializer:  # pylint: disable=too-many-public-methods
 
         :param Datetime attr: Object to be serialized.
         :rtype: str
-        :raises: SerializationError if format invalid.
+        :raises SerializationError: if format invalid.
         :return: serialized iso
         """
         if isinstance(attr, str):
@@ -1250,7 +1182,7 @@ class Serializer:  # pylint: disable=too-many-public-methods
 
         :param Datetime attr: Object to be serialized.
         :rtype: int
-        :raises: SerializationError if format invalid
+        :raises SerializationError: if format invalid
         :return: serialied unix
         """
         if isinstance(attr, int):
@@ -1487,7 +1419,7 @@ class Deserializer:
         :param str target_obj: Target data type to deserialize to.
         :param requests.Response response_data: REST response object.
         :param str content_type: Swagger "produces" if available.
-        :raises: DeserializationError if deserialization fails.
+        :raises DeserializationError: if deserialization fails.
         :return: Deserialized object.
         :rtype: object
         """
@@ -1501,7 +1433,7 @@ class Deserializer:
 
         :param str target_obj: Target data type to deserialize to.
         :param object data: Object to deserialize.
-        :raises: DeserializationError if deserialization fails.
+        :raises DeserializationError: if deserialization fails.
         :return: Deserialized object.
         :rtype: object
         """
@@ -1716,7 +1648,7 @@ class Deserializer:
 
         :param str data: The response string to be deserialized.
         :param str data_type: The type to deserialize to.
-        :raises: DeserializationError if deserialization fails.
+        :raises DeserializationError: if deserialization fails.
         :return: Deserialized object.
         :rtype: object
         """
@@ -1798,7 +1730,7 @@ class Deserializer:
         :param dict attr: Dictionary to be deserialized.
         :return: Deserialized object.
         :rtype: dict
-        :raises: TypeError if non-builtin datatype encountered.
+        :raises TypeError: if non-builtin datatype encountered.
         """
         if attr is None:
             return None
@@ -1844,7 +1776,7 @@ class Deserializer:
         :param str data_type: deserialization data type.
         :return: Deserialized basic type.
         :rtype: str, int, float or bool
-        :raises: TypeError if string format is not valid.
+        :raises TypeError: if string format is not valid.
         """
         # If we're here, data is supposed to be a basic type.
         # If it's still an XML node, take the text
@@ -1935,7 +1867,7 @@ class Deserializer:
         :param str attr: response string to be deserialized.
         :return: Deserialized bytearray
         :rtype: bytearray
-        :raises: TypeError if string format invalid.
+        :raises TypeError: if string format invalid.
         """
         if isinstance(attr, ET.Element):
             attr = attr.text
@@ -1948,7 +1880,7 @@ class Deserializer:
         :param str attr: response string to be deserialized.
         :return: Deserialized base64 string
         :rtype: bytearray
-        :raises: TypeError if string format invalid.
+        :raises TypeError: if string format invalid.
         """
         if isinstance(attr, ET.Element):
             attr = attr.text
@@ -1963,7 +1895,7 @@ class Deserializer:
 
         :param str attr: response string to be deserialized.
         :return: Deserialized decimal
-        :raises: DeserializationError if string format invalid.
+        :raises DeserializationError: if string format invalid.
         :rtype: decimal
         """
         if isinstance(attr, ET.Element):
@@ -1981,7 +1913,7 @@ class Deserializer:
         :param str attr: response string to be deserialized.
         :return: Deserialized int
         :rtype: long or int
-        :raises: ValueError if string format invalid.
+        :raises ValueError: if string format invalid.
         """
         if isinstance(attr, ET.Element):
             attr = attr.text
@@ -1994,7 +1926,7 @@ class Deserializer:
         :param str attr: response string to be deserialized.
         :return: Deserialized duration
         :rtype: TimeDelta
-        :raises: DeserializationError if string format invalid.
+        :raises DeserializationError: if string format invalid.
         """
         if isinstance(attr, ET.Element):
             attr = attr.text
@@ -2012,7 +1944,7 @@ class Deserializer:
         :param str attr: response string to be deserialized.
         :return: Deserialized date
         :rtype: Date
-        :raises: DeserializationError if string format invalid.
+        :raises DeserializationError: if string format invalid.
         """
         if isinstance(attr, ET.Element):
             attr = attr.text
@@ -2028,7 +1960,7 @@ class Deserializer:
         :param str attr: response string to be deserialized.
         :return: Deserialized time
         :rtype: datetime.time
-        :raises: DeserializationError if string format invalid.
+        :raises DeserializationError: if string format invalid.
         """
         if isinstance(attr, ET.Element):
             attr = attr.text
@@ -2043,14 +1975,14 @@ class Deserializer:
         :param str attr: response string to be deserialized.
         :return: Deserialized RFC datetime
         :rtype: Datetime
-        :raises: DeserializationError if string format invalid.
+        :raises DeserializationError: if string format invalid.
         """
         if isinstance(attr, ET.Element):
             attr = attr.text
         try:
             parsed_date = email.utils.parsedate_tz(attr)  # type: ignore
             date_obj = datetime.datetime(
-                *parsed_date[:6], tzinfo=_FixedOffset(datetime.timedelta(minutes=(parsed_date[9] or 0) / 60))
+                *parsed_date[:6], tzinfo=datetime.timezone(datetime.timedelta(minutes=(parsed_date[9] or 0) / 60))
             )
             if not date_obj.tzinfo:
                 date_obj = date_obj.astimezone(tz=TZ_UTC)
@@ -2066,7 +1998,7 @@ class Deserializer:
         :param str attr: response string to be deserialized.
         :return: Deserialized ISO datetime
         :rtype: Datetime
-        :raises: DeserializationError if string format invalid.
+        :raises DeserializationError: if string format invalid.
         """
         if isinstance(attr, ET.Element):
             attr = attr.text
@@ -2104,7 +2036,7 @@ class Deserializer:
         :param int attr: Object to be serialized.
         :return: Deserialized datetime
         :rtype: Datetime
-        :raises: DeserializationError if format invalid
+        :raises DeserializationError: if format invalid
         """
         if isinstance(attr, ET.Element):
             attr = int(attr.text)  # type: ignore

package/generator/build/lib/pygen/preprocess/__init__.py

@@ -92,9 +92,9 @@ def add_overloads_for_body_param(yaml_data: Dict[str, Any]) -> None:
     for body_type in body_parameter["type"]["types"]:
         if any(o for o in yaml_data["overloads"] if id(o["bodyParameter"]["type"]) == id(body_type)):
             continue
-        yaml_data["overloads"].append(add_overload(yaml_data, body_type))
         if body_type.get("type") == "model" and body_type.get("base") == "json":
             yaml_data["overloads"].append(add_overload(yaml_data, body_type, for_flatten_params=True))
+        yaml_data["overloads"].append(add_overload(yaml_data, body_type))
     content_type_param = next(p for p in yaml_data["parameters"] if p["wireName"].lower() == "content-type")
     content_type_param["inOverload"] = False
     content_type_param["inOverridden"] = True

package/generator/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/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/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/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/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/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/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/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/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}, "