@autorest/python 6.6.0 → 6.7.1

package/autorest/codegen/models/__init__.py

@@ -28,6 +28,7 @@ from .primitive_types import (
     BooleanType,
     AnyObjectType,
     UnixTimeType,
+    AzureCoreType,
 )
 from .enum_type import EnumType
 from .base import BaseType
@@ -144,6 +145,7 @@ TYPE_TO_OBJECT = {
     "any-object": AnyObjectType,
     "unixtime": UnixTimeType,
     "credential": StringType,
+    "azurecore": AzureCoreType,
 }
 _LOGGER = logging.getLogger(__name__)
 

package/autorest/codegen/models/client.py

@@ -76,6 +76,8 @@ class Client(_ClientConfigBase[ClientGlobalParameterList]):
                 for op_group in self.yaml_data.get("operationGroups", [])
             ]
             self.link_lro_initial_operations()
+        self.request_id_header_name = self.yaml_data.get("requestIdHeaderName", None)
+        self.has_etag: bool = yaml_data.get("hasEtag", False)
 
     def _build_request_builders(
         self,
@@ -236,11 +238,6 @@ class Client(_ClientConfigBase[ClientGlobalParameterList]):
         """Do we want a mixin ABC class for typing purposes?"""
         return any(o for o in self.operation_groups if o.is_mixin)
 
-    @property
-    def need_format_url(self) -> bool:
-        """Whether we need to format urls. If so, we need to vendor core."""
-        return any(rq for rq in self.request_builders if rq.parameters.path)
-
     @property
     def has_lro_operations(self) -> bool:
         """Are there any LRO operations in this SDK?"""
@@ -269,8 +266,8 @@ class Client(_ClientConfigBase[ClientGlobalParameterList]):
     @property
     def need_request_converter(self) -> bool:
         """
-        Whether we need to convert our created azure.core.rest.HttpRequests to
-        azure.core.pipeline.transport.HttpRequests
+        Whether we need to convert our created azure.core.rest.HttpRequest to
+        azure.core.pipeline.transport.HttpRequest
         """
         return (
             self.code_model.options["show_operations"]

package/autorest/codegen/models/code_model.py

@@ -15,10 +15,10 @@ from .constant_type import ConstantType
 
 
 def _is_legacy(options) -> bool:
-    return not (options["version_tolerant"] or options["low_level_client"])
+    return not (options.get("version_tolerant") or options.get("low_level_client"))
 
 
-class CodeModel:  # pylint: disable=too-many-public-methods
+class CodeModel:  # pylint: disable=too-many-public-methods, disable=too-many-instance-attributes
     """Top level code model
 
     :param options: Options of the code model. I.e., whether this is for management generation
@@ -77,6 +77,10 @@ class CodeModel:  # pylint: disable=too-many-public-methods
             t for t in self.types_map.values() if isinstance(t, CombinedType) and t.name
         ]
 
+    @property
+    def has_etag(self) -> bool:
+        return any(client.has_etag for client in self.clients)
+
     @property
     def has_operations(self) -> bool:
         if any(c for c in self.clients if c.has_operations):
@@ -129,18 +133,12 @@ class CodeModel:  # pylint: disable=too-many-public-methods
             return True
         if async_mode:
             return self.need_mixin_abc
-        return (
-            self.need_request_converter or self.need_format_url or self.need_mixin_abc
-        )
+        return self.need_request_converter or self.need_mixin_abc
 
     @property
     def need_request_converter(self) -> bool:
         return any(c for c in self.clients if c.need_request_converter)
 
-    @property
-    def need_format_url(self) -> bool:
-        return any(c for c in self.clients if c.need_format_url)
-
     @property
     def need_mixin_abc(self) -> bool:
         return any(c for c in self.clients if c.has_mixin)

package/autorest/codegen/models/dictionary_type.py

@@ -30,6 +30,10 @@ class DictionaryType(BaseType):
         super().__init__(yaml_data=yaml_data, code_model=code_model)
         self.element_type = element_type
 
+    @property
+    def format(self) -> Optional[str]:
+        return self.element_type.format if hasattr(self.element_type, "format") else None  # type: ignore
+
     @property
     def serialization_type(self) -> str:
         """Returns the serialization value for msrest.

package/autorest/codegen/models/list_type.py

@@ -25,6 +25,10 @@ class ListType(BaseType):
         self.min_items: Optional[int] = yaml_data.get("minItems")
         self.unique_items: bool = yaml_data.get("uniqueItems", False)
 
+    @property
+    def format(self) -> Optional[str]:
+        return self.element_type.format if hasattr(self.element_type, "format") else None  # type: ignore
+
     @property
     def serialization_type(self) -> str:
         return f"[{self.element_type.serialization_type}]"

package/autorest/codegen/models/lro_operation.py

@@ -128,6 +128,18 @@ class LROOperationBase(OperationBase[LROResponseType]):
                 "distributed_trace_async",
                 ImportType.AZURECORE,
             )
+        if (
+            self.code_model.options["models_mode"] == "dpg"
+            and self.lro_response
+            and self.lro_response.type
+            and self.lro_response.type.type == "model"
+        ):
+            # used in the case if initial operation returns none
+            # but final call returns a model
+            relative_path = "..." if async_mode else ".."
+            file_import.add_submodule_import(
+                f"{relative_path}_model_base", "_deserialize", ImportType.LOCAL
+            )
         file_import.add_submodule_import(
             "typing", "Union", ImportType.STDLIB, TypingSection.CONDITIONAL
         )

package/autorest/codegen/models/model_type.py

@@ -207,7 +207,10 @@ class ModelType(  # pylint: disable=abstract-method
 
     @property
     def has_readonly_or_constant_property(self) -> bool:
-        return any(x.readonly or x.constant for x in self.properties)
+        return any(
+            x.readonly or x.constant or x.visibility == ["read"]
+            for x in self.properties
+        )
 
     @property
     def discriminator(self) -> Optional[Property]:

package/autorest/codegen/models/operation.py

@@ -90,6 +90,7 @@ class OperationBase(  # pylint: disable=too-many-public-methods
         self.internal: bool = self.yaml_data.get("internal", False)
         if self.internal:
             self.name = "_" + self.name
+        self.has_etag: bool = self.yaml_data.get("hasEtag", False)
 
     @property
     def expose_stream_keyword(self) -> bool:
@@ -331,7 +332,7 @@ class OperationBase(  # pylint: disable=too-many-public-methods
             )
         return file_import
 
-    def imports(  # pylint: disable=too-many-branches
+    def imports(  # pylint: disable=too-many-branches, disable=too-many-statements
         self, async_mode: bool, **kwargs: Any
     ) -> FileImport:
         if self.abstract:
@@ -394,21 +395,46 @@ class OperationBase(  # pylint: disable=too-many-public-methods
         if self.deprecated:
             file_import.add_import("warnings", ImportType.STDLIB)
 
+        relative_path = "..." if async_mode else ".."
         if self.code_model.need_request_converter:
-            relative_path = "..." if async_mode else ".."
             file_import.add_submodule_import(
                 f"{relative_path}_vendor", "_convert_request", ImportType.LOCAL
             )
-        if async_mode:
+        if self.has_etag:
             file_import.add_submodule_import(
-                "azure.core.pipeline.transport",
-                "AsyncHttpResponse",
-                ImportType.AZURECORE,
+                "azure.core.exceptions", "ResourceModifiedError", ImportType.AZURECORE
             )
+            if not async_mode:
+                file_import.add_submodule_import(
+                    f"{relative_path}_vendor", "prep_if_match", ImportType.LOCAL
+                )
+                file_import.add_submodule_import(
+                    f"{relative_path}_vendor", "prep_if_none_match", ImportType.LOCAL
+                )
+        if self.code_model.need_request_converter:
+            if async_mode:
+                file_import.add_submodule_import(
+                    "azure.core.pipeline.transport",
+                    "AsyncHttpResponse",
+                    ImportType.AZURECORE,
+                )
+            else:
+                file_import.add_submodule_import(
+                    "azure.core.pipeline.transport",
+                    "HttpResponse",
+                    ImportType.AZURECORE,
+                )
         else:
-            file_import.add_submodule_import(
-                "azure.core.pipeline.transport", "HttpResponse", ImportType.AZURECORE
-            )
+            if async_mode:
+                file_import.add_submodule_import(
+                    "azure.core.rest",
+                    "AsyncHttpResponse",
+                    ImportType.AZURECORE,
+                )
+            else:
+                file_import.add_submodule_import(
+                    "azure.core.rest", "HttpResponse", ImportType.AZURECORE
+                )
         if (
             self.code_model.options["builders_visibility"] == "embedded"
             and not async_mode

package/autorest/codegen/models/parameter.py

@@ -52,9 +52,6 @@ class ParameterDelimeter(str, Enum):
     COMMA = "comma"
 
 
-SPECIAL_HANDLE_HEADERS = ["repeatability-request-id", "repeatability-first-sent"]
-
-
 class _ParameterBase(
     BaseModel, abc.ABC
 ):  # pylint: disable=too-many-instance-attributes
@@ -93,10 +90,7 @@ class _ParameterBase(
         self.default_to_unset_sentinel: bool = self.yaml_data.get(
             "defaultToUnsetSentinel", False
         )
-        self.is_special_handle_header: bool = (
-            self.location == ParameterLocation.HEADER
-            and self.wire_name.lower() in SPECIAL_HANDLE_HEADERS
-        )
+        self.hide_in_method: bool = self.yaml_data.get("hideInMethod", False)
 
     @property
     def constant(self) -> bool:

package/autorest/codegen/models/parameter_list.py

@@ -215,7 +215,7 @@ class _ParameterListBase(
             for p in self.parameters
             if p.in_method_signature
             and p.implementation == self.implementation
-            and not p.is_special_handle_header
+            and (self.code_model.is_legacy or not p.hide_in_method)
         ]
         if self._body_parameter:
             if self._body_parameter.in_method_signature:

package/autorest/codegen/models/primitive_types.py

@@ -4,7 +4,6 @@
 # license information.
 # --------------------------------------------------------------------------
 import datetime
-from enum import Enum
 from typing import Any, Dict, List, Optional, Union, TYPE_CHECKING
 
 from .base import BaseType
@@ -356,17 +355,17 @@ class StringType(PrimitiveType):
 class DatetimeType(PrimitiveType):
     def __init__(self, yaml_data: Dict[str, Any], code_model: "CodeModel") -> None:
         super().__init__(yaml_data=yaml_data, code_model=code_model)
-        self.format = self.Formats(yaml_data.get("format", "date-time"))
-
-    class Formats(str, Enum):
-        datetime = "date-time"
-        rfc1123 = "date-time-rfc1123"
+        self.format = (
+            "rfc3339"
+            if yaml_data.get("format", "date-time") == "date-time"
+            else "rfc7231"
+        )
 
     @property
     def serialization_type(self) -> str:
         formats_to_attribute_type = {
-            self.Formats.datetime: "iso-8601",
-            self.Formats.rfc1123: "rfc-1123",
+            "rfc3339": "iso-8601",
+            "rfc7231": "rfc-1123",
         }
         return formats_to_attribute_type[self.format]
 
@@ -454,6 +453,10 @@ class TimeType(PrimitiveType):
 
 
 class UnixTimeType(PrimitiveType):
+    @property
+    def format(self) -> str:
+        return "unix-timestamp"
+
     @property
     def serialization_type(self) -> str:
         return "unix-time"
@@ -588,7 +591,7 @@ class DurationType(PrimitiveType):
 class ByteArraySchema(PrimitiveType):
     def __init__(self, yaml_data: Dict[str, Any], code_model: "CodeModel") -> None:
         super().__init__(yaml_data=yaml_data, code_model=code_model)
-        self.format = yaml_data.get("format", "bytes")
+        self.format = yaml_data.get("format", "base64")
 
     @property
     def serialization_type(self) -> str:
@@ -605,3 +608,28 @@ class ByteArraySchema(PrimitiveType):
     @property
     def instance_check_template(self) -> str:
         return "isinstance({}, bytes)"
+
+
+class AzureCoreType(PrimitiveType):
+    def __init__(self, yaml_data: Dict[str, Any], code_model: "CodeModel") -> None:
+        super().__init__(yaml_data=yaml_data, code_model=code_model)
+        self.name = yaml_data.get("name", "")
+
+    def docstring_type(self, **kwargs: Any) -> str:
+        return "~azure.core." + self.type_annotation(**kwargs)
+
+    def type_annotation(self, **kwargs: Any) -> str:
+        return self.name
+
+    def imports(self, **kwargs: Any) -> FileImport:
+        file_import = FileImport()
+        file_import.add_submodule_import("azure.core", self.name, ImportType.AZURECORE)
+        return file_import
+
+    @property
+    def instance_check_template(self) -> str:
+        return f"isinstance({{}}, {self.name})"
+
+    @property
+    def serialization_type(self) -> str:
+        return self.name

package/autorest/codegen/models/property.py

@@ -29,6 +29,7 @@ class Property(BaseModel):  # pylint: disable=too-many-instance-attributes
         self.type = type
         self.optional: bool = self.yaml_data["optional"]
         self.readonly: bool = self.yaml_data.get("readonly", False)
+        self.visibility: List[str] = self.yaml_data.get("visibility", [])
         self.is_polymorphic: bool = self.yaml_data.get("isPolymorphic", False)
         self.is_discriminator: bool = yaml_data.get("isDiscriminator", False)
         self.client_default_value = yaml_data.get("clientDefaultValue", None)

package/autorest/codegen/models/request_builder.py

@@ -92,10 +92,6 @@ class RequestBuilderBase(BaseBuilder[ParameterListType]):
             ImportType.AZURECORE,
         )
 
-        if self.parameters.path:
-            file_import.add_submodule_import(
-                f"{relative_path}_vendor", "_format_url_section", ImportType.LOCAL
-            )
         if self.parameters.headers or self.parameters.query:
             file_import.add_submodule_import(
                 "azure.core.utils", "case_insensitive_dict", ImportType.AZURECORE

package/autorest/codegen/serializers/__init__.py

@@ -52,6 +52,7 @@ _PACKAGE_FILES = [
 
 _REGENERATE_FILES = {"setup.py", "MANIFEST.in"}
 
+
 # extract sub folders. For example, source_file_path is like:
 # "xxx/resource-manager/Microsoft.XX/stable/2023-04-01/examples/Compute/createOrUpdate/AKSCompute.json",
 # and we want to extract the sub folders after "examples/", which is "compute/create_or_update"

package/autorest/codegen/serializers/builder_serializer.py

@@ -18,7 +18,6 @@ from ..models import (
     ModelType,
     DictionaryType,
     ListType,
-    Parameter,
     RequestBuilder,
     ParameterLocation,
     Response,
@@ -422,36 +421,6 @@ class _BuilderBaseSerializer(Generic[BuilderType]):  # pylint: disable=abstract-
         )
         return template
 
-    def _serialize_parameter(self, param: Parameter, kwarg_name: str) -> List[str]:
-        set_parameter = "_{}['{}'] = {}".format(
-            kwarg_name,
-            param.wire_name,
-            self.parameter_serializer.serialize_parameter(param, self.serializer_name),
-        )
-        if not param.optional:
-            retval = [set_parameter]
-        else:
-            retval = [
-                f"if {param.full_client_name} is not None:",
-                f"    {set_parameter}",
-            ]
-        return retval
-
-    @staticmethod
-    def _serialize_special_handle_header(param: Parameter) -> List[str]:
-        if param.wire_name.lower() == "repeatability-request-id":
-            return [
-                """if "Repeatability-Request-ID" not in _headers:""",
-                """    _headers["Repeatability-Request-ID"] = str(uuid.uuid4())""",
-            ]
-        if param.wire_name.lower() == "repeatability-first-sent":
-            return [
-                """if "Repeatability-First-Sent" not in _headers:""",
-                """    _headers["Repeatability-First-Sent"] = _SERIALIZER.serialize_data(datetime.datetime.now(),
-                "rfc-1123")""",
-            ]
-        raise ValueError(f"Unsupported special header: {param}")
-
     def serialize_path(self, builder: BuilderType) -> List[str]:
         return self.parameter_serializer.serialize_path(
             builder.parameters.path, self.serializer_name
@@ -563,24 +532,25 @@ class RequestBuilderSerializer(
     def serialize_headers(self, builder: RequestBuilderType) -> List[str]:
         retval = ["# Construct headers"]
         for parameter in builder.parameters.headers:
-            if parameter.is_special_handle_header:
-                retval.extend(self._serialize_special_handle_header(parameter))
-            else:
-                retval.extend(
-                    self._serialize_parameter(
-                        parameter,
-                        kwarg_name="headers",
-                    )
+            retval.extend(
+                self.parameter_serializer.serialize_query_header(
+                    parameter,
+                    "headers",
+                    self.serializer_name,
+                    self.code_model.is_legacy,
                 )
+            )
         return retval
 
     def serialize_query(self, builder: RequestBuilderType) -> List[str]:
         retval = ["# Construct parameters"]
         for parameter in builder.parameters.query:
             retval.extend(
-                self._serialize_parameter(
+                self.parameter_serializer.serialize_query_header(
                     parameter,
-                    kwarg_name="params",
+                    "params",
+                    self.serializer_name,
+                    self.code_model.is_legacy,
                 )
             )
         return retval
@@ -1119,9 +1089,17 @@ class _OperationSerializer(
         return retval
 
     def handle_error_response(self, builder: OperationType) -> List[str]:
+        async_await = "await " if self.async_mode else ""
         retval = [
             f"if response.status_code not in {str(builder.success_status_codes)}:"
         ]
+        if not self.code_model.need_request_converter:
+            retval.extend(
+                [
+                    "    if _stream:",
+                    f"        {async_await} response.read()  # Load the body in memory and close the socket",
+                ]
+            )
         retval.append(
             "    map_error(status_code=response.status_code, response=response, error_map=error_map)"
         )
@@ -1283,6 +1261,17 @@ class _OperationSerializer(
                 "304: ResourceNotModifiedError"
             )
         retval.append("}")
+        if builder.has_etag:
+            retval.extend(
+                [
+                    "if match_condition == MatchConditions.IfNotModified:",
+                    "    error_map[412] = ResourceModifiedError",
+                    "elif match_condition == MatchConditions.IfPresent:",
+                    "    error_map[412] = ResourceNotFoundError",
+                    "elif match_condition == MatchConditions.IfMissing:",
+                    "    error_map[412] = ResourceExistsError",
+                ]
+            )
         retval.append("error_map.update(kwargs.pop('error_map', {}) or {})")
         return retval
 
@@ -1543,7 +1532,7 @@ class _LROOperationSerializer(_OperationSerializer[LROOperationType]):
         retval.append("if cont_token is None:")
         retval.append(
             f"    raw_result = {self._call_method}self.{builder.initial_operation.name}("
-            f"{'' if builder.lro_response and builder.lro_response.type else '  # type: ignore'}"
+            f"{'' if any(rsp.type for rsp in builder.initial_operation.responses) else '  # type: ignore'}"
         )
         retval.extend(
             [

package/autorest/codegen/serializers/client_serializer.py

@@ -109,9 +109,15 @@ class ClientSerializer:
 
     def initialize_pipeline_client(self, async_mode: bool) -> str:
         pipeline_client_name = self.client.pipeline_class(async_mode)
+        params = {
+            "base_url": self.host_variable_name,
+            "config": "self._config",
+        }
+        if not self.client.code_model.is_legacy and self.client.request_id_header_name:
+            params["request_id_header_name"] = f'"{self.client.request_id_header_name}"'
         return (
-            f"self._client: {pipeline_client_name} = {pipeline_client_name}(base_url={self.host_variable_name}, "
-            "config=self._config, **kwargs)"
+            f"self._client: {pipeline_client_name} = {pipeline_client_name}("
+            f"{', '.join(f'{k}={v}' for k, v in params.items())}, **kwargs)"
         )
 
     def serializers_and_operation_groups_properties(self) -> List[str]:

package/autorest/codegen/serializers/general_serializer.py

@@ -109,10 +109,6 @@ class GeneralSerializer:
                 ImportType.AZURECORE,
             )
 
-        if self.code_model.need_format_url and not self.async_mode:
-            file_import.add_submodule_import("typing", "List", ImportType.STDLIB)
-            file_import.add_submodule_import("typing", "cast", ImportType.STDLIB)
-
         if self.code_model.need_mixin_abc:
             file_import.add_submodule_import(
                 "abc",
@@ -137,6 +133,13 @@ class GeneralSerializer:
                     f"{client.name}Configuration",
                     ImportType.LOCAL,
                 )
+        if self.code_model.has_etag:
+            file_import.add_submodule_import("typing", "Optional", ImportType.STDLIB)
+            file_import.add_submodule_import(
+                "azure.core",
+                "MatchConditions",
+                ImportType.AZURECORE,
+            )
 
         return template.render(
             code_model=self.code_model,

package/autorest/codegen/serializers/model_serializer.py

@@ -255,10 +255,13 @@ class DpgModelSerializer(_ModelSerializer):
         args = []
         if prop.client_name != prop.wire_name or prop.is_discriminator:
             args.append(f'name="{prop.wire_name}"')
-        if prop.readonly:
-            args.append("readonly=True")
+        if prop.visibility:
+            v_list = ", ".join(f'"{x}"' for x in prop.visibility)
+            args.append(f"visibility=[{v_list}]")
         if prop.client_default_value is not None:
             args.append(f"default={prop.client_default_value_declaration}")
+        if hasattr(prop.type, "format") and prop.type.format:  # type: ignore
+            args.append(f'format="{prop.type.format}"')  # type: ignore
 
         field = "rest_discriminator" if prop.is_discriminator else "rest_field"
         type_ignore = (
@@ -280,3 +283,11 @@ class DpgModelSerializer(_ModelSerializer):
                     f"{cast(ConstantType, prop.type).get_declaration()}"
                 )
         return init_args
+
+    @staticmethod
+    def _init_line_parameters(model: ModelType):
+        return [
+            p
+            for p in model.properties
+            if not p.is_discriminator and not p.constant and p.visibility != ["read"]
+        ]

package/autorest/codegen/serializers/parameter_serializer.py

@@ -3,10 +3,9 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
-from typing import List, Sequence, Union, Optional
+from typing import List, Sequence, Union, Optional, Dict
 from enum import Enum, auto
 
-
 from ..models import (
     Parameter,
     ParameterLocation,
@@ -26,6 +25,32 @@ class PopKwargType(Enum):
     CASE_INSENSITIVE = auto()
 
 
+SPECIAL_HEADER_SERIALIZATION: Dict[str, List[str]] = {
+    "repeatability-request-id": [
+        """if "Repeatability-Request-ID" not in _headers:""",
+        """    _headers["Repeatability-Request-ID"] = str(uuid.uuid4())""",
+    ],
+    "repeatability-first-sent": [
+        """if "Repeatability-First-Sent" not in _headers:""",
+        """    _headers["Repeatability-First-Sent"] = _SERIALIZER.serialize_data(datetime.datetime.now(),
+        "rfc-1123")""",
+    ],
+    "client-request-id": [],
+    "x-ms-client-request-id": [],
+    "return-client-request-id": [],
+    "etag": [
+        """if_match = prep_if_match(etag, match_condition)""",
+        """if if_match is not None:""",
+        """    _headers["If-Match"] = _SERIALIZER.header("if_match", if_match, "str")""",
+    ],
+    "match-condition": [
+        """if_none_match = prep_if_none_match(etag, match_condition)""",
+        """if if_none_match is not None:""",
+        """    _headers["If-None-Match"] = _SERIALIZER.header("if_none_match", if_none_match, "str")""",
+    ],
+}
+
+
 class ParameterSerializer:
     @staticmethod
     def serialize_parameter(parameter: ParameterType, serializer_name: str) -> str:
@@ -81,8 +106,8 @@ class ParameterSerializer:
             return f"[{serialize_line} if q is not None else '' for q in {origin_name}]"
         return serialize_line
 
+    @staticmethod
     def serialize_path(
-        self,
         parameters: Union[
             List[Parameter],
             List[RequestBuilderParameter],
@@ -96,7 +121,9 @@ class ParameterSerializer:
             [
                 '    "{}": {},'.format(
                     path_parameter.wire_name,
-                    self.serialize_parameter(path_parameter, serializer_name),
+                    ParameterSerializer.serialize_parameter(
+                        path_parameter, serializer_name
+                    ),
                 )
                 for path_parameter in parameters
             ]
@@ -104,6 +131,34 @@ class ParameterSerializer:
         retval.append("}")
         return retval
 
+    @staticmethod
+    def serialize_query_header(
+        param: Parameter,
+        kwarg_name: str,
+        serializer_name: str,
+        is_legacy: bool,
+    ) -> List[str]:
+        if (
+            not is_legacy
+            and param.location == ParameterLocation.HEADER
+            and param.wire_name.lower() in SPECIAL_HEADER_SERIALIZATION
+        ):
+            return SPECIAL_HEADER_SERIALIZATION[param.wire_name.lower()]
+
+        set_parameter = "_{}['{}'] = {}".format(
+            kwarg_name,
+            param.wire_name,
+            ParameterSerializer.serialize_parameter(param, serializer_name),
+        )
+        if not param.optional:
+            retval = [set_parameter]
+        else:
+            retval = [
+                f"if {param.full_client_name} is not None:",
+                f"    {set_parameter}",
+            ]
+        return retval
+
     @staticmethod
     def pop_kwargs_from_signature(
         parameters: Sequence[_ParameterBase],