@autorest/python 5.10.0 → 5.12.0

package/ChangeLog.md

@@ -1,5 +1,79 @@
 # Change Log
 
+### 2021-12-06 - 5.12.0
+
+| Library | Min Version
+| --------------- | -------
+|`@autorest/core` |  `3.6.2`
+|`@autorest/modelerfour` | `4.19.1`
+|`azure-core` dep of generated code | `1.20.1`
+|`msrest` dep of generated code | `0.6.21`
+|`azure-mgmt-core` dep of generated code (If generating mgmt plane code) | `1.3.0`
+
+**Breaking Changes in Version Tolerant Generation**
+
+- Remove metadata property for version tolerant and low level client generations #1090
+- Generate SDKs with `--python3-only` defaulting to `True` for version tolerant and low level client  #1087
+
+**New Features**
+
+- Generate a `_patch.py` file if one does not exist. These files are used to customize the generated code  #1092
+
+**Bug Fixes**
+
+- Can now handle body params with names `json`, `content`, `data`, and `files` #1081
+- Improve generated templates for `data` and `files` input body params by adding quotes around the keys  #1082
+- Using flag `--python3-only` will get you typed sync client and config files  #1085
+- Pin `mistune` dependency to less than `2.x.x` so autorest can be successfully installed  #1106
+
+### 2021-11-05 - 5.11.2
+
+| Library | Min Version
+| --------------- | -------
+|`@autorest/core` |  `3.6.2`
+|`@autorest/modelerfour` | `4.19.1`
+|`azure-core` dep of generated code | `1.20.0`
+|`msrest` dep of generated code | `0.6.21`
+|`azure-mgmt-core` dep of generated code (If generating mgmt plane code) | `1.3.0`
+
+**Bug Fixes**
+
+- Respect no client side validation for low level client generations  #1080
+
+### 2021-11-05 - 5.11.1
+
+| Library | Min Version
+| --------------- | -------
+|`@autorest/core` |  `3.6.2`
+|`@autorest/modelerfour` | `4.19.1`
+|`azure-core` dep of generated code | `1.20.0`
+|`msrest` dep of generated code | `0.6.21`
+|`azure-mgmt-core` dep of generated code (If generating mgmt plane code) | `1.3.0`
+
+**Bug Fixes**
+
+- Hide mixin operations for version tolerant generation  #1071
+
+### 2021-11-04 - 5.11.0
+
+| Library | Min Version
+| --------------- | -------
+|`@autorest/core` |  `3.6.2`
+|`@autorest/modelerfour` | `4.19.1`
+|`azure-core` dep of generated code | `1.20.0`
+|`msrest` dep of generated code | `0.6.21`
+|`azure-mgmt-core` dep of generated code (If generating mgmt plane code) | `1.3.0`
+
+**New Features**
+
+- Add `_patch.py` support for `aio` folder #1070
+
+**Bug Fixes**
+
+- Fix documentation for HEAD calls that perform boolean checks on returned status codes in version tolerant code #1072
+- Fix body grouping by content types for binary bodies #1076
+- Fix default content type determination #1078
+
 ### 2021-11-01 - 5.10.0
 
 | Library | Min Version

package/autorest/codegen/__init__.py

@@ -31,9 +31,9 @@ def _build_convenience_layer(yaml_data: Dict[str, Any], code_model: CodeModel) -
             code_model.sort_schemas()
 
     if code_model.options["show_operations"]:
-        code_model.link_operation_to_request_builder()
         code_model.add_schema_link_to_operation()
-        code_model.generate_single_parameter_from_multiple_media_types_operation()
+        code_model.generate_single_parameter_from_multiple_content_types_operation()
+        code_model.link_operation_to_request_builder()
         # LRO operation
         code_model.format_lro_operations()
         code_model.remove_next_operation()
@@ -60,7 +60,7 @@ def _validate_code_model_options(options: Dict[str, Any]) -> None:
             "to 'public' or 'hidden'."
         )
 
-    if not options["show_operations"] and options["add_python_3_operation_files"]:
+    if not options["show_operations"] and options["add_python3_operation_files"]:
         raise ValueError(
             "Can not add typed sync operation files if you are not showing operations. "
             "If you want typed synced operation files, you have to add flag "
@@ -256,7 +256,7 @@ class CodeGenerator(Plugin):
         version_tolerant = self._autorestapi.get_boolean_value("version-tolerant", False)
         show_operations = self._autorestapi.get_boolean_value("show-operations", not low_level_client)
         models_mode_default = "none" if low_level_client or version_tolerant else "msrest"
-        python_3_only = self._autorestapi.get_boolean_value("python3-only", False)
+        python3_only = self._autorestapi.get_boolean_value("python3-only", low_level_client or version_tolerant)
 
         options: Dict[str, Any] = {
             "azure_arm": azure_arm,
@@ -282,13 +282,13 @@ class CodeGenerator(Plugin):
             "only_path_and_body_params_positional": self._autorestapi.get_boolean_value(
                 "only-path-and-body-params-positional", low_level_client or version_tolerant
             ),
-            "add_python_3_operation_files": self._autorestapi.get_boolean_value(
-                "add-python3-operation-files", python_3_only
+            "add_python3_operation_files": self._autorestapi.get_boolean_value(
+                "add-python3-operation-files", python3_only and not low_level_client
             ),
             "version_tolerant": version_tolerant,
             "low_level_client": low_level_client,
             "combine_operation_files": self._autorestapi.get_boolean_value("combine-operation-files", version_tolerant),
-            "python_3_only": python_3_only,
+            "python3_only": python3_only,
         }
 
         if options["builders_visibility"] is None:

package/autorest/codegen/models/__init__.py

@@ -10,7 +10,7 @@ from .credential_schema import AzureKeyCredentialSchema, TokenCredentialSchema
 from .object_schema import ObjectSchema, get_object_schema, HiddenModelObjectSchema
 from .dictionary_schema import DictionarySchema
 from .list_schema import ListSchema
-from .primitive_schemas import get_primitive_schema, AnySchema, PrimitiveSchema
+from .primitive_schemas import get_primitive_schema, AnySchema, PrimitiveSchema, IOSchema
 from .enum_schema import EnumSchema, HiddenModelEnumSchema, get_enum_schema
 from .base_schema import BaseSchema
 from .constant_schema import ConstantSchema
@@ -62,6 +62,7 @@ __all__ = [
     "RequestBuilderParameter",
     "HiddenModelObjectSchema",
     "ParameterStyle",
+    "IOSchema",
 ]
 
 def _generate_as_object_schema(yaml_data: Dict[str, Any]) -> bool:

package/autorest/codegen/models/base_builder.py

@@ -6,6 +6,7 @@
 from typing import Any, Callable, Dict, List, Optional, Union, TYPE_CHECKING
 from .base_model import BaseModel
 from .schema_response import SchemaResponse
+from .schema_request import SchemaRequest
 
 if TYPE_CHECKING:
     from . import ParameterListType
@@ -13,11 +14,16 @@ if TYPE_CHECKING:
 
 _M4_HEADER_PARAMETERS = ["content_type", "accept"]
 
-def create_parameters(yaml_data: Dict[str, Any], code_model, parameter_creator: Callable):
+def create_parameters(
+    yaml_data: Dict[str, Any], code_model, parameter_creator: Callable
+):
     multiple_requests = len(yaml_data["requests"]) > 1
 
-    multiple_media_type_parameters = []
-    parameters = [parameter_creator(yaml, code_model=code_model) for yaml in yaml_data.get("parameters", [])]
+    multiple_content_type_parameters = []
+    parameters = [
+        parameter_creator(yaml, code_model=code_model)
+        for yaml in yaml_data.get("parameters", [])
+    ]
 
     for request in yaml_data["requests"]:
         for yaml in request.get("parameters", []):
@@ -26,14 +32,14 @@ def create_parameters(yaml_data: Dict[str, Any], code_model, parameter_creator:
             if name in _M4_HEADER_PARAMETERS:
                 parameters.append(parameter)
             elif multiple_requests:
-                parameter.has_multiple_media_types = True
-                multiple_media_type_parameters.append(parameter)
+                parameter.has_multiple_content_types = True
+                multiple_content_type_parameters.append(parameter)
             else:
                 parameters.append(parameter)
 
-    if multiple_media_type_parameters:
+    if multiple_content_type_parameters:
         body_parameters_name_set = set(
-            p.serialized_name for p in multiple_media_type_parameters
+            p.serialized_name for p in multiple_content_type_parameters
         )
         if len(body_parameters_name_set) > 1:
             raise ValueError(
@@ -53,7 +59,7 @@ def create_parameters(yaml_data: Dict[str, Any], code_model, parameter_creator:
         if parameter_original_id in parameters_index:
             parameter.original_parameter = parameters_index[parameter_original_id]
 
-    return parameters, multiple_media_type_parameters
+    return parameters, multiple_content_type_parameters
 
 class BaseBuilder(BaseModel):
     """Base class for Operations and Request Builders"""
@@ -65,6 +71,7 @@ class BaseBuilder(BaseModel):
         name: str,
         description: str,
         parameters: "ParameterListType",
+        schema_requests: List[SchemaRequest],
         responses: Optional[List[SchemaResponse]] = None,
         summary: Optional[str] = None,
     ) -> None:
@@ -75,6 +82,7 @@ class BaseBuilder(BaseModel):
         self.parameters = parameters
         self.responses = responses or []
         self.summary = summary
+        self.schema_requests = schema_requests
 
     @property
     def default_content_type_declaration(self) -> str:

package/autorest/codegen/models/client.py

@@ -73,7 +73,9 @@ class Client:
             )
         file_import.add_from_import("azure.core.rest", "HttpRequest", ImportType.AZURECORE, TypingSection.CONDITIONAL)
         for og in self.code_model.operation_groups:
-            file_import.add_from_import(".operations", og.class_name, ImportType.LOCAL)
+            file_import.add_from_import(
+                f".{self.code_model.operations_folder_name}", og.class_name, ImportType.LOCAL
+            )
 
         if self.code_model.sorted_schemas:
             path_to_models = ".." if async_mode else "."
@@ -94,6 +96,6 @@ class Client:
             pass
         return file_import
 
-    def send_request_signature(self, async_mode) -> List[str]:
+    def send_request_signature(self, async_mode: bool, is_python3_file: bool) -> List[str]:
         request_signature = ["request: HttpRequest," if async_mode else "request,  # type: HttpRequest"]
-        return request_signature + self.parameters.method_signature_kwargs(async_mode)
+        return request_signature + self.parameters.method_signature_kwargs(is_python3_file)

package/autorest/codegen/models/code_model.py

@@ -29,7 +29,7 @@ from .rest import Rest
 
 _LOGGER = logging.getLogger(__name__)
 
-class CodeModel:  # pylint: disable=too-many-instance-attributes
+class CodeModel:  # pylint: disable=too-many-instance-attributes, too-many-public-methods
     """Holds all of the information we have parsed out of the yaml file. The CodeModel is what gets
     serialized by the serializers.
 
@@ -203,6 +203,10 @@ class CodeModel:  # pylint: disable=too-many-instance-attributes
                 operation for operation in operation_group.operations if operation not in next_operations
             ]
 
+    @property
+    def has_schemas(self):
+        return self.schemas or self.enums
+
     @property
     def default_authentication_policy(self) -> Type[CredentialSchemaPolicy]:
         return ARMChallengeAuthenticationPolicy if self.options['azure_arm'] else BearerTokenCredentialPolicy
@@ -238,6 +242,15 @@ class CodeModel:  # pylint: disable=too-many-instance-attributes
 
         return properties
 
+    @property
+    def operations_folder_name(self) -> str:
+        name = "operations"
+        if self.options["version_tolerant"] and not any(
+            og for og in self.operation_groups if not og.is_empty_operation_group
+        ):
+            name = f"_{name}"
+        return name
+
     def _add_properties_from_inheritance(self) -> None:
         """Adds properties from base classes to schemas with parents.
 
@@ -316,7 +329,7 @@ class CodeModel:  # pylint: disable=too-many-instance-attributes
             for operation in operation_group.operations:
                 for obj in chain(
                     operation.parameters,
-                    operation.multiple_media_type_parameters or [],
+                    operation.multiple_content_type_parameters or [],
                     operation.responses,
                     operation.exceptions,
                     chain.from_iterable(response.headers for response in operation.responses),
@@ -337,11 +350,11 @@ class CodeModel:  # pylint: disable=too-many-instance-attributes
         for parameter in self.global_parameters:
             self._populate_schema(parameter)
 
-    def generate_single_parameter_from_multiple_media_types_operation(self) -> None:
+    def generate_single_parameter_from_multiple_content_types_operation(self) -> None:
         for operation_group in self.operation_groups:
             for operation in operation_group.operations:
-                if operation.multiple_media_type_parameters:
-                    operation.convert_multiple_media_type_parameters()
+                if operation.multiple_content_type_parameters:
+                    operation.convert_multiple_content_type_parameters()
 
     @property
     def need_vendored_code(self) -> bool:
@@ -383,3 +396,4 @@ class CodeModel:  # pylint: disable=too-many-instance-attributes
                 if isinstance(operation, LROOperation):
                     request_builder.name = request_builder.name + "_initial"
                 operation.request_builder = request_builder
+                operation.link_body_kwargs_to_body_params()

package/autorest/codegen/models/imports.py

@@ -36,6 +36,8 @@ class FileImport:
             TypingSection,
             Dict[ImportType, Dict[str, Set[Optional[Union[str, Tuple[str, str]]]]]]
         ] = imports or dict()
+        # has sync and async type definitions
+        self.type_definitions: Dict[str, Tuple[str, str]] = {}
 
     def _add_import(
         self,
@@ -82,6 +84,10 @@ class FileImport:
         ]:
         return self._imports
 
+    def define_mypy_type(self, type_name: str, type_value: str, async_type_value: Optional[str] = None):
+        self._add_import("typing", ImportType.STDLIB, "TypeVar", TypingSection.CONDITIONAL)
+        self.type_definitions[type_name] = (type_value, async_type_value or type_value)
+
     def merge(self, file_import: "FileImport") -> None:
         """Merge the given file import format."""
         for typing_section, import_type_dict in file_import.imports.items():
@@ -89,3 +95,4 @@ class FileImport:
                 for package_name, module_list in package_list.items():
                     for module_name in module_list:
                         self._add_import(package_name, import_type, module_name, typing_section)
+        self.type_definitions.update(file_import.type_definitions)

package/autorest/codegen/models/lro_operation.py

@@ -11,6 +11,7 @@ from .parameter_list import ParameterList
 from .schema_response import SchemaResponse
 from .imports import ImportType, TypingSection
 from .base_schema import BaseSchema
+from .schema_request import SchemaRequest
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -24,7 +25,8 @@ class LROOperation(Operation):
         description: str,
         api_versions: Set[str],
         parameters: ParameterList,
-        multiple_media_type_parameters: ParameterList,
+        multiple_content_type_parameters: ParameterList,
+        schema_requests: List[SchemaRequest],
         summary: Optional[str] = None,
         responses: Optional[List[SchemaResponse]] = None,
         exceptions: Optional[List[SchemaResponse]] = None,
@@ -38,7 +40,8 @@ class LROOperation(Operation):
             description,
             api_versions,
             parameters,
-            multiple_media_type_parameters,
+            multiple_content_type_parameters,
+            schema_requests,
             summary,
             responses,
             exceptions,
@@ -86,7 +89,8 @@ class LROOperation(Operation):
             description="",
             api_versions=self.api_versions,
             parameters=self.parameters,
-            multiple_media_type_parameters=self.multiple_media_type_parameters,
+            schema_requests=self.schema_requests,
+            multiple_content_type_parameters=self.multiple_content_type_parameters,
             summary=self.summary,
             responses=self.responses,
             want_description_docstring=False,

package/autorest/codegen/models/object_schema.py

@@ -224,15 +224,15 @@ class HiddenModelObjectSchema(ObjectSchema):
 
     @property
     def type_annotation(self) -> str:
-        return "Any"
+        return "JSONType"
 
     @property
     def operation_type_annotation(self) -> str:
-        return "Any"
+        return "JSONType"
 
     @property
     def docstring_type(self) -> str:
-        return "Any"
+        return "JSONType"
 
     @property
     def docstring_text(self) -> str:

package/autorest/codegen/models/operation.py

@@ -10,11 +10,13 @@ from typing import cast, Dict, List, Any, Optional, Union, Set
 from .base_builder import BaseBuilder, create_parameters
 from .imports import FileImport, ImportType, TypingSection
 from .schema_response import SchemaResponse
-from .parameter import get_parameter
+from .parameter import Parameter, get_parameter
 from .parameter_list import ParameterList, get_parameter_list
 from .base_schema import BaseSchema
 from .object_schema import ObjectSchema
 from .request_builder import RequestBuilder
+from .schema_request import SchemaRequest
+from .primitive_schemas import IOSchema
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -30,7 +32,8 @@ class Operation(BaseBuilder):  # pylint: disable=too-many-public-methods, too-ma
         description: str,
         api_versions: Set[str],
         parameters: ParameterList,
-        multiple_media_type_parameters: ParameterList,
+        multiple_content_type_parameters: ParameterList,
+        schema_requests: List[SchemaRequest],
         summary: Optional[str] = None,
         responses: Optional[List[SchemaResponse]] = None,
         exceptions: Optional[List[SchemaResponse]] = None,
@@ -44,11 +47,12 @@ class Operation(BaseBuilder):  # pylint: disable=too-many-public-methods, too-ma
             description=description,
             parameters=parameters,
             responses=responses,
+            schema_requests=schema_requests,
             summary=summary,
         )
-        self.multiple_media_type_parameters = multiple_media_type_parameters
+        self.multiple_content_type_parameters = multiple_content_type_parameters
         self.api_versions = api_versions
-        self.multiple_media_type_parameters = multiple_media_type_parameters
+        self.multiple_content_type_parameters = multiple_content_type_parameters
         self.exceptions = exceptions or []
         self.want_description_docstring = want_description_docstring
         self.want_tracing = want_tracing
@@ -79,28 +83,7 @@ class Operation(BaseBuilder):  # pylint: disable=too-many-public-methods, too-ma
 
     @property
     def body_kwargs_to_pass_to_request_builder(self) -> List[str]:
-        kwargs = []
-        if not self.parameters.has_body:
-            return []
-        body_kwarg_names = self.request_builder.parameters.body_kwarg_names
-        for kwarg in body_kwarg_names:
-            if kwarg == "content":
-                if self.request_builder.is_stream:
-                    kwargs.append("content")
-            else:
-                kwargs.append(kwarg)
-        if not kwargs and not self.parameters.body[0].constant:
-            kwargs.append("content")
-        return kwargs
-
-    @property
-    def serialized_body_kwarg(self) -> str:
-        # body serialization can be passed to either "json" or "content"
-        if "json" in self.body_kwargs_to_pass_to_request_builder:
-            return "json"
-        if not self.request_builder.is_stream:
-            return "content"
-        raise ValueError("You should not be trying to serialize this body")
+        return [p.serialized_name for p in self.request_builder.body_kwargs_to_get]
 
     @property
     def has_optional_return_type(self) -> bool:
@@ -168,7 +151,7 @@ class Operation(BaseBuilder):  # pylint: disable=too-many-public-methods, too-ma
         for param in self.parameters.method:
             file_import.merge(param.imports())
 
-        for param in self.multiple_media_type_parameters:
+        for param in self.multiple_content_type_parameters:
             file_import.merge(param.imports())
 
         for response in self.responses:
@@ -239,30 +222,72 @@ class Operation(BaseBuilder):  # pylint: disable=too-many-public-methods, too-ma
             file_import.add_from_import(
                 f"{relative_path}_vendor", "_convert_request", ImportType.LOCAL
             )
+        if self.code_model.options["version_tolerant"] and (
+            self.parameters.has_body or
+            any(r for r in self.responses if r.has_body)
+        ):
+            file_import.define_mypy_type("JSONType", "Any")
         return file_import
 
-    def convert_multiple_media_type_parameters(self) -> None:
+    def _get_body_param_from_body_kwarg(self, body_kwarg: Parameter) -> Parameter:
+        # determine which of the body parameters returned from m4 corresponds to this body_kwarg
+        if not self.multiple_content_type_parameters.has_body:
+            return self.parameters.body[0]
+        if body_kwarg.serialized_name == "data":
+            return next(p for p in self.multiple_content_type_parameters.body if p.is_data_input)
+        if body_kwarg.serialized_name == "files":
+            return next(p for p in self.multiple_content_type_parameters.body if p.is_multipart)
+        if body_kwarg.serialized_name == "json":
+            # first check if there's any non-binary. In the case of multiple content types, there's
+            # usually one binary (for content), and one schema parameter (for json)
+            try:
+                return next(
+                    p for p in self.multiple_content_type_parameters.body
+                    if not isinstance(p.schema, IOSchema)
+                )
+            except StopIteration:
+                return next(p for p in self.multiple_content_type_parameters.body if p.is_json_parameter)
+        return self.multiple_content_type_parameters.body[0]
+
+    def link_body_kwargs_to_body_params(self) -> None:
+        if not self.parameters.has_body:
+            return
+        body_kwargs = [
+            p for p in self.request_builder.parameters.body
+            if p.content_types
+        ]
+        if len(body_kwargs) == 1:
+            self.parameters.body[0].body_kwargs = [body_kwargs[0]]
+            return
+        for body_kwarg in body_kwargs:
+            body_param = self._get_body_param_from_body_kwarg(body_kwarg)
+            body_param.body_kwargs.append(body_kwarg)
+
+    def convert_multiple_content_type_parameters(self) -> None:
         type_annot = ", ".join([
             param.schema.operation_type_annotation
-            for param in self.multiple_media_type_parameters
+            for param in self.multiple_content_type_parameters
         ])
         docstring_type = " or ".join([
-            param.schema.docstring_type for param in self.multiple_media_type_parameters
+            param.schema.docstring_type for param in self.multiple_content_type_parameters
         ])
         try:
             # get an optional param with object first. These params are the top choice
             # bc they have more info about how to serialize the body
             chosen_parameter = next(
-                p for p in self.multiple_media_type_parameters if not p.required and isinstance(p.schema, ObjectSchema)
+                p for p in self.multiple_content_type_parameters
+                if not p.required and isinstance(p.schema, ObjectSchema)
             )
         except StopIteration:  # pylint: disable=broad-except
             # otherwise, we get the first optional param, if that exists. If not, we just grab the first one
-            optional_parameters = [p for p in self.multiple_media_type_parameters if not p.required]
-            chosen_parameter = optional_parameters[0] if optional_parameters else self.multiple_media_type_parameters[0]
+            optional_parameters = [p for p in self.multiple_content_type_parameters if not p.required]
+            chosen_parameter = (
+                optional_parameters[0] if optional_parameters else self.multiple_content_type_parameters[0]
+            )
         if not chosen_parameter:
             raise ValueError("You are missing a parameter that has multiple media types")
-        chosen_parameter.multiple_media_types_type_annot = f"Union[{type_annot}]"
-        chosen_parameter.multiple_media_types_docstring_type = docstring_type
+        chosen_parameter.multiple_content_types_type_annot = f"Union[{type_annot}]"
+        chosen_parameter.multiple_content_types_docstring_type = docstring_type
         self.parameters.append(chosen_parameter)
 
     @classmethod
@@ -272,7 +297,10 @@ class Operation(BaseBuilder):  # pylint: disable=too-many-public-methods, too-ma
 
         parameter_creator = get_parameter(code_model).from_yaml
         parameter_list_creator = get_parameter_list(code_model)
-        parameters, multiple_media_type_parameters = create_parameters(yaml_data, code_model, parameter_creator)
+        schema_requests = [SchemaRequest.from_yaml(yaml, code_model=code_model) for yaml in yaml_data["requests"]]
+        parameters, multiple_content_type_parameters = create_parameters(
+            yaml_data, code_model, parameter_creator
+        )
 
         return cls(
             code_model=code_model,
@@ -280,8 +308,11 @@ class Operation(BaseBuilder):  # pylint: disable=too-many-public-methods, too-ma
             name=name,
             description=yaml_data["language"]["python"]["description"],
             api_versions=set(value_dict["version"] for value_dict in yaml_data["apiVersions"]),
-            parameters=parameter_list_creator(code_model, parameters),
-            multiple_media_type_parameters=parameter_list_creator(code_model, multiple_media_type_parameters),
+            parameters=parameter_list_creator(code_model, parameters, schema_requests),
+            multiple_content_type_parameters=parameter_list_creator(
+                code_model, multiple_content_type_parameters, schema_requests
+            ),
+            schema_requests=schema_requests,
             summary=yaml_data["language"]["python"].get("summary"),
             responses=[SchemaResponse.from_yaml(yaml) for yaml in yaml_data.get("responses", [])],
             # Exception with no schema means default exception, we don't store them

package/autorest/codegen/models/operation_group.py

@@ -56,7 +56,7 @@ class OperationGroup(BaseModel):
             file_import.merge(operation.imports_for_multiapi(async_mode))
         return file_import
 
-    def imports(self, async_mode: bool, has_schemas: bool) -> FileImport:
+    def imports(self, async_mode: bool) -> FileImport:
         file_import = FileImport()
         file_import.add_from_import("azure.core.exceptions", "ClientAuthenticationError", ImportType.AZURECORE)
         file_import.add_from_import("azure.core.exceptions", "ResourceNotFoundError", ImportType.AZURECORE)
@@ -73,7 +73,7 @@ class OperationGroup(BaseModel):
                     "azure.core.tracing.decorator", "distributed_trace", ImportType.AZURECORE,
                 )
         local_path = "..." if async_mode else ".."
-        if has_schemas and self.code_model.options["models_mode"]:
+        if self.code_model.has_schemas and self.code_model.options["models_mode"]:
             file_import.add_from_import(local_path, "models", ImportType.LOCAL, alias="_models")
         if self.code_model.options["builders_visibility"] == "embedded" and async_mode:
             if not self.code_model.options["combine_operation_files"]:
@@ -85,25 +85,30 @@ class OperationGroup(BaseModel):
             else:
                 operation_group_builders = self.code_model.rest.request_builders
             for request_builder in operation_group_builders:
+                python3_only = self.code_model.options["python3_only"]
+                typed_sync_operation_file = self.code_model.options["add_python3_operation_files"]
+                suffix = "_py3" if typed_sync_operation_file and not python3_only else ""
                 file_import.add_from_import(
-                    f"...operations.{self.filename}",
+                    f"...{self.code_model.operations_folder_name}.{self.filename}{suffix}",
                     request_builder.name,
                     import_type=ImportType.LOCAL
                 )
-
+        type_value = "Optional[Callable[[PipelineResponse[HttpRequest, {}HttpResponse], T, Dict[str, Any]], Any]]"
+        file_import.define_mypy_type(
+            "ClsType",
+            type_value.format(""),
+            type_value.format("Async")
+        )
         return file_import
 
 
     @property
     def filename(self) -> str:
-        if self.code_model.options["combine_operation_files"]:
-            return "_operations"
-
         basename = self.name
         if self.is_empty_operation_group:
             basename = self.code_model.module_name
 
-        if basename == "operations":
+        if basename == "operations" or self.code_model.options["combine_operation_files"]:
             return f"_operations"
         return f"_{basename}_operations"
 

package/autorest/codegen/models/paging_operation.py

@@ -11,6 +11,7 @@ from .schema_response import SchemaResponse
 from .request_builder import RequestBuilder
 from .imports import ImportType, FileImport, TypingSection
 from .object_schema import ObjectSchema
+from .schema_request import SchemaRequest
 from .parameter_list import ParameterList
 
 _LOGGER = logging.getLogger(__name__)
@@ -25,7 +26,8 @@ class PagingOperation(Operation):
         description: str,
         api_versions: Set[str],
         parameters: ParameterList,
-        multiple_media_type_parameters: ParameterList,
+        multiple_content_type_parameters: ParameterList,
+        schema_requests: List[SchemaRequest],
         summary: Optional[str] = None,
         responses: Optional[List[SchemaResponse]] = None,
         exceptions: Optional[List[SchemaResponse]] = None,
@@ -41,7 +43,8 @@ class PagingOperation(Operation):
             description,
             api_versions,
             parameters,
-            multiple_media_type_parameters,
+            multiple_content_type_parameters,
+            schema_requests,
             summary,
             responses,
             exceptions,