@autorest/python 5.13.0 → 5.16.0

package/autorest/codegen/models/request_builder.py

@@ -3,7 +3,8 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
-from typing import Any, Dict, List, TypeVar, Optional
+from typing import Any, Dict, List, TypeVar, Optional, TYPE_CHECKING
+import logging
 
 from .base_builder import BaseBuilder, create_parameters
 from .request_builder_parameter import RequestBuilderParameter
@@ -13,15 +14,20 @@ from .schema_response import SchemaResponse
 from .imports import FileImport, ImportType, TypingSection
 from .parameter import Parameter
 
+if TYPE_CHECKING:
+    from .code_model import CodeModel
 
-T = TypeVar('T')
+_LOGGER = logging.getLogger(__name__)
+
+T = TypeVar("T")
 OrderedSet = Dict[T, None]
 
+
 class RequestBuilder(BaseBuilder):
     def __init__(
         self,
-        code_model,
         yaml_data: Dict[str, Any],
+        code_model: "CodeModel",
         name: str,
         url: str,
         method: str,
@@ -31,16 +37,20 @@ class RequestBuilder(BaseBuilder):
         description: str,
         summary: str,
         responses: Optional[List[SchemaResponse]] = None,
+        *,
+        abstract: bool = False,
     ):
         super().__init__(
-            code_model=code_model,
             yaml_data=yaml_data,
+            code_model=code_model,
             name=name,
             description=description,
             parameters=parameters,
             responses=responses,
             schema_requests=schema_requests,
             summary=summary,
+            abstract=abstract,
+            want_tracing=False,
         )
         self.url = url
         self.method = method
@@ -65,64 +75,86 @@ class RequestBuilder(BaseBuilder):
 
     def imports(self) -> FileImport:
         file_import = FileImport()
-        for parameter in self.parameters:
-            if parameter.need_import:
-                file_import.merge(parameter.imports())
+        for parameter in self.parameters.method:
+            if self.abstract and (parameter.is_multipart or parameter.is_data_input):
+                continue
+            file_import.merge(parameter.imports())
 
         file_import.add_submodule_import(
             "azure.core.rest",
             "HttpRequest",
             ImportType.AZURECORE,
         )
-        if self.parameters.path:
-            relative_path = ".."
-            if not self.code_model.options["builders_visibility"] == "embedded" and self.operation_group_name:
-                relative_path = "..." if self.operation_group_name else ".."
-            file_import.add_submodule_import(
-                f"{relative_path}_vendor", "_format_url_section", ImportType.LOCAL
-            )
-        if self.parameters.headers or self.parameters.query:
-            file_import.add_submodule_import(
-                "typing", "Dict", ImportType.STDLIB, typing_section=TypingSection.CONDITIONAL
-            )
+        if not self.abstract:
+            if self.parameters.path:
+                relative_path = ".."
+                if (
+                    not self.code_model.options["builders_visibility"] == "embedded"
+                    and self.operation_group_name
+                ):
+                    relative_path = "..." if self.operation_group_name else ".."
+                file_import.add_submodule_import(
+                    f"{relative_path}_vendor", "_format_url_section", ImportType.LOCAL
+                )
+            if self.parameters.headers or self.parameters.query:
+                file_import.add_submodule_import(
+                    "azure.core.utils", "case_insensitive_dict", ImportType.AZURECORE
+                )
         file_import.add_submodule_import(
             "typing", "Any", ImportType.STDLIB, typing_section=TypingSection.CONDITIONAL
         )
         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"]
-        ):
-            file_import.define_mypy_type("JSONType", "Any")
         return file_import
 
     @classmethod
-    def from_yaml(cls, yaml_data: Dict[str, Any], *, code_model) -> "RequestBuilder":
+    def from_yaml(
+        cls, yaml_data: Dict[str, Any], code_model: "CodeModel"
+    ) -> "RequestBuilder":
 
         # when combine embeded builders into one operation file, we need to avoid duplicated build function name.
         # So add operation group name is effective method
         additional_mark = ""
-        if code_model.options["combine_operation_files"] and code_model.options["builders_visibility"] == "embedded":
+        if (
+            code_model.options["combine_operation_files"]
+            and code_model.options["builders_visibility"] == "embedded"
+        ):
             additional_mark = yaml_data["language"]["python"]["builderGroupName"]
         names = [
             "build",
             additional_mark,
             yaml_data["language"]["python"]["name"],
-            "request"
+            "request",
         ]
         name = "_".join([n for n in names if n])
 
         first_request = yaml_data["requests"][0]
-        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)
+        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_content_type_parameters, schema_requests
         )
+        abstract = False
+        if (
+            code_model.options["version_tolerant"]
+            or code_model.options["low_level_client"]
+        ) and any(p for p in parameter_list if p.is_multipart or p.is_data_input):
+            _LOGGER.warning(
+                'Not going to generate request_builder "%s" because it has multipart / urlencoded '
+                "body parameters. Multipart / urlencoded body parameters are not supported for version "
+                "tolerant and low level generations right now. Please write your own custom operation "
+                "in the _patch.py file following https://aka.ms/azsdk/python/dpcodegen/python/customize.",
+                name,
+            )
+            abstract = True
+
         request_builder_class = cls(
-            code_model=code_model,
             yaml_data=yaml_data,
+            code_model=code_model,
             name=name,
             url=first_request["protocol"]["http"]["path"],
             method=first_request["protocol"]["http"]["method"].upper(),
@@ -130,9 +162,12 @@ class RequestBuilder(BaseBuilder):
             schema_requests=schema_requests,
             parameters=parameter_list,
             description=yaml_data["language"]["python"]["description"],
-            responses=[SchemaResponse.from_yaml(yaml) for yaml in yaml_data.get("responses", [])],
+            responses=[
+                SchemaResponse.from_yaml(yaml, code_model=code_model)
+                for yaml in yaml_data.get("responses", [])
+            ],
             summary=yaml_data["language"]["python"].get("summary"),
+            abstract=abstract,
         )
-        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,21 +3,32 @@
 # 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
+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(
-            # don't put accept in method signature
-            self.rest_api_name == "Accept"
+        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
             or not self.in_method_code
             # If I'm a flattened property of a body, don't want me, want the body param
@@ -27,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"]
@@ -59,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:
@@ -73,15 +86,29 @@ 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)
+        target_property = yaml_data.get("targetProperty")
+        target_property_name = (
+            get_target_property_name(code_model, id(target_property))
+            if target_property
+            else None
+        )
         return cls(
             code_model=code_model,
             yaml_data=yaml_data,
-            schema=yaml_data.get("schema", None),  # FIXME replace by operation model
+            schema=schema,
             # See also https://github.com/Azure/autorest.modelerfour/issues/80
             rest_api_name=yaml_data["language"]["default"].get(
                 "serializedName", yaml_data["language"]["default"]["name"]
@@ -91,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=id(yaml_data["targetProperty"]) if yaml_data.get("targetProperty") else None,
-            style=ParameterStyle(http_protocol["style"]) if "style" in http_protocol else None,
+            target_property_name=target_property_name,
+            style=ParameterStyle(http_protocol["style"])
+            if "style" in http_protocol
+            else None,
             explode=http_protocol.get("explode", False),
             grouped_by=yaml_data.get("groupedBy", None),
             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