@autorest/python 5.12.6 → 5.15.0

package/autorest/codegen/serializers/builder_serializer.py

@@ -27,6 +27,7 @@ from ..models import (
     SchemaResponse,
     IOSchema,
     ParameterStyle,
+    ParameterLocation
 )
 from . import utils
 
@@ -109,12 +110,6 @@ def _serialize_files_and_data_body(builder, param_name: str) -> List[str]:
     retval.append("}")
     return retval
 
-def _pop_parameters_kwarg(
-    function_name: str,
-    kwarg_name: str,
-) -> str:
-    return f'_{function_name}_parameters = kwargs.pop("{kwarg_name}", {{}})  # type: Dict[str, Any]'
-
 def _serialize_grouped_body(builder) -> List[str]:
     retval: List[str] = []
     for grouped_parameter in builder.parameters.grouped:
@@ -152,12 +147,21 @@ def _serialize_flattened_body(builder) -> List[str]:
     return retval
 
 def _content_type_docstring(builder) -> str:
-    content_type_str = (
-        ":keyword str content_type: Media type of the body sent to the API. " +
-        f'Default value is "{builder.parameters.default_content_type}". ' +
-        'Allowed values are: "{}."'.format('", "'.join(builder.parameters.content_types))
+    content_types = [f'"{c}"' for c in builder.parameters.content_types]
+    if len(content_types) == 2:
+        possible_values_str = " or ".join(content_types)
+    else:
+        possible_values_str = ", ".join(
+            content_types[: len(content_types) - 1]
+        ) + f", and {content_types[-1]}"
+    default_value = next(
+        p for p in builder.parameters.method if p.rest_api_name == "Content-Type"
+    ).default_value_declaration
+    return (
+        ":keyword content_type: Media type of the body sent to the API. " +
+        f"Known values are: {possible_values_str}. " +
+        f"Default value is {default_value}."
     )
-    return content_type_str
 
 class _BuilderSerializerProtocol(ABC):
     @property
@@ -304,13 +308,14 @@ class _BuilderBaseSerializer(_BuilderSerializerProtocol):  # pylint: disable=abs
             description_list.append(
                 f":{param.docstring_type_keyword} { param.serialized_name }: { param.docstring_type }"
             )
-        try:
-            request_builder: RequestBuilder = cast(Operation, builder).request_builder
-        except AttributeError:
-            request_builder = cast(RequestBuilder, builder)
 
-        if len(request_builder.schema_requests) > 1:
-            description_list.append(_content_type_docstring(builder))
+        if len(builder.parameters.content_types) > 1:
+            description_list = [
+                _content_type_docstring(builder) if l.startswith(":keyword content_type:") else l
+                for l in description_list
+            ]
+            if not any(l for l in description_list if l.startswith(":keyword content_type:")):
+                description_list.append(_content_type_docstring(builder))
         return description_list
 
     def param_description_and_response_docstring(self, builder) -> List[str]:
@@ -400,10 +405,11 @@ class _BuilderBaseSerializer(_BuilderSerializerProtocol):  # pylint: disable=abs
         ...
 
     def _serialize_parameter(
-        self, param: Parameter, function_name: str
+        self, param: Parameter, kwarg_name: str
     ) -> List[str]:
-        set_parameter = "_{}_parameters['{}'] = {}".format(
-            function_name,
+        function_name = "header" if kwarg_name == "headers" else "query"
+        set_parameter = "_{}['{}'] = {}".format(
+            kwarg_name,
             param.rest_api_name,
             utils.build_serialize_data_call(param, function_name, self.serializer_name)
         )
@@ -423,10 +429,6 @@ class _BuilderBaseSerializer(_BuilderSerializerProtocol):  # pylint: disable=abs
             template.extend(f"response.json() == {response_body}".splitlines())
         return template
 
-
-    def pop_kwargs_from_signature(self, builder) -> List[str]:
-        return utils.pop_kwargs_from_signature(self._get_kwargs_to_pop(builder))
-
     def serialize_path(self, builder) -> List[str]:
         return utils.serialize_path(builder.parameters.path, self.serializer_name)
 
@@ -452,6 +454,21 @@ class _RequestBuilderBaseSerializer(_BuilderBaseSerializer):  # pylint: disable=
     def serializer_name(self) -> str:
         return "_SERIALIZER"
 
+    @staticmethod
+    def declare_non_inputtable_constants(builder) -> List[str]:
+        def _get_value(param: Parameter):
+            if param.location in [ParameterLocation.Header, ParameterLocation.Query]:
+                kwarg_dict = "headers" if param.location == ParameterLocation.Header else "params"
+                return f"_{kwarg_dict}.pop('{param.rest_api_name}', {param.constant_declaration})"
+            return f"{param.constant_declaration}"
+        return [
+            f"{p.serialized_name} = {_get_value(p)}"
+            for p in builder.parameters.constant
+            if p.original_parameter is None and
+            p.in_method_code and
+            not p.in_method_signature
+        ]
+
     def want_example_template(self, builder) -> bool:
         if self.code_model.options["builders_visibility"] != "public":
             return False  # if we're not exposing rest layer, don't need to generate
@@ -496,14 +513,24 @@ class _RequestBuilderBaseSerializer(_BuilderBaseSerializer):  # pylint: disable=
     def _body_params_to_pass_to_request_creation(self, builder) -> List[str]:
         ...
 
+    def pop_kwargs_from_signature(self, builder) -> List[str]:
+        return utils.pop_kwargs_from_signature(
+            self._get_kwargs_to_pop(builder),
+            check_kwarg_dict=True,
+            pop_headers_kwarg=utils.PopKwargType.CASE_INSENSITIVE if bool(builder.parameters.headers)
+                                else utils.PopKwargType.NO,
+            pop_params_kwarg=utils.PopKwargType.CASE_INSENSITIVE if bool(builder.parameters.query)
+                                else utils.PopKwargType.NO,
+        )
+
     def create_http_request(self, builder) -> List[str]:
         retval = ["return HttpRequest("]
         retval.append(f'    method="{builder.method}",')
         retval.append("    url=_url,")
         if builder.parameters.query:
-            retval.append("    params=_query_parameters,")
+            retval.append("    params=_params,")
         if builder.parameters.headers:
-            retval.append("    headers=_header_parameters,")
+            retval.append("    headers=_headers,")
         if builder.parameters.has_body:
             retval.extend([
                 f"    {body_kwarg}={body_kwarg},"
@@ -515,21 +542,19 @@ class _RequestBuilderBaseSerializer(_BuilderBaseSerializer):  # pylint: disable=
 
     def serialize_headers(self, builder) -> List[str]:
         retval = ["# Construct headers"]
-        retval.append(_pop_parameters_kwarg("header", "headers"))
         for parameter in builder.parameters.headers:
             retval.extend(self._serialize_parameter(
                 parameter,
-                function_name="header",
+                kwarg_name="headers",
             ))
         return retval
 
     def serialize_query(self, builder) -> List[str]:
         retval = ["# Construct parameters"]
-        retval.append(_pop_parameters_kwarg("query", "params"))
         for parameter in builder.parameters.query:
             retval.extend(self._serialize_parameter(
                 parameter,
-                function_name="query",
+                kwarg_name="params",
             ))
         return retval
 
@@ -633,7 +658,7 @@ class _OperationBaseSerializer(_BuilderBaseSerializer):  # pylint: disable=abstr
             return "bool"
         response_body_annotations: OrderedSet[str] = {}
         for response in [r for r in builder.responses if r.has_body]:
-            response_body_annotations[response.operation_type_annotation] = None
+            response_body_annotations[response.type_annotation(is_operation_file=True)] = None
         response_str = ", ".join(response_body_annotations.keys()) or "None"
         if len(response_body_annotations) > 1:
             response_str = f"Union[{response_str}]"
@@ -641,6 +666,19 @@ class _OperationBaseSerializer(_BuilderBaseSerializer):  # pylint: disable=abstr
             response_str = f"Optional[{response_str}]"
         return response_str
 
+    def pop_kwargs_from_signature(self, builder) -> List[str]:
+        kwargs_to_pop = self._get_kwargs_to_pop(builder)
+        kwargs = utils.pop_kwargs_from_signature(
+            kwargs_to_pop,
+            check_kwarg_dict=True,
+            pop_headers_kwarg=utils.PopKwargType.CASE_INSENSITIVE if builder.has_kwargs_to_pop_with_default(
+                kwargs_to_pop, ParameterLocation.Header) else utils.PopKwargType.SIMPLE,
+            pop_params_kwarg=utils.PopKwargType.CASE_INSENSITIVE if builder.has_kwargs_to_pop_with_default(
+                kwargs_to_pop, ParameterLocation.Query) else utils.PopKwargType.SIMPLE,
+        )
+        kwargs.append(f"cls = kwargs.pop('cls', None)  {self.cls_type_annotation(builder)}")
+        return kwargs
+
     def cls_type_annotation(self, builder) -> str:
         return f"# type: ClsType[{self._response_type_annotation(builder, modify_if_head_as_boolean=False)}]"
 
@@ -769,6 +807,7 @@ class _OperationBaseSerializer(_BuilderBaseSerializer):  # pylint: disable=abstr
         if len(body_kwargs) == 1:
             retval.extend(self._set_body_content_kwarg(builder, builder.parameters.body[0], body_kwargs[0]))
         else:
+            retval.append('content_type = content_type or ""')
             for idx, body_kwarg in enumerate(body_kwargs):
                 body_param = next(
                     b for b in builder_params
@@ -788,6 +827,7 @@ class _OperationBaseSerializer(_BuilderBaseSerializer):  # pylint: disable=abstr
         builder,
         request_builder: RequestBuilder,
         template_url: Optional[str] = None,
+        is_next_request: bool = False,
     ) -> List[str]:
         retval = []
         if len(builder.body_kwargs_to_pass_to_request_builder) > 1:
@@ -827,11 +867,23 @@ class _OperationBaseSerializer(_BuilderBaseSerializer):  # pylint: disable=abstr
                 parameter.serialized_name not in builder.body_kwargs_to_pass_to_request_builder
             ):
                 continue
+            if (
+                is_next_request and
+                not bool(builder.next_request_builder) and
+                not self.code_model.options["reformat_next_link"] and
+                parameter.location == ParameterLocation.Query
+            ):
+                # if we don't want to reformat query parameters for next link calls
+                # in paging operations with a single swagger operation defintion,
+                # we skip passing query params when building the next request
+                continue
             high_level_name = cast(RequestBuilderParameter, parameter).name_in_high_level_operation
             retval.append(f"    {parameter.serialized_name}={high_level_name},")
         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('    headers=_headers,')
+        retval.append('    params=_params,')
         retval.append(f")")
         if not self.code_model.options["version_tolerant"]:
             pass_files = ""
@@ -844,7 +896,7 @@ class _OperationBaseSerializer(_BuilderBaseSerializer):  # pylint: disable=abstr
         if self.code_model.options["version_tolerant"] and template_url:
             url_to_format = template_url
         retval.append(
-            "request.url = self._client.format_url({}{})".format(
+            "request.url = self._client.format_url({}{})  # type: ignore".format(
                 url_to_format,
                 ", **path_format_arguments" if builder.parameters.path else ""
             )
@@ -879,12 +931,11 @@ class _OperationBaseSerializer(_BuilderBaseSerializer):  # pylint: disable=abstr
                 retval.append(f"deserialized = self._deserialize('{response.serialization_type}', pipeline_response)")
             else:
                 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:")
                 retval.append(f"    deserialized = {deserialized_value}")
                 retval.append("else:")
-                retval.append("    deserialized = None")
+                retval.append(f"    deserialized = None")
         return retval
 
     @property
@@ -932,14 +983,18 @@ class _OperationBaseSerializer(_BuilderBaseSerializer):  # pylint: disable=abstr
                     builder.responses[0]
                 ))
                 retval.append("")
+        if builder.has_optional_return_type or self.code_model.options["models_mode"]:
+            deserialized = "deserialized"
+        else:
+            deserialized = f"cast({self._response_type_annotation(builder)}, deserialized)"
         retval.append("if cls:")
         retval.append("    return cls(pipeline_response, {}, {})".format(
-            "deserialized" if builder.has_response_body else "None",
+            deserialized if builder.has_response_body else "None",
             "response_headers" if builder.any_response_has_headers else '{}'
         ))
         if builder.has_response_body:
             retval.append("")
-            retval.append("return deserialized")
+            retval.append(f"return {deserialized}")
         if builder.request_builder.method == 'HEAD' and self.code_model.options['head_as_boolean']:
             retval.append("return 200 <= response.status_code <= 299")
         return retval
@@ -988,7 +1043,7 @@ class _OperationBaseSerializer(_BuilderBaseSerializer):  # pylint: disable=abstr
         else:
             retval.append("    401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError")
         retval.append("}")
-        retval.append("error_map.update(kwargs.pop('error_map', {}))")
+        retval.append("error_map.update(kwargs.pop('error_map', {}) or {})")
         return retval
 
     @staticmethod
@@ -1073,11 +1128,13 @@ class _PagingOperationBaseSerializer(_OperationBaseSerializer):  # pylint: disab
         else:
             request_builder = builder.request_builder
             template_url = "next_link"
+
         request_builder = builder.next_request_builder or builder.request_builder
         return self._call_request_builder_helper(
             builder,
             request_builder,
             template_url=template_url,
+            is_next_request=True
         )
 
     def _prepare_request_callback(self, builder) -> List[str]:
@@ -1161,7 +1218,7 @@ class _PagingOperationBaseSerializer(_OperationBaseSerializer):  # pylint: disab
         return retval
 
     def set_up_params_for_pager(self, builder) -> List[str]:
-        retval = [f"cls = kwargs.pop('cls', None)  {self.cls_type_annotation(builder)}"]
+        retval = []
         retval.extend(self.error_map(builder))
         retval.extend(self._prepare_request_callback(builder))
         retval.append("")
@@ -1252,19 +1309,20 @@ class _LROOperationBaseSerializer(_OperationBaseSerializer):  # pylint: disable=
 
     def initial_call(self, builder) -> List[str]:
         retval = [f"polling = kwargs.pop('polling', True)  # type: Union[bool, {self._polling_method_type}]"]
-        retval.append(f"cls = kwargs.pop('cls', None)  {self.cls_type_annotation(builder)}")
         retval.append("lro_delay = kwargs.pop(")
         retval.append("    'polling_interval',")
         retval.append("    self._config.polling_interval")
         retval.append(")")
         retval.append("cont_token = kwargs.pop('continuation_token', None)  # type: Optional[str]")
         retval.append("if cont_token is None:")
-        retval.append(f"    raw_result = {self._call_method}self.{builder.initial_operation.name}(")
+        retval.append(f"    raw_result = {self._call_method}self.{builder.initial_operation.name}(  # type: ignore")
         retval.extend([
             f"        {parameter.serialized_name}={parameter.serialized_name},"
             for parameter in builder.parameters.method
         ])
         retval.append("        cls=lambda x,y,z: x,")
+        retval.append("        headers=_headers,")
+        retval.append("        params=_params,")
         retval.append("        **kwargs")
         retval.append("    )")
         retval.append("kwargs.pop('error_map', None)")
@@ -1273,20 +1331,27 @@ class _LROOperationBaseSerializer(_OperationBaseSerializer):  # pylint: disable=
     def return_lro_poller(self, builder) -> List[str]:
         retval = []
         lro_options_str = (
-            ", lro_options={'final-state-via': '" + builder.lro_options['final-state-via'] + "'}"
+            "lro_options={'final-state-via': '" + builder.lro_options['final-state-via'] + "'},"
             if builder.lro_options else ""
         )
         path_format_arguments_str = ""
         if builder.parameters.path:
-            path_format_arguments_str = ", path_format_arguments=path_format_arguments"
+            path_format_arguments_str = "path_format_arguments=path_format_arguments,"
             retval.extend(self.serialize_path(builder))
             retval.append("")
-        retval.append(
-            f"if polling is True: polling_method = {self._default_polling_method(builder)}" +
-            f"(lro_delay{lro_options_str}{path_format_arguments_str}, **kwargs)"
+        retval.extend([
+            "if polling is True:",
+            f"    polling_method = cast({self._polling_method_type}, {self._default_polling_method(builder)}(",
+            "        lro_delay,",
+            f"        {lro_options_str}",
+            f"        {path_format_arguments_str}",
+            "        **kwargs",
+            f"))  # type: {self._polling_method_type}",
+        ]
         )
         retval.append(
-            f"elif polling is False: polling_method = {self._default_no_polling_method(builder)}()"
+            f"elif polling is False: polling_method = cast({self._polling_method_type}, "
+            f"{self._default_no_polling_method(builder)}())"
         )
         retval.append("else: polling_method = polling")
         retval.append("if cont_token:")
@@ -1307,7 +1372,8 @@ class _LROOperationBaseSerializer(_OperationBaseSerializer):  # pylint: disable=
         if builder.lro_response:
             if builder.lro_response.has_headers:
                 retval.append("    response_headers = {}")
-            retval.append("    response = pipeline_response.http_response")
+            if not self.code_model.options["models_mode"] or builder.lro_response.has_headers:
+                retval.append("    response = pipeline_response.http_response")
             retval.extend([
                 f"    {line}"
                 for line in self.response_headers_and_deserialization(builder.lro_response)

package/autorest/codegen/serializers/client_serializer.py

@@ -32,9 +32,14 @@ class ClientSerializer:
         )
 
     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 or self.is_python3_file
-        ))
+        return utils.pop_kwargs_from_signature(
+            self.code_model.service_client.parameters.kwargs_to_pop(
+                async_mode or self.is_python3_file,
+            ),
+            check_kwarg_dict=False,
+            pop_headers_kwarg=utils.PopKwargType.NO,
+            pop_params_kwarg=utils.PopKwargType.NO,
+        )
 
     def class_definition(self, async_mode) -> str:
         class_name = self.code_model.class_name
@@ -212,9 +217,14 @@ class ConfigSerializer:
         )
 
     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 or self.is_python3_file
-        ))
+        return utils.pop_kwargs_from_signature(
+            self.code_model.global_parameters.config_kwargs_to_pop(
+                async_mode or self.is_python3_file
+            ),
+            check_kwarg_dict=False,
+            pop_headers_kwarg=utils.PopKwargType.NO,
+            pop_params_kwarg=utils.PopKwargType.NO,
+        )
 
     def set_constants(self) -> List[str]:
         return [

package/autorest/codegen/serializers/general_serializer.py

@@ -50,7 +50,7 @@ class GeneralSerializer:
 
         if (
             self.code_model.options['credential'] and
-            isinstance(self.code_model.credential_schema_policy.credential, TokenCredentialSchema)
+            isinstance(self.code_model.credential_model.credential_schema_policy.credential, TokenCredentialSchema)
         ):
             self._correct_credential_parameter()
 
@@ -77,12 +77,33 @@ class GeneralSerializer:
                 ImportType.AZURECORE,
             )
 
+        if self.code_model.need_mixin_abc:
+            file_import.add_submodule_import(
+                "abc",
+                "ABC",
+                ImportType.STDLIB,
+            )
+            file_import.add_submodule_import(
+                "azure.core",
+                f"{'Async' if self.async_mode else ''}PipelineClient",
+                ImportType.AZURECORE,
+                TypingSection.TYPING,
+            )
+            file_import.add_submodule_import(
+                "._configuration",
+                f"{self.code_model.class_name}Configuration",
+                ImportType.LOCAL
+            )
+            file_import.add_submodule_import("msrest", "Serializer", ImportType.THIRDPARTY, TypingSection.TYPING)
+            file_import.add_submodule_import("msrest", "Deserializer", ImportType.THIRDPARTY, TypingSection.TYPING)
+
         return template.render(
             code_model=self.code_model,
             imports=FileImportSerializer(
                 file_import,
                 is_python3_file=self.async_mode,
-            )
+            ),
+            async_mode=self.async_mode,
         )
 
 
@@ -95,7 +116,7 @@ class GeneralSerializer:
 
         if (
             self.code_model.options['credential'] and
-            isinstance(self.code_model.credential_schema_policy.credential, TokenCredentialSchema)
+            isinstance(self.code_model.credential_model.credential_schema_policy.credential, TokenCredentialSchema)
         ):
             self._correct_credential_parameter()
 
@@ -119,4 +140,7 @@ class GeneralSerializer:
 
     def serialize_setup_file(self) -> str:
         template = self.env.get_template("setup.py.jinja2")
-        return template.render(code_model=self.code_model)
+        params = {}
+        params.update(self.code_model.options)
+        params.update(self.code_model.package_dependency)
+        return template.render(code_model=self.code_model, **params)

package/autorest/codegen/serializers/import_serializer.py

@@ -12,7 +12,7 @@ def _serialize_package(
 ) -> str:
     buffer = []
     if any(i for i in imports if i.submodule_name is None):
-        buffer.append(f"import {imports[0].module_name}")
+        buffer.append(f"import {imports[0].module_name}{f' as {imports[0].alias}' if imports[0].alias else ''}")
     else:
         import_str = ", ".join(sorted([
             f"{i.submodule_name} as {i.alias}" if i.alias else i.submodule_name for i in imports # type: ignore

package/autorest/codegen/serializers/metadata_serializer.py

@@ -145,7 +145,7 @@ class MetadataSerializer:
         async_global_parameters = self.code_model.global_parameters
         if (
             self.code_model.options['credential'] and
-            isinstance(self.code_model.credential_schema_policy.credential, TokenCredentialSchema)
+            isinstance(self.code_model.credential_model.credential_schema_policy.credential, TokenCredentialSchema)
         ):
             # this ensures that the TokenCredentialSchema showing up in the list of code model's global parameters
             # is sync. This way we only have to make a copy for an async_credential

package/autorest/codegen/serializers/model_base_serializer.py

@@ -40,6 +40,7 @@ class ModelBaseSerializer:
             init_args=self.init_args,
             input_documentation_string=ModelBaseSerializer.input_documentation_string,
             variable_documentation_string=ModelBaseSerializer.variable_documentation_string,
+            declare_model=ModelBaseSerializer.declare_model,
         )
 
     def imports(self) -> FileImport:
@@ -62,6 +63,13 @@ class ModelBaseSerializer:
             properties_to_initialize = model.properties
         return properties_to_initialize
 
+    @staticmethod
+    def declare_model(model: ObjectSchema) -> str:
+        basename = "msrest.serialization.Model"
+        if model.base_models:
+            basename = ", ".join([cast(ObjectSchema, m).name for m in model.base_models])
+        return f"class {model.name}({basename}):"
+
     @staticmethod
     def input_documentation_string(prop: Property) -> List[str]:
         # building the param line of the property doc

package/autorest/codegen/serializers/model_python3_serializer.py

@@ -46,11 +46,11 @@ class ModelPython3Serializer(ModelBaseSerializer):
         return ", ".join(properties_to_pass_to_super)
 
     def required_property_no_default_init(self, prop: Property) -> str:
-        return f"{prop.name}: {prop.type_annotation}"
+        return f"{prop.name}: {prop.type_annotation()}"
 
     def optional_property_init(self, prop: Property) -> str:
         default = prop.default_value_declaration
-        return f"{prop.name}: {prop.type_annotation} = {default}"
+        return f"{prop.name}: {prop.type_annotation()} = {default}"
 
     def initialize_standard_arg(self, prop: Property) -> str:
         return f"self.{prop.name} = {prop.name}"

package/autorest/codegen/serializers/operation_groups_serializer.py

@@ -43,6 +43,7 @@ class OperationGroupsSerializer:
         for operation_group in operation_groups:
             imports.merge(operation_group.imports(
                 async_mode=self.async_mode,
+                is_python3_file=self.is_python3_file,
             ))
 
         template = self.env.get_or_select_template("operation_groups_container.py.jinja2")

package/autorest/codegen/serializers/patch_serializer.py

@@ -4,12 +4,21 @@
 # license information.
 # --------------------------------------------------------------------------
 from jinja2 import Environment
-
+from .import_serializer import FileImportSerializer
+from ..models import CodeModel, FileImport, ImportType, TypingSection
 
 class PatchSerializer:
-    def __init__(self, env: Environment) -> None:
+    def __init__(self, env: Environment, code_model: CodeModel) -> None:
         self.env = env
+        self.code_model = code_model
 
     def serialize(self) -> str:
         template = self.env.get_template("patch.py.jinja2")
-        return template.render()
+        imports = FileImport()
+        imports.add_submodule_import("typing", "List", ImportType.STDLIB, TypingSection.CONDITIONAL)
+        is_python3_file = self.code_model.options["python3_only"]
+        return template.render(
+            code_model=self.code_model,
+            imports=FileImportSerializer(imports, is_python3_file=is_python3_file),
+            is_python3_file=is_python3_file,
+        )

package/autorest/codegen/serializers/utils.py

@@ -3,8 +3,9 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
+from enum import Enum, auto
 from typing import List
-from ..models import ParameterStyle, ListSchema, Parameter
+from ..models import ParameterStyle, ListSchema, Parameter, ParameterLocation
 
 
 def serialize_method(
@@ -102,16 +103,40 @@ def method_signature_and_response_type_annotation_template(
         return f"{method_signature} -> {response_type_annotation}:"
     return f"{method_signature}:\n    # type: (...) -> {response_type_annotation}"
 
-def pop_kwargs_from_signature(kwargs_to_pop: List[Parameter]) -> List[str]:
+class PopKwargType(Enum):
+    NO = auto()
+    SIMPLE = auto()
+    CASE_INSENSITIVE = auto()
+
+def pop_kwargs_from_signature(
+    kwargs_to_pop: List[Parameter],
+    check_kwarg_dict: bool,
+    pop_headers_kwarg: PopKwargType,
+    pop_params_kwarg: PopKwargType,
+) -> List[str]:
     retval = []
+    def append_pop_kwarg(key: str, pop_type: PopKwargType) -> None:
+        if PopKwargType.CASE_INSENSITIVE == pop_type:
+            retval.append(f'_{key} = case_insensitive_dict(kwargs.pop("{key}", {{}}) or {{}})')
+        elif PopKwargType.SIMPLE == pop_type:
+            retval.append(f'_{key} = kwargs.pop("{key}", {{}}) or {{}}')
+    append_pop_kwarg("headers", pop_headers_kwarg)
+    append_pop_kwarg("params", pop_params_kwarg)
+    if pop_headers_kwarg != PopKwargType.NO or pop_params_kwarg != PopKwargType.NO:
+        retval.append("")
     for kwarg in kwargs_to_pop:
         if kwarg.has_default_value:
+            default_value = kwarg.default_value_declaration
+            if check_kwarg_dict and (kwarg.location in [ParameterLocation.Header, ParameterLocation.Query]):
+                kwarg_dict = "headers" if kwarg.location == ParameterLocation.Header else "params"
+                default_value = f"_{kwarg_dict}.pop('{kwarg.rest_api_name}', {default_value})"
             retval.append(
                 f"{kwarg.serialized_name} = kwargs.pop('{kwarg.serialized_name}', "
-                + f"{kwarg.default_value_declaration})  # type: {kwarg.type_annotation}"
+                + f"{default_value})  # type: {kwarg.type_annotation(is_operation_file=True)}"
             )
         else:
+            type_annot = kwarg.type_annotation(is_operation_file=True)
             retval.append(
-                f"{kwarg.serialized_name} = kwargs.pop('{kwarg.serialized_name}')  # type: {kwarg.type_annotation}"
+                f"{kwarg.serialized_name} = kwargs.pop('{kwarg.serialized_name}')  # type: {type_annot}"
             )
     return retval

package/autorest/codegen/templates/CHANGELOG.md.jinja2

@@ -0,0 +1,6 @@
+# Release History
+
+## 1.0.0b1 (1970-01-01)
+
+- Initial version
+

package/autorest/codegen/templates/LICENSE.jinja2

@@ -0,0 +1,21 @@
+Copyright (c) Microsoft Corporation.
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED *AS IS*, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/autorest/codegen/templates/MANIFEST.in.jinja2

@@ -0,0 +1,7 @@
+include *.md
+include LICENSE
+recursive-include tests *.py
+recursive-include samples *.py *.md
+{%- for init_name in init_names %}
+include {{ init_name }}
+{%- endfor %}