@autorest/python 5.12.5 → 5.14.0

package/autorest/codegen/models/operation.py

@@ -159,7 +159,8 @@ 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:
+        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:
@@ -179,13 +180,10 @@ class Operation(BaseBuilder):  # pylint: disable=too-many-public-methods, too-ma
             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_import("functools", ImportType.STDLIB)
         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("typing", "Generic", 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:
@@ -193,9 +191,7 @@ class Operation(BaseBuilder):  # pylint: disable=too-many-public-methods, too-ma
         else:
             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":
@@ -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

@@ -63,15 +63,6 @@ class OperationGroup(BaseModel):
         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_submodule_import(
-                    "azure.core.tracing.decorator_async", "distributed_trace_async", ImportType.AZURECORE,
-                )
-            else:
-                file_import.add_submodule_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_submodule_import(local_path, "models", ImportType.LOCAL, alias="_models")

package/autorest/codegen/models/paging_operation.py

@@ -147,6 +147,8 @@ class PagingOperation(Operation):
 
     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)
@@ -156,11 +158,9 @@ class PagingOperation(Operation):
         if async_mode:
             file_import.add_submodule_import("azure.core.async_paging", "AsyncList", ImportType.AZURECORE)
 
-        if self.code_model.options["tracing"]:
+        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_submodule_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)
@@ -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

package/autorest/codegen/models/parameter_list.py

@@ -207,7 +207,9 @@ class ParameterList(MutableSequence):  # pylint: disable=too-many-public-methods
             lambda parameter: parameter.implementation == self.implementation
         )
         positional = [p for p in parameters_of_this_implementation if p.is_positional]
-        keyword_only = [p for p in parameters_of_this_implementation if p.is_keyword_only]
+        keyword_only = self._filter_out_multiple_content_type(
+            [p for p in parameters_of_this_implementation if p.is_keyword_only]
+        )
         kwargs = self._filter_out_multiple_content_type(
             [p for p in parameters_of_this_implementation if p.is_kwarg]
         )
@@ -275,6 +277,7 @@ class ParameterList(MutableSequence):  # pylint: disable=too-many-public-methods
 def _create_files_or_data_param(
     params: List[Parameter], serialized_name: str, description: str
 ) -> Parameter:
+    params[0].need_import = False
     param = copy(params[0])
     param.serialized_name = serialized_name
     param.schema = DictionarySchema(
@@ -314,7 +317,9 @@ class ParameterOnlyPathAndBodyPositionalList(ParameterList):
             file_and_data_params.append(data_param)
         method_params = [p for p in method_params if not p.is_multipart and not p.is_data_input]
         positional = [p for p in method_params if p.is_positional]
-        keyword_only = [p for p in method_params if p.is_keyword_only]
+        keyword_only = self._filter_out_multiple_content_type(
+            [p for p in method_params if p.is_keyword_only]
+        )
         kwargs = self._filter_out_multiple_content_type(
             [p for p in method_params if p.is_kwarg]
         )
@@ -337,7 +342,9 @@ class GlobalParameterList(ParameterList):
         """
         # Client level should not be on Method, etc.
         positional = [p for p in self.parameters if p.is_positional]
-        keyword_only = [p for p in self.parameters if p.is_keyword_only]
+        keyword_only = self._filter_out_multiple_content_type(
+            [p for p in self.parameters if p.is_keyword_only]
+        )
         kwargs = self._filter_out_multiple_content_type(
             [p for p in self.parameters if p.is_kwarg]
         )
@@ -383,7 +390,7 @@ class GlobalParameterList(ParameterList):
             schema=StringSchema(namespace="", yaml_data={"type": "str"}),
             rest_api_name=self.host_variable_name,
             serialized_name=self.host_variable_name,
-            description=f"Service URL. Default value is '{host_value}'.",
+            description=f"Service URL.",
             implementation="Client",
             required=True,
             location=ParameterLocation.Other,

package/autorest/codegen/models/request_builder.py

@@ -66,7 +66,8 @@ class RequestBuilder(BaseBuilder):
     def imports(self) -> FileImport:
         file_import = FileImport()
         for parameter in self.parameters:
-            file_import.merge(parameter.imports())
+            if parameter.need_import:
+                file_import.merge(parameter.imports())
 
         file_import.add_submodule_import(
             "azure.core.rest",
@@ -87,7 +88,7 @@ class RequestBuilder(BaseBuilder):
         file_import.add_submodule_import(
             "typing", "Any", ImportType.STDLIB, typing_section=TypingSection.CONDITIONAL
         )
-        file_import.add_submodule_import("msrest", "Serializer", ImportType.AZURECORE)
+        file_import.add_submodule_import("msrest", "Serializer", ImportType.THIRDPARTY)
         if self.parameters.has_body and (
             self.code_model.options["builders_visibility"] != "embedded" or
             self.code_model.options["add_python3_operation_files"]

package/autorest/codegen/models/request_builder_parameter.py

@@ -62,6 +62,11 @@ class RequestBuilderParameter(ParameterOnlyPathAndBodyPositional):
     def is_keyword_only(self) -> bool:
         return not self.location == ParameterLocation.Path and not self.is_kwarg
 
+    @is_keyword_only.setter
+    def is_keyword_only(self, val: bool) -> None:
+        self._keyword_only = val
+        self.is_kwarg = False
+
     @property
     def full_serialized_name(self) -> str:
         return self.serialized_name

package/autorest/codegen/models/request_builder_parameter_list.py

@@ -198,6 +198,7 @@ class RequestBuilderParameterList(ParameterList):
         else:
             for kwarg in body_kwargs_added:
                 kwarg.required = False
+        first_body_param.need_import = False
         self.parameters = body_kwargs_added + self.parameters
 
     @property