@autorest/python 5.12.4 → 5.13.0

package/autorest/codegen/models/enum_schema.py

@@ -178,7 +178,7 @@ class EnumSchema(BaseSchema):
 
     def imports(self) -> FileImport:
         file_import = FileImport()
-        file_import.add_from_import("typing", "Union", ImportType.STDLIB, TypingSection.CONDITIONAL)
+        file_import.add_submodule_import("typing", "Union", ImportType.STDLIB, TypingSection.CONDITIONAL)
         file_import.merge(self.enum_type.imports())
         return file_import
 
@@ -186,7 +186,7 @@ class EnumSchema(BaseSchema):
         imports = self.imports()
         # we import every enum since we can get extremely long imports
         # if we import my name
-        imports.add_from_import("." + self.enum_file_name, "*", ImportType.LOCAL)
+        imports.add_submodule_import("." + self.enum_file_name, "*", ImportType.LOCAL)
         return imports
 
 class HiddenModelEnumSchema(EnumSchema):

package/autorest/codegen/models/imports.py

@@ -4,8 +4,7 @@
 # license information.
 # --------------------------------------------------------------------------
 from enum import Enum
-from typing import Dict, Optional, Set, Tuple, Union
-
+from typing import Dict, List, Optional, Tuple, Union, Set
 
 class ImportType(str, Enum):
     STDLIB = "stdlib"
@@ -18,81 +17,122 @@ class TypingSection(str, Enum):
     CONDITIONAL = "conditional"  # is a typing import when we're dealing with files that py2 will use, else regular
     TYPING = "typing"  # never a typing import
 
+class ImportModel:
+    def __init__(
+        self,
+        typing_section: TypingSection,
+        import_type: ImportType,
+        module_name: str,
+        *,
+        submodule_name: Optional[str] = None,
+        alias: Optional[str] = None,
+    ):
+        self.typing_section = typing_section
+        self.import_type = import_type
+        self.module_name = module_name
+        self.submodule_name = submodule_name
+        self.alias = alias
+
+    def __eq__(self, other):
+        try:
+            return (
+                self.typing_section == other.typing_section and
+                self.import_type == other.import_type and
+                self.module_name == other.module_name and
+                self.submodule_name == other.submodule_name and
+                self.alias == other.alias
+            )
+        except AttributeError:
+            return False
+
+    def __hash__(self):
+        retval: int = 0
+        for attr in dir(self):
+            if attr[0] != "_":
+                retval += hash(getattr(self, attr))
+        return retval
 
 class FileImport:
     def __init__(
         self,
-        imports: Dict[
-            TypingSection,
-            Dict[ImportType, Dict[str, Set[Optional[Union[str, Tuple[str, str]]]]]]
-        ] = None
+        imports: List[ImportModel] = None
     ) -> None:
-        # Basic implementation
-        # First level dict: TypingSection
-        # Second level dict: ImportType
-        # Third level dict: the package name.
-        # Fourth level set: None if this import is a "import", the name to import if it's a "from"
-        self._imports: Dict[
-            TypingSection,
-            Dict[ImportType, Dict[str, Set[Optional[Union[str, Tuple[str, str]]]]]]
-        ] = imports or dict()
+        self.imports = imports or []
         # has sync and async type definitions
         self.type_definitions: Dict[str, Tuple[str, str]] = {}
 
-    def _add_import(
-        self,
-        from_section: str,
-        import_type: ImportType,
-        name_import: Optional[Union[str, Tuple[str, str]]] = None,
-        typing_section: TypingSection = TypingSection.REGULAR
-    ) -> None:
-        self._imports.setdefault(
-                typing_section, dict()
-            ).setdefault(
-                import_type, dict()
-            ).setdefault(
-                from_section, set()
-            ).add(name_import)
+    def _append_import(self, import_model: ImportModel) -> None:
+        if not any(
+            i for i in self.imports
+            if all(
+                getattr(i, attr) == getattr(import_model, attr)
+                for attr in dir(i)
+                if attr[0] != "_"
+            )
+        ):
+            self.imports.append(import_model)
+
+    def get_imports_from_section(self, typing_section: TypingSection) -> List[ImportModel]:
+        return [i for i in self.imports if i.typing_section == typing_section]
 
-    def add_from_import(
+    def add_submodule_import(
         self,
-        from_section: str,
-        name_import: str,
+        module_name: str,
+        submodule_name: str,
         import_type: ImportType,
         typing_section: TypingSection = TypingSection.REGULAR,
         alias: Optional[str] = None,
     ) -> None:
         """Add an import to this import block.
         """
-        self._add_import(
-            from_section, import_type, (name_import, alias) if alias else name_import, typing_section
-        )
+        self._append_import(ImportModel(
+            typing_section=typing_section,
+            import_type=import_type,
+            module_name=module_name,
+            submodule_name=submodule_name,
+            alias=alias,
+        ))
 
     def add_import(
         self,
-        name_import: str,
+        module_name: str,
         import_type: ImportType,
         typing_section: TypingSection = TypingSection.REGULAR
     ) -> None:
         # Implementation detail: a regular import is just a "from" with no from
-        self._add_import(name_import, import_type, None, typing_section)
-
-    @property
-    def imports(self) -> Dict[
-            TypingSection,
-            Dict[ImportType, Dict[str, Set[Optional[Union[str, Tuple[str, str]]]]]]
-        ]:
-        return self._imports
+        self._append_import(ImportModel(
+            typing_section=typing_section,
+            import_type=import_type,
+            module_name=module_name,
+        ))
 
     def define_mypy_type(self, type_name: str, type_value: str, async_type_value: Optional[str] = None):
-        self._add_import("typing", ImportType.STDLIB, "TypeVar", TypingSection.CONDITIONAL)
+        self.add_submodule_import("typing", "TypeVar", ImportType.STDLIB, TypingSection.CONDITIONAL)
         self.type_definitions[type_name] = (type_value, async_type_value or type_value)
 
     def merge(self, file_import: "FileImport") -> None:
         """Merge the given file import format."""
-        for typing_section, import_type_dict in file_import.imports.items():
-            for import_type, package_list in import_type_dict.items():
-                for package_name, module_list in package_list.items():
-                    for module_name in module_list:
-                        self._add_import(package_name, import_type, module_name, typing_section)
+        for i in file_import.imports:
+            self._append_import(i)
         self.type_definitions.update(file_import.type_definitions)
+
+    def to_dict(self) -> Dict[
+        TypingSection,
+        Dict[ImportType, Dict[str, Set[Optional[Union[str, Tuple[str, str]]]]]]
+    ]:
+        retval: Dict[
+            TypingSection,
+            Dict[ImportType, Dict[str, Set[Optional[Union[str, Tuple[str, str]]]]]]
+        ] = dict()
+        for i in self.imports:
+            name_import: Optional[Union[str, Tuple[str, str]]] = None
+            if i.submodule_name:
+                name_import = (i.submodule_name, i.alias) if i.alias else i.submodule_name
+            retval.setdefault(
+                    i.typing_section, dict()
+                ).setdefault(
+                    i.import_type, dict()
+                ).setdefault(
+                    i.module_name, set()
+                ).add(name_import)
+        return retval

package/autorest/codegen/models/list_schema.py

@@ -108,6 +108,6 @@ class ListSchema(BaseSchema):
 
     def imports(self) -> FileImport:
         file_import = FileImport()
-        file_import.add_from_import("typing", "List", ImportType.STDLIB, TypingSection.CONDITIONAL)
+        file_import.add_submodule_import("typing", "List", ImportType.STDLIB, TypingSection.CONDITIONAL)
         file_import.merge(self.element_type.imports())
         return file_import

package/autorest/codegen/models/lro_operation.py

@@ -140,28 +140,30 @@ class LROOperation(Operation):
         file_import = super().imports_for_multiapi(async_mode)
         poller_import_path = ".".join(self.get_poller_path(async_mode).split(".")[:-1])
         poller = self.get_poller(async_mode)
-        file_import.add_from_import(poller_import_path, poller, ImportType.AZURECORE, TypingSection.CONDITIONAL)
+        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)
-        file_import.add_from_import("typing", "Union", ImportType.STDLIB, TypingSection.CONDITIONAL)
+        file_import.add_submodule_import("typing", "Union", ImportType.STDLIB, TypingSection.CONDITIONAL)
 
         poller_import_path = ".".join(self.get_poller_path(async_mode).split(".")[:-1])
         poller = self.get_poller(async_mode)
-        file_import.add_from_import(poller_import_path, poller, ImportType.AZURECORE)
+        file_import.add_submodule_import(poller_import_path, poller, ImportType.AZURECORE)
 
         default_polling_method_import_path = ".".join(
             self.get_default_polling_method_path(async_mode, self.code_model.options['azure_arm']).split(".")[:-1]
         )
         default_polling_method = self.get_default_polling_method(async_mode, self.code_model.options['azure_arm'])
-        file_import.add_from_import(default_polling_method_import_path, default_polling_method, ImportType.AZURECORE)
+        file_import.add_submodule_import(
+            default_polling_method_import_path, default_polling_method, ImportType.AZURECORE
+        )
 
         default_no_polling_method_import_path = ".".join(
             self.get_default_no_polling_method_path(async_mode).split(".")[:-1]
         )
         default_no_polling_method = self.get_default_no_polling_method(async_mode)
-        file_import.add_from_import(
+        file_import.add_submodule_import(
             default_no_polling_method_import_path, default_no_polling_method, ImportType.AZURECORE
         )
 
@@ -169,10 +171,14 @@ class LROOperation(Operation):
             self.get_base_polling_method_path(async_mode).split(".")[:-1]
         )
         base_polling_method = self.get_base_polling_method(async_mode)
-        file_import.add_from_import(base_polling_method_import_path, base_polling_method, ImportType.AZURECORE)
+        file_import.add_submodule_import(base_polling_method_import_path, base_polling_method, ImportType.AZURECORE)
 
         if async_mode:
-            file_import.add_from_import("typing", "Optional", ImportType.STDLIB, TypingSection.CONDITIONAL)
-        if self.lro_response and self.lro_response.has_body and not self.code_model.options["models_mode"]:
-            file_import.add_from_import("json", "loads", import_type=ImportType.STDLIB, alias="_loads")
+            file_import.add_submodule_import("typing", "Optional", ImportType.STDLIB, TypingSection.CONDITIONAL)
+        if self.code_model.options["tracing"] and self.want_tracing:
+            file_import.add_submodule_import(
+                f"azure.core.tracing.decorator{'_async' if async_mode else ''}",
+                f"distributed_trace{'_async' if async_mode else ''}",
+                ImportType.AZURECORE,
+            )
         return file_import

package/autorest/codegen/models/object_schema.py

@@ -213,7 +213,7 @@ class ObjectSchema(BaseSchema):  # pylint: disable=too-many-instance-attributes
     def imports(self) -> FileImport:
         file_import = FileImport()
         if self.is_exception:
-            file_import.add_from_import("azure.core.exceptions", "HttpResponseError", ImportType.AZURECORE)
+            file_import.add_submodule_import("azure.core.exceptions", "HttpResponseError", ImportType.AZURECORE)
         return file_import
 
 class HiddenModelObjectSchema(ObjectSchema):
@@ -240,7 +240,7 @@ class HiddenModelObjectSchema(ObjectSchema):
 
     def imports(self) -> FileImport:
         file_import = FileImport()
-        file_import.add_from_import("typing", "Any", ImportType.STDLIB, TypingSection.CONDITIONAL)
+        file_import.add_submodule_import("typing", "Any", ImportType.STDLIB, TypingSection.CONDITIONAL)
         return file_import
 
 def get_object_schema(code_model) -> Type[ObjectSchema]:

package/autorest/codegen/models/operation.py

@@ -147,7 +147,7 @@ class Operation(BaseBuilder):  # pylint: disable=too-many-public-methods, too-ma
 
     def _imports_shared(self, async_mode: bool) -> FileImport: # pylint: disable=unused-argument
         file_import = FileImport()
-        file_import.add_from_import("typing", "Any", ImportType.STDLIB, TypingSection.CONDITIONAL)
+        file_import.add_submodule_import("typing", "Any", ImportType.STDLIB, TypingSection.CONDITIONAL)
         for param in self.parameters.method:
             file_import.merge(param.imports())
 
@@ -159,11 +159,12 @@ class Operation(BaseBuilder):  # pylint: disable=too-many-public-methods, too-ma
             if response.has_body:
                 file_import.merge(cast(BaseSchema, response.schema).imports())
 
-        if len([r for r in self.responses if r.has_body]) > 1:
-            file_import.add_from_import("typing", "Union", ImportType.STDLIB, TypingSection.CONDITIONAL)
+        response_types = [r.operation_type_annotation 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)
 
         if self.is_stream_response:
-            file_import.add_from_import("typing", "IO", ImportType.STDLIB, TypingSection.CONDITIONAL)
+            file_import.add_submodule_import("typing", "IO", ImportType.STDLIB, TypingSection.CONDITIONAL)
         return file_import
 
 
@@ -174,42 +175,37 @@ class Operation(BaseBuilder):  # pylint: disable=too-many-public-methods, too-ma
         file_import = self._imports_shared(async_mode)
 
         # Exceptions
-        file_import.add_from_import("azure.core.exceptions", "map_error", ImportType.AZURECORE)
+        file_import.add_submodule_import("azure.core.exceptions", "map_error", ImportType.AZURECORE)
         if self.code_model.options["azure_arm"]:
-            file_import.add_from_import("azure.mgmt.core.exceptions", "ARMErrorFormat", ImportType.AZURECORE)
-        file_import.add_from_import("azure.core.exceptions", "HttpResponseError", ImportType.AZURECORE)
-
-
-        file_import.add_import("functools", ImportType.STDLIB)
-        file_import.add_from_import("typing", "Callable", ImportType.STDLIB, TypingSection.CONDITIONAL)
-        file_import.add_from_import("typing", "Optional", ImportType.STDLIB, TypingSection.CONDITIONAL)
-        file_import.add_from_import("typing", "Dict", ImportType.STDLIB, TypingSection.CONDITIONAL)
-        file_import.add_from_import("typing", "TypeVar", ImportType.STDLIB, TypingSection.CONDITIONAL)
-        file_import.add_from_import("typing", "Generic", ImportType.STDLIB, TypingSection.CONDITIONAL)
-        file_import.add_from_import("azure.core.pipeline", "PipelineResponse", ImportType.AZURECORE)
-        file_import.add_from_import("azure.core.rest", "HttpRequest", ImportType.AZURECORE)
+            file_import.add_submodule_import("azure.mgmt.core.exceptions", "ARMErrorFormat", ImportType.AZURECORE)
+        file_import.add_submodule_import("azure.core.exceptions", "HttpResponseError", ImportType.AZURECORE)
+
+        file_import.add_submodule_import("typing", "Callable", ImportType.STDLIB, TypingSection.CONDITIONAL)
+        file_import.add_submodule_import("typing", "Optional", ImportType.STDLIB, TypingSection.CONDITIONAL)
+        file_import.add_submodule_import("typing", "Dict", ImportType.STDLIB, TypingSection.CONDITIONAL)
+        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)
         if async_mode:
-            file_import.add_from_import("azure.core.pipeline.transport", "AsyncHttpResponse", ImportType.AZURECORE)
+            file_import.add_submodule_import("azure.core.pipeline.transport", "AsyncHttpResponse", ImportType.AZURECORE)
         else:
-            file_import.add_from_import("azure.core.pipeline.transport", "HttpResponse", ImportType.AZURECORE)
+            file_import.add_submodule_import("azure.core.pipeline.transport", "HttpResponse", ImportType.AZURECORE)
 
-        # Deprecation
-        # FIXME: Replace with "the YAML contains deprecated:true"
-        if True:  # pylint: disable=using-constant-test
+        if self.deprecated:
             file_import.add_import("warnings", ImportType.STDLIB)
 
         if self.code_model.options["builders_visibility"] != "embedded":
             builder_group_name = self.request_builder.builder_group_name
             rest_import_path = "..." if async_mode else ".."
             if builder_group_name:
-                file_import.add_from_import(
+                file_import.add_submodule_import(
                     f"{rest_import_path}{self.code_model.rest_layer_name}",
-                    name_import=builder_group_name,
+                    builder_group_name,
                     import_type=ImportType.LOCAL,
                     alias=f"rest_{builder_group_name}"
                 )
             else:
-                file_import.add_from_import(
+                file_import.add_submodule_import(
                     rest_import_path,
                     self.code_model.rest_layer_name,
                     import_type=ImportType.LOCAL,
@@ -219,7 +215,7 @@ class Operation(BaseBuilder):  # pylint: disable=too-many-public-methods, too-ma
             file_import.merge(self.request_builder.imports())
         if self.code_model.need_request_converter:
             relative_path = "..." if async_mode else ".."
-            file_import.add_from_import(
+            file_import.add_submodule_import(
                 f"{relative_path}_vendor", "_convert_request", ImportType.LOCAL
             )
         if self.code_model.options["version_tolerant"] and (
@@ -227,6 +223,12 @@ class Operation(BaseBuilder):  # pylint: disable=too-many-public-methods, too-ma
             any(r for r in self.responses if r.has_body)
         ):
             file_import.define_mypy_type("JSONType", "Any")
+        if self.code_model.options["tracing"] and self.want_tracing:
+            file_import.add_submodule_import(
+                f"azure.core.tracing.decorator{'_async' if async_mode else ''}",
+                f"distributed_trace{'_async' if async_mode else ''}",
+                ImportType.AZURECORE,
+            )
         return file_import
 
     def _get_body_param_from_body_kwarg(self, body_kwarg: Parameter) -> Parameter:
@@ -301,6 +303,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,
@@ -308,10 +319,8 @@ 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", [])],

package/autorest/codegen/models/operation_group.py

@@ -58,23 +58,14 @@ class OperationGroup(BaseModel):
 
     def imports(self, async_mode: bool) -> FileImport:
         file_import = FileImport()
-        file_import.add_from_import("azure.core.exceptions", "ClientAuthenticationError", ImportType.AZURECORE)
-        file_import.add_from_import("azure.core.exceptions", "ResourceNotFoundError", ImportType.AZURECORE)
-        file_import.add_from_import("azure.core.exceptions", "ResourceExistsError", ImportType.AZURECORE)
+        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))
-        if self.code_model.options["tracing"]:
-            if async_mode:
-                file_import.add_from_import(
-                    "azure.core.tracing.decorator_async", "distributed_trace_async", ImportType.AZURECORE,
-                )
-            else:
-                file_import.add_from_import(
-                    "azure.core.tracing.decorator", "distributed_trace", ImportType.AZURECORE,
-                )
         local_path = "..." if async_mode else ".."
         if self.code_model.has_schemas and self.code_model.options["models_mode"]:
-            file_import.add_from_import(local_path, "models", ImportType.LOCAL, alias="_models")
+            file_import.add_submodule_import(local_path, "models", ImportType.LOCAL, alias="_models")
         if self.code_model.options["builders_visibility"] == "embedded" and async_mode:
             if not self.code_model.options["combine_operation_files"]:
                 operation_group_name = "" if self.is_empty_operation_group else self.name
@@ -88,7 +79,7 @@ class OperationGroup(BaseModel):
                 python3_only = self.code_model.options["python3_only"]
                 typed_sync_operation_file = self.code_model.options["add_python3_operation_files"]
                 suffix = "_py3" if typed_sync_operation_file and not python3_only else ""
-                file_import.add_from_import(
+                file_import.add_submodule_import(
                     f"...{self.code_model.operations_folder_name}.{self.filename}{suffix}",
                     request_builder.name,
                     import_type=ImportType.LOCAL

package/autorest/codegen/models/paging_operation.py

@@ -125,9 +125,9 @@ class PagingOperation(Operation):
     def _imports_shared(self, async_mode: bool) -> FileImport:
         file_import = super()._imports_shared(async_mode)
         if async_mode:
-            file_import.add_from_import("typing", "AsyncIterable", ImportType.STDLIB, TypingSection.CONDITIONAL)
+            file_import.add_submodule_import("typing", "AsyncIterable", ImportType.STDLIB, TypingSection.CONDITIONAL)
         else:
-            file_import.add_from_import("typing", "Iterable", ImportType.STDLIB, TypingSection.CONDITIONAL)
+            file_import.add_submodule_import("typing", "Iterable", ImportType.STDLIB, TypingSection.CONDITIONAL)
         if (
             self.next_request_builder and
             self.code_model.options["builders_visibility"] == "embedded"
@@ -141,26 +141,26 @@ class PagingOperation(Operation):
         pager_import_path = ".".join(self.get_pager_path(async_mode).split(".")[:-1])
         pager = self.get_pager(async_mode)
 
-        file_import.add_from_import(pager_import_path, pager, ImportType.AZURECORE, TypingSection.CONDITIONAL)
+        file_import.add_submodule_import(pager_import_path, pager, ImportType.AZURECORE, TypingSection.CONDITIONAL)
 
         return file_import
 
     def imports(self, async_mode: bool) -> FileImport:
         file_import = super(PagingOperation, self).imports(async_mode)
+        # 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"]
 
         pager_import_path = ".".join(self.get_pager_path(async_mode).split(".")[:-1])
         pager = self.get_pager(async_mode)
 
-        file_import.add_from_import(pager_import_path, pager, ImportType.AZURECORE)
+        file_import.add_submodule_import(pager_import_path, pager, ImportType.AZURECORE)
 
         if async_mode:
-            file_import.add_from_import("azure.core.async_paging", "AsyncList", ImportType.AZURECORE)
+            file_import.add_submodule_import("azure.core.async_paging", "AsyncList", ImportType.AZURECORE)
 
-        if self.code_model.options["tracing"]:
-            file_import.add_from_import(
+        if self.code_model.options["tracing"] and self.want_tracing:
+            file_import.add_submodule_import(
                 "azure.core.tracing.decorator", "distributed_trace", ImportType.AZURECORE,
             )
-        if not self.code_model.options["models_mode"]:
-            file_import.add_from_import("json", "loads", ImportType.STDLIB, alias="_loads")
 
         return file_import

package/autorest/codegen/models/parameter.py

@@ -68,7 +68,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)
@@ -98,6 +98,8 @@ class Parameter(BaseModel):  # pylint: disable=too-many-instance-attributes, too
         self.content_types = content_types or []
         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.rest_api_name != "Accept"))
 
     def __hash__(self) -> int:
         return hash(self.serialized_name)
@@ -110,6 +112,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"Possible 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
@@ -231,7 +241,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
@@ -297,22 +312,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)
@@ -354,9 +373,9 @@ class Parameter(BaseModel):  # pylint: disable=too-many-instance-attributes, too
     def imports(self) -> FileImport:
         file_import = self.schema.imports()
         if not self.required:
-            file_import.add_from_import("typing", "Optional", ImportType.STDLIB, TypingSection.CONDITIONAL)
+            file_import.add_submodule_import("typing", "Optional", ImportType.STDLIB, TypingSection.CONDITIONAL)
         if self.has_multiple_content_types or self._is_io_json:
-            file_import.add_from_import("typing", "Union", ImportType.STDLIB, TypingSection.CONDITIONAL)
+            file_import.add_submodule_import("typing", "Union", ImportType.STDLIB, TypingSection.CONDITIONAL)
 
         return file_import
 
@@ -364,6 +383,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
@@ -372,6 +393,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