@autorest/python 5.15.0 → 5.16.0

package/autorest/codegen/models/request_builder_parameter.py

@@ -3,20 +3,30 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
-from typing import Any, Dict, List, Optional
-from .parameter import ParameterOnlyPathAndBodyPositional, ParameterLocation, ParameterStyle, get_target_property_name
+from typing import Any, Dict, List, Optional, TYPE_CHECKING
+from .parameter import (
+    ParameterMethodLocation,
+    ParameterOnlyPathAndBodyPositional,
+    ParameterLocation,
+    ParameterStyle,
+    get_target_property_name,
+)
 from .utils import get_schema
 
+if TYPE_CHECKING:
+    from .code_model import CodeModel
+
+
 def _make_public(name):
     if name[0] == "_":
         return name[1:]
     return name
 
-class RequestBuilderParameter(ParameterOnlyPathAndBodyPositional):
 
+class RequestBuilderParameter(ParameterOnlyPathAndBodyPositional):
     @property
     def in_method_signature(self) -> bool:
-        return not(
+        return not (
             # 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
@@ -28,11 +38,6 @@ 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 template.format("files")
-        if self.is_data_input:
-            return template.format("data")
         if self.is_body and not self.constant:
             return f"_{self.serialized_name}"
         name = self.yaml_data["language"]["python"]["name"]
@@ -60,13 +65,20 @@ class RequestBuilderParameter(ParameterOnlyPathAndBodyPositional):
         return super().default_value_declaration
 
     @property
-    def is_keyword_only(self) -> bool:
-        return not self.location == ParameterLocation.Path and not self.is_kwarg
+    def method_location(self) -> ParameterMethodLocation:
+        super_method_location = super().method_location
+        if super_method_location in (
+            ParameterMethodLocation.KWARG,
+            ParameterMethodLocation.HIDDEN_KWARG,
+        ):
+            return super_method_location
+        if self.location != ParameterLocation.Path:
+            return ParameterMethodLocation.KEYWORD_ONLY
+        return super_method_location
 
-    @is_keyword_only.setter
-    def is_keyword_only(self, val: bool) -> None:
-        self._keyword_only = val
-        self.is_kwarg = False
+    @method_location.setter
+    def method_location(self, val: ParameterMethodLocation) -> None:
+        self._method_location = val
 
     @property
     def full_serialized_name(self) -> str:
@@ -74,17 +86,25 @@ class RequestBuilderParameter(ParameterOnlyPathAndBodyPositional):
 
     @classmethod
     def from_yaml(
-        cls, yaml_data: Dict[str, Any], *, code_model, content_types: Optional[List[str]] = None
+        cls,
+        yaml_data: Dict[str, Any],
+        code_model: "CodeModel",
+        *,
+        content_types: Optional[List[str]] = None,
     ) -> "RequestBuilderParameter":
-        http_protocol = yaml_data["protocol"].get("http", {"in": ParameterLocation.Other})
+        http_protocol = yaml_data["protocol"].get(
+            "http", {"in": ParameterLocation.Other}
+        )
         name = yaml_data["language"]["python"]["name"]
         location = ParameterLocation(http_protocol["in"])
         serialized_name = yaml_data["language"]["python"]["name"]
-        schema = get_schema(
-            code_model, yaml_data.get("schema"), serialized_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
+        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,
@@ -98,10 +118,14 @@ class RequestBuilderParameter(ParameterOnlyPathAndBodyPositional):
             implementation=yaml_data["implementation"],
             required=yaml_data.get("required", False),
             location=location,
-            skip_url_encoding=yaml_data.get("extensions", {}).get("x-ms-skip-url-encoding", False),
+            skip_url_encoding=yaml_data.get("extensions", {}).get(
+                "x-ms-skip-url-encoding", False
+            ),
             constraints=[],  # FIXME constraints
             target_property_name=target_property_name,
-            style=ParameterStyle(http_protocol["style"]) if "style" in http_protocol else None,
+            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),
             original_parameter=yaml_data.get("originalParameter", None),

package/autorest/codegen/models/request_builder_parameter_list.py

@@ -4,38 +4,48 @@
 # license information.
 # --------------------------------------------------------------------------
 from copy import copy
-from typing import List, Optional, Tuple, TypeVar, Dict
+from typing import List, Optional, Tuple, TypeVar, Dict, TYPE_CHECKING
 from .request_builder_parameter import RequestBuilderParameter
 from .parameter_list import ParameterList
-from .parameter import ParameterLocation, Parameter, ParameterStyle
-from .primitive_schemas import AnySchema, JSONSchema
+from .parameter import (
+    ParameterLocation,
+    Parameter,
+    ParameterMethodLocation,
+    ParameterStyle,
+)
+from .primitive_schemas import AnySchema
 from .dictionary_schema import DictionarySchema
 from .base_schema import BaseSchema
+from .list_schema import ListSchema
+from .object_schema import ObjectSchema
 from .schema_request import SchemaRequest
 from .utils import JSON_REGEXP
 
-T = TypeVar('T')
+if TYPE_CHECKING:
+    from .code_model import CodeModel
+
+T = TypeVar("T")
 OrderedSet = Dict[T, None]
 
 
 def _update_content_types(content_types_to_assign: List[str], param: Parameter):
-    return [
-        c for c in content_types_to_assign if c not in param.content_types
-    ]
+    return [c for c in content_types_to_assign if c not in param.content_types]
+
 
 def _kwarg_not_added(body_method_params, serialized_name: str) -> bool:
-    return not any(b for b in body_method_params if b.serialized_name == serialized_name)
+    return not any(
+        b for b in body_method_params if b.serialized_name == serialized_name
+    )
+
 
 class RequestBuilderParameterList(ParameterList):
     def __init__(
         self,
-        code_model,
+        code_model: "CodeModel",
         parameters: Optional[List[RequestBuilderParameter]] = None,
         schema_requests: Optional[List[SchemaRequest]] = None,
     ) -> None:
-        super(RequestBuilderParameterList, self).__init__(
-            code_model, parameters, schema_requests  # type: ignore
-        )
+        super().__init__(code_model, parameters, schema_requests)  # type: ignore
         self.body_kwarg_names: OrderedSet[str] = {}
         self.parameters: List[RequestBuilderParameter] = parameters or []  # type: ignore
 
@@ -45,17 +55,20 @@ class RequestBuilderParameterList(ParameterList):
         parameter.is_body_kwarg = True
 
     def _is_json(self, body_method_param: Parameter) -> bool:
-        if 'json' in body_method_param.serialization_formats:
+        if "json" in body_method_param.serialization_formats:
             return True
         if not any(
-            flag for flag in ["version_tolerant", "low_level_client"]
+            flag
+            for flag in ["version_tolerant", "low_level_client"]
             if self.code_model.options.get(flag)
         ):
             if body_method_param.style == ParameterStyle.binary:
                 return False
         if any(
-            sr for sr in self.schema_requests
-            if sr.yaml_data.get("protocol", {}).get('http', {}).get('knownMediaType') == "json"
+            sr
+            for sr in self.schema_requests
+            if sr.yaml_data.get("protocol", {}).get("http", {}).get("knownMediaType")
+            == "json"
         ):
             return True
         return any(c for c in self.content_types if JSON_REGEXP.match(c))
@@ -70,11 +83,9 @@ class RequestBuilderParameterList(ParameterList):
         # we don't currently have a fully constant data or files input
         # so we don't need to modify the body kwarg
         constant_bodies = [
-            p for p in self.parameters
-            if p.location == ParameterLocation.Body
-            and p.constant
-            and not p.is_data_input
-            and not p.is_multipart
+            p
+            for p in self.parameters
+            if p.location == ParameterLocation.Body and p.constant
         ]
         for constant_body in constant_bodies:
             if self._is_json(constant_body):
@@ -82,48 +93,6 @@ class RequestBuilderParameterList(ParameterList):
             else:
                 constant_body.serialized_name = "content"
 
-    def _add_files_kwarg(
-        self, content_types_to_assign, body_method_param
-    ) -> Tuple[List[str], RequestBuilderParameter]:
-        file_kwarg = copy(body_method_param)
-        self._change_body_param_name(file_kwarg, "files")
-        file_kwarg.schema = DictionarySchema(
-            namespace="",
-            yaml_data={},
-            element_type=AnySchema(namespace="", yaml_data={}),
-        )
-        file_kwarg.description = (
-            "Multipart input for files. See the template in our example to find the input shape. " +
-            file_kwarg.description
-        )
-        file_kwarg.content_types = [
-            c for c in content_types_to_assign
-            if c == "multipart/form-data"
-        ]
-        content_types_to_assign = _update_content_types(content_types_to_assign, file_kwarg)
-        return content_types_to_assign, file_kwarg
-
-    def _add_data_kwarg(
-        self, content_types_to_assign, body_method_param
-    ) -> Tuple[List[str], RequestBuilderParameter]:
-        data_kwarg = copy(body_method_param)
-        self._change_body_param_name(data_kwarg, "data")
-        data_kwarg.schema = DictionarySchema(
-            namespace="",
-            yaml_data={},
-            element_type=AnySchema(namespace="", yaml_data={}),
-        )
-        data_kwarg.description = (
-            "Pass in dictionary that contains form data to include in the body of the request. " +
-            data_kwarg.description
-        )
-        data_kwarg.content_types = [
-            c for c in content_types_to_assign
-            if c == "application/x-www-form-urlencoded"
-        ]
-        content_types_to_assign = _update_content_types(content_types_to_assign, data_kwarg)
-        return content_types_to_assign, data_kwarg
-
     def _add_json_kwarg(
         self, content_types_to_assign, body_method_param
     ) -> Tuple[List[str], RequestBuilderParameter]:
@@ -131,15 +100,19 @@ class RequestBuilderParameterList(ParameterList):
         self._change_body_param_name(json_kwarg, "json")
         json_kwarg.description = (
             "Pass in a JSON-serializable object (usually a dictionary). "
-            "See the template in our example to find the input shape. " +
-            json_kwarg.description
+            "See the template in our example to find the input shape. "
+            + json_kwarg.description
         )
-        json_kwarg.schema = JSONSchema(namespace="", yaml_data={})
+        if not isinstance(
+            body_method_param.schema, (ObjectSchema, DictionarySchema, ListSchema)
+        ):
+            json_kwarg.schema = AnySchema(yaml_data={}, code_model=self.code_model)
         json_kwarg.content_types = [
-            c for c in content_types_to_assign
-            if JSON_REGEXP.match(c)
+            c for c in content_types_to_assign if JSON_REGEXP.match(c)
         ]
-        content_types_to_assign = _update_content_types(content_types_to_assign, json_kwarg)
+        content_types_to_assign = _update_content_types(
+            content_types_to_assign, json_kwarg
+        )
         return content_types_to_assign, json_kwarg
 
     def _add_content_kwarg(
@@ -147,14 +120,11 @@ class RequestBuilderParameterList(ParameterList):
     ) -> RequestBuilderParameter:
         content_kwarg = copy(body_method_param)
         self._change_body_param_name(content_kwarg, "content")
-        content_kwarg.schema = AnySchema(namespace="", yaml_data={})
+        content_kwarg.schema = AnySchema(yaml_data={}, code_model=self.code_model)
         content_kwarg.description = (
             "Pass in binary content you want in the body of the request (typically bytes, "
-            "a byte iterator, or stream input). " +
-            content_kwarg.description
+            "a byte iterator, or stream input). " + content_kwarg.description
         )
-        content_kwarg.is_data_input = False
-        content_kwarg.is_multipart = False
         content_kwarg.content_types = content_types_to_assign
         return content_kwarg
 
@@ -162,25 +132,18 @@ class RequestBuilderParameterList(ParameterList):
         self._update_constant_params()
         body_kwargs_added: List[RequestBuilderParameter] = []
         body_method_params = [
-            p for p in self.parameters
-            if p.location == ParameterLocation.Body and not p.constant
+            p
+            for p in self.parameters
+            if p.location == ParameterLocation.Body
+            and not (p.constant or p.is_multipart or p.is_data_input)
         ]
         if not body_method_params:
             return
         content_types_to_assign = copy(self.content_types)
         for body_method_param in body_method_params:
-            if body_method_param.is_multipart and _kwarg_not_added(body_kwargs_added, "files"):
-                content_types_to_assign, file_kwarg = self._add_files_kwarg(
-                    content_types_to_assign, body_method_param
-                )
-                body_kwargs_added.append(file_kwarg)
-
-            elif body_method_param.is_data_input and _kwarg_not_added(body_kwargs_added, "data"):
-                content_types_to_assign, data_kwarg = self._add_data_kwarg(
-                    content_types_to_assign, body_method_param
-                )
-                body_kwargs_added.append(data_kwarg)
-            elif self._is_json(body_method_param) and _kwarg_not_added(body_kwargs_added, "json"):
+            if self._is_json(body_method_param) and _kwarg_not_added(
+                body_kwargs_added, "json"
+            ):
                 content_types_to_assign, json_kwarg = self._add_json_kwarg(
                     content_types_to_assign, body_method_param
                 )
@@ -206,8 +169,7 @@ class RequestBuilderParameterList(ParameterList):
         if not self._json_body:
             try:
                 json_param = next(
-                    b for b in self.body if not b.is_body_kwarg and
-                    b.is_json_parameter
+                    b for b in self.body if not b.is_body_kwarg and b.is_json_parameter
                 )
                 self._json_body = json_param.schema
                 return self._json_body
@@ -219,13 +181,14 @@ class RequestBuilderParameterList(ParameterList):
         # we don't want to pop the body kwargs in py2.7. We send them straight to HttpRequest
         kwargs_to_pop = self.kwargs
         if not is_python3_file:
-            kwargs_to_pop += [k for k in self.keyword_only if not (k.is_body and not k.constant)]
+            kwargs_to_pop += [
+                k for k in self.keyword_only if not (k.is_body and not k.constant)
+            ]
         return kwargs_to_pop
 
     @property
     def method(self) -> List[Parameter]:
-        """The list of parameter used in method signature. Includes both positional and kwargs
-        """
+        """The list of parameter used in method signature. Includes both positional and kwargs"""
         signature_parameters_no_default_value = []
         signature_parameters_default_value = []
 
@@ -233,29 +196,28 @@ class RequestBuilderParameterList(ParameterList):
         # Also allow client parameters if they're going to be used in the request body.
         # i.e., path parameter, query parameter, header.
         parameters = self.get_from_predicate(
-            lambda parameter: parameter.implementation == self.implementation or parameter.in_method_code
+            lambda parameter: parameter.implementation == self.implementation
+            or parameter.in_method_code
         )
         seen_content_type = False
 
         for parameter in parameters:
-
-            if (
-                parameter.location == ParameterLocation.Body and
-                (parameter.is_data_input or parameter.is_multipart) and
-                not parameter.is_body_kwarg
+            if parameter.location == ParameterLocation.Body and (
+                parameter.is_multipart or parameter.is_data_input
             ):
-                # if i am a part of files or data, and i'm not the files or
-                # data kwarg, ignore me
+                # don't want any multipart for formdata params in our signature
                 continue
             if (
-                parameter.location == ParameterLocation.Body and
-                not parameter.is_body_kwarg and
-                not parameter.constant
+                parameter.location == ParameterLocation.Body
+                and not parameter.is_body_kwarg
+                and not parameter.constant
             ):
                 # we keep the original body param from the swagger for documentation purposes
                 # we don't want it in the method signature
                 continue
-            if any([g for g in self.groupers if id(g.yaml_data) == id(parameter.yaml_data)]):
+            if any(
+                [g for g in self.groupers if id(g.yaml_data) == id(parameter.yaml_data)]
+            ):
                 # we don't allow a grouped parameter for the body param
                 continue
             if seen_content_type and parameter.serialized_name == "content_type":
@@ -270,9 +232,16 @@ class RequestBuilderParameterList(ParameterList):
                 else:
                     signature_parameters_default_value.append(parameter)
 
-        signature_parameters = signature_parameters_no_default_value + signature_parameters_default_value
-        signature_parameters.sort(key=lambda item: item.is_keyword_only)
-        signature_parameters = self._filter_out_multiple_content_type(signature_parameters)
+        signature_parameters = (
+            signature_parameters_no_default_value + signature_parameters_default_value
+        )
+        signature_parameters.sort(
+            key=lambda item: item.method_location
+            == ParameterMethodLocation.KEYWORD_ONLY
+        )
+        signature_parameters = self._filter_out_multiple_content_type(
+            signature_parameters
+        )
         return signature_parameters
 
     @staticmethod

package/autorest/codegen/models/schema_request.py

@@ -3,32 +3,41 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
-from typing import Dict, List, Any, Optional
+from typing import Dict, List, Any, Optional, TYPE_CHECKING
 
 from .base_model import BaseModel
 from .parameter import Parameter
 from .parameter_list import ParameterList
 
+if TYPE_CHECKING:
+    from .code_model import CodeModel
+
+
 class SchemaRequest(BaseModel):
     def __init__(
         self,
         yaml_data: Dict[str, Any],
+        code_model: "CodeModel",
         content_types: List[str],
         parameters: ParameterList,
     ) -> None:
-        super().__init__(yaml_data)
+        super().__init__(yaml_data, code_model)
         self.content_types = content_types
         self.parameters = parameters
 
     @property
     def is_stream_request(self) -> bool:
         """Is the request expected to be streamable, like a download."""
-        if self.yaml_data['protocol']['http'].get('knownMediaType'):
-            return self.yaml_data['protocol']['http']['knownMediaType'] == 'binary' # FIXME: this might be an m4 issue
+        if self.yaml_data["protocol"]["http"].get("knownMediaType"):
+            return (
+                self.yaml_data["protocol"]["http"]["knownMediaType"] == "binary"
+            )  # FIXME: this might be an m4 issue
         return self.yaml_data["protocol"]["http"].get("binary", False)
 
     @classmethod
-    def from_yaml(cls, yaml_data: Dict[str, Any], *, code_model) -> "SchemaRequest":
+    def from_yaml(
+        cls, yaml_data: Dict[str, Any], code_model: "CodeModel"
+    ) -> "SchemaRequest":
 
         parameters: Optional[List[Parameter]] = [
             Parameter.from_yaml(yaml, code_model=code_model)
@@ -37,8 +46,9 @@ class SchemaRequest(BaseModel):
 
         return cls(
             yaml_data=yaml_data,
+            code_model=code_model,
             content_types=yaml_data["protocol"]["http"].get("mediaTypes", []),
-            parameters=ParameterList(code_model, parameters)
+            parameters=ParameterList(code_model, parameters),
         )
 
     def __repr__(self) -> str:

package/autorest/codegen/models/schema_response.py

@@ -29,16 +29,15 @@ class HeaderResponse:
 class SchemaResponse(BaseModel):
     def __init__(
         self,
-        code_model: "CodeModel",
         yaml_data: Dict[str, Any],
+        code_model: "CodeModel",
         schema: Optional[BaseSchema],
         content_types: List[str],
         status_codes: List[Union[str, int]],
         headers: List[HeaderResponse],
         binary: bool,
     ) -> None:
-        super().__init__(yaml_data)
-        self.code_model = code_model
+        super().__init__(yaml_data, code_model)
         self.schema = schema
         self.content_types = content_types
         self.status_codes = status_codes
@@ -48,14 +47,12 @@ class SchemaResponse(BaseModel):
 
     @property
     def has_body(self) -> bool:
-        """Tell if that response defines a body.
-        """
+        """Tell if that response defines a body."""
         return bool(self.schema)
 
     @property
     def has_headers(self) -> bool:
-        """Tell if that response defines headers.
-        """
+        """Tell if that response defines headers."""
         return bool(self.headers)
 
     @property
@@ -105,27 +102,35 @@ class SchemaResponse(BaseModel):
     def imports(self, code_model) -> FileImport:
         file_import = FileImport()
         if not code_model.options["models_mode"] and self.is_xml:
-            file_import.add_submodule_import("xml.etree", "ElementTree", ImportType.STDLIB, alias="ET")
+            file_import.add_submodule_import(
+                "xml.etree", "ElementTree", ImportType.STDLIB, alias="ET"
+            )
         return file_import
 
     @classmethod
-    def from_yaml(cls, yaml_data: Dict[str, Any], *, code_model: "CodeModel") -> "SchemaResponse":
+    def from_yaml(
+        cls, yaml_data: Dict[str, Any], code_model: "CodeModel"
+    ) -> "SchemaResponse":
         binary = yaml_data.get("binary", False)
         if binary:
-            schema: BaseSchema = IOSchema(namespace=None, yaml_data={})
+            schema: BaseSchema = IOSchema(yaml_data={}, code_model=code_model)
         else:
             schema = get_schema(code_model, yaml_data.get("schema"))
         return cls(
-            code_model=code_model,
             yaml_data=yaml_data,
+            code_model=code_model,
             schema=schema,
             content_types=yaml_data["protocol"]["http"].get("mediaTypes", []),
             status_codes=[
-                int(code) if code != "default" else "default" for code in yaml_data["protocol"]["http"]["statusCodes"]
+                int(code) if code != "default" else "default"
+                for code in yaml_data["protocol"]["http"]["statusCodes"]
             ],
             headers=[
                 HeaderResponse(
-                    header_prop["header"], get_schema(code_model, header_prop["schema"], header_prop["header"])
+                    header_prop["header"],
+                    get_schema(
+                        code_model, header_prop["schema"], header_prop["header"]
+                    ),
                 )
                 for header_prop in yaml_data["protocol"]["http"].get("headers", [])
             ],

package/autorest/codegen/models/utils.py

@@ -14,9 +14,12 @@ if TYPE_CHECKING:
 
 _LOGGER = logging.getLogger(__name__)
 
-JSON_REGEXP = re.compile(r'^(application|text)/(.+\+)?json$')
+JSON_REGEXP = re.compile(r"^(application|text)/(.+\+)?json$")
 
-def get_schema(code_model: "CodeModel", schema: Any, serialized_name: str = "unknown") -> BaseSchema:
+
+def get_schema(
+    code_model: "CodeModel", schema: Any, serialized_name: str = "unknown"
+) -> BaseSchema:
     if not isinstance(schema, dict):
         return schema
     schema_id = id(schema)