@autorest/python 5.12.6 → 5.15.0

package/autorest/codegen/models/enum_schema.py

@@ -59,13 +59,11 @@ class EnumSchema(BaseSchema):
         name: str,
         values: List["EnumValue"],
         enum_type: PrimitiveSchema,
-        enum_file_name: str
     ) -> None:
         super(EnumSchema, self).__init__(namespace=namespace, yaml_data=yaml_data)
         self.description = description
         self.name = name
         self.values = values
-        self.enum_file_name = enum_file_name
         self.enum_type = enum_type
 
     def __lt__(self, other):
@@ -80,23 +78,13 @@ class EnumSchema(BaseSchema):
         """
         return self.enum_type.serialization_type
 
-    @property
-    def type_annotation(self) -> str:
+    def type_annotation(self, *, is_operation_file: bool = False) -> str:
         """The python type used for type annotation
 
         :return: The type annotation for this schema
         :rtype: str
         """
-        return f'Union[{self.enum_type.type_annotation}, "{self.name}"]'
-
-    @property
-    def operation_type_annotation(self) -> str:
-        """The python type used for type annotation
-
-        :return: The type annotation for this schema
-        :rtype: str
-        """
-        return f'Union[{self.enum_type.type_annotation}, "_models.{self.name}"]'
+        return f'Union[{self.enum_type.type_annotation(is_operation_file=is_operation_file)}, "_models.{self.name}"]'
 
     def get_declaration(self, value: Any) -> str:
         return self.enum_type.get_declaration(value)
@@ -109,7 +97,7 @@ class EnumSchema(BaseSchema):
     def docstring_type(self) -> str:
         """The python type used for RST syntax input and type annotation.
         """
-        return f"{self.enum_type.type_annotation} or ~{self.namespace}.models.{self.name}"
+        return f"{self.enum_type.type_annotation()} or ~{self.namespace}.models.{self.name}"
 
     @staticmethod
     def _get_enum_values(yaml_data: List[Dict[str, Any]]) -> List["EnumValue"]:
@@ -164,8 +152,6 @@ class EnumSchema(BaseSchema):
         else:
             enum_type = StringSchema(namespace, {"type": "str"})
         values = EnumSchema._get_enum_values(yaml_data["choices"])
-        code_model = kwargs.pop("code_model")
-
         return cls(
             namespace=namespace,
             yaml_data=yaml_data,
@@ -173,7 +159,6 @@ class EnumSchema(BaseSchema):
             name=name,
             values=values,
             enum_type=enum_type,
-            enum_file_name=f"_{code_model.module_name}_enums"
         )
 
     def imports(self) -> FileImport:
@@ -182,12 +167,6 @@ class EnumSchema(BaseSchema):
         file_import.merge(self.enum_type.imports())
         return file_import
 
-    def model_file_imports(self) -> FileImport:
-        imports = self.imports()
-        # we import every enum since we can get extremely long imports
-        # if we import my name
-        imports.add_submodule_import("." + self.enum_file_name, "*", ImportType.LOCAL)
-        return imports
 
 class HiddenModelEnumSchema(EnumSchema):
 
@@ -196,27 +175,17 @@ class HiddenModelEnumSchema(EnumSchema):
         file_import.merge(self.enum_type.imports())
         return file_import
 
-    @property
-    def type_annotation(self) -> str:
-        """The python type used for type annotation
-
-        :return: The type annotation for this schema
-        :rtype: str
-        """
-        return self.enum_type.type_annotation
-
-    @property
-    def operation_type_annotation(self) -> str:
+    def type_annotation(self, *, is_operation_file: bool = False) -> str:
         """The python type used for type annotation
 
         :return: The type annotation for this schema
         :rtype: str
         """
-        return self.enum_type.type_annotation
+        return self.enum_type.type_annotation(is_operation_file=is_operation_file)
 
     @property
     def docstring_text(self) -> str:
-        return f"{self.enum_type.type_annotation}. {self.extra_description_information}"
+        return f"{self.enum_type.type_annotation()}. {self.extra_description_information}"
 
     @property
     def extra_description_information(self):
@@ -232,13 +201,13 @@ class HiddenModelEnumSchema(EnumSchema):
                 possible_values[: len(possible_values) - 1]
             ) + f", and {possible_values[-1]}"
 
-        return "Possible values are: {}.".format(possible_values_str)
+        return "Known values are: {}.".format(possible_values_str)
 
     @property
     def docstring_type(self) -> str:
         """The python type used for RST syntax input and type annotation.
         """
-        return self.enum_type.type_annotation
+        return self.enum_type.type_annotation()
 
 def get_enum_schema(code_model) -> Type[EnumSchema]:
     if code_model.options["models_mode"]:

package/autorest/codegen/models/imports.py

@@ -97,13 +97,15 @@ class FileImport:
         self,
         module_name: str,
         import_type: ImportType,
-        typing_section: TypingSection = TypingSection.REGULAR
+        typing_section: TypingSection = TypingSection.REGULAR,
+        alias: Optional[str] = None,
     ) -> None:
         # Implementation detail: a regular import is just a "from" with no from
         self._append_import(ImportModel(
             typing_section=typing_section,
             import_type=import_type,
             module_name=module_name,
+            alias=alias,
         ))
 
     def define_mypy_type(self, type_name: str, type_value: str, async_type_value: Optional[str] = None):

package/autorest/codegen/models/list_schema.py

@@ -29,20 +29,24 @@ class ListSchema(BaseSchema):
     def serialization_type(self) -> str:
         return f"[{self.element_type.serialization_type}]"
 
-    @property
-    def type_annotation(self) -> str:
-        return f"List[{self.element_type.type_annotation}]"
-
-    @property
-    def operation_type_annotation(self) -> str:
-        return f"List[{self.element_type.operation_type_annotation}]"
+    def type_annotation(self, *, is_operation_file: bool = False) -> str:
+        if self.element_type.type_annotation() == "ET.Element":
+            # this means we're version tolerant XML, we just return the XML element
+            return self.element_type.type_annotation(is_operation_file=is_operation_file)
+        return f"List[{self.element_type.type_annotation(is_operation_file=is_operation_file)}]"
 
     @property
     def docstring_type(self) -> str:
+        if self.element_type.docstring_type == "ET.Element":
+            # this means we're version tolerant XML, we just return the XML element
+            return self.element_type.docstring_type
         return f"list[{self.element_type.docstring_type}]"
 
     @property
     def docstring_text(self) -> str:
+        if self.element_type.docstring_text == "XML Element":
+            # this means we're version tolerant XML, we just return the XML element
+            return self.element_type.docstring_text
         return f"list of {self.element_type.docstring_text}"
 
     @property
@@ -108,6 +112,12 @@ class ListSchema(BaseSchema):
 
     def imports(self) -> FileImport:
         file_import = FileImport()
-        file_import.add_submodule_import("typing", "List", ImportType.STDLIB, TypingSection.CONDITIONAL)
+        if not self.element_type.type_annotation(is_operation_file=True) == "ET.Element":
+            file_import.add_submodule_import("typing", "List", ImportType.STDLIB, TypingSection.CONDITIONAL)
         file_import.merge(self.element_type.imports())
         return file_import
+
+    def model_file_imports(self) -> FileImport:
+        file_import = self.imports()
+        file_import.merge(self.element_type.model_file_imports())
+        return file_import

package/autorest/codegen/models/lro_operation.py

@@ -143,8 +143,8 @@ class LROOperation(Operation):
         file_import.add_submodule_import(poller_import_path, poller, ImportType.AZURECORE, TypingSection.CONDITIONAL)
         return file_import
 
-    def imports(self, async_mode: bool) -> FileImport:
-        file_import = super().imports(async_mode)
+    def imports(self, async_mode: bool, is_python3_file: bool) -> FileImport:
+        file_import = self._imports_base(async_mode, is_python3_file)
         file_import.add_submodule_import("typing", "Union", ImportType.STDLIB, TypingSection.CONDITIONAL)
 
         poller_import_path = ".".join(self.get_poller_path(async_mode).split(".")[:-1])
@@ -172,7 +172,7 @@ class LROOperation(Operation):
         )
         base_polling_method = self.get_base_polling_method(async_mode)
         file_import.add_submodule_import(base_polling_method_import_path, base_polling_method, ImportType.AZURECORE)
-
+        file_import.add_submodule_import("typing", "cast", ImportType.STDLIB)
         if async_mode:
             file_import.add_submodule_import("typing", "Optional", ImportType.STDLIB, TypingSection.CONDITIONAL)
         if self.code_model.options["tracing"] and self.want_tracing:

package/autorest/codegen/models/lro_paging_operation.py

@@ -9,9 +9,9 @@ from .paging_operation import PagingOperation
 
 class LROPagingOperation(PagingOperation, LROOperation):
 
-    def imports(self, async_mode: bool) -> FileImport:
-        lro_imports = LROOperation.imports(self, async_mode)
-        paging_imports = PagingOperation.imports(self, async_mode)
+    def imports(self, async_mode: bool, is_python3_file: bool) -> FileImport:
+        lro_imports = LROOperation.imports(self, async_mode, is_python3_file)
+        paging_imports = PagingOperation.imports(self, async_mode, is_python3_file)
 
         file_import = lro_imports
         file_import.merge(paging_imports)

package/autorest/codegen/models/object_schema.py

@@ -39,13 +39,9 @@ class ObjectSchema(BaseSchema):  # pylint: disable=too-many-instance-attributes
     def serialization_type(self) -> str:
         return self.name
 
-    @property
-    def type_annotation(self) -> str:
-        return f'"{self.name}"'
-
-    @property
-    def operation_type_annotation(self) -> str:
-        return f'"_models.{self.name}"'
+    def type_annotation(self, *, is_operation_file: bool = False) -> str:
+        retval = f"_models.{self.name}"
+        return retval if is_operation_file else f'"{retval}"'
 
     @property
     def docstring_type(self) -> str:
@@ -216,31 +212,39 @@ class ObjectSchema(BaseSchema):  # pylint: disable=too-many-instance-attributes
             file_import.add_submodule_import("azure.core.exceptions", "HttpResponseError", ImportType.AZURECORE)
         return file_import
 
+    def model_file_imports(self) -> FileImport:
+        file_import = self.imports()
+        file_import.add_import("__init__", ImportType.LOCAL, typing_section=TypingSection.TYPING, alias="_models")
+        return file_import
+
 class HiddenModelObjectSchema(ObjectSchema):
 
     @property
     def serialization_type(self) -> str:
         return "object"
 
-    @property
-    def type_annotation(self) -> str:
-        return "JSONType"
-
-    @property
-    def operation_type_annotation(self) -> str:
+    def type_annotation(self, *, is_operation_file: bool = False) -> str:  # pylint: disable=unused-argument
+        if self.xml_metadata:
+            return "ET.Element"
         return "JSONType"
 
     @property
     def docstring_type(self) -> str:
+        if self.xml_metadata:
+            return "ET.Element"
         return "JSONType"
 
     @property
     def docstring_text(self) -> str:
+        if self.xml_metadata:
+            return "XML Element"
         return "JSON object"
 
     def imports(self) -> FileImport:
         file_import = FileImport()
         file_import.add_submodule_import("typing", "Any", ImportType.STDLIB, TypingSection.CONDITIONAL)
+        if self.xml_metadata:
+            file_import.add_submodule_import("xml.etree", "ElementTree", ImportType.STDLIB, alias="ET")
         return file_import
 
 def get_object_schema(code_model) -> Type[ObjectSchema]:

package/autorest/codegen/models/operation.py

@@ -10,7 +10,7 @@ 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 Parameter, get_parameter
+from .parameter import Parameter, get_parameter, ParameterLocation
 from .parameter_list import ParameterList, get_parameter_list
 from .base_schema import BaseSchema
 from .object_schema import ObjectSchema
@@ -159,7 +159,7 @@ class Operation(BaseBuilder):  # pylint: disable=too-many-public-methods, too-ma
             if response.has_body:
                 file_import.merge(cast(BaseSchema, response.schema).imports())
 
-        response_types = [r.operation_type_annotation for r in self.responses if r.has_body]
+        response_types = [r.type_annotation(is_operation_file=True) for r in self.responses if r.has_body]
         if len(set(response_types)) > 1:
             file_import.add_submodule_import("typing", "Union", ImportType.STDLIB, TypingSection.CONDITIONAL)
 
@@ -171,7 +171,17 @@ class Operation(BaseBuilder):  # pylint: disable=too-many-public-methods, too-ma
     def imports_for_multiapi(self, async_mode: bool) -> FileImport:  # pylint: disable=unused-argument
         return self._imports_shared(async_mode)
 
-    def imports(self, async_mode: bool) -> FileImport:
+    def imports(self, async_mode: bool, is_python3_file: bool) -> FileImport:
+        file_import = self._imports_base(async_mode, is_python3_file)
+        if self.has_response_body and not self.has_optional_return_type and not self.code_model.options["models_mode"]:
+            file_import.add_submodule_import("typing", "cast", ImportType.STDLIB)
+        return file_import
+
+    @staticmethod
+    def has_kwargs_to_pop_with_default(kwargs_to_pop: List[Parameter], location: ParameterLocation) -> bool:
+        return any(kwarg.has_default_value and kwarg.location == location for kwarg in kwargs_to_pop)
+
+    def _imports_base(self, async_mode: bool, is_python3_file: bool) -> FileImport:
         file_import = self._imports_shared(async_mode)
 
         # Exceptions
@@ -186,6 +196,10 @@ class Operation(BaseBuilder):  # pylint: disable=too-many-public-methods, too-ma
         file_import.add_submodule_import("typing", "TypeVar", ImportType.STDLIB, TypingSection.CONDITIONAL)
         file_import.add_submodule_import("azure.core.pipeline", "PipelineResponse", ImportType.AZURECORE)
         file_import.add_submodule_import("azure.core.rest", "HttpRequest", ImportType.AZURECORE)
+        kwargs_to_pop = self.parameters.kwargs_to_pop(is_python3_file)
+        if (self.has_kwargs_to_pop_with_default(kwargs_to_pop, ParameterLocation.Header) or
+            self.has_kwargs_to_pop_with_default(kwargs_to_pop, ParameterLocation.Query)):
+            file_import.add_submodule_import("azure.core.utils", "case_insensitive_dict", ImportType.AZURECORE)
         if async_mode:
             file_import.add_submodule_import("azure.core.pipeline.transport", "AsyncHttpResponse", ImportType.AZURECORE)
         else:
@@ -218,6 +232,7 @@ class Operation(BaseBuilder):  # pylint: disable=too-many-public-methods, too-ma
             file_import.add_submodule_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)
@@ -267,7 +282,7 @@ class Operation(BaseBuilder):  # pylint: disable=too-many-public-methods, too-ma
 
     def convert_multiple_content_type_parameters(self) -> None:
         type_annot = ", ".join([
-            param.schema.operation_type_annotation
+            param.schema.type_annotation(is_operation_file=True)
             for param in self.multiple_content_type_parameters
         ])
         docstring_type = " or ".join([
@@ -303,6 +318,15 @@ class Operation(BaseBuilder):  # pylint: disable=too-many-public-methods, too-ma
         parameters, multiple_content_type_parameters = create_parameters(
             yaml_data, code_model, parameter_creator
         )
+        parameter_list = parameter_list_creator(code_model, parameters, schema_requests)
+        multiple_content_type_parameter_list = parameter_list_creator(
+            code_model, multiple_content_type_parameters, schema_requests
+        )
+
+        if len(parameter_list.content_types) > 1:
+            for p in parameter_list.parameters:
+                if p.rest_api_name == "Content-Type":
+                    p.is_keyword_only = True
 
         return cls(
             code_model=code_model,
@@ -310,13 +334,17 @@ 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, schema_requests),
-            multiple_content_type_parameters=parameter_list_creator(
-                code_model, multiple_content_type_parameters, schema_requests
-            ),
+            parameters=parameter_list,
+            multiple_content_type_parameters=multiple_content_type_parameter_list,
             schema_requests=schema_requests,
             summary=yaml_data["language"]["python"].get("summary"),
-            responses=[SchemaResponse.from_yaml(yaml) for yaml in yaml_data.get("responses", [])],
+            responses=[
+                SchemaResponse.from_yaml(yaml, code_model=code_model)
+                for yaml in yaml_data.get("responses", [])
+            ],
             # Exception with no schema means default exception, we don't store them
-            exceptions=[SchemaResponse.from_yaml(yaml) for yaml in yaml_data.get("exceptions", []) if "schema" in yaml],
+            exceptions=[
+                SchemaResponse.from_yaml(yaml, code_model=code_model)
+                for yaml in yaml_data.get("exceptions", []) if "schema" in yaml
+            ],
         )

package/autorest/codegen/models/operation_group.py

@@ -54,15 +54,16 @@ class OperationGroup(BaseModel):
         file_import = FileImport()
         for operation in self.operations:
             file_import.merge(operation.imports_for_multiapi(async_mode))
+        file_import.add_submodule_import(".." if async_mode else ".", "models", ImportType.LOCAL, alias="_models")
         return file_import
 
-    def imports(self, async_mode: bool) -> FileImport:
+    def imports(self, async_mode: bool, is_python3_file: bool) -> FileImport:
         file_import = FileImport()
         file_import.add_submodule_import("azure.core.exceptions", "ClientAuthenticationError", ImportType.AZURECORE)
         file_import.add_submodule_import("azure.core.exceptions", "ResourceNotFoundError", ImportType.AZURECORE)
         file_import.add_submodule_import("azure.core.exceptions", "ResourceExistsError", ImportType.AZURECORE)
         for operation in self.operations:
-            file_import.merge(operation.imports(async_mode))
+            file_import.merge(operation.imports(async_mode, is_python3_file))
         local_path = "..." if async_mode else ".."
         if self.code_model.has_schemas and self.code_model.options["models_mode"]:
             file_import.add_submodule_import(local_path, "models", ImportType.LOCAL, alias="_models")
@@ -84,6 +85,10 @@ class OperationGroup(BaseModel):
                     request_builder.name,
                     import_type=ImportType.LOCAL
                 )
+        if self.code_model.need_mixin_abc:
+            file_import.add_submodule_import(
+                ".._vendor", "MixinABC", ImportType.LOCAL
+            )
         type_value = "Optional[Callable[[PipelineResponse[HttpRequest, {}HttpResponse], T, Dict[str, Any]], Any]]"
         file_import.define_mypy_type(
             "ClsType",

package/autorest/codegen/models/paging_operation.py

@@ -66,7 +66,7 @@ class PagingOperation(Operation):
         return response
 
     def _find_python_name(self, rest_api_name: str, log_name: str) -> str:
-        response = self._get_response()
+        response = self.responses[0]
         response_schema = cast(ObjectSchema, response.schema)
         if response_schema:
             for prop in response_schema.properties:
@@ -145,8 +145,8 @@ class PagingOperation(Operation):
 
         return file_import
 
-    def imports(self, async_mode: bool) -> FileImport:
-        file_import = super(PagingOperation, self).imports(async_mode)
+    def imports(self, async_mode: bool, is_python3_file: bool) -> FileImport:
+        file_import = self._imports_base(async_mode, is_python3_file)
         # operation adds an import for distributed_trace_async, we don't want it
         file_import.imports = [i for i in file_import.imports if not i.submodule_name == "distributed_trace_async"]
 

package/autorest/codegen/models/parameter.py

@@ -6,7 +6,7 @@
 import logging
 from enum import Enum
 
-from typing import Dict, Optional, List, Any, Union, Tuple, cast
+from typing import Dict, Optional, List, Any, Union, Tuple, cast, TYPE_CHECKING
 
 from .imports import FileImport, ImportType, TypingSection
 from .base_model import BaseModel
@@ -15,6 +15,10 @@ from .constant_schema import ConstantSchema
 from .object_schema import ObjectSchema
 from .property import Property
 from .primitive_schemas import IOSchema
+from .utils import get_schema
+
+if TYPE_CHECKING:
+    from .code_model import CodeModel
 
 
 _LOGGER = logging.getLogger(__name__)
@@ -46,6 +50,15 @@ class ParameterStyle(Enum):
     multipart = "multipart"
 
 
+
+def get_target_property_name(code_model: "CodeModel", target_property_id: int) -> str:
+    for obj in code_model.schemas.values():
+        for prop in obj.properties:
+            if prop.id == target_property_id:
+                return prop.name
+    raise KeyError("Didn't find the target property")
+
+
 class Parameter(BaseModel):  # pylint: disable=too-many-instance-attributes, too-many-public-methods
     def __init__(
         self,
@@ -68,7 +81,7 @@ class Parameter(BaseModel):  # pylint: disable=too-many-instance-attributes, too
         grouped_by: Optional["Parameter"] = None,
         original_parameter: Optional["Parameter"] = None,
         client_default_value: Optional[Any] = None,
-        keyword_only: bool = False,
+        keyword_only: Optional[bool] = None,
         content_types: Optional[List[str]] = None,
     ) -> None:
         super().__init__(yaml_data)
@@ -99,6 +112,7 @@ class Parameter(BaseModel):  # pylint: disable=too-many-instance-attributes, too
         self.body_kwargs: List[Parameter] = []
         self.is_body_kwarg = False
         self.need_import = True
+        self.is_kwarg = (self.rest_api_name == "Content-Type" or (self.constant and self.inputtable_by_user))
 
     def __hash__(self) -> int:
         return hash(self.serialized_name)
@@ -111,6 +125,14 @@ class Parameter(BaseModel):  # pylint: disable=too-many-instance-attributes, too
                 if description:
                     description += " "
                 description += f"{self.schema.extra_description_information}"
+            if isinstance(self.schema, ConstantSchema) and not self.constant:
+                if description:
+                    description += " "
+                description += f"Known values are {self.schema.get_declaration(self.schema.value)} or {None}."
+            if self.has_default_value and not any(
+                l for l in ["default value is", "default is"] if l in description.lower()
+            ):
+                description += f" Default value is {self.default_value_declaration}."
             if self.constant:
                 description += " Note that overriding this default value may result in unsupported behavior."
             return description
@@ -166,6 +188,10 @@ class Parameter(BaseModel):  # pylint: disable=too-many-instance-attributes, too
     def is_body(self) -> bool:
         return self.location == ParameterLocation.Body
 
+    @property
+    def inputtable_by_user(self) -> bool:
+        return self.rest_api_name != "Accept"
+
     @property
     def pre_semicolon_content_types(self) -> List[str]:
         """Splits on semicolon of media types and returns the first half.
@@ -176,8 +202,8 @@ class Parameter(BaseModel):  # pylint: disable=too-many-instance-attributes, too
     @property
     def in_method_signature(self) -> bool:
         return not(
-            # don't put accept in signature
-            self.rest_api_name == "Accept"
+            # if not inputtable, don't put in signature
+            not self.inputtable_by_user
             # If i'm not in the method code, no point in being in signature
             or not self.in_method_code
             # If I'm grouped, my grouper will be on signature, not me
@@ -216,7 +242,7 @@ class Parameter(BaseModel):  # pylint: disable=too-many-instance-attributes, too
         ) and isinstance(self.schema, IOSchema)
 
     def _default_value(self) -> Tuple[Optional[Any], str, str]:
-        type_annot = self.multiple_content_types_type_annot or self.schema.operation_type_annotation
+        type_annot = self.multiple_content_types_type_annot or self.schema.type_annotation(is_operation_file=True)
         if self._is_io_json:
             type_annot = f"Union[{type_annot}, JSONType]"
         any_types = ["Any", "JSONType"]
@@ -232,7 +258,12 @@ class Parameter(BaseModel):  # pylint: disable=too-many-instance-attributes, too
             default_value_declaration = "None"
         else:
             if isinstance(self.schema, ConstantSchema):
-                default_value = self.schema.get_declaration(self.schema.value)
+                if (self.required or
+                    self.is_content_type or
+                    not self.code_model.options["default_optional_constants_to_none"]):
+                    default_value = self.schema.get_declaration(self.schema.value)
+                else:
+                    default_value = None
                 default_value_declaration = default_value
             else:
                 default_value = self.schema.default_value
@@ -263,8 +294,7 @@ class Parameter(BaseModel):  # pylint: disable=too-many-instance-attributes, too
     def default_value_declaration(self) -> Optional[Any]:
         return self._default_value()[1]
 
-    @property
-    def type_annotation(self) -> str:
+    def type_annotation(self, *, is_operation_file: bool = False) -> str:  # pylint: disable=unused-argument
         return self._default_value()[2]
 
     @property
@@ -283,13 +313,14 @@ class Parameter(BaseModel):  # pylint: disable=too-many-instance-attributes, too
         return self.default_value is not None or not self.required
 
     def method_signature(self, is_python3_file: bool) -> str:
+        type_annot = self.type_annotation(is_operation_file=True)
         if is_python3_file:
             if self.has_default_value:
-                return f"{self.serialized_name}: {self.type_annotation} = {self.default_value_declaration},"
-            return f"{self.serialized_name}: {self.type_annotation},"
+                return f"{self.serialized_name}: {type_annot} = {self.default_value_declaration},"
+            return f"{self.serialized_name}: {type_annot},"
         if self.has_default_value:
-            return f"{self.serialized_name}={self.default_value_declaration},  # type: {self.type_annotation}"
-        return f"{self.serialized_name},  # type: {self.type_annotation}"
+            return f"{self.serialized_name}={self.default_value_declaration},  # type: {type_annot}"
+        return f"{self.serialized_name},  # type: {type_annot}"
 
     @property
     def full_serialized_name(self) -> str:
@@ -298,22 +329,26 @@ class Parameter(BaseModel):  # pylint: disable=too-many-instance-attributes, too
             origin_name = f"self._config.{self.serialized_name}"
         return origin_name
 
-    @property
-    def is_kwarg(self) -> bool:
-        # this means "am I in **kwargs?"
-        return self.rest_api_name == "Content-Type" or (self.constant and self.rest_api_name != "Accept")
-
     @property
     def is_keyword_only(self) -> bool:
         # this means in async mode, I am documented like def hello(positional_1, *, me!)
-        return self._keyword_only
+        return self._keyword_only or False
+
+    @is_keyword_only.setter
+    def is_keyword_only(self, val: bool) -> None:
+        self._keyword_only = val
+        self.is_kwarg = False
 
     @property
     def is_hidden(self) -> bool:
-        return self.serialized_name in _HIDDEN_KWARGS or (
+        return self.serialized_name in _HIDDEN_KWARGS and self.is_kwarg or (
             self.yaml_data["implementation"] == "Client" and self.constant
         )
 
+    @property
+    def is_content_type(self) -> bool:
+        return self.rest_api_name == "Content-Type" and self.location == ParameterLocation.Header
+
     @property
     def is_positional(self) -> bool:
         return self.in_method_signature and not (self.is_keyword_only or self.is_kwarg)
@@ -327,22 +362,29 @@ class Parameter(BaseModel):  # pylint: disable=too-many-instance-attributes, too
         content_types: Optional[List[str]] = None
     ) -> "Parameter":
         http_protocol = yaml_data["protocol"].get("http", {"in": ParameterLocation.Other})
+        serialized_name = yaml_data["language"]["python"]["name"]
+        schema = get_schema(
+            code_model, yaml_data.get("schema"), serialized_name
+        )
+        target_property = yaml_data.get("targetProperty")
+        target_property_name = get_target_property_name(code_model, id(target_property)) if target_property else None
+
         return cls(
             code_model=code_model,
             yaml_data=yaml_data,
-            schema=yaml_data.get("schema", None),  # FIXME replace by operation model
+            schema=schema,  # FIXME replace by operation model
             # See also https://github.com/Azure/autorest.modelerfour/issues/80
             rest_api_name=yaml_data["language"]["default"].get(
                 "serializedName", yaml_data["language"]["default"]["name"]
             ),
-            serialized_name=yaml_data["language"]["python"]["name"],
+            serialized_name=serialized_name,
             description=yaml_data["language"]["python"]["description"],
             implementation=yaml_data["implementation"],
             required=yaml_data.get("required", False),
             location=ParameterLocation(http_protocol["in"]),
             skip_url_encoding=yaml_data.get("extensions", {}).get("x-ms-skip-url-encoding", False),
             constraints=[],  # FIXME constraints
-            target_property_name=id(yaml_data["targetProperty"]) if yaml_data.get("targetProperty") else None,
+            target_property_name=target_property_name,
             style=ParameterStyle(http_protocol["style"]) if "style" in http_protocol else None,
             explode=http_protocol.get("explode", False),
             grouped_by=yaml_data.get("groupedBy", None),
@@ -365,6 +407,8 @@ class ParameterOnlyPathAndBodyPositional(Parameter):
 
     @property
     def is_keyword_only(self) -> bool:
+        if self._keyword_only is not None:
+            return self._keyword_only
         return self.in_method_signature and not (
             self.is_hidden or
             self.location == ParameterLocation.Path or
@@ -373,6 +417,11 @@ class ParameterOnlyPathAndBodyPositional(Parameter):
             self.is_kwarg
         )
 
+    @is_keyword_only.setter
+    def is_keyword_only(self, val: bool) -> None:
+        self._keyword_only = val
+        self.is_kwarg = False
+
 def get_parameter(code_model):
     if code_model.options["only_path_and_body_params_positional"]:
         return ParameterOnlyPathAndBodyPositional