@autorest/python 5.10.0 → 5.12.0

package/autorest/codegen/models/parameter.py

@@ -69,6 +69,7 @@ class Parameter(BaseModel):  # pylint: disable=too-many-instance-attributes, too
         original_parameter: Optional["Parameter"] = None,
         client_default_value: Optional[Any] = None,
         keyword_only: bool = False,
+        content_types: Optional[List[str]] = None,
     ) -> None:
         super().__init__(yaml_data)
         self.code_model = code_model
@@ -88,12 +89,15 @@ class Parameter(BaseModel):  # pylint: disable=too-many-instance-attributes, too
         self.grouped_by = grouped_by
         self.original_parameter = original_parameter
         self.client_default_value = client_default_value
-        self.has_multiple_media_types: bool = False
-        self.multiple_media_types_type_annot: Optional[str] = None
-        self.multiple_media_types_docstring_type: Optional[str] = None
+        self.has_multiple_content_types: bool = False
+        self.multiple_content_types_type_annot: Optional[str] = None
+        self.multiple_content_types_docstring_type: Optional[str] = None
         self._keyword_only = keyword_only
         self.is_multipart = yaml_data.get("language", {}).get("python", {}).get("multipart", False)
         self.is_data_input = yaml_data.get("isPartialBody", False) and not self.is_multipart
+        self.content_types = content_types or []
+        self.body_kwargs: List[Parameter] = []
+        self.is_body_kwarg = False
 
     def __hash__(self) -> int:
         return hash(self.serialized_name)
@@ -121,8 +125,6 @@ class Parameter(BaseModel):  # pylint: disable=too-many-instance-attributes, too
     def is_json_parameter(self) -> bool:
         if self.is_multipart or self.is_data_input:
             return False
-        if isinstance(self.schema, IOSchema):
-            return False
         if self.style == ParameterStyle.xml:
             return False
         return True
@@ -151,6 +153,10 @@ class Parameter(BaseModel):  # pylint: disable=too-many-instance-attributes, too
                 )
         raise ValueError("Trying to get a declaration for a schema that doesn't exist")
 
+    @property
+    def serialization_formats(self) -> List[str]:
+        return self.yaml_data.get('serializationFormats', [])
+
     @property
     def xml_serialization_ctxt(self) -> str:
         return self.schema.xml_serialization_ctxt() or ""
@@ -159,6 +165,13 @@ class Parameter(BaseModel):  # pylint: disable=too-many-instance-attributes, too
     def is_body(self) -> bool:
         return self.location == ParameterLocation.Body
 
+    @property
+    def pre_semicolon_content_types(self) -> List[str]:
+        """Splits on semicolon of media types and returns the first half.
+        I.e. ["text/plain; charset=UTF-8"] -> ["text/plain"]
+        """
+        return [content_type.split(";")[0] for content_type in self.content_types]
+
     @property
     def in_method_signature(self) -> bool:
         return not(
@@ -197,15 +210,24 @@ class Parameter(BaseModel):  # pylint: disable=too-many-instance-attributes, too
             return "Method"
         return self._implementation
 
+    @property
+    def _is_io_json(self):
+        return any(
+            k for k in self.body_kwargs if k.serialized_name == "json"
+        ) and isinstance(self.schema, IOSchema)
+
     def _default_value(self) -> Tuple[Optional[Any], str, str]:
-        type_annot = self.multiple_media_types_type_annot or self.schema.operation_type_annotation
-        if not self.required and not type_annot == "Any":
+        type_annot = self.multiple_content_types_type_annot or self.schema.operation_type_annotation
+        if self._is_io_json:
+            type_annot = f"Union[{type_annot}, JSONType]"
+        any_types = ["Any", "JSONType"]
+        if not self.required and type_annot not in any_types and not self._is_io_json:
             type_annot = f"Optional[{type_annot}]"
 
         if self.client_default_value is not None:
             return self.client_default_value, self.schema.get_declaration(self.client_default_value), type_annot
 
-        if self.multiple_media_types_type_annot:
+        if self.multiple_content_types_type_annot:
             # means this parameter has multiple media types. We force default value to be None.
             default_value = None
             default_value_declaration = "None"
@@ -252,14 +274,17 @@ class Parameter(BaseModel):  # pylint: disable=too-many-instance-attributes, too
 
     @property
     def docstring_type(self) -> str:
-        return self.multiple_media_types_docstring_type or self.schema.docstring_type
+        retval = self.multiple_content_types_docstring_type or self.schema.docstring_type
+        if self._is_io_json:
+            retval += " or JSONType"
+        return retval
 
     @property
     def has_default_value(self):
         return self.default_value is not None or not self.required
 
-    def method_signature(self, is_python_3_file: bool) -> str:
-        if is_python_3_file:
+    def method_signature(self, is_python3_file: bool) -> str:
+        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},"
@@ -295,7 +320,13 @@ class Parameter(BaseModel):  # pylint: disable=too-many-instance-attributes, too
         return self.in_method_signature and not (self.is_keyword_only or self.is_kwarg)
 
     @classmethod
-    def from_yaml(cls, yaml_data: Dict[str, Any], *, code_model) -> "Parameter":
+    def from_yaml(
+        cls,
+        yaml_data: Dict[str, Any],
+        *,
+        code_model,
+        content_types: Optional[List[str]] = None
+    ) -> "Parameter":
         http_protocol = yaml_data["protocol"].get("http", {"in": ParameterLocation.Other})
         return cls(
             code_model=code_model,
@@ -319,14 +350,16 @@ class Parameter(BaseModel):  # pylint: disable=too-many-instance-attributes, too
             original_parameter=yaml_data.get("originalParameter", None),
             flattened=yaml_data.get("flattened", False),
             client_default_value=yaml_data.get("clientDefaultValue"),
+            content_types=content_types
         )
 
     def imports(self) -> FileImport:
         file_import = self.schema.imports()
         if not self.required:
             file_import.add_from_import("typing", "Optional", ImportType.STDLIB, TypingSection.CONDITIONAL)
-        if self.has_multiple_media_types:
+        if self.has_multiple_content_types or self._is_io_json:
             file_import.add_from_import("typing", "Union", ImportType.STDLIB, TypingSection.CONDITIONAL)
+
         return file_import
 
 class ParameterOnlyPathAndBodyPositional(Parameter):

package/autorest/codegen/models/parameter_list.py

@@ -6,15 +6,16 @@
 from collections.abc import MutableSequence
 from copy import copy
 import logging
-from typing import cast, List, Callable, Optional, TypeVar, Dict
+from typing import cast, List, Callable, Optional, TypeVar, Dict, TYPE_CHECKING
 
 from .parameter import Parameter, ParameterLocation
-from .constant_schema import ConstantSchema
 from .base_schema import BaseSchema
-from .enum_schema import EnumSchema
 from .dictionary_schema import DictionarySchema
 from .primitive_schemas import AnySchema, StringSchema
 
+if TYPE_CHECKING:
+    from .schema_request import SchemaRequest
+
 T = TypeVar('T')
 OrderedSet = Dict[T, None]
 
@@ -27,12 +28,15 @@ def _method_signature_helper(positional: List[str], keyword_only: Optional[List[
 
 class ParameterList(MutableSequence):  # pylint: disable=too-many-public-methods
     def __init__(
-        self, code_model, parameters: Optional[List[Parameter]] = None
+        self,
+        code_model,
+        parameters: Optional[List[Parameter]] = None,
+        schema_requests: Optional[List["SchemaRequest"]] = None,
     ) -> None:
         self.code_model = code_model
+        self.schema_requests = schema_requests or []
         self.parameters = parameters or []
         self._json_body: Optional[BaseSchema] = None
-        self._content_types: Optional[List[str]] = None
 
     # MutableSequence
 
@@ -64,6 +68,30 @@ class ParameterList(MutableSequence):  # pylint: disable=too-many-public-methods
     def get_from_location(self, location: ParameterLocation) -> List[Parameter]:
         return self.get_from_predicate(lambda parameter: parameter.location == location)
 
+    @property
+    def content_types(self) -> List[str]:
+        ordered_set = {
+            m: None
+            for request in self.schema_requests
+            for m in request.content_types
+        }
+        return list(ordered_set.keys())
+
+    @property
+    def default_content_type(self) -> str:
+        json_content_types = [c for c in self.content_types if "json" in c]
+        if json_content_types:
+            if "application/json" in json_content_types:
+                return "application/json"
+            return json_content_types[0]
+
+        xml_content_types = [c for c in self.content_types if "xml" in c]
+        if xml_content_types:
+            if "application/xml" in xml_content_types:
+                return "application/xml"
+            return xml_content_types[0]
+        return self.content_types[0]
+
     @property
     def json_body(self) -> BaseSchema:
         if not self._json_body:
@@ -144,51 +172,15 @@ class ParameterList(MutableSequence):  # pylint: disable=too-many-public-methods
 
     @property
     def multipart(self) -> List[Parameter]:
-        return self.get_from_predicate(lambda parameter: parameter.is_multipart)
+        return self.get_from_predicate(
+            lambda parameter: parameter.is_multipart and not parameter.is_body_kwarg
+        )
 
     @property
     def data_inputs(self) -> List[Parameter]:
-        return self.get_from_predicate(lambda parameter: parameter.is_data_input)
-
-    @property
-    def content_types(self) -> List[str]:
-        if self._content_types is not None:
-            return self._content_types
-        content_type_params = self.get_from_predicate(
-            lambda parameter: parameter.serialized_name == "content_type"
+        return self.get_from_predicate(
+            lambda parameter: parameter.is_data_input and not parameter.is_body_kwarg
         )
-        content_types: OrderedSet[str] = {}
-        for param in content_type_params:
-            if isinstance(param.schema, dict):
-                if param.schema.get("value"):
-                    content_types[param.schema["value"]["value"]] = None
-                if param.schema.get("choices"):
-                    for choice in param.schema['choices']:
-                        content_types[choice['value']] = None
-            elif isinstance(param.schema, ConstantSchema) and param.schema.value:
-                content_types[param.schema.value] = None
-            elif isinstance(param.schema, EnumSchema):
-                # enums
-                content_types.update({v.value: None for v in param.schema.values})
-            if param.client_default_value:
-                content_types.update({param.client_default_value: None})
-        self._content_types = [k for k in content_types if k is not None]
-        return self._content_types
-
-    @property
-    def default_content_type(self) -> str:
-        json_content_types = [c for c in self.content_types if "json" in c]
-        if json_content_types:
-            if "application/json" in json_content_types:
-                return "application/json"
-            return json_content_types[0]
-
-        xml_content_types = [c for c in self.content_types if "xml" in c]
-        if xml_content_types:
-            if "application/xml" in xml_content_types:
-                return "application/xml"
-            return xml_content_types[0]
-        return self.content_types[0]
 
     def _filter_out_multiple_content_type(self, kwarg_params):
         """We don't want multiple content type kwargs in the method signature"""
@@ -226,24 +218,24 @@ class ParameterList(MutableSequence):  # pylint: disable=too-many-public-methods
         return signature_parameters
 
 
-    def method_signature(self, is_python_3_file: bool) -> List[str]:
+    def method_signature(self, is_python3_file: bool) -> List[str]:
         return _method_signature_helper(
-            positional=self.method_signature_positional(is_python_3_file),
-            keyword_only=self.method_signature_keyword_only(is_python_3_file),
-            kwarg_params=self.method_signature_kwargs(is_python_3_file)
+            positional=self.method_signature_positional(is_python3_file),
+            keyword_only=self.method_signature_keyword_only(is_python3_file),
+            kwarg_params=self.method_signature_kwargs(is_python3_file)
         )
 
-    def method_signature_positional(self, is_python_3_file: bool) -> List[str]:
-        return [parameter.method_signature(is_python_3_file) for parameter in self.positional]
+    def method_signature_positional(self, is_python3_file: bool) -> List[str]:
+        return [parameter.method_signature(is_python3_file) for parameter in self.positional]
 
-    def method_signature_keyword_only(self, is_python_3_file: bool) -> List[str]:
-        if not (self.keyword_only and is_python_3_file):
+    def method_signature_keyword_only(self, is_python3_file: bool) -> List[str]:
+        if not (self.keyword_only and is_python3_file):
             return []
-        return ["*,"] + [parameter.method_signature(is_python_3_file) for parameter in self.keyword_only]
+        return ["*,"] + [parameter.method_signature(is_python3_file) for parameter in self.keyword_only]
 
     @staticmethod
-    def method_signature_kwargs(is_python_3_file: bool) -> List[str]:
-        return ["**kwargs: Any"] if is_python_3_file else ["**kwargs  # type: Any"]
+    def method_signature_kwargs(is_python3_file: bool) -> List[str]:
+        return ["**kwargs: Any"] if is_python3_file else ["**kwargs  # type: Any"]
 
     @property
     def positional(self) -> List[Parameter]:
@@ -257,9 +249,9 @@ class ParameterList(MutableSequence):  # pylint: disable=too-many-public-methods
     def kwargs(self) -> List[Parameter]:
         return [p for p in self.method if p.is_kwarg]
 
-    def kwargs_to_pop(self, is_python_3_file: bool) -> List[Parameter]:
+    def kwargs_to_pop(self, is_python3_file: bool) -> List[Parameter]:
         kwargs_to_pop = self.kwargs
-        if not is_python_3_file:
+        if not is_python3_file:
             kwargs_to_pop += self.keyword_only
         return kwargs_to_pop
 
@@ -445,41 +437,41 @@ class GlobalParameterList(ParameterList):
             return True
         return serialized_name != self.host_variable_name
 
-    def kwargs_to_pop(self, is_python_3_file: bool) -> List[Parameter]:
+    def kwargs_to_pop(self, is_python3_file: bool) -> List[Parameter]:
         return [
-            k for k in super().kwargs_to_pop(is_python_3_file)
+            k for k in super().kwargs_to_pop(is_python3_file)
             if not self._param_is_in_config_method(k.serialized_name)
         ]
 
-    def config_kwargs_to_pop(self, is_python_3_file: bool) -> List[Parameter]:
-        current_kwargs_to_pop = super().kwargs_to_pop(is_python_3_file)
+    def config_kwargs_to_pop(self, is_python3_file: bool) -> List[Parameter]:
+        current_kwargs_to_pop = super().kwargs_to_pop(is_python3_file)
         return [k for k in current_kwargs_to_pop if self._param_is_in_config_method(k.serialized_name)]
 
     @property
     def config_method(self) -> List[Parameter]:
         return [p for p in self.method if self._param_is_in_config_method(p.serialized_name)]
 
-    def client_method_signature(self, is_python_3_file: bool) -> List[str]:
-        return self.method_signature(is_python_3_file)
+    def client_method_signature(self, is_python3_file: bool) -> List[str]:
+        return self.method_signature(is_python3_file)
 
-    def config_method_signature(self, is_python_3_file: bool) -> List[str]:
+    def config_method_signature(self, is_python3_file: bool) -> List[str]:
 
         positional = [
-            p.method_signature(is_python_3_file)
+            p.method_signature(is_python3_file)
             for p in self.positional
             if self._param_is_in_config_method(p.serialized_name)
         ]
         keyword_only_params = [p for p in self.keyword_only if self._param_is_in_config_method(p.serialized_name)]
         keyword_only_method_signature = []
-        if is_python_3_file:
+        if is_python3_file:
             keyword_only_method_signature = (
                 ["*,"] +
                 [
-                    p.method_signature(is_python_3_file) for p in keyword_only_params
+                    p.method_signature(is_python3_file) for p in keyword_only_params
                 ]
             ) if keyword_only_params else []
         return _method_signature_helper(
             positional=positional,
             keyword_only=keyword_only_method_signature,
-            kwarg_params=self.method_signature_kwargs(is_python_3_file)
+            kwarg_params=self.method_signature_kwargs(is_python3_file)
         )

package/autorest/codegen/models/primitive_schemas.py

@@ -141,6 +141,17 @@ class AnySchema(PrimitiveSchema):
         file_import.add_from_import("typing", "Any", ImportType.STDLIB, TypingSection.CONDITIONAL)
         return file_import
 
+class JSONSchema(AnySchema):
+
+    @property
+    def docstring_type(self) -> str:
+        return "JSONType"
+
+    @property
+    def type_annotation(self) -> str:
+        return "JSONType"
+
+
 class NumberSchema(PrimitiveSchema):
     def __init__(self, namespace: str, yaml_data: Dict[str, Any]) -> None:
         super(NumberSchema, self).__init__(namespace=namespace, yaml_data=yaml_data)

package/autorest/codegen/models/request_builder.py

@@ -11,6 +11,7 @@ from .request_builder_parameter_list import RequestBuilderParameterList
 from .schema_request import SchemaRequest
 from .schema_response import SchemaResponse
 from .imports import FileImport, ImportType, TypingSection
+from .parameter import Parameter
 
 
 T = TypeVar('T')
@@ -38,18 +39,22 @@ class RequestBuilder(BaseBuilder):
             description=description,
             parameters=parameters,
             responses=responses,
+            schema_requests=schema_requests,
             summary=summary,
         )
         self.url = url
         self.method = method
         self.multipart = multipart
-        self.schema_requests = schema_requests
 
     @property
     def is_stream(self) -> bool:
         """Is the request we're preparing a stream, like an upload."""
         return any(request.is_stream_request for request in self.schema_requests)
 
+    @property
+    def body_kwargs_to_get(self) -> List[Parameter]:
+        return self.parameters.body_kwargs_to_get
+
     @property
     def operation_group_name(self) -> str:
         return self.yaml_data["language"]["python"]["operationGroupName"]
@@ -75,10 +80,19 @@ class RequestBuilder(BaseBuilder):
             file_import.add_from_import(
                 f"{relative_path}_vendor", "_format_url_section", ImportType.LOCAL
             )
+        if self.parameters.headers or self.parameters.query:
+            file_import.add_from_import(
+                "typing", "Dict", ImportType.STDLIB, typing_section=TypingSection.CONDITIONAL
+            )
         file_import.add_from_import(
             "typing", "Any", ImportType.STDLIB, typing_section=TypingSection.CONDITIONAL
         )
         file_import.add_from_import("msrest", "Serializer", ImportType.AZURECORE)
+        if self.parameters.has_body and (
+            self.code_model.options["builders_visibility"] != "embedded" or
+            self.code_model.options["add_python3_operation_files"]
+        ):
+            file_import.define_mypy_type("JSONType", "Any")
         return file_import
 
     @classmethod
@@ -98,15 +112,13 @@ class RequestBuilder(BaseBuilder):
         name = "_".join([n for n in names if n])
 
         first_request = yaml_data["requests"][0]
-
-        parameters, multiple_media_type_parameters = (
+        schema_requests = [SchemaRequest.from_yaml(yaml, code_model=code_model) for yaml in yaml_data["requests"]]
+        parameters, multiple_content_type_parameters = (
             create_parameters(yaml_data, code_model, RequestBuilderParameter.from_yaml)
         )
-        parameter_list = RequestBuilderParameterList(code_model, parameters + multiple_media_type_parameters)
-
-        schema_requests = [SchemaRequest.from_yaml(yaml, code_model=code_model) for yaml in yaml_data["requests"]]
-        parameter_list.add_body_kwargs(schema_requests)
-
+        parameter_list = RequestBuilderParameterList(
+            code_model, parameters + multiple_content_type_parameters, schema_requests
+        )
         request_builder_class = cls(
             code_model=code_model,
             yaml_data=yaml_data,
@@ -121,4 +133,5 @@ class RequestBuilder(BaseBuilder):
             summary=yaml_data["language"]["python"].get("summary"),
         )
         code_model.request_builder_ids[id(yaml_data)] = request_builder_class
+        parameter_list.add_body_kwargs()
         return request_builder_class

package/autorest/codegen/models/request_builder_parameter.py

@@ -3,7 +3,7 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
-from typing import Any, Dict, Optional
+from typing import Any, Dict, List, Optional
 from .parameter import ParameterOnlyPathAndBodyPositional, ParameterLocation, ParameterStyle
 
 def _make_public(name):
@@ -29,12 +29,13 @@ class RequestBuilderParameter(ParameterOnlyPathAndBodyPositional):
 
     @property
     def name_in_high_level_operation(self) -> str:
+        template = "{}" if self.code_model.options["version_tolerant"] else "_{}"
         if self.is_multipart:
-            return "files"
+            return template.format("files")
         if self.is_data_input:
-            return "data"
+            return template.format("data")
         if self.is_body and not self.constant:
-            return self.serialized_name
+            return f"_{self.serialized_name}"
         name = self.yaml_data["language"]["python"]["name"]
         if self.implementation == "Client" and self.in_method_code:
             # for these, we're passing the client params to the request builder.
@@ -68,7 +69,9 @@ class RequestBuilderParameter(ParameterOnlyPathAndBodyPositional):
         return self.serialized_name
 
     @classmethod
-    def from_yaml(cls, yaml_data: Dict[str, Any], *, code_model) -> "RequestBuilderParameter":
+    def from_yaml(
+        cls, yaml_data: Dict[str, Any], *, code_model, content_types: Optional[List[str]] = None
+    ) -> "RequestBuilderParameter":
         http_protocol = yaml_data["protocol"].get("http", {"in": ParameterLocation.Other})
         name = yaml_data["language"]["python"]["name"]
         location = ParameterLocation(http_protocol["in"])
@@ -94,4 +97,5 @@ class RequestBuilderParameter(ParameterOnlyPathAndBodyPositional):
             original_parameter=yaml_data.get("originalParameter", None),
             flattened=yaml_data.get("flattened", False),
             client_default_value=yaml_data.get("clientDefaultValue"),
+            content_types=content_types,
         )