@autorest/python 5.19.0 → 6.0.1

package/autorest/codegen/serializers/__init__.py

@@ -9,14 +9,14 @@ from jinja2 import PackageLoader, Environment, FileSystemLoader, StrictUndefined
 from autorest.codegen.models.operation_group import OperationGroup
 from autorest.codegen.models.request_builder import OverloadedRequestBuilder
 
+from ... import ReaderAndWriter, ReaderAndWriterAutorest
 from ...jsonrpc import AutorestAPI
 from ..models import CodeModel, OperationGroup, RequestBuilder
 from ..models import TokenCredentialType
 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 .model_serializer import ModelSerializer
 from .operations_init_serializer import OperationsInitSerializer
 from .operation_groups_serializer import OperationGroupsSerializer
 from .metadata_serializer import MetadataSerializer
@@ -39,9 +39,9 @@ _PACKAGE_FILES = [
 _REGENERATE_FILES = {"setup.py", "MANIFEST.in"}
 
 
-class JinjaSerializer:
-    def __init__(self, autorestapi: AutorestAPI, code_model: CodeModel) -> None:
-        self._autorestapi = autorestapi
+class JinjaSerializer(ReaderAndWriter):  # pylint: disable=abstract-method
+    def __init__(self, code_model: CodeModel, **kwargs: Any) -> None:
+        super().__init__(**kwargs)
         self.code_model = code_model
 
     @property
@@ -130,10 +130,10 @@ class JinjaSerializer:
             )
         if not self.code_model.options["models_mode"]:
             # keep models file if users ended up just writing a models file
-            if self._autorestapi.read_file(namespace_path / Path("models.py")):
-                self._autorestapi.write_file(
+            if self.read_file(namespace_path / Path("models.py")):
+                self.write_file(
                     namespace_path / Path("models.py"),
-                    self._autorestapi.read_file(namespace_path / Path("models.py")),
+                    self.read_file(namespace_path / Path("models.py")),
                 )
 
         if self.code_model.options["package_mode"]:
@@ -144,13 +144,10 @@ class JinjaSerializer:
             for template_name in package_files:
                 file = template_name.replace(".jinja2", "")
                 output_name = out_path / file
-                if (
-                    not self._autorestapi.read_file(output_name)
-                    or file in _REGENERATE_FILES
-                ):
+                if not self.read_file(output_name) or file in _REGENERATE_FILES:
                     template = env.get_template(template_name)
                     render_result = template.render(**kwargs)
-                    self._autorestapi.write_file(output_name, render_result)
+                    self.write_file(output_name, render_result)
 
         def _prepare_params() -> Dict[Any, Any]:
             package_parts = package_name.split("-")[:-1]
@@ -208,12 +205,10 @@ class JinjaSerializer:
             _serialize_and_write_package_files_proc(**params)
 
     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)
-            )
+        if self.read_file(path_file):
+            self.write_file(path_file, self.read_file(path_file))
         else:
-            self._autorestapi.write_file(
+            self.write_file(
                 path_file,
                 PatchSerializer(env=env, code_model=self.code_model).serialize(),
             )
@@ -224,29 +219,16 @@ class JinjaSerializer:
         # Write the models folder
         models_path = namespace_path / Path("models")
         if self.code_model.model_types:
-            if not self.code_model.options["python3_only"]:
-                self._autorestapi.write_file(
-                    models_path
-                    / Path(
-                        f"{self.code_model.get_models_filename(is_python3_file=False)}.py"
-                    ),
-                    ModelGenericSerializer(
-                        code_model=self.code_model, env=env
-                    ).serialize(),
-                )
-            self._autorestapi.write_file(
-                models_path
-                / Path(
-                    f"{self.code_model.get_models_filename(is_python3_file=True)}.py"
-                ),
-                ModelPython3Serializer(code_model=self.code_model, env=env).serialize(),
+            self.write_file(
+                models_path / Path(f"{self.code_model.models_filename}.py"),
+                ModelSerializer(code_model=self.code_model, env=env).serialize(),
             )
         if self.code_model.enums:
-            self._autorestapi.write_file(
+            self.write_file(
                 models_path / Path(f"{self.code_model.enums_filename}.py"),
                 EnumSerializer(code_model=self.code_model, env=env).serialize(),
             )
-        self._autorestapi.write_file(
+        self.write_file(
             models_path / Path("__init__.py"),
             ModelInitSerializer(code_model=self.code_model, env=env).serialize(),
         )
@@ -267,7 +249,7 @@ class JinjaSerializer:
                 env, rest_path, request_builders
             )
         if not "" in group_names:
-            self._autorestapi.write_file(
+            self.write_file(
                 rest_path / Path("__init__.py"),
                 self.code_model.options["license_header"],
             )
@@ -281,35 +263,22 @@ class JinjaSerializer:
         group_name = request_builders[0].group_name
         output_path = rest_path / Path(group_name) if group_name else rest_path
         # write generic request builders file
-        self._autorestapi.write_file(
+        self.write_file(
             output_path / Path("_request_builders.py"),
             RequestBuildersSerializer(
                 code_model=self.code_model,
                 env=env,
                 request_builders=request_builders,
-                is_python3_file=False,
-            ).serialize_request_builders(),
-        )
-
-        # write python3 request builders file
-        self._autorestapi.write_file(
-            output_path / Path("_request_builders_py3.py"),
-            RequestBuildersSerializer(
-                code_model=self.code_model,
-                env=env,
-                request_builders=request_builders,
-                is_python3_file=True,
             ).serialize_request_builders(),
         )
 
         # write rest init file
-        self._autorestapi.write_file(
+        self.write_file(
             output_path / Path("__init__.py"),
             RequestBuildersSerializer(
                 code_model=self.code_model,
                 env=env,
                 request_builders=request_builders,
-                is_python3_file=True,
             ).serialize_init(),
         )
 
@@ -325,44 +294,24 @@ class JinjaSerializer:
             code_model=self.code_model,
             env=env,
             async_mode=False,
-            is_python3_file=self.code_model.options["python3_only"],
             operation_group=operation_group,
         )
-        self._autorestapi.write_file(
+        self.write_file(
             namespace_path
             / Path(self.code_model.operations_folder_name)
             / Path(f"{filename}.py"),
             operation_group_serializer.serialize(),
         )
 
-        if (
-            not self.code_model.options["python3_only"]
-            and self.code_model.options["add_python3_operation_files"]
-        ):
-            # write typed second file if not python 3 only
-            operation_group_serializer = OperationGroupsSerializer(
-                code_model=self.code_model,
-                env=env,
-                async_mode=False,
-                is_python3_file=True,
-            )
-            self._autorestapi.write_file(
-                namespace_path
-                / Path(self.code_model.operations_folder_name)
-                / Path(f"{filename}_py3.py"),
-                operation_group_serializer.serialize(),
-            )
-
         if self.has_aio_folder:
             # write async operation group and operation files
             operation_group_async_serializer = OperationGroupsSerializer(
                 code_model=self.code_model,
                 env=env,
                 async_mode=True,
-                is_python3_file=True,
                 operation_group=operation_group,
             )
-            self._autorestapi.write_file(
+            self.write_file(
                 (
                     namespace_path
                     / Path("aio")
@@ -379,7 +328,7 @@ class JinjaSerializer:
         operations_init_serializer = OperationsInitSerializer(
             code_model=self.code_model, env=env, async_mode=False
         )
-        self._autorestapi.write_file(
+        self.write_file(
             namespace_path
             / Path(self.code_model.operations_folder_name)
             / Path("__init__.py"),
@@ -391,7 +340,7 @@ class JinjaSerializer:
             operations_async_init_serializer = OperationsInitSerializer(
                 code_model=self.code_model, env=env, async_mode=True
             )
-            self._autorestapi.write_file(
+            self.write_file(
                 namespace_path
                 / Path("aio")
                 / Path(self.code_model.operations_folder_name)
@@ -416,12 +365,10 @@ class JinjaSerializer:
         self, namespace_path: Path, general_serializer: GeneralSerializer
     ):
         def _read_version_file(original_version_file_name: str) -> str:
-            return self._autorestapi.read_file(
-                namespace_path / original_version_file_name
-            )
+            return self.read_file(namespace_path / original_version_file_name)
 
         def _write_version_file(original_version_file_name: str) -> None:
-            self._autorestapi.write_file(
+            self.write_file(
                 namespace_path / Path("_version.py"),
                 _read_version_file(original_version_file_name),
             )
@@ -432,7 +379,7 @@ class JinjaSerializer:
         elif keep_version_file and _read_version_file("version.py"):
             _write_version_file(original_version_file_name="version.py")
         elif self.code_model.options["package_version"]:
-            self._autorestapi.write_file(
+            self.write_file(
                 namespace_path / Path("_version.py"),
                 general_serializer.serialize_version_file(),
             )
@@ -444,14 +391,14 @@ class JinjaSerializer:
             code_model=self.code_model, env=env, async_mode=False
         )
 
-        self._autorestapi.write_file(
+        self.write_file(
             namespace_path / Path("__init__.py"),
             general_serializer.serialize_init_file(),
         )
         p = namespace_path.parent
         while p != Path("."):
             # write pkgutil init file
-            self._autorestapi.write_file(
+            self.write_file(
                 p / Path("__init__.py"),
                 general_serializer.serialize_pkgutil_init_file(),
             )
@@ -459,13 +406,13 @@ class JinjaSerializer:
 
         # Write the service client
         if self.code_model.request_builders:
-            self._autorestapi.write_file(
+            self.write_file(
                 namespace_path / Path(f"{self.code_model.client.filename}.py"),
                 general_serializer.serialize_service_client_file(),
             )
 
         if self.code_model.need_vendored_code(async_mode=False):
-            self._autorestapi.write_file(
+            self.write_file(
                 namespace_path / Path("_vendor.py"),
                 general_serializer.serialize_vendor_file(),
             )
@@ -473,31 +420,27 @@ class JinjaSerializer:
         self._serialize_and_write_version_file(namespace_path, general_serializer)
 
         # write the empty py.typed file
-        self._autorestapi.write_file(
-            namespace_path / Path("py.typed"), "# Marker file for PEP 561."
-        )
+        self.write_file(namespace_path / Path("py.typed"), "# Marker file for PEP 561.")
 
         if (
             not self.code_model.options["client_side_validation"]
             and not self.code_model.options["multiapi"]
         ):
-            self._autorestapi.write_file(
+            self.write_file(
                 namespace_path / Path("_serialization.py"),
                 general_serializer.serialize_serialization_file(),
             )
 
         # Write the config file
         if self.code_model.request_builders:
-            self._autorestapi.write_file(
+            self.write_file(
                 namespace_path / Path("_configuration.py"),
                 general_serializer.serialize_config_file(),
             )
 
         # Write the setup file
         if self.code_model.options["basic_setup_py"]:
-            self._autorestapi.write_file(
-                Path("setup.py"), general_serializer.serialize_setup_file()
-            )
+            self.write_file(Path("setup.py"), general_serializer.serialize_setup_file())
 
     def _serialize_and_write_aio_top_level_folder(
         self, env: Environment, namespace_path: Path
@@ -509,24 +452,24 @@ class JinjaSerializer:
         aio_path = namespace_path / Path("aio")
 
         # Write the __init__ file
-        self._autorestapi.write_file(
+        self.write_file(
             aio_path / Path("__init__.py"), aio_general_serializer.serialize_init_file()
         )
 
         # Write the service client
         if self.code_model.request_builders:
-            self._autorestapi.write_file(
+            self.write_file(
                 aio_path / Path(f"{self.code_model.client.filename}.py"),
                 aio_general_serializer.serialize_service_client_file(),
             )
 
         # Write the config file
-        self._autorestapi.write_file(
+        self.write_file(
             aio_path / Path("_configuration.py"),
             aio_general_serializer.serialize_config_file(),
         )
         if self.code_model.need_vendored_code(async_mode=True):
-            self._autorestapi.write_file(
+            self.write_file(
                 aio_path / Path("_vendor.py"),
                 aio_general_serializer.serialize_vendor_file(),
             )
@@ -535,6 +478,11 @@ class JinjaSerializer:
         self, env: Environment, namespace_path: Path
     ) -> None:
         metadata_serializer = MetadataSerializer(self.code_model, env)
-        self._autorestapi.write_file(
+        self.write_file(
             namespace_path / Path("_metadata.json"), metadata_serializer.serialize()
         )
+
+
+class JinjaSerializerAutorest(JinjaSerializer, ReaderAndWriterAutorest):
+    def __init__(self, autorestapi: AutorestAPI, code_model: CodeModel) -> None:
+        super().__init__(autorestapi=autorestapi, code_model=code_model)

package/autorest/codegen/serializers/builder_serializer.py

@@ -176,12 +176,9 @@ def _get_json_response_template_to_status_codes(
 
 
 class _BuilderBaseSerializer(Generic[BuilderType]):  # pylint: disable=abstract-method
-    def __init__(
-        self, code_model: CodeModel, async_mode: bool, is_python3_file: bool
-    ) -> None:
+    def __init__(self, code_model: CodeModel, async_mode: bool) -> None:
         self.code_model = code_model
         self.async_mode = async_mode
-        self.is_python3_file = is_python3_file
         self.parameter_serializer = ParameterSerializer()
 
     @property
@@ -225,9 +222,7 @@ class _BuilderBaseSerializer(Generic[BuilderType]):  # pylint: disable=abstract-
             function_def=self._function_def,
             method_name=builder.name,
             need_self_param=self._need_self_param,
-            method_param_signatures=builder.method_signature(
-                self.async_mode or self.is_python3_file, self.async_mode
-            ),
+            method_param_signatures=builder.method_signature(self.async_mode),
             pylint_disable=builder.pylint_disable,
         )
 
@@ -245,7 +240,6 @@ class _BuilderBaseSerializer(Generic[BuilderType]):  # pylint: disable=abstract-
         return (
             decorators_str
             + utils.method_signature_and_response_type_annotation_template(
-                is_python3_file=self.is_python3_file,
                 method_signature=method_signature,
                 response_type_annotation=response_type_annotation,
             )
@@ -442,7 +436,7 @@ class RequestBuilderSerializer(
 
     def pop_kwargs_from_signature(self, builder: RequestBuilderType) -> List[str]:
         return self.parameter_serializer.pop_kwargs_from_signature(
-            builder.parameters.kwargs_to_pop(is_python3_file=self.is_python3_file),
+            builder.parameters.kwargs_to_pop,
             check_kwarg_dict=True,
             pop_headers_kwarg=PopKwargType.CASE_INSENSITIVE
             if bool(builder.parameters.headers)
@@ -452,7 +446,8 @@ class RequestBuilderSerializer(
             else PopKwargType.NO,
         )
 
-    def create_http_request(self, builder: RequestBuilderType) -> List[str]:
+    @staticmethod
+    def create_http_request(builder: RequestBuilderType) -> List[str]:
         retval = ["return HttpRequest("]
         retval.append(f'    method="{builder.method}",')
         retval.append("    url=_url,")
@@ -465,9 +460,9 @@ class RequestBuilderSerializer(
             and builder.parameters.body_parameter.in_method_signature
         ):
             body_param = builder.parameters.body_parameter
-            if body_param.constant or (
-                self.is_python3_file
-                and body_param.method_location != ParameterMethodLocation.KWARG
+            if (
+                body_param.constant
+                or body_param.method_location != ParameterMethodLocation.KWARG
             ):
                 # we only need to pass it through if it's not a kwarg or it's a popped kwarg
                 retval.append(
@@ -611,9 +606,7 @@ class _OperationSerializer(
         return description_list
 
     def pop_kwargs_from_signature(self, builder: OperationType) -> List[str]:
-        kwargs_to_pop = builder.parameters.kwargs_to_pop(
-            is_python3_file=self.is_python3_file
-        )
+        kwargs_to_pop = builder.parameters.kwargs_to_pop
         kwargs = self.parameter_serializer.pop_kwargs_from_signature(
             kwargs_to_pop,
             check_kwarg_dict=True,
@@ -822,7 +815,6 @@ class _OperationSerializer(
                 is_next_request
                 and builder.operation_type == "paging"
                 and not bool(builder.next_request_builder)  # type: ignore
-                and not self.code_model.options["reformat_next_link"]
                 and parameter.location == ParameterLocation.QUERY
             ):
                 # if we don't want to reformat query parameters for next link calls
@@ -833,10 +825,15 @@ class _OperationSerializer(
                 f"    {parameter.client_name}={parameter.name_in_high_level_operation},"
             )
         if request_builder.overloads:
+            seen_body_params = set()
             for overload in request_builder.overloads:
                 body_param = cast(
                     RequestBuilderBodyParameter, overload.parameters.body_parameter
                 )
+                if body_param.client_name in seen_body_params:
+                    continue
+                seen_body_params.add(body_param.client_name)
+
                 retval.append(
                     f"    {body_param.client_name}={body_param.name_in_high_level_operation},"
                 )
@@ -1103,15 +1100,12 @@ PagingOperationType = TypeVar(
 class _PagingOperationSerializer(
     _OperationSerializer[PagingOperationType]
 ):  # pylint: disable=abstract-method
-    def __init__(
-        self, code_model: CodeModel, async_mode: bool, is_python3_file: bool
-    ) -> None:
+    def __init__(self, code_model: CodeModel, async_mode: bool) -> None:
         # for pylint reasons need to redefine init
         # probably because inheritance is going too deep
-        super().__init__(code_model, async_mode, is_python3_file)
+        super().__init__(code_model, async_mode)
         self.code_model = code_model
         self.async_mode = async_mode
-        self.is_python3_file = is_python3_file
         self.parameter_serializer = ParameterSerializer()
 
     def serialize_path(self, builder: PagingOperationType) -> List[str]:
@@ -1139,9 +1133,39 @@ class _PagingOperationSerializer(
             template_url = "next_link"
 
         request_builder = builder.next_request_builder or builder.request_builder
-        return self._call_request_builder_helper(
-            builder, request_builder, template_url=template_url, is_next_request=True
-        )
+        if builder.next_request_builder:
+            return self._call_request_builder_helper(
+                builder,
+                request_builder,
+                template_url=template_url,
+                is_next_request=True,
+            )
+        retval: List[str] = []
+        query_str = ""
+        next_link_str = "next_link"
+        try:
+            api_version_param = next(
+                p
+                for p in self.code_model.client.parameters
+                if p.rest_api_name == "api-version"
+            )
+            retval.append("# make call to next link with the client's api-version")
+            retval.append("_parsed_next_link = urlparse(next_link)")
+            retval.append(
+                "_next_request_params = case_insensitive_dict(parse_qs(_parsed_next_link.query))"
+            )
+            retval.append(
+                f'_next_request_params["api-version"] = {api_version_param.full_client_name}'
+            )
+            query_str = ", params=_next_request_params"
+            next_link_str = "urljoin(next_link, _parsed_next_link.path)"
+        except StopIteration:
+            pass
+
+        retval.append(f'request = HttpRequest("GET", {next_link_str}{query_str})')
+        retval.extend(self._postprocess_http_request(builder, "request.url"))
+
+        return retval
 
     def _prepare_request_callback(self, builder: PagingOperationType) -> List[str]:
         retval = ["def prepare_request(next_link=None):"]
@@ -1154,10 +1178,7 @@ class _PagingOperationSerializer(
         retval.extend(
             [f"        {line}" for line in self.call_next_link_request_builder(builder)]
         )
-        if not builder.next_request_builder and builder.parameters.path:
-            retval.append("")
-            retval.extend([f"        {line}" for line in self.serialize_path(builder)])
-        if not builder.next_request_builder:
+        if not builder.next_request_builder and self.code_model.is_legacy:
             retval.append('        request.method = "GET"')
         else:
             retval.append("")
@@ -1235,15 +1256,12 @@ LROOperationType = TypeVar(
 
 
 class _LROOperationSerializer(_OperationSerializer[LROOperationType]):
-    def __init__(
-        self, code_model: CodeModel, async_mode: bool, is_python3_file: bool
-    ) -> None:
+    def __init__(self, code_model: CodeModel, async_mode: bool) -> None:
         # for pylint reasons need to redefine init
         # probably because inheritance is going too deep
-        super().__init__(code_model, async_mode, is_python3_file)
+        super().__init__(code_model, async_mode)
         self.code_model = code_model
         self.async_mode = async_mode
-        self.is_python3_file = is_python3_file
         self.parameter_serializer = ParameterSerializer()
 
     def param_description(self, builder: LROOperationType) -> List[str]:
@@ -1423,7 +1441,6 @@ def get_operation_serializer(
     builder: Operation,
     code_model,
     async_mode: bool,
-    is_python3_file: bool,
 ) -> Union[
     OperationSerializer,
     PagingOperationSerializer,
@@ -1442,4 +1459,4 @@ def get_operation_serializer(
         retcls = LROOperationSerializer
     elif builder.operation_type == "paging":
         retcls = PagingOperationSerializer
-    return retcls(code_model, async_mode, is_python3_file)
+    return retcls(code_model, async_mode)