@autorest/python 5.10.0 → 5.12.0

package/autorest/codegen/models/request_builder_parameter_list.py

@@ -3,12 +3,13 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
+import re
 from copy import copy
-from typing import List, Optional, TypeVar, Dict
+from typing import List, Optional, Tuple, TypeVar, Dict
 from .request_builder_parameter import RequestBuilderParameter
 from .parameter_list import ParameterList
-from .parameter import ParameterLocation, Parameter
-from .primitive_schemas import AnySchema
+from .parameter import ParameterLocation, Parameter, ParameterStyle
+from .primitive_schemas import AnySchema, JSONSchema
 from .dictionary_schema import DictionarySchema
 from .base_schema import BaseSchema
 from .schema_request import SchemaRequest
@@ -17,14 +18,25 @@ T = TypeVar('T')
 OrderedSet = Dict[T, None]
 
 _REQUEST_BUILDER_BODY_NAMES = ["files", "json", "content", "data"]
+_JSON_REGEXP = re.compile(r'^(application|text)/([0-9a-z+.]+\+)?json$')
 
+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
+    ]
+
+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)
 
 class RequestBuilderParameterList(ParameterList):
     def __init__(
-        self, code_model, parameters: Optional[List[RequestBuilderParameter]] = None
+        self,
+        code_model,
+        parameters: Optional[List[RequestBuilderParameter]] = None,
+        schema_requests: Optional[List[SchemaRequest]] = None,
     ) -> None:
         super(RequestBuilderParameterList, self).__init__(
-            code_model, parameters  # type: ignore
+            code_model, parameters, schema_requests  # type: ignore
         )
         self.body_kwarg_names: OrderedSet[str] = {}
         self.parameters: List[RequestBuilderParameter] = parameters or []  # type: ignore
@@ -32,90 +44,170 @@ class RequestBuilderParameterList(ParameterList):
     def _change_body_param_name(self, parameter: Parameter, name: str) -> None:
         self.body_kwarg_names[name] = None
         parameter.serialized_name = name
+        parameter.is_body_kwarg = True
 
-    def add_body_kwargs(self, schema_requests: List[SchemaRequest]) -> None:
-        try:
-            body_kwargs_added = []
-            body_method_param = next(
-                p for p in self.parameters if p.location == ParameterLocation.Body
-            )
-        except StopIteration:
-            pass
-        else:
-            serialized_name: str = ""
-            if body_method_param.is_multipart:
-                serialized_name = "files"
-                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
+    def _is_json(self, body_method_param: Parameter) -> bool:
+        if 'json' in body_method_param.serialization_formats:
+            return True
+        if not any(
+            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"
+        ):
+            return True
+        return any(c for c in self.content_types if _JSON_REGEXP.match(c))
+
+    @property
+    def body_kwargs_to_get(self) -> List[Parameter]:
+        if not self.body_kwarg_names:
+            return []
+        return [b for b in self.body if b.content_types]
+
+    def _update_constant_params(self):
+        # 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
+        ]
+        for constant_body in constant_bodies:
+            if self._is_json(constant_body):
+                constant_body.serialized_name = "json"
+            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]:
+        json_kwarg = copy(body_method_param)
+        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
+        )
+        json_kwarg.schema = JSONSchema(namespace="", yaml_data={})
+        json_kwarg.content_types = [
+            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)
+        return content_types_to_assign, json_kwarg
+
+    def _add_content_kwarg(
+        self, content_types_to_assign, body_method_param
+    ) -> RequestBuilderParameter:
+        content_kwarg = copy(body_method_param)
+        self._change_body_param_name(content_kwarg, "content")
+        content_kwarg.schema = AnySchema(namespace="", yaml_data={})
+        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
+        )
+        content_kwarg.is_data_input = False
+        content_kwarg.is_multipart = False
+        content_kwarg.content_types = content_types_to_assign
+        return content_kwarg
+
+    def add_body_kwargs(self) -> None:
+        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
+        ]
+        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
                 )
-                file_kwarg.is_multipart = False
                 body_kwargs_added.append(file_kwarg)
-            if body_method_param.is_data_input:
-                serialized_name = "data"
-                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
+
+            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
                 )
-                data_kwarg.is_data_input = False
                 body_kwargs_added.append(data_kwarg)
-            if body_method_param.constant:
-                # we don't add body kwargs for constant bodies
-                if not serialized_name:
-                    serialized_name = "json" if body_method_param.is_json_parameter else "content"
-                body_method_param.serialized_name = serialized_name
-                return
-            if (
-                any(sr for sr in schema_requests if not sr.is_stream_request) and
-                any([ct for ct in self.content_types if "json" in ct])
-            ):
-                json_kwarg = copy(body_method_param)
-                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
+            elif 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
                 )
-                json_kwarg.schema = AnySchema(namespace="", yaml_data={})
                 body_kwargs_added.append(json_kwarg)
-            content_kwarg = copy(body_method_param)
-            self._change_body_param_name(content_kwarg, "content")
-            content_kwarg.schema = AnySchema(namespace="", yaml_data={})
-            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
+
+        first_body_param = body_method_params[0]
+        if _kwarg_not_added(body_kwargs_added, "content"):
+            # we always add a content kwarg so users can pass in input by stream
+            content_kwarg = self._add_content_kwarg(
+                content_types_to_assign, first_body_param
             )
-            content_kwarg.is_data_input = False
-            content_kwarg.is_multipart = False
             body_kwargs_added.append(content_kwarg)
-            if len(body_kwargs_added) == 1:
-                body_kwargs_added[0].required = body_method_param.required
-            else:
-                for kwarg in body_kwargs_added:
-                    kwarg.required = False
-            self.parameters = body_kwargs_added + self.parameters
+        if len(body_kwargs_added) == 1:
+            body_kwargs_added[0].required = first_body_param.required
+        else:
+            for kwarg in body_kwargs_added:
+                kwarg.required = False
+        self.parameters = body_kwargs_added + self.parameters
 
     @property
     def json_body(self) -> BaseSchema:
         if not self._json_body:
             try:
                 json_param = next(
-                    b for b in self.body if b.serialized_name not in _REQUEST_BUILDER_BODY_NAMES and
+                    b for b in self.body if not b.is_body_kwarg and
                     b.is_json_parameter
                 )
                 self._json_body = json_param.schema
@@ -124,10 +216,10 @@ class RequestBuilderParameterList(ParameterList):
                 raise ValueError("There is no JSON body in these parameters")
         return self._json_body
 
-    def kwargs_to_pop(self, is_python_3_file: bool) -> List[Parameter]:
+    def kwargs_to_pop(self, is_python3_file: bool) -> List[Parameter]:
         # 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_python_3_file:
+        if not is_python3_file:
             kwargs_to_pop += [k for k in self.keyword_only if not (k.is_body and not k.constant)]
         return kwargs_to_pop
 
@@ -147,9 +239,19 @@ class RequestBuilderParameterList(ParameterList):
         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 i am a part of files or data, and i'm not the files or
+                # data kwarg, ignore me
+                continue
             if (
                 parameter.location == ParameterLocation.Body and
-                parameter.serialized_name not in _REQUEST_BUILDER_BODY_NAMES
+                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

package/autorest/codegen/models/rest.py

@@ -19,10 +19,11 @@ class Rest(BaseModel):
         super(Rest, self). __init__(yaml_data=yaml_data)
         self.request_builders = request_builders
 
-    def imports(self) -> FileImport:
+    def imports(self, builder_group_name: str) -> FileImport:
         file_import = FileImport()
         for request_builder in self.request_builders:
-            file_import.merge(request_builder.imports())
+            if request_builder.builder_group_name == builder_group_name:
+                file_import.merge(request_builder.imports())
         return file_import
 
     @classmethod

package/autorest/codegen/models/schema_request.py

@@ -13,26 +13,13 @@ class SchemaRequest(BaseModel):
     def __init__(
         self,
         yaml_data: Dict[str, Any],
-        media_types: List[str],
+        content_types: List[str],
         parameters: ParameterList,
     ) -> None:
         super().__init__(yaml_data)
-        self.media_types = media_types
+        self.content_types = content_types
         self.parameters = parameters
 
-    @property
-    def pre_semicolon_media_types(self) -> List[str]:
-        """Splits on semicolon of media types and returns the first half.
-        I.e. ["text/plain; encoding=UTF-8"] -> ["text/plain"]
-        """
-        return [media_type.split(";")[0] for media_type in self.media_types]
-
-    @property
-    def body_parameter_has_schema(self) -> bool:
-        """Tell if that request has a parameter that defines a body.
-        """
-        return any([p for p in self.parameters if hasattr(p, 'schema') and p.schema])
-
     @property
     def is_stream_request(self) -> bool:
         """Is the request expected to be streamable, like a download."""
@@ -50,9 +37,9 @@ class SchemaRequest(BaseModel):
 
         return cls(
             yaml_data=yaml_data,
-            media_types=yaml_data["protocol"]["http"].get("mediaTypes", []),
+            content_types=yaml_data["protocol"]["http"].get("mediaTypes", []),
             parameters=ParameterList(code_model, parameters)
         )
 
     def __repr__(self) -> str:
-        return f"<{self.__class__.__name__} {self.media_types}>"
+        return f"<{self.__class__.__name__} {self.content_types}>"

package/autorest/codegen/models/schema_response.py

@@ -26,14 +26,14 @@ class SchemaResponse(BaseModel):
         self,
         yaml_data: Dict[str, Any],
         schema: Optional[BaseSchema],
-        media_types: List[str],
+        content_types: List[str],
         status_codes: List[Union[str, int]],
         headers: List[HeaderResponse],
         binary: bool,
     ) -> None:
         super().__init__(yaml_data)
         self.schema = schema
-        self.media_types = media_types
+        self.content_types = content_types
         self.status_codes = status_codes
         self.headers = headers
         self.binary = binary
@@ -94,7 +94,7 @@ class SchemaResponse(BaseModel):
 
     @property
     def is_xml(self) -> bool:
-        return any(["xml" in ct for ct in self.media_types])
+        return any(["xml" in ct for ct in self.content_types])
 
     def imports(self, code_model) -> FileImport:
         file_import = FileImport()
@@ -108,7 +108,7 @@ class SchemaResponse(BaseModel):
         return cls(
             yaml_data=yaml_data,
             schema=yaml_data.get("schema", None),  # FIXME replace by operation model
-            media_types=yaml_data["protocol"]["http"].get("mediaTypes", []),
+            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"]
             ],

package/autorest/codegen/serializers/__init__.py

@@ -3,29 +3,32 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
-from typing import List
+from typing import List, Optional
 from pathlib import Path
 from jinja2 import PackageLoader, Environment
 from autorest.codegen.models.operation_group import OperationGroup
 
 from ...jsonrpc import AutorestAPI
-from ..models import CodeModel
-from ..models.request_builder import RequestBuilder
+from ..models import (
+    CodeModel,
+    OperationGroup,
+    RequestBuilder,
+)
 from .enum_serializer import EnumSerializer
 from .general_serializer import GeneralSerializer
 from .model_generic_serializer import ModelGenericSerializer
 from .model_init_serializer import ModelInitSerializer
 from .model_python3_serializer import ModelPython3Serializer
 from .operations_init_serializer import OperationsInitSerializer
-from .operation_group_serializer import OperationGroupSerializer
+from .operation_groups_serializer import OperationGroupsSerializer
 from .metadata_serializer import MetadataSerializer
 from .rest_serializer import RestPython3Serializer, RestGenericSerializer, RestSerializer
+from .patch_serializer import PatchSerializer
 
 __all__ = [
     "JinjaSerializer",
 ]
 
-
 class JinjaSerializer:
     def __init__(self, autorestapi: AutorestAPI) -> None:
         self._autorestapi = autorestapi
@@ -45,11 +48,8 @@ class JinjaSerializer:
         )
 
         # if there was a patch file before, we keep it
-        if self._autorestapi.read_file(namespace_path / "_patch.py"):
-            self._autorestapi.write_file(
-                namespace_path / Path("_patch.py"),
-                self._autorestapi.read_file(namespace_path / "_patch.py")
-            )
+        self._keep_patch_file(namespace_path / Path("_patch.py"), env)
+        self._keep_patch_file(namespace_path / Path("aio") / Path("_patch.py"), env)
 
         self._serialize_and_write_top_level_folder(code_model=code_model, env=env, namespace_path=namespace_path)
 
@@ -72,11 +72,19 @@ class JinjaSerializer:
             self._serialize_and_write_models_folder(code_model=code_model, env=env, namespace_path=namespace_path)
 
 
+
+    def _keep_patch_file(self, path_file: Path, env: Environment):
+        if self._autorestapi.read_file(path_file):
+            self._autorestapi.write_file(path_file, self._autorestapi.read_file(path_file))
+        else:
+            self._autorestapi.write_file(path_file, PatchSerializer(env=env).serialize())
+
+
     def _serialize_and_write_models_folder(self, code_model: CodeModel, env: Environment, namespace_path: Path) -> None:
         # Write the models folder
         models_path = namespace_path / Path("models")
         if code_model.schemas:
-            if not code_model.options['python_3_only']:
+            if not code_model.options['python3_only']:
                 self._autorestapi.write_file(
                     models_path / Path("_models.py"), ModelGenericSerializer(code_model=code_model, env=env).serialize()
                 )
@@ -141,96 +149,92 @@ class JinjaSerializer:
             ).serialize_init()
         )
 
-    def _serialize_and_write_operations_folder_process(
+    def _serialize_and_write_operations_file(
         self,
         code_model: CodeModel,
         env: Environment,
         namespace_path: Path,
-        operation_groups: List[OperationGroup],
-        filename: str
+        operation_group: Optional[OperationGroup] = None
     ) -> None:
-        # write sync operation group and operation files
-        if not code_model.options['python_3_only'] and not code_model.options["add_python_3_operation_files"]:
-            operation_group_serializer = OperationGroupSerializer(
+        filename = operation_group.filename if operation_group else "_operations"
+        # write first sync file
+        operation_group_serializer = OperationGroupsSerializer(
+            code_model=code_model,
+            env=env,
+            async_mode=False,
+            is_python3_file=code_model.options['python3_only'],
+            operation_group=operation_group
+        )
+        self._autorestapi.write_file(
+            namespace_path / Path(code_model.operations_folder_name) / Path(f"{filename}.py"),
+            operation_group_serializer.serialize(),
+        )
+
+        if not code_model.options['python3_only'] and code_model.options["add_python3_operation_files"]:
+            # write typed second file if not python 3 only
+            operation_group_serializer = OperationGroupsSerializer(
                 code_model=code_model,
                 env=env,
-                operation_groups=operation_groups,
                 async_mode=False,
-                is_python_3_file=False,
+                is_python3_file=True,
+
             )
             self._autorestapi.write_file(
-                namespace_path / Path(f"operations") / Path(f"{filename}.py"),
+                namespace_path / Path(code_model.operations_folder_name) / Path(f"{filename}_py3.py"),
                 operation_group_serializer.serialize(),
             )
 
         if not code_model.options["no_async"]:
             # write async operation group and operation files
-            operation_group_async_serializer = OperationGroupSerializer(
+            operation_group_async_serializer = OperationGroupsSerializer(
                 code_model=code_model,
                 env=env,
-                operation_groups=operation_groups,
                 async_mode=True,
-                is_python_3_file=True,
+                is_python3_file=True,
+                operation_group=operation_group
             )
             self._autorestapi.write_file(
                 (
                     namespace_path
                     / Path("aio")
-                    / Path(f"operations")
+                    / Path(code_model.operations_folder_name)
                     / Path(f"{filename}.py")
                 ),
                 operation_group_async_serializer.serialize(),
             )
 
-        if code_model.options["add_python_3_operation_files"]:
-            # write typed sync operation files
-            operation_group_serializer = OperationGroupSerializer(
-                code_model=code_model,
-                env=env,
-                operation_groups=operation_groups,
-                async_mode=False,
-                is_python_3_file=True,
-            )
-            self._autorestapi.write_file(
-                namespace_path / Path(f"operations") / Path(f"{filename}_py3.py"),
-                operation_group_serializer.serialize(),
-            )
-
     def _serialize_and_write_operations_folder(
         self, code_model: CodeModel, env: Environment, namespace_path: Path
     ) -> None:
         # write sync operations init file
         operations_init_serializer = OperationsInitSerializer(code_model=code_model, env=env, async_mode=False)
         self._autorestapi.write_file(
-            namespace_path / Path(f"operations") / Path("__init__.py"), operations_init_serializer.serialize()
+            namespace_path / Path(code_model.operations_folder_name) / Path("__init__.py"),
+            operations_init_serializer.serialize(),
         )
 
         # write async operations init file
         if not code_model.options["no_async"]:
             operations_async_init_serializer = OperationsInitSerializer(code_model=code_model, env=env, async_mode=True)
             self._autorestapi.write_file(
-                namespace_path / Path("aio") / Path(f"operations") / Path("__init__.py"),
+                namespace_path / Path("aio") / Path(code_model.operations_folder_name) / Path("__init__.py"),
                 operations_async_init_serializer.serialize(),
             )
 
-        if not code_model.options["combine_operation_files"]:
+        if code_model.options["combine_operation_files"]:
+            self._serialize_and_write_operations_file(
+                code_model=code_model,
+                env=env,
+                namespace_path=namespace_path,
+            )
+        else:
             for operation_group in code_model.operation_groups:
-                self._serialize_and_write_operations_folder_process(
+                self._serialize_and_write_operations_file(
                     code_model=code_model,
                     env=env,
                     namespace_path=namespace_path,
-                    operation_groups=[operation_group],
-                    filename=operation_group.filename
+                    operation_group=operation_group,
                 )
-        else:
-            self._serialize_and_write_operations_folder_process(
-                code_model=code_model,
-                env=env,
-                namespace_path=namespace_path,
-                operation_groups=code_model.operation_groups,
-                filename="_operations"
-            )
-
 
     def _serialize_and_write_version_file(
         self, code_model: CodeModel, namespace_path: Path, general_serializer: GeneralSerializer