@autorest/python 5.18.0 → 6.0.0

package/autorest/codegen/models/operation.py

@@ -3,7 +3,6 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
-import logging
 from itertools import chain
 from typing import (
     Dict,
@@ -43,8 +42,6 @@ from .request_builder import OverloadedRequestBuilder, RequestBuilder
 if TYPE_CHECKING:
     from .code_model import CodeModel
 
-_LOGGER = logging.getLogger(__name__)
-
 ResponseType = TypeVar(
     "ResponseType",
     bound=Union[Response, PagingResponse, LROResponse, LROPagingResponse],
@@ -67,7 +64,6 @@ class OperationBase(  # pylint: disable=too-many-public-methods
         overloads: Optional[List["Operation"]] = None,
         public: bool = True,
         want_tracing: bool = True,
-        abstract: bool = False,
     ) -> None:
         super().__init__(
             code_model=code_model,
@@ -75,7 +71,6 @@ class OperationBase(  # pylint: disable=too-many-public-methods
             name=name,
             parameters=parameters,
             overloads=overloads,
-            abstract=abstract,
             want_tracing=want_tracing,
         )
         self.overloads: List["Operation"] = overloads or []
@@ -204,9 +199,8 @@ class OperationBase(  # pylint: disable=too-many-public-methods
         file_import.add_submodule_import(
             "typing", "Any", ImportType.STDLIB, TypingSection.CONDITIONAL
         )
-        if not self.abstract:
-            for param in self.parameters.method:
-                file_import.merge(param.imports(async_mode, **kwargs))
+        for param in self.parameters.method:
+            file_import.merge(param.imports(async_mode, **kwargs))
 
         response_types = [
             r.type_annotation(async_mode=async_mode) for r in self.responses if r.type
@@ -218,6 +212,8 @@ class OperationBase(  # pylint: disable=too-many-public-methods
         return file_import
 
     def imports_for_multiapi(self, async_mode: bool, **kwargs: Any) -> FileImport:
+        if self.abstract:
+            return FileImport()
         file_import = self._imports_shared(async_mode, **kwargs)
         for response in self.responses:
             file_import.merge(
@@ -273,22 +269,16 @@ class OperationBase(  # pylint: disable=too-many-public-methods
                     alias="rest",
                 )
         if self.code_model.options["builders_visibility"] == "embedded" and async_mode:
-            suffix = (
-                "_py3"
-                if self.code_model.options["add_python3_operation_files"]
-                and not self.code_model.options["python3_only"]
-                else ""
-            )
             file_import.add_submodule_import(
-                f"...{self.code_model.operations_folder_name}.{self.filename}{suffix}",
+                f"...{self.code_model.operations_folder_name}.{self.filename}",
                 request_builder.name,
                 import_type=ImportType.LOCAL,
             )
         return file_import
 
-    def imports(
-        self, async_mode: bool, is_python3_file: bool, **kwargs: Any
-    ) -> FileImport:
+    def imports(self, async_mode: bool, **kwargs: Any) -> FileImport:
+        if self.abstract:
+            return FileImport()
         file_import = self._imports_shared(async_mode, **kwargs)
 
         for response in self.responses:
@@ -301,48 +291,44 @@ class OperationBase(  # pylint: disable=too-many-public-methods
             file_import.merge(self.parameters.body_parameter.type.imports(**kwargs))
 
         # Exceptions
-        if self.abstract:
-            file_import.add_import("abc", ImportType.STDLIB)
-        else:
-            file_import.add_submodule_import(
-                "azure.core.exceptions", "map_error", ImportType.AZURECORE
-            )
-            if self.code_model.options["azure_arm"]:
-                file_import.add_submodule_import(
-                    "azure.mgmt.core.exceptions", "ARMErrorFormat", ImportType.AZURECORE
-                )
-            file_import.add_submodule_import(
-                "azure.core.exceptions", "HttpResponseError", ImportType.AZURECORE
-            )
+        file_import.add_submodule_import(
+            "azure.core.exceptions", "map_error", ImportType.AZURECORE
+        )
+        if self.code_model.options["azure_arm"]:
             file_import.add_submodule_import(
-                "azure.core.exceptions",
-                "ClientAuthenticationError",
-                ImportType.AZURECORE,
+                "azure.mgmt.core.exceptions", "ARMErrorFormat", ImportType.AZURECORE
             )
+        file_import.add_submodule_import(
+            "azure.core.exceptions", "HttpResponseError", ImportType.AZURECORE
+        )
+        file_import.add_submodule_import(
+            "azure.core.exceptions",
+            "ClientAuthenticationError",
+            ImportType.AZURECORE,
+        )
+        file_import.add_submodule_import(
+            "azure.core.exceptions", "ResourceNotFoundError", ImportType.AZURECORE
+        )
+        file_import.add_submodule_import(
+            "azure.core.exceptions", "ResourceExistsError", ImportType.AZURECORE
+        )
+
+        if self.has_kwargs_to_pop_with_default(
+            self.parameters.kwargs_to_pop, ParameterLocation.HEADER
+        ) or self.has_kwargs_to_pop_with_default(
+            self.parameters.kwargs_to_pop, ParameterLocation.QUERY
+        ):
             file_import.add_submodule_import(
-                "azure.core.exceptions", "ResourceNotFoundError", ImportType.AZURECORE
+                "azure.core.utils", "case_insensitive_dict", ImportType.AZURECORE
             )
+        if self.deprecated:
+            file_import.add_import("warnings", ImportType.STDLIB)
+
+        if self.code_model.need_request_converter:
+            relative_path = "..." if async_mode else ".."
             file_import.add_submodule_import(
-                "azure.core.exceptions", "ResourceExistsError", ImportType.AZURECORE
+                f"{relative_path}_vendor", "_convert_request", ImportType.LOCAL
             )
-
-            kwargs_to_pop = self.parameters.kwargs_to_pop(is_python3_file)
-            if self.has_kwargs_to_pop_with_default(
-                kwargs_to_pop, ParameterLocation.HEADER
-            ) or self.has_kwargs_to_pop_with_default(
-                kwargs_to_pop, ParameterLocation.QUERY
-            ):
-                file_import.add_submodule_import(
-                    "azure.core.utils", "case_insensitive_dict", ImportType.AZURECORE
-                )
-            if self.deprecated:
-                file_import.add_import("warnings", ImportType.STDLIB)
-
-            if self.code_model.need_request_converter:
-                relative_path = "..." if async_mode else ".."
-                file_import.add_submodule_import(
-                    f"{relative_path}_vendor", "_convert_request", ImportType.LOCAL
-                )
         if async_mode:
             file_import.add_submodule_import(
                 "azure.core.pipeline.transport",
@@ -382,10 +368,9 @@ class OperationBase(  # pylint: disable=too-many-public-methods
                 f"distributed_trace",
                 ImportType.AZURECORE,
             )
-        if not self.abstract:
-            file_import.merge(
-                self.get_request_builder_import(self.request_builder, async_mode)
-            )
+        file_import.merge(
+            self.get_request_builder_import(self.request_builder, async_mode)
+        )
         if self.overloads:
             file_import.add_submodule_import("typing", "overload", ImportType.STDLIB)
         return file_import
@@ -439,20 +424,6 @@ class OperationBase(  # pylint: disable=too-many-public-methods
             cls.from_yaml(overload, code_model)
             for overload in yaml_data.get("overloads", [])
         ]
-        abstract = False
-        if (
-            code_model.options["version_tolerant"]
-            and parameter_list.has_body
-            and isinstance(parameter_list.body_parameter, MultipartBodyParameter)
-        ):
-            _LOGGER.warning(
-                'Not going to generate operation "%s" because it has multipart / urlencoded body parameters. '
-                "Multipart / urlencoded body parameters are not supported for version tolerant generation 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
 
         return cls(
             yaml_data=yaml_data,
@@ -464,23 +435,20 @@ class OperationBase(  # pylint: disable=too-many-public-methods
             responses=responses,
             exceptions=exceptions,
             want_tracing=not yaml_data["isOverload"],
-            abstract=abstract,
         )
 
 
 class Operation(OperationBase[Response]):
-    def imports(
-        self, async_mode: bool, is_python3_file: bool, **kwargs: Any
-    ) -> FileImport:
-        file_import = super().imports(async_mode, is_python3_file, **kwargs)
+    def imports(self, async_mode: bool, **kwargs: Any) -> FileImport:
+        file_import = super().imports(async_mode, **kwargs)
+        if self.abstract:
+            return file_import
         if async_mode:
             file_import.add_submodule_import(
                 f"azure.core.tracing.decorator_async",
                 f"distributed_trace_async",
                 ImportType.AZURECORE,
             )
-        if self.abstract:
-            return file_import
         if (
             self.has_response_body
             and not self.has_optional_return_type

package/autorest/codegen/models/operation_group.py

@@ -36,14 +36,11 @@ class OperationGroup(BaseModel):
     def has_abstract_operations(self) -> bool:
         return any(o for o in self.operations if o.abstract)
 
-    def base_class(self, async_mode: bool) -> str:
+    @property
+    def base_class(self) -> str:
         base_classes: List[str] = []
         if self.is_mixin and self.code_model.need_mixin_abc:
             base_classes.append("MixinABC")
-        if not (async_mode or self.code_model.options["python3_only"]):
-            base_classes.append("object")
-        if self.has_abstract_operations:
-            base_classes.append("abc.ABC")
         return ", ".join(base_classes)
 
     def imports_for_multiapi(self, async_mode: bool) -> FileImport:
@@ -69,15 +66,13 @@ class OperationGroup(BaseModel):
             return "  # type: ignore"
         return ""
 
-    def imports(self, async_mode: bool, is_python3_file: bool) -> FileImport:
+    def imports(self, async_mode: bool) -> FileImport:
         file_import = FileImport()
 
         relative_path = "..." if async_mode else ".."
         for operation in self.operations:
             file_import.merge(
-                operation.imports(
-                    async_mode, is_python3_file, relative_path=relative_path
-                )
+                operation.imports(async_mode, relative_path=relative_path)
             )
         # for multiapi
         if not self.code_model.options["version_tolerant"]:
@@ -89,6 +84,12 @@ class OperationGroup(BaseModel):
                 )
         if self.code_model.need_mixin_abc:
             file_import.add_submodule_import(".._vendor", "MixinABC", ImportType.LOCAL)
+        if self.has_abstract_operations:
+            file_import.add_submodule_import(
+                ".._vendor", "raise_if_not_implemented", ImportType.LOCAL
+            )
+        if all(o.abstract for o in self.operations):
+            return file_import
         file_import.add_submodule_import(
             "typing", "TypeVar", ImportType.STDLIB, TypingSection.CONDITIONAL
         )

package/autorest/codegen/models/paging_operation.py

@@ -38,7 +38,6 @@ class PagingOperationBase(OperationBase[PagingResponseType]):
         overloads: Optional[List[Operation]] = None,
         public: bool = True,
         want_tracing: bool = True,
-        abstract: bool = False,
         override_success_response_to_200: bool = False,
     ) -> None:
         super().__init__(
@@ -52,7 +51,6 @@ class PagingOperationBase(OperationBase[PagingResponseType]):
             overloads=overloads,
             public=public,
             want_tracing=want_tracing,
-            abstract=abstract,
         )
         self.next_request_builder: Optional[
             Union[RequestBuilder, OverloadedRequestBuilder]
@@ -127,11 +125,11 @@ class PagingOperationBase(OperationBase[PagingResponseType]):
     def has_optional_return_type(self) -> bool:
         return False
 
-    def imports(
-        self, async_mode: bool, is_python3_file: bool, **kwargs: Any
-    ) -> FileImport:
+    def imports(self, async_mode: bool, **kwargs: Any) -> FileImport:
+        if self.abstract:
+            return FileImport()
         file_import = self._imports_shared(async_mode, **kwargs)
-        file_import.merge(super().imports(async_mode, is_python3_file, **kwargs))
+        file_import.merge(super().imports(async_mode, **kwargs))
         if self.code_model.options["tracing"] and self.want_tracing:
             file_import.add_submodule_import(
                 "azure.core.tracing.decorator",
@@ -142,7 +140,21 @@ class PagingOperationBase(OperationBase[PagingResponseType]):
             file_import.merge(
                 self.get_request_builder_import(self.next_request_builder, async_mode)
             )
-
+        elif "api-version" in [
+            p.rest_api_name for p in self.code_model.client.parameters
+        ]:
+            file_import.add_submodule_import(
+                "urllib.parse", "urlparse", ImportType.STDLIB
+            )
+            file_import.add_submodule_import(
+                "urllib.parse", "urljoin", ImportType.STDLIB
+            )
+            file_import.add_submodule_import(
+                "urllib.parse", "parse_qs", ImportType.STDLIB
+            )
+            file_import.add_submodule_import(
+                "azure.core.utils", "case_insensitive_dict", ImportType.AZURECORE
+            )
         return file_import
 
 

package/autorest/codegen/models/parameter.py

@@ -179,15 +179,11 @@ class _ParameterBase(
     def in_method_signature(self) -> bool:
         ...
 
-    def method_signature(self, is_python3_file: bool, async_mode: bool) -> str:
+    def method_signature(self, async_mode: bool) -> str:
         type_annot = self.type_annotation(async_mode=async_mode)
-        if is_python3_file:
-            if self.client_default_value is not None or self.optional:
-                return f"{self.client_name}: {type_annot} = {self.client_default_value_declaration},"
-            return f"{self.client_name}: {type_annot},"
         if self.client_default_value is not None or self.optional:
-            return f"{self.client_name}={self.client_default_value_declaration},  # type: {type_annot}"
-        return f"{self.client_name},  # type: {type_annot}"
+            return f"{self.client_name}: {type_annot} = {self.client_default_value_declaration},"
+        return f"{self.client_name}: {type_annot},"
 
 
 class _BodyParameterBase(_ParameterBase):

package/autorest/codegen/models/parameter_list.py

@@ -235,49 +235,36 @@ class _ParameterListBase(
         """Sorted method params. First positional, then keyword only, then kwarg"""
         return self.positional + self.keyword_only + self.kwarg
 
-    def method_signature(self, is_python3_file: bool, async_mode: bool) -> List[str]:
+    def method_signature(self, async_mode: bool) -> List[str]:
         """Method signature for this parameter list."""
         return method_signature_helper(
-            positional=self.method_signature_positional(is_python3_file, async_mode),
-            keyword_only=self.method_signature_keyword_only(
-                is_python3_file, async_mode
-            ),
-            kwarg_params=self.method_signature_kwargs(is_python3_file),
+            positional=self.method_signature_positional(async_mode),
+            keyword_only=self.method_signature_keyword_only(async_mode),
+            kwarg_params=self.method_signature_kwargs,
         )
 
-    def method_signature_positional(
-        self, is_python3_file: bool, async_mode: bool
-    ) -> List[str]:
+    def method_signature_positional(self, async_mode: bool) -> List[str]:
         """Signature for positional parameters"""
-        return [
-            parameter.method_signature(is_python3_file, async_mode)
-            for parameter in self.positional
-        ]
+        return [parameter.method_signature(async_mode) for parameter in self.positional]
 
-    def method_signature_keyword_only(
-        self, is_python3_file: bool, async_mode: bool
-    ) -> List[str]:
+    def method_signature_keyword_only(self, async_mode: bool) -> List[str]:
         """Signature for keyword only parameters"""
-        if not (self.keyword_only and is_python3_file):
+        if not self.keyword_only:
             return []
         return ["*,"] + [
-            parameter.method_signature(is_python3_file, async_mode)
-            for parameter in self.keyword_only
+            parameter.method_signature(async_mode) for parameter in self.keyword_only
         ]
 
-    @staticmethod
-    def method_signature_kwargs(is_python3_file: bool) -> List[str]:
+    @property
+    def method_signature_kwargs(self) -> List[str]:
         """Signature for kwargs"""
-        return ["**kwargs: Any"] if is_python3_file else ["**kwargs  # type: Any"]
+        return ["**kwargs: Any"]
 
-    def kwargs_to_pop(
-        self, is_python3_file: bool
-    ) -> List[Union[ParameterType, BodyParameterType]]:
+    @property
+    def kwargs_to_pop(self) -> List[Union[ParameterType, BodyParameterType]]:
         """Method kwargs we want to pop"""
         # don't want to pop bodies unless it's a constant
         kwargs_to_pop = self.kwarg
-        if not is_python3_file:
-            kwargs_to_pop += self.keyword_only
         return [
             k
             for k in kwargs_to_pop
@@ -416,14 +403,12 @@ class RequestBuilderParameterList(_RequestBuilderParameterList):
 class OverloadedRequestBuilderParameterList(_RequestBuilderParameterList):
     """Parameter list for OverloadedRequestBuilder"""
 
-    def method_signature_keyword_only(
-        self, is_python3_file: bool, async_mode: bool
-    ) -> List[str]:
+    def method_signature_keyword_only(self, async_mode: bool) -> List[str]:
         """Signature for keyword only parameters"""
-        if not (self.keyword_only and is_python3_file):
+        if not self.keyword_only:
             return []
         return ["*,"] + [
-            parameter.method_signature(is_python3_file, async_mode)
+            parameter.method_signature(async_mode)
             for parameter in self.keyword_only
             if parameter.location != ParameterLocation.BODY
         ]
@@ -478,13 +463,12 @@ class ClientGlobalParameterList(_ClientGlobalParameterList[ClientParameter]):
         except StopIteration:
             return None
 
-    def kwargs_to_pop(
-        self, is_python3_file: bool
-    ) -> List[Union[ClientParameter, BodyParameter]]:
+    @property
+    def kwargs_to_pop(self) -> List[Union[ClientParameter, BodyParameter]]:
         """We only want to pass base url path parameters in the client"""
         return [
             k
-            for k in super().kwargs_to_pop(is_python3_file=is_python3_file)
+            for k in super().kwargs_to_pop
             if k.location == ParameterLocation.ENDPOINT_PATH
         ]
 

package/autorest/codegen/models/request_builder.py

@@ -3,7 +3,6 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
-import logging
 from typing import (
     Any,
     Callable,
@@ -21,13 +20,11 @@ from .parameter_list import (
     RequestBuilderParameterList,
     OverloadedRequestBuilderParameterList,
 )
-from .imports import FileImport, ImportType, TypingSection
-from .request_builder_parameter import RequestBuilderMultipartBodyParameter
+from .imports import FileImport, ImportType, TypingSection, MsrestImportType
 
 if TYPE_CHECKING:
     from .code_model import CodeModel
 
-_LOGGER = logging.getLogger(__name__)
 ParameterListType = TypeVar(
     "ParameterListType",
     bound=Union[RequestBuilderParameterList, OverloadedRequestBuilderParameterList],
@@ -43,7 +40,6 @@ class RequestBuilderBase(BaseBuilder[ParameterListType]):
         parameters: ParameterListType,
         *,
         overloads: Optional[List["RequestBuilder"]] = None,
-        abstract: bool = False,
     ) -> None:
         super().__init__(
             code_model=code_model,
@@ -51,7 +47,6 @@ class RequestBuilderBase(BaseBuilder[ParameterListType]):
             name=name,
             parameters=parameters,
             overloads=overloads,
-            abstract=abstract,
             want_tracing=False,
         )
         self.overloads: List["RequestBuilder"] = overloads or []
@@ -73,34 +68,45 @@ class RequestBuilderBase(BaseBuilder[ParameterListType]):
 
     def imports(self) -> FileImport:
         file_import = FileImport()
-        if not self.abstract:
-            for parameter in self.parameters.method:
-                file_import.merge(parameter.imports(async_mode=False))
+        if self.abstract:
+            return file_import
+        for parameter in self.parameters.method:
+            file_import.merge(parameter.imports(async_mode=False))
 
         file_import.add_submodule_import(
             "azure.core.rest",
             "HttpRequest",
             ImportType.AZURECORE,
         )
-        if not self.abstract:
-            if self.parameters.path:
-                relative_path = ".."
-                if (
-                    not self.code_model.options["builders_visibility"] == "embedded"
-                    and self.group_name
-                ):
-                    relative_path = "..." if self.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
-                )
+
+        if self.parameters.path:
+            relative_path = ".."
+            if (
+                not self.code_model.options["builders_visibility"] == "embedded"
+                and self.group_name
+            ):
+                relative_path = "..." if self.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)
+        file_import.add_msrest_import(
+            self.code_model,
+            "..."
+            if (
+                not self.code_model.options["builders_visibility"] == "embedded"
+                and self.group_name
+            )
+            else "..",
+            MsrestImportType.Serializer,
+            TypingSection.REGULAR,
+        )
         if (
             self.overloads
             and self.code_model.options["builders_visibility"] != "embedded"
@@ -136,23 +142,7 @@ class RequestBuilderBase(BaseBuilder[ParameterListType]):
             RequestBuilder.from_yaml(rb_yaml_data, code_model)
             for rb_yaml_data in yaml_data.get("overloads", [])
         ]
-        abstract = False
         parameter_list = cls.parameter_list_type()(yaml_data, code_model)
-        if (
-            code_model.options["version_tolerant"]
-            and parameter_list.has_body
-            and isinstance(
-                parameter_list.body_parameter, RequestBuilderMultipartBodyParameter
-            )
-        ):
-            _LOGGER.warning(
-                'Not going to generate operation "%s" because it has multipart / urlencoded body parameters. '
-                "Multipart / urlencoded body parameters are not supported for version tolerant generation 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
 
         return cls(
             yaml_data=yaml_data,
@@ -160,7 +150,6 @@ class RequestBuilderBase(BaseBuilder[ParameterListType]):
             name=name,
             parameters=parameter_list,
             overloads=overloads,
-            abstract=abstract,
         )