@autorest/python 6.2.11 → 6.2.15

package/autorest/__init__.py

@@ -25,7 +25,9 @@ class ReaderAndWriter:
         self._list_file: List[str] = []
         try:
             with open(
-                Path(self.output_folder) / Path("..") / Path("python.json"), "r"
+                Path(self.output_folder) / Path("..") / Path("python.json"),
+                "r",
+                encoding="utf-8-sig",
             ) as fd:
                 python_json = json.load(fd)
         except Exception:  # pylint: disable=broad-except
@@ -41,7 +43,7 @@ class ReaderAndWriter:
         """Directly reading from disk"""
         # make path relative to output folder
         try:
-            with open(self.output_folder / Path(path), "r") as fd:
+            with open(self.output_folder / Path(path), "r", encoding="utf-8-sig") as fd:
                 return fd.read()
         except FileNotFoundError:
             return ""
@@ -51,7 +53,7 @@ class ReaderAndWriter:
         file_folder = Path(filename).parent
         if not Path.is_dir(self.output_folder / file_folder):
             Path.mkdir(self.output_folder / file_folder, parents=True)
-        with open(self.output_folder / Path(filename), "w") as fd:
+        with open(self.output_folder / Path(filename), "w", encoding="utf-8") as fd:
             fd.write(file_content)
 
     def list_file(self) -> List[str]:
@@ -111,11 +113,11 @@ class YamlUpdatePlugin(Plugin):
 
     def get_yaml(self) -> Dict[str, Any]:
         # cadl file doesn't have to be relative to output folder
-        with open(self.options["cadl_file"], "r") as fd:
+        with open(self.options["cadl_file"], "r", encoding="utf-8-sig") as fd:
             return yaml.safe_load(fd.read())
 
     def write_yaml(self, yaml_string: str) -> None:
-        with open(self.options["cadl_file"], "w") as fd:
+        with open(self.options["cadl_file"], "w", encoding="utf-8-sig") as fd:
             fd.write(yaml_string)
 
     def process(self) -> bool:

package/autorest/_utils.py

@@ -77,7 +77,13 @@ def parse_args(
         return value
 
     unknown_args_ret = {
-        ua.strip("--").split("=")[0]: _get_value(ua.strip("--").split("=")[1])
+        ua.strip("--").split("=", maxsplit=1)[  # pylint: disable=bad-str-strip-call
+            0
+        ]: _get_value(
+            ua.strip("--").split("=", maxsplit=1)[  # pylint: disable=bad-str-strip-call
+                1
+            ]
+        )
         for ua in unknown_args
     }
     return args, unknown_args_ret

package/autorest/black/__init__.py

@@ -31,7 +31,12 @@ class BlackScriptPlugin(Plugin):  # pylint: disable=abstract-method
 
     def process(self) -> bool:
         # apply format_file on every file in the output folder
-        list(map(self.format_file, [Path(f) for f in self.list_file()]))
+        list(
+            map(
+                self.format_file,
+                [Path(f) for f in self.list_file() if "__pycache__" not in f],
+            )
+        )
         return True
 
     def format_file(self, file: Path) -> None:

package/autorest/codegen/__init__.py

@@ -186,7 +186,7 @@ class CodeGenerator(Plugin):
 
     def get_yaml(self) -> Dict[str, Any]:
         # cadl file doesn't have to be relative to output folder
-        with open(self.options["cadl_file"], "r") as fd:
+        with open(self.options["cadl_file"], "r", encoding="utf-8-sig") as fd:
             return yaml.safe_load(fd.read())
 
     def get_serializer(self, code_model: CodeModel):

package/autorest/codegen/models/__init__.py

@@ -9,7 +9,7 @@ from .base import BaseModel
 from .base_builder import BaseBuilder
 from .code_model import CodeModel
 from .client import Client
-from .model_type import ModelType
+from .model_type import ModelType, JSONModelType, DPGModelType, MsrestModelType
 from .dictionary_type import DictionaryType
 from .list_type import ListType
 from .combined_type import CombinedType
@@ -156,7 +156,13 @@ def build_type(yaml_data: Dict[str, Any], code_model: CodeModel) -> BaseType:
         pass
     if yaml_data["type"] == "model":
         # need to special case model to avoid recursion
-        response = ModelType(yaml_data, code_model)
+        if yaml_data["base"] == "json" or not code_model.options["models_mode"]:
+            model_type = JSONModelType
+        elif yaml_data["base"] == "dpg":
+            model_type = DPGModelType  # type: ignore
+        else:
+            model_type = MsrestModelType  # type: ignore
+        response = model_type(yaml_data, code_model)
         code_model.types_map[yaml_id] = response
         response.fill_instance_from_yaml(yaml_data, code_model)
     else:

package/autorest/codegen/models/base.py

@@ -52,9 +52,7 @@ class BaseType(BaseModel, ABC):  # pylint: disable=too-many-public-methods
     ) -> "BaseType":
         return cls(yaml_data=yaml_data, code_model=code_model)
 
-    def imports(  # pylint: disable=no-self-use
-        self, **kwargs  # pylint: disable=unused-argument
-    ) -> FileImport:
+    def imports(self, **kwargs) -> FileImport:  # pylint: disable=unused-argument
         return FileImport()
 
     def imports_for_multiapi(self, **kwargs: Any) -> FileImport:
@@ -91,7 +89,7 @@ class BaseType(BaseModel, ABC):  # pylint: disable=too-many-public-methods
         if self.xml_metadata.get("namespace", False):
             attrs_list.append(f"'ns': '{self.xml_metadata['namespace']}'")
         if self.xml_metadata.get("text"):
-            attrs_list.append(f"'text': True")
+            attrs_list.append("'text': True")
         return ", ".join(attrs_list)
 
     @property
@@ -106,7 +104,6 @@ class BaseType(BaseModel, ABC):  # pylint: disable=too-many-public-methods
         If list: '[str]'
         If dict: '{str}'
         """
-        ...
         raise NotImplementedError()
 
     @property
@@ -121,12 +118,10 @@ class BaseType(BaseModel, ABC):  # pylint: disable=too-many-public-methods
     @abstractmethod
     def description(self, *, is_operation_file: bool) -> str:
         """The description"""
-        ...
 
     @abstractmethod
     def docstring_text(self, **kwargs: Any) -> str:
         """The names used in rtype documentation"""
-        ...
 
     @abstractmethod
     def docstring_type(self, **kwargs: Any) -> str:
@@ -134,7 +129,6 @@ class BaseType(BaseModel, ABC):  # pylint: disable=too-many-public-methods
 
         Special case for enum, for instance: 'str or ~namespace.EnumName'
         """
-        ...
 
     @abstractmethod
     def type_annotation(self, **kwargs: Any) -> str:
@@ -142,7 +136,6 @@ class BaseType(BaseModel, ABC):  # pylint: disable=too-many-public-methods
 
         Special case for enum, for instance: Union[str, "EnumName"]
         """
-        ...
 
     @property
     def validation(self) -> Optional[Dict[str, Any]]:
@@ -153,7 +146,7 @@ class BaseType(BaseModel, ABC):  # pylint: disable=too-many-public-methods
         """
         return None
 
-    def get_declaration(self, value: Any) -> str:  # pylint: disable=no-self-use
+    def get_declaration(self, value: Any) -> str:
         """Return the current value from YAML as a Python string that represents the constant.
 
         Example, if schema is "bytearray" and value is "foo",
@@ -175,9 +168,8 @@ class BaseType(BaseModel, ABC):  # pylint: disable=too-many-public-methods
         description: Optional[str] = None,
     ) -> Any:
         """Template of what this schema would look like as JSON input"""
-        ...
 
-    def get_polymorphic_subtypes(  # pylint: disable=no-self-use
+    def get_polymorphic_subtypes(
         self, polymorphic_subtypes: List["ModelType"]  # pylint: disable=unused-argument
     ) -> None:
         return None
@@ -186,7 +178,6 @@ class BaseType(BaseModel, ABC):  # pylint: disable=too-many-public-methods
     @abstractmethod
     def instance_check_template(self) -> str:
         """Template of what an instance check of a variable for this type would look like"""
-        ...
 
     @property
     def serialization_constraints(self) -> List[str]:

package/autorest/codegen/models/client.py

@@ -155,8 +155,10 @@ class Client(_ClientConfigBase[ClientGlobalParameterList]):
                 for rb in self.request_builders
                 if id(rb.yaml_data) == request_builder_id
             )
-        except StopIteration:
-            raise KeyError(f"No request builder with id {request_builder_id} found.")
+        except StopIteration as exc:
+            raise KeyError(
+                f"No request builder with id {request_builder_id} found."
+            ) from exc
 
     def _imports_shared(self, async_mode: bool) -> FileImport:
         file_import = FileImport()
@@ -207,20 +209,16 @@ class Client(_ClientConfigBase[ClientGlobalParameterList]):
     def has_lro_operations(self) -> bool:
         """Are there any LRO operations in this SDK?"""
         return any(
-            [
-                operation.operation_type in ("lro", "lropaging")
-                for operation_group in self.operation_groups
-                for operation in operation_group.operations
-            ]
+            operation.operation_type in ("lro", "lropaging")
+            for operation_group in self.operation_groups
+            for operation in operation_group.operations
         )
 
     @property
     def has_operations(self) -> bool:
         return any(
-            [
-                bool(operation_group.operations)
-                for operation_group in self.operation_groups
-            ]
+            bool(operation_group.operations)
+            for operation_group in self.operation_groups
         )
 
     def format_lro_operations(self) -> None:

package/autorest/codegen/models/code_model.py

@@ -172,8 +172,8 @@ class CodeModel:  # pylint: disable=too-many-public-methods
         """
         try:
             return next(type for id, type in self.types_map.items() if id == schema_id)
-        except StopIteration:
-            raise KeyError(f"Couldn't find schema with id {schema_id}")
+        except StopIteration as exc:
+            raise KeyError(f"Couldn't find schema with id {schema_id}") from exc
 
     @property
     def model_types(self) -> List[ModelType]:
@@ -190,7 +190,7 @@ class CodeModel:  # pylint: disable=too-many-public-methods
 
     @property
     def public_model_types(self) -> List[ModelType]:
-        return [m for m in self.model_types if m.is_public]
+        return [m for m in self.model_types if m.is_public and not m.base == "json"]
 
     @property
     def enums(self) -> List[EnumType]:

package/autorest/codegen/models/combined_type.py

@@ -79,9 +79,10 @@ class CombinedType(BaseType):
         client_default_value_declaration: Optional[str] = None,
         description: Optional[str] = None,
     ) -> Any:
-        """Template of what this schema would look like as JSON input"""
-        raise ValueError(
-            "You shouldn't get a JSON template representation of multiple types"
+        return self.types[0].get_json_template_representation(
+            optional=optional,
+            client_default_value_declaration=client_default_value_declaration,
+            description=description,
         )
 
     def get_polymorphic_subtypes(self, polymorphic_subtypes: List["ModelType"]) -> None:

package/autorest/codegen/models/credential_types.py

@@ -38,7 +38,6 @@ class _CredentialPolicyBaseType:
         """
         How to call this credential policy. Used to initialize the credential policy in the config file.
         """
-        ...
 
 
 class BearerTokenCredentialPolicyType(_CredentialPolicyBaseType):
@@ -158,17 +157,17 @@ class TokenCredentialType(
 ):
     """Type of a token credential. Used by BearerAuth and ARMChallenge policies"""
 
-    def type_annotation(self, **kwargs: Any) -> str:  # pylint: disable=no-self-use
+    def type_annotation(self, **kwargs: Any) -> str:
         if kwargs.get("async_mode"):
             return '"AsyncTokenCredential"'
         return '"TokenCredential"'
 
-    def docstring_type(self, **kwargs: Any) -> str:  # pylint: disable=no-self-use
+    def docstring_type(self, **kwargs: Any) -> str:
         if kwargs.get("async_mode"):
             return "~azure.core.credentials_async.AsyncTokenCredential"
         return "~azure.core.credentials.TokenCredential"
 
-    def imports(self, **kwargs: Any) -> FileImport:  # pylint: disable=no-self-use
+    def imports(self, **kwargs: Any) -> FileImport:
         file_import = FileImport()
         if kwargs.get("async_mode"):
             file_import.add_submodule_import(
@@ -188,7 +187,7 @@ class TokenCredentialType(
 
     @property
     def instance_check_template(self) -> str:
-        return "hasattr({}, get_token)"
+        return "hasattr({}, 'get_token')"
 
 
 class AzureKeyCredentialType(
@@ -197,23 +196,17 @@ class AzureKeyCredentialType(
 ):
     """Type for an AzureKeyCredential"""
 
-    def docstring_type(  # pylint: disable=no-self-use
-        self, **kwargs: Any  # pylint: disable=unused-argument
-    ) -> str:
+    def docstring_type(self, **kwargs: Any) -> str:  # pylint: disable=unused-argument
         return "~azure.core.credentials.AzureKeyCredential"
 
-    def type_annotation(  # pylint: disable=no-self-use
-        self, **kwargs: Any  # pylint: disable=unused-argument
-    ) -> str:
+    def type_annotation(self, **kwargs: Any) -> str:  # pylint: disable=unused-argument
         return "AzureKeyCredential"
 
     @property
     def instance_check_template(self) -> str:
         return "isinstance({}, AzureKeyCredential)"
 
-    def imports(  # pylint: disable=no-self-use
-        self, **kwargs: Any  # pylint: disable=unused-argument
-    ) -> FileImport:
+    def imports(self, **kwargs: Any) -> FileImport:  # pylint: disable=unused-argument
         file_import = FileImport()
         file_import.add_submodule_import(
             "azure.core.credentials",

package/autorest/codegen/models/dictionary_type.py

@@ -73,7 +73,7 @@ class DictionaryType(BaseType):
         description: Optional[str] = None,
     ) -> Any:
         return {
-            f'"str"': self.element_type.get_json_template_representation(
+            '"str"': self.element_type.get_json_template_representation(
                 optional=optional,
                 client_default_value_declaration=client_default_value_declaration,
                 description=description,

package/autorest/codegen/models/imports.py

@@ -228,7 +228,7 @@ class FileImport:
                     ],
                 ],
             ],
-        ] = dict()
+        ] = {}
         for i in self.imports:
             name_import: Optional[
                 Union[
@@ -248,8 +248,8 @@ class FileImport:
                     name_import = (i.submodule_name, i.alias)
                 else:
                     name_import = i.submodule_name
-            retval.setdefault(i.typing_section, dict()).setdefault(
-                i.import_type, dict()
+            retval.setdefault(i.typing_section, {}).setdefault(
+                i.import_type, {}
             ).setdefault(i.module_name, set()).add(name_import)
         return retval
 

package/autorest/codegen/models/lro_operation.py

@@ -73,11 +73,11 @@ class LROOperationBase(OperationBase[LROResponseType]):
                 response = next(
                     r for r in responses_with_bodies if 200 in r.status_codes
                 )
-            except StopIteration:
+            except StopIteration as exc:
                 raise ValueError(
-                    f"Your swagger is invalid because you have multiple response schemas for LRO"
+                    "Your swagger is invalid because you have multiple response schemas for LRO"
                     + f" method {self.name} and none of them have a 200 status code."
-                )
+                ) from exc
 
         elif num_response_schemas:
             response = responses_with_bodies[0]
@@ -134,8 +134,8 @@ class LROOperationBase(OperationBase[LROResponseType]):
             return file_import
         if async_mode:
             file_import.add_submodule_import(
-                f"azure.core.tracing.decorator_async",
-                f"distributed_trace_async",
+                "azure.core.tracing.decorator_async",
+                "distributed_trace_async",
                 ImportType.AZURECORE,
             )
         file_import.add_submodule_import(

package/autorest/codegen/models/model_type.py

@@ -5,13 +5,20 @@
 # --------------------------------------------------------------------------
 from collections import OrderedDict
 from typing import Any, Dict, List, Optional, TYPE_CHECKING, cast
-
+import sys
 from autorest.codegen.models.utils import add_to_pylint_disable
 from .base import BaseType
 from .constant_type import ConstantType
 from .property import Property
 from .imports import FileImport, ImportType, TypingSection
 
+
+if sys.version_info >= (3, 8):
+    from typing import Literal  # pylint: disable=no-name-in-module, ungrouped-imports
+else:
+    from typing_extensions import Literal  # type: ignore  # pylint: disable=ungrouped-imports
+
+
 if TYPE_CHECKING:
     from .code_model import CodeModel
 
@@ -33,7 +40,7 @@ def _get_properties(type: "ModelType", properties: List[Property]) -> List[Prope
     return properties
 
 
-class ModelType(
+class ModelType(  # pylint: disable=abstract-method
     BaseType
 ):  # pylint: disable=too-many-instance-attributes, too-many-public-methods
     """Represents a class ready to be serialized in Python.
@@ -44,6 +51,8 @@ class ModelType(
     :type properties: dict(str, str)
     """
 
+    base: Literal["msrest", "dpg", "json"]
+
     def __init__(
         self,
         yaml_data: Dict[str, Any],
@@ -72,15 +81,6 @@ class ModelType(
     def is_xml(self) -> bool:
         return self.yaml_data.get("isXml", False)
 
-    @property
-    def serialization_type(self) -> str:
-        if self.code_model.options["models_mode"] == "msrest":
-            private_model_path = f"_models.{self.code_model.models_filename}."
-            return f"{'' if self.is_public else private_model_path}{self.name}"
-        if self.code_model.options["models_mode"] == "dpg":
-            return f"{'' if self.is_public else '_models.'}_models.{self.name}"
-        return "object"
-
     @property
     def msrest_deserialization_key(self) -> str:
         return self.name
@@ -89,28 +89,9 @@ class ModelType(
     def is_polymorphic(self) -> bool:
         return any(p.is_polymorphic for p in self.properties)
 
-    def type_annotation(self, **kwargs: Any) -> str:
-        if self.code_model.options["models_mode"]:
-            is_operation_file = kwargs.pop("is_operation_file", False)
-            retval = f"_models.{self.name}"
-            if not self.is_public:
-                retval = f"{self.code_model.models_filename}.{retval}"
-            return retval if is_operation_file else f'"{retval}"'
-        return "ET.Element" if self.is_xml else "JSON"
-
-    def docstring_type(self, **kwargs: Any) -> str:
-        if self.code_model.options["models_mode"]:
-            return f"~{self.code_model.namespace}.models.{self.name}"
-        return "ET.Element" if self.is_xml else "JSON"
-
     def description(self, *, is_operation_file: bool = False) -> str:
         return "" if is_operation_file else self.yaml_data.get("description", self.name)
 
-    def docstring_text(self, **kwargs: Any) -> str:
-        if self.code_model.options["models_mode"]:
-            return self.name
-        return "XML Element" if self.is_xml else "JSON object"
-
     def get_declaration(self, value: Any) -> str:
         return f"{self.name}()"
 
@@ -252,15 +233,6 @@ class ModelType(
         except StopIteration:
             return None
 
-    @property
-    def instance_check_template(self) -> str:
-        models_mode = self.code_model.options["models_mode"]
-        if models_mode == "msrest":
-            return "isinstance({}, msrest.Model)"
-        if models_mode == "dpg":
-            return "isinstance({}, _model_base.Model)"
-        return "isinstance({}, MutableMapping)"
-
     @property
     def pylint_disable(self) -> str:
         retval: str = ""
@@ -275,16 +247,29 @@ class ModelType(
             retval = add_to_pylint_disable(retval, "too-many-locals")
         return retval
 
+
+class JSONModelType(ModelType):
+    base = "json"
+
+    def type_annotation(self, **kwargs: Any) -> str:
+        return "ET.Element" if self.is_xml else "JSON"
+
+    @property
+    def serialization_type(self) -> str:
+        return "object"
+
+    def docstring_type(self, **kwargs: Any) -> str:
+        return "ET.Element" if self.is_xml else "JSON"
+
+    def docstring_text(self, **kwargs: Any) -> str:
+        return "XML Element" if self.is_xml else "JSON object"
+
+    @property
+    def instance_check_template(self) -> str:
+        return "isinstance({}, MutableMapping)"
+
     def imports(self, **kwargs: Any) -> FileImport:
         file_import = FileImport()
-        relative_path = kwargs.pop("relative_path", None)
-        if self.code_model.options["models_mode"] and relative_path:
-            # add import for models in operations file
-            file_import.add_submodule_import(
-                relative_path, "models", ImportType.LOCAL, alias="_models"
-            )
-        if self.code_model.options["models_mode"] == "msrest":
-            return file_import
         file_import.add_submodule_import(
             "typing", "Any", ImportType.STDLIB, TypingSection.CONDITIONAL
         )
@@ -294,3 +279,60 @@ class ModelType(
                 "xml.etree", "ElementTree", ImportType.STDLIB, alias="ET"
             )
         return file_import
+
+
+class GeneratedModelType(ModelType):  # pylint: disable=abstract-method
+    def type_annotation(self, **kwargs: Any) -> str:
+        is_operation_file = kwargs.pop("is_operation_file", False)
+        retval = f"_models.{self.name}"
+        if not self.is_public:
+            retval = f"{self.code_model.models_filename}.{retval}"
+        return retval if is_operation_file else f'"{retval}"'
+
+    def docstring_type(self, **kwargs: Any) -> str:
+        return f"~{self.code_model.namespace}.models.{self.name}"
+
+    def docstring_text(self, **kwargs: Any) -> str:
+        return self.name
+
+    def imports(self, **kwargs: Any) -> FileImport:
+        file_import = super().imports(**kwargs)
+        relative_path = kwargs.pop("relative_path", None)
+        if relative_path:
+            # add import for models in operations file
+            file_import.add_submodule_import(
+                relative_path, "models", ImportType.LOCAL, alias="_models"
+            )
+        return file_import
+
+
+class MsrestModelType(GeneratedModelType):
+    base = "msrest"
+
+    @property
+    def serialization_type(self) -> str:
+        private_model_path = f"_models.{self.code_model.models_filename}."
+        return f"{'' if self.is_public else private_model_path}{self.name}"
+
+    @property
+    def instance_check_template(self) -> str:
+        return "isinstance({}, msrest.Model)"
+
+    def imports(self, **kwargs: Any) -> FileImport:
+        file_import = super().imports(**kwargs)
+        file_import.add_submodule_import(
+            "typing", "Any", ImportType.STDLIB, TypingSection.CONDITIONAL
+        )
+        return file_import
+
+
+class DPGModelType(GeneratedModelType):
+    base = "dpg"
+
+    @property
+    def serialization_type(self) -> str:
+        return f"{'' if self.is_public else '_models.'}_models.{self.name}"
+
+    @property
+    def instance_check_template(self) -> str:
+        return "isinstance({}, _model_base.Model)"

package/autorest/codegen/models/operation.py

@@ -394,8 +394,8 @@ class OperationBase(  # pylint: disable=too-many-public-methods
         )
         if self.code_model.options["tracing"] and self.want_tracing and not async_mode:
             file_import.add_submodule_import(
-                f"azure.core.tracing.decorator",
-                f"distributed_trace",
+                "azure.core.tracing.decorator",
+                "distributed_trace",
                 ImportType.AZURECORE,
             )
         file_import.merge(
@@ -410,10 +410,10 @@ class OperationBase(  # pylint: disable=too-many-public-methods
     ) -> ResponseType:
         try:
             return next(r for r in self.responses if status_code in r.status_codes)
-        except StopIteration:
+        except StopIteration as exc:
             raise ValueError(
                 f"Incorrect status code {status_code}, operation {self.name}"
-            )
+            ) from exc
 
     @property
     def success_status_codes(self) -> List[Union[str, int]]:
@@ -431,7 +431,7 @@ class OperationBase(  # pylint: disable=too-many-public-methods
             basename == "operations"
             or self.code_model.options["combine_operation_files"]
         ):
-            return f"_operations"
+            return "_operations"
         return f"_{basename}_operations"
 
     @property
@@ -481,8 +481,8 @@ class Operation(OperationBase[Response]):
             return file_import
         if async_mode:
             file_import.add_submodule_import(
-                f"azure.core.tracing.decorator_async",
-                f"distributed_trace_async",
+                "azure.core.tracing.decorator_async",
+                "distributed_trace_async",
                 ImportType.AZURECORE,
             )
         if (
@@ -499,7 +499,7 @@ class Operation(OperationBase[Response]):
                 )
                 file_import.add_import("json", ImportType.STDLIB)
             if self.default_error_deserialization or any(
-                [r.type for r in self.responses]
+                r.type for r in self.responses
             ):
                 file_import.add_submodule_import(
                     f"{relative_path}_model_base", "_deserialize", ImportType.LOCAL

package/autorest/codegen/models/operation_group.py

@@ -76,7 +76,9 @@ class OperationGroup(BaseModel):
     def imports(self, async_mode: bool) -> FileImport:
         file_import = FileImport()
 
-        relative_path = "..." if async_mode else ".."
+        relative_path = ("..." if async_mode else "..") + (
+            "." if self.client.is_subclient else ""
+        )
         for operation in self.operations:
             file_import.merge(
                 operation.imports(async_mode, relative_path=relative_path)

package/autorest/codegen/models/paging_operation.py

@@ -74,10 +74,10 @@ class PagingOperationBase(OperationBase[PagingResponseType]):
                 for p in cast(ModelType, response.type).properties
                 if p.rest_api_name == rest_api_name
             )
-        except StopIteration:
+        except StopIteration as exc:
             raise ValueError(
                 f"Can't find a matching property in response for {rest_api_name}"
-            )
+            ) from exc
 
     def get_pager(self, async_mode: bool) -> str:
         return self.responses[0].get_pager(async_mode)