@autorest/python 5.10.0 → 5.12.0

package/autorest/codegen/serializers/builder_serializer.py

@@ -21,12 +21,13 @@ from ..models import (
     DictionarySchema,
     ListSchema,
     BaseSchema,
-    SchemaRequest,
     Parameter,
     RequestBuilder,
     RequestBuilderParameter,
     EnumSchema,
     SchemaResponse,
+    IOSchema,
+    ParameterStyle,
 )
 from . import utils
 
@@ -56,7 +57,7 @@ def _json_dumps_template(template_representation: Any) -> Any:
 def _serialize_files_or_data_dict(multipart_parameters: List[Parameter]) -> str:
     # only for template use
     template = {
-        param.serialized_name: param.schema.get_files_and_data_template_representation(
+        f'"{param.serialized_name}"': param.schema.get_files_and_data_template_representation(
             optional=not param.required,
             description=param.description,
         )
@@ -541,11 +542,11 @@ class RequestBuilderGenericSerializer(_RequestBuilderBaseSerializer):
     @staticmethod
     def _method_signature_and_response_type_annotation_template(method_signature: str, response_type_annotation: str):
         return utils.method_signature_and_response_type_annotation_template(
-            is_python_3_file=False, method_signature=method_signature, response_type_annotation=response_type_annotation
+            is_python3_file=False, method_signature=method_signature, response_type_annotation=response_type_annotation
         )
 
     def _get_kwargs_to_pop(self, builder: BuilderType):
-        return builder.parameters.kwargs_to_pop(is_python_3_file=False)
+        return builder.parameters.kwargs_to_pop(is_python3_file=False)
 
     def _body_params_to_pass_to_request_creation(self, builder: BuilderType) -> List[str]:
         if builder.parameters.has_body and not builder.parameters.body_kwarg_names:
@@ -563,11 +564,11 @@ class RequestBuilderPython3Serializer(_RequestBuilderBaseSerializer):
     @staticmethod
     def _method_signature_and_response_type_annotation_template(method_signature: str, response_type_annotation: str):
         return utils.method_signature_and_response_type_annotation_template(
-            is_python_3_file=True, method_signature=method_signature, response_type_annotation=response_type_annotation
+            is_python3_file=True, method_signature=method_signature, response_type_annotation=response_type_annotation
         )
 
     def _get_kwargs_to_pop(self, builder: BuilderType):
-        return builder.parameters.kwargs_to_pop(is_python_3_file=True)
+        return builder.parameters.kwargs_to_pop(is_python3_file=True)
 
     def _body_params_to_pass_to_request_creation(self, builder: BuilderType) -> List[str]:
         body_kwargs = list(builder.parameters.body_kwarg_names.keys())
@@ -620,7 +621,7 @@ class _OperationBaseSerializer(_BuilderBaseSerializer):  # pylint: disable=abstr
     def _response_type_annotation(self, builder: BuilderType, modify_if_head_as_boolean: bool = True) -> str:
         if (
             modify_if_head_as_boolean
-            and builder.request_builder.method == "head"
+            and builder.request_builder.method.lower() == "head"
             and self.code_model.options["head_as_boolean"]
         ):
             return "bool"
@@ -643,7 +644,7 @@ class _OperationBaseSerializer(_BuilderBaseSerializer):  # pylint: disable=abstr
 
     def response_docstring(self, builder: BuilderType) -> List[str]:
         responses_with_body = [r for r in builder.responses if r.has_body]
-        if builder.request_builder.method == "head" and self.code_model.options["head_as_boolean"]:
+        if builder.request_builder.method.lower() == "head" and self.code_model.options["head_as_boolean"]:
             response_docstring_text = "bool"
             rtype = "bool"
         elif responses_with_body:
@@ -690,28 +691,32 @@ class _OperationBaseSerializer(_BuilderBaseSerializer):  # pylint: disable=abstr
         return bool(builder.parameters.data_inputs)
 
     def _serialize_body_call(
-        self, builder: BuilderType, send_xml: bool, ser_ctxt: Optional[str], ser_ctxt_name: str
+        self, builder: BuilderType, body_param: Parameter, send_xml: bool, ser_ctxt: Optional[str], ser_ctxt_name: str
     ) -> str:
-        body_param = builder.parameters.body[0]
         body_is_xml = ", is_xml=True" if send_xml else ""
         pass_ser_ctxt = f", {ser_ctxt_name}={ser_ctxt_name}" if ser_ctxt else ""
+        body_kwarg_to_pass = builder.body_kwargs_to_pass_to_request_builder[0]
         if self.code_model.options["models_mode"]:
             return (
-                f"{builder.serialized_body_kwarg} = self._serialize.body({body_param.serialized_name}, "
+                f"_{body_kwarg_to_pass} = self._serialize.body({body_param.serialized_name}, "
                 f"'{ body_param.serialization_type }'{body_is_xml}{ pass_ser_ctxt })"
             )
-        return f"{builder.serialized_body_kwarg} = {body_param.serialized_name}"
+        return f"_{body_kwarg_to_pass} = {body_param.serialized_name}"
 
-    def _serialize_body(self, builder: BuilderType) -> List[str]:
+    def _serialize_body(self, builder: BuilderType, body_param: Parameter, body_kwarg: str) -> List[str]:
         retval = []
-        send_xml = bool(builder.parameters.has_body and any(["xml" in ct for ct in builder.parameters.content_types]))
+        send_xml = bool(
+            builder.parameters.has_body and
+            any(["xml" in ct for ct in builder.parameters.content_types]) and
+            not isinstance(body_param.schema, IOSchema)
+        )
         ser_ctxt_name = "serialization_ctxt"
         ser_ctxt = builder.parameters.body[0].xml_serialization_ctxt if send_xml else None
         if ser_ctxt:
             retval.append(f'{ser_ctxt_name} = {{"xml": {{{ser_ctxt}}}}}')
-        body_param = builder.parameters.body[0]
         serialize_body_call = self._serialize_body_call(
             builder,
+            body_param,
             send_xml,
             ser_ctxt,
             ser_ctxt_name,
@@ -723,15 +728,22 @@ class _OperationBaseSerializer(_BuilderBaseSerializer):  # pylint: disable=abstr
             retval.append("    " + serialize_body_call)
             if len(builder.body_kwargs_to_pass_to_request_builder) == 1:
                 retval.append("else:")
-                retval.append(f"    {builder.serialized_body_kwarg} = None")
+                retval.append(f"    _{body_kwarg} = None")
         return retval
 
-    def _set_body_content_kwarg(self, builder: BuilderType, schema_request: SchemaRequest):
-        retval = []
-        if schema_request.is_stream_request:
-            retval.append(f"content = {builder.parameters.body[0].serialized_name}")
-        elif schema_request.body_parameter_has_schema and not builder.request_builder.multipart:
-            retval.extend(self._serialize_body(builder))
+    def _set_body_content_kwarg(
+        self, builder: BuilderType, body_param: Parameter, body_kwarg: Parameter
+    ) -> List[str]:
+        retval: List[str] = []
+        if body_kwarg.serialized_name == "data" or body_kwarg.serialized_name == "files":
+            return retval
+        try:
+            if not body_param.style == ParameterStyle.binary:
+                retval.extend(self._serialize_body(builder, body_param, body_kwarg.serialized_name))
+                return retval
+        except AttributeError:
+            pass
+        retval.append(f"_{body_kwarg.serialized_name} = {body_param.serialized_name}")
         return retval
 
 
@@ -739,15 +751,28 @@ class _OperationBaseSerializer(_BuilderBaseSerializer):  # pylint: disable=abstr
         self, builder: BuilderType,
     ) -> List[str]:
         retval = []
-        if len(builder.request_builder.schema_requests) == 1:
-            retval.extend(self._set_body_content_kwarg(builder, builder.request_builder.schema_requests[0]))
+        body_kwargs = [
+            p for p in builder.request_builder.parameters.body
+            if p.content_types
+        ]
+        builder_params = []
+        if builder.parameters.has_body:
+            builder_params += builder.parameters.body
+        if builder.multiple_content_type_parameters.has_body:
+            builder_params += builder.multiple_content_type_parameters.body
+        if len(body_kwargs) == 1:
+            retval.extend(self._set_body_content_kwarg(builder, builder.parameters.body[0], body_kwargs[0]))
         else:
-            for idx, schema_request in enumerate(builder.request_builder.schema_requests):
+            for idx, body_kwarg in enumerate(body_kwargs):
+                body_param = next(
+                    b for b in builder_params
+                    if body_kwarg in b.body_kwargs
+                )
                 if_statement = "if" if idx == 0 else "elif"
                 retval.append(
-                    f'{if_statement} content_type.split(";")[0] in {schema_request.pre_semicolon_media_types}:'
+                    f'{if_statement} content_type.split(";")[0] in {body_kwarg.pre_semicolon_content_types}:'
                 )
-                retval.extend(["    " + line for line in self._set_body_content_kwarg(builder, schema_request)])
+                retval.extend(["    " + line for line in self._set_body_content_kwarg(builder, body_param, body_kwarg)])
             retval.extend(_content_type_error_check(builder))
 
         return retval
@@ -765,7 +790,7 @@ class _OperationBaseSerializer(_BuilderBaseSerializer):  # pylint: disable=abstr
             if self.code_model.options["version_tolerant"]:
                 body_params_to_initialize = [p for p in body_params_to_initialize if p != "files"]
             for k in body_params_to_initialize:
-                retval.append(f"{k} = None")
+                retval.append(f"_{k} = None")
         if builder.parameters.grouped:
             # request builders don't allow grouped parameters, so we group them before making the call
             retval.extend(_serialize_grouped_body(builder))
@@ -774,8 +799,8 @@ class _OperationBaseSerializer(_BuilderBaseSerializer):  # pylint: disable=abstr
             # unflatten before passing to request builder as well
             retval.extend(_serialize_flattened_body(builder))
         if request_builder.multipart or request_builder.parameters.data_inputs:
-            param_name = "files" if request_builder.multipart else "data"
             if not self.code_model.options["version_tolerant"]:
+                param_name = "_files" if request_builder.multipart else "_data"
                 retval.extend(_serialize_files_and_data_body(builder, param_name))
         elif builder.parameters.has_body and not builder.parameters.body[0].constant:
             retval.extend(self._serialize_body_parameters(builder))
@@ -798,18 +823,23 @@ class _OperationBaseSerializer(_BuilderBaseSerializer):  # pylint: disable=abstr
                 continue
             high_level_name = cast(RequestBuilderParameter, parameter).name_in_high_level_operation
             retval.append(f"    {parameter.serialized_name}={high_level_name},")
-        template_url = template_url or f"self.{builder.name}.metadata['url']"
-        retval.append(f"    template_url={template_url},")
+        if not self.code_model.options["version_tolerant"]:
+            template_url = template_url or f"self.{builder.name}.metadata['url']"
+            retval.append(f"    template_url={template_url},")
         retval.append(f")")
         if not self.code_model.options["version_tolerant"]:
             pass_files = ""
             if "files" in builder.body_kwargs_to_pass_to_request_builder:
-                pass_files = ", files"
+                pass_files = ", _files"
             retval.append(f"request = _convert_request(request{pass_files})")
         if builder.parameters.path:
             retval.extend(self.serialize_path(builder))
+        url_to_format = "request.url"
+        if self.code_model.options["version_tolerant"] and template_url:
+            url_to_format = template_url
         retval.append(
-            "request.url = self._client.format_url(request.url{})".format(
+            "request.url = self._client.format_url({}{})".format(
+                url_to_format,
                 ", **path_format_arguments" if builder.parameters.path else ""
             )
         )
@@ -842,7 +872,7 @@ class _OperationBaseSerializer(_BuilderBaseSerializer):  # pylint: disable=abstr
             if self.code_model.options["models_mode"]:
                 retval.append(f"deserialized = self._deserialize('{response.serialization_type}', pipeline_response)")
             else:
-                is_xml = any(["xml" in ct for ct in response.media_types])
+                is_xml = any(["xml" in ct for ct in response.content_types])
                 deserialized_value = ""
                 deserialized_value = "ET.fromstring(response.text())" if is_xml else "response.json()"
                 retval.append(f"if response.content:")
@@ -980,11 +1010,11 @@ class SyncOperationGenericSerializer(_SyncOperationBaseSerializer):
     @staticmethod
     def _method_signature_and_response_type_annotation_template(method_signature: str, response_type_annotation: str):
         return utils.method_signature_and_response_type_annotation_template(
-            is_python_3_file=False, method_signature=method_signature, response_type_annotation=response_type_annotation
+            is_python3_file=False, method_signature=method_signature, response_type_annotation=response_type_annotation
         )
 
     def _get_kwargs_to_pop(self, builder: BuilderType):
-        return builder.parameters.kwargs_to_pop(is_python_3_file=False)
+        return builder.parameters.kwargs_to_pop(is_python3_file=False)
 
 
 class SyncOperationPython3Serializer(_SyncOperationBaseSerializer):
@@ -995,11 +1025,11 @@ class SyncOperationPython3Serializer(_SyncOperationBaseSerializer):
     @staticmethod
     def _method_signature_and_response_type_annotation_template(method_signature: str, response_type_annotation: str):
         return utils.method_signature_and_response_type_annotation_template(
-            is_python_3_file=True, method_signature=method_signature, response_type_annotation=response_type_annotation
+            is_python3_file=True, method_signature=method_signature, response_type_annotation=response_type_annotation
         )
 
     def _get_kwargs_to_pop(self, builder: BuilderType):
-        return builder.parameters.kwargs_to_pop(is_python_3_file=True)
+        return builder.parameters.kwargs_to_pop(is_python3_file=True)
 
 class AsyncOperationSerializer(SyncOperationPython3Serializer):
 
@@ -1032,7 +1062,7 @@ class _PagingOperationBaseSerializer(_OperationBaseSerializer):  # pylint: disab
     def call_next_link_request_builder(self, builder: BuilderType) -> List[str]:
         if builder.next_request_builder:
             request_builder = builder.next_request_builder
-            template_url = f"'{request_builder.url}'"
+            template_url = None if self.code_model.options["version_tolerant"] else f"'{request_builder.url}'"
         else:
             request_builder = builder.request_builder
             template_url = "next_link"
@@ -1420,14 +1450,14 @@ def get_operation_serializer(
     builder: BuilderType,
     code_model,
     async_mode: bool,
-    is_python_3_file: bool,
+    is_python3_file: bool,
 ) -> _OperationBaseSerializer:
     retcls = _OperationBaseSerializer
     if isinstance(builder, LROPagingOperation):
         retcls = (
             AsyncLROPagingOperationSerializer if async_mode
             else (
-                SyncLROPagingOperationPython3Serializer if is_python_3_file
+                SyncLROPagingOperationPython3Serializer if is_python3_file
                 else SyncLROPagingOperationGenericSerializer
             )
         )
@@ -1435,22 +1465,22 @@ def get_operation_serializer(
     if isinstance(builder, LROOperation):
         retcls = (
             AsyncLROOperationSerializer if async_mode
-            else (SyncLROOperationPython3Serializer if is_python_3_file else SyncLROOperationGenericSerializer)
+            else (SyncLROOperationPython3Serializer if is_python3_file else SyncLROOperationGenericSerializer)
         )
         return retcls(code_model)
     if isinstance(builder, PagingOperation):
         retcls = (
             AsyncPagingOperationSerializer if async_mode
-            else (SyncPagingOperationPython3Serializer if is_python_3_file else SyncPagingOperationGenericSerializer)
+            else (SyncPagingOperationPython3Serializer if is_python3_file else SyncPagingOperationGenericSerializer)
         )
         return retcls(code_model)
     retcls = (
         AsyncOperationSerializer if async_mode
-        else (SyncOperationPython3Serializer if is_python_3_file else SyncOperationGenericSerializer)
+        else (SyncOperationPython3Serializer if is_python3_file else SyncOperationGenericSerializer)
     )
     return retcls(code_model)
 
 
-def get_request_builder_serializer(code_model, is_python_3_file: bool) -> _RequestBuilderBaseSerializer:
-    retcls = RequestBuilderPython3Serializer if is_python_3_file else RequestBuilderGenericSerializer
+def get_request_builder_serializer(code_model, is_python3_file: bool) -> _RequestBuilderBaseSerializer:
+    retcls = RequestBuilderPython3Serializer if is_python3_file else RequestBuilderGenericSerializer
     return retcls(code_model)

package/autorest/codegen/serializers/client_serializer.py

@@ -9,27 +9,32 @@ from ..models import CodeModel
 
 
 class ClientSerializer:
-    def __init__(self, code_model: CodeModel) -> None:
+    def __init__(self, code_model: CodeModel, is_python3_file: bool) -> None:
         self.code_model = code_model
+        self.is_python3_file = is_python3_file
 
     def _init_signature(self, async_mode: bool) -> str:
         return utils.serialize_method(
             function_def="def",
             method_name="__init__",
             is_in_class=True,
-            method_param_signatures=self.code_model.service_client.parameters.client_method_signature(async_mode),
+            method_param_signatures=self.code_model.service_client.parameters.client_method_signature(
+                async_mode or self.is_python3_file
+            ),
         )
 
     def init_signature_and_response_type_annotation(self, async_mode: bool) -> str:
         init_signature = self._init_signature(async_mode)
         return utils.method_signature_and_response_type_annotation_template(
-            is_python_3_file=async_mode,
+            is_python3_file=async_mode or self.is_python3_file,
             method_signature=init_signature,
             response_type_annotation="None",
         )
 
     def pop_kwargs_from_signature(self, async_mode: bool) -> List[str]:
-        return utils.pop_kwargs_from_signature(self.code_model.service_client.parameters.kwargs_to_pop(async_mode))
+        return utils.pop_kwargs_from_signature(self.code_model.service_client.parameters.kwargs_to_pop(
+            async_mode or self.is_python3_file
+        ))
 
     def class_definition(self, async_mode) -> str:
         class_name = self.code_model.class_name
@@ -37,7 +42,7 @@ class ClientSerializer:
         base_class = ""
         if has_mixin_og:
             base_class = f"{class_name}OperationsMixin"
-        elif not async_mode:
+        elif not (async_mode or self.is_python3_file):
             base_class = "object"
         if base_class:
             return f"class {class_name}({base_class}):"
@@ -107,13 +112,15 @@ class ClientSerializer:
             function_def="def",
             method_name=self.code_model.send_request_name,
             is_in_class=True,
-            method_param_signatures=self.code_model.service_client.send_request_signature(async_mode),
+            method_param_signatures=self.code_model.service_client.send_request_signature(
+                async_mode, async_mode or self.is_python3_file
+            ),
         )
 
     def send_request_signature_and_response_type_annotation(self, async_mode: bool) -> str:
         send_request_signature = self._send_request_signature(async_mode)
         return utils.method_signature_and_response_type_annotation_template(
-            is_python_3_file=async_mode,
+            is_python3_file=async_mode or self.is_python3_file,
             method_signature=send_request_signature,
             response_type_annotation="Awaitable[AsyncHttpResponse]" if async_mode else "HttpResponse",
         )
@@ -179,11 +186,32 @@ class ClientSerializer:
 
 class ConfigSerializer:
 
-    def __init__(self, code_model: CodeModel) -> None:
+    def __init__(self, code_model: CodeModel, is_python3_file: bool) -> None:
         self.code_model = code_model
+        self.is_python3_file = is_python3_file
+
+    def _init_signature(self, async_mode: bool) -> str:
+        return utils.serialize_method(
+            function_def="def",
+            method_name="__init__",
+            is_in_class=True,
+            method_param_signatures=self.code_model.global_parameters.config_method_signature(
+                async_mode or self.is_python3_file
+            ),
+        )
+
+    def init_signature_and_response_type_annotation(self, async_mode: bool) -> str:
+        init_signature = self._init_signature(async_mode)
+        return utils.method_signature_and_response_type_annotation_template(
+            is_python3_file=async_mode or self.is_python3_file,
+            method_signature=init_signature,
+            response_type_annotation="None",
+        )
 
     def pop_kwargs_from_signature(self, async_mode: bool) -> List[str]:
-        return utils.pop_kwargs_from_signature(self.code_model.global_parameters.config_kwargs_to_pop(async_mode))
+        return utils.pop_kwargs_from_signature(self.code_model.global_parameters.config_kwargs_to_pop(
+            async_mode or self.is_python3_file
+        ))
 
     def set_constants(self) -> List[str]:
         return [

package/autorest/codegen/serializers/general_serializer.py

@@ -54,13 +54,14 @@ class GeneralSerializer:
         ):
             self._correct_credential_parameter()
 
+        python3_only = self.code_model.options["python3_only"]
         return template.render(
             code_model=self.code_model,
             async_mode=self.async_mode,
-            serializer=ClientSerializer(self.code_model),
+            serializer=ClientSerializer(self.code_model, is_python3_file=python3_only),
             imports=FileImportSerializer(
                 self.code_model.service_client.imports(self.async_mode),
-                is_python_3_file=self.async_mode
+                is_python3_file=self.async_mode or python3_only
             ),
         )
 
@@ -80,7 +81,7 @@ class GeneralSerializer:
             code_model=self.code_model,
             imports=FileImportSerializer(
                 file_import,
-                is_python_3_file=self.async_mode,
+                is_python3_file=self.async_mode,
             )
         )
 
@@ -99,15 +100,16 @@ class GeneralSerializer:
             self._correct_credential_parameter()
 
         template = self.env.get_template("config.py.jinja2")
+        python3_only = self.code_model.options["python3_only"]
         return template.render(
             code_model=self.code_model,
             async_mode=self.async_mode,
             imports=FileImportSerializer(
                 config_imports(
                     self.code_model, self.code_model.global_parameters, self.async_mode
-                ), is_python_3_file=self.async_mode
+                ), is_python3_file=self.async_mode or python3_only
             ),
-            serializer=ConfigSerializer(self.code_model),
+            serializer=ConfigSerializer(self.code_model, is_python3_file=python3_only),
             sdk_moniker=sdk_moniker,
         )
 

package/autorest/codegen/serializers/import_serializer.py

@@ -42,9 +42,10 @@ def _get_import_clauses(
 
 
 class FileImportSerializer:
-    def __init__(self, file_import: FileImport, is_python_3_file: bool) -> None:
+    def __init__(self, file_import: FileImport, is_python3_file: bool, async_mode: bool = False) -> None:
         self._file_import = file_import
-        self.is_python_3_file = is_python_3_file
+        self.is_python3_file = is_python3_file
+        self.async_mode = async_mode
 
     def _switch_typing_section_key(self, new_key: TypingSection):
         switched_dictionary = {}
@@ -66,15 +67,30 @@ class FileImportSerializer:
     def _add_type_checking_import(self):
         if (
             self._file_import.imports.get(TypingSection.TYPING) or
-            (not self.is_python_3_file and self._file_import.imports.get(TypingSection.CONDITIONAL))
+            (not self.is_python3_file and self._file_import.imports.get(TypingSection.CONDITIONAL))
         ):
             self._file_import.add_from_import("typing", "TYPE_CHECKING", ImportType.STDLIB)
 
+    def _get_typing_definitions(self) -> str:
+        if not self._file_import.type_definitions:
+            return ""
+        spacing = "" if self.is_python3_file else "    "
+        declarations: List[str] = [f"\n{spacing}T = TypeVar('T')"]
+        declarations.extend([
+            "{}{} = {}".format(
+                spacing,
+                type_name,
+                values[1] if self.async_mode else values[0]
+            )
+            for type_name, values in self._file_import.type_definitions.items()
+        ])
+        return "\n".join(declarations)
+
     def __str__(self) -> str:
         self._add_type_checking_import()
         regular_imports = ""
         regular_imports_dict = self._get_imports_dict(
-            baseline_typing_section=TypingSection.REGULAR, add_conditional_typing=self.is_python_3_file
+            baseline_typing_section=TypingSection.REGULAR, add_conditional_typing=self.is_python3_file
         )
 
         if regular_imports_dict:
@@ -84,10 +100,9 @@ class FileImportSerializer:
 
         typing_imports = ""
         typing_imports_dict = self._get_imports_dict(
-            baseline_typing_section=TypingSection.TYPING, add_conditional_typing=not self.is_python_3_file
+            baseline_typing_section=TypingSection.TYPING, add_conditional_typing=not self.is_python3_file
         )
         if typing_imports_dict:
             typing_imports += "\n\nif TYPE_CHECKING:\n    # pylint: disable=unused-import,ungrouped-imports\n    "
             typing_imports += "\n\n    ".join(_get_import_clauses(typing_imports_dict, "\n    "))
-
-        return regular_imports + typing_imports
+        return regular_imports + typing_imports + self._get_typing_definitions()

package/autorest/codegen/serializers/metadata_serializer.py

@@ -185,9 +185,9 @@ class MetadataSerializer:
                 config_imports(self.code_model, async_global_parameters, async_mode=True).imports
             ),
             get_async_operation_serializer=functools.partial(
-                get_operation_serializer, code_model=self.code_model, async_mode=True, is_python_3_file=True
+                get_operation_serializer, code_model=self.code_model, async_mode=True, is_python3_file=True
             ),
             get_sync_operation_serializer=functools.partial(
-                get_operation_serializer, code_model=self.code_model, async_mode=False, is_python_3_file=False
+                get_operation_serializer, code_model=self.code_model, async_mode=False, is_python3_file=False
             ),
         )

package/autorest/codegen/serializers/model_base_serializer.py

@@ -24,17 +24,17 @@ def _documentation_string(
 
 
 class ModelBaseSerializer:
-    def __init__(self, code_model: CodeModel, env: Environment, is_python_3_file: bool) -> None:
+    def __init__(self, code_model: CodeModel, env: Environment, is_python3_file: bool) -> None:
         self.code_model = code_model
         self.env = env
-        self.is_python_3_file = is_python_3_file
+        self.is_python3_file = is_python3_file
 
     def serialize(self) -> str:
         # Generate the models
         template = self.env.get_template("model_container.py.jinja2")
         return template.render(
             code_model=self.code_model,
-            imports=FileImportSerializer(self.imports(), is_python_3_file=self.is_python_3_file),
+            imports=FileImportSerializer(self.imports(), is_python3_file=self.is_python3_file),
             str=str,
             init_line=self.init_line,
             init_args=self.init_args,

package/autorest/codegen/serializers/model_generic_serializer.py

@@ -13,7 +13,7 @@ class ModelGenericSerializer(ModelBaseSerializer):
 
     def __init__(self, code_model: CodeModel, env: Environment) -> None:
         super(ModelGenericSerializer, self).__init__(
-            code_model=code_model, env=env, is_python_3_file=False
+            code_model=code_model, env=env, is_python3_file=False
         )
 
     def init_line(self, model: ObjectSchema) -> List[str]:

package/autorest/codegen/serializers/model_python3_serializer.py

@@ -14,7 +14,7 @@ class ModelPython3Serializer(ModelBaseSerializer):
 
     def __init__(self, code_model: CodeModel, env: Environment) -> None:
         super(ModelPython3Serializer, self).__init__(
-            code_model=code_model, env=env, is_python_3_file=True
+            code_model=code_model, env=env, is_python3_file=True
         )
 
     def init_line(self, model: ObjectSchema) -> List[str]:

package/autorest/codegen/serializers/operation_groups_serializer.py

@@ -0,0 +1,70 @@
+# -------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for
+# license information.
+# --------------------------------------------------------------------------
+from typing import Optional
+import functools
+from jinja2 import Environment
+
+from ..models import (
+    CodeModel,
+    OperationGroup,
+    FileImport,
+    LROOperation,
+    PagingOperation
+)
+from .import_serializer import FileImportSerializer
+from .builder_serializer import get_operation_serializer, get_request_builder_serializer
+
+class OperationGroupsSerializer:
+    def __init__(
+        self,
+        code_model: CodeModel,
+        env: Environment,
+        async_mode: bool,
+        is_python3_file: bool,
+        operation_group: Optional[OperationGroup] = None,
+    ) -> None:
+        self.code_model = code_model
+        self.env = env
+        self.async_mode = async_mode
+        self.is_python3_file = is_python3_file
+        self.operation_group = operation_group
+
+    def serialize(self) -> str:
+        def _is_lro(operation):
+            return isinstance(operation, LROOperation)
+
+        def _is_paging(operation):
+            return isinstance(operation, PagingOperation)
+        operation_groups = [self.operation_group] if self.operation_group else self.code_model.operation_groups
+        imports = FileImport()
+        for operation_group in operation_groups:
+            imports.merge(operation_group.imports(
+                async_mode=self.async_mode,
+            ))
+
+        template = self.env.get_or_select_template("operation_groups_container.py.jinja2")
+        return template.render(
+            code_model=self.code_model,
+            operation_groups=operation_groups,
+            imports=FileImportSerializer(
+                imports,
+                is_python3_file=self.is_python3_file,
+                async_mode=self.async_mode
+            ),
+            async_mode=self.async_mode,
+            is_python3_file=self.is_python3_file,
+            is_lro=_is_lro,
+            is_paging=_is_paging,
+            get_operation_serializer=functools.partial(
+                get_operation_serializer,
+                code_model=self.code_model,
+                async_mode=self.async_mode,
+                is_python3_file=self.is_python3_file,
+            ),
+            request_builder_serializer=get_request_builder_serializer(
+                self.code_model, self.is_python3_file,
+            ),
+        )