@autorest/python 5.13.0 → 5.16.0

package/autorest/codegen/models/operation_group.py

@@ -4,19 +4,23 @@
 # license information.
 # --------------------------------------------------------------------------
 import logging
-from typing import Dict, List, Any, Set
+from typing import Dict, List, Any, Set, TYPE_CHECKING
 
 from .base_model import BaseModel
 from .operation import Operation
 from .lro_operation import LROOperation
 from .paging_operation import PagingOperation
 from .lro_paging_operation import LROPagingOperation
-from .imports import FileImport, ImportType
+from .imports import FileImport, ImportType, TypingSection
+
+if TYPE_CHECKING:
+    from .code_model import CodeModel
 
 
 _LOGGER = logging.getLogger(__name__)
 
-def _get_operation(code_model, yaml_data: Dict[str, Any]) -> Operation:
+
+def _get_operation(yaml_data: Dict[str, Any], code_model: "CodeModel") -> Operation:
     lro_operation = yaml_data.get("extensions", {}).get("x-ms-long-running-operation")
     paging_operation = yaml_data.get("extensions", {}).get("x-ms-pageable")
     operation_schema = Operation
@@ -31,101 +35,132 @@ def _get_operation(code_model, yaml_data: Dict[str, Any]) -> Operation:
 
 
 class OperationGroup(BaseModel):
-    """Represent an operation group.
+    """Represent an operation group."""
 
-    """
     def __init__(
         self,
-        code_model,
         yaml_data: Dict[str, Any],
+        code_model: "CodeModel",
         name: str,
         class_name: str,
         operations: List[Operation],
-        api_versions: Set[str]
+        api_versions: Set[str],
     ) -> None:
-        super().__init__(yaml_data)
-        self.code_model = code_model
+        super().__init__(yaml_data, code_model)
         self.name = name
         self.class_name = class_name
         self.operations = operations
         self.api_versions = api_versions
 
+    @property
+    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:
+        base_classes: List[str] = []
+        if self.is_empty_operation_group 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:
         file_import = FileImport()
         for operation in self.operations:
             file_import.merge(operation.imports_for_multiapi(async_mode))
+        file_import.add_submodule_import(
+            ".." if async_mode else ".", "models", ImportType.LOCAL, alias="_models"
+        )
         return file_import
 
-    def imports(self, async_mode: bool) -> FileImport:
+    def imports(self, async_mode: bool, is_python3_file: bool) -> FileImport:
         file_import = FileImport()
-        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)
+
         for operation in self.operations:
-            file_import.merge(operation.imports(async_mode))
+            file_import.merge(operation.imports(async_mode, is_python3_file))
         local_path = "..." if async_mode else ".."
         if self.code_model.has_schemas and self.code_model.options["models_mode"]:
-            file_import.add_submodule_import(local_path, "models", ImportType.LOCAL, alias="_models")
+            file_import.add_submodule_import(
+                local_path, "models", ImportType.LOCAL, alias="_models"
+            )
         if self.code_model.options["builders_visibility"] == "embedded" and async_mode:
             if not self.code_model.options["combine_operation_files"]:
-                operation_group_name = "" if self.is_empty_operation_group else self.name
+                operation_group_name = (
+                    "" if self.is_empty_operation_group else self.name
+                )
                 operation_group_builders = [
-                    r for r in self.code_model.rest.request_builders
+                    r
+                    for r in self.code_model.request_builders
                     if r.operation_group_name == operation_group_name
                 ]
             else:
-                operation_group_builders = self.code_model.rest.request_builders
+                operation_group_builders = self.code_model.request_builders
             for request_builder in operation_group_builders:
+                if request_builder.abstract:
+                    continue
                 python3_only = self.code_model.options["python3_only"]
-                typed_sync_operation_file = self.code_model.options["add_python3_operation_files"]
-                suffix = "_py3" if typed_sync_operation_file and not python3_only else ""
+                typed_sync_operation_file = self.code_model.options[
+                    "add_python3_operation_files"
+                ]
+                suffix = (
+                    "_py3" if typed_sync_operation_file and not python3_only else ""
+                )
                 file_import.add_submodule_import(
                     f"...{self.code_model.operations_folder_name}.{self.filename}{suffix}",
                     request_builder.name,
-                    import_type=ImportType.LOCAL
+                    import_type=ImportType.LOCAL,
                 )
+        if self.code_model.need_mixin_abc:
+            file_import.add_submodule_import(".._vendor", "MixinABC", ImportType.LOCAL)
+        file_import.add_submodule_import(
+            "typing", "TypeVar", ImportType.STDLIB, TypingSection.CONDITIONAL
+        )
+        file_import.define_mypy_type("T", "TypeVar('T')")
         type_value = "Optional[Callable[[PipelineResponse[HttpRequest, {}HttpResponse], T, Dict[str, Any]], Any]]"
         file_import.define_mypy_type(
-            "ClsType",
-            type_value.format(""),
-            type_value.format("Async")
+            "ClsType", type_value.format(""), type_value.format("Async")
         )
         return file_import
 
-
     @property
     def filename(self) -> str:
         basename = self.name
         if self.is_empty_operation_group:
             basename = self.code_model.module_name
 
-        if basename == "operations" or self.code_model.options["combine_operation_files"]:
+        if (
+            basename == "operations"
+            or self.code_model.options["combine_operation_files"]
+        ):
             return f"_operations"
         return f"_{basename}_operations"
 
     @property
     def is_empty_operation_group(self) -> bool:
-        """The operation group with no name is the direct client methods.
-        """
+        """The operation group with no name is the direct client methods."""
         return not self.yaml_data["language"]["default"]["name"]
 
     @classmethod
-    def from_yaml(cls, code_model, yaml_data: Dict[str, Any]) -> "OperationGroup":
+    def from_yaml(
+        cls, yaml_data: Dict[str, Any], code_model: "CodeModel"
+    ) -> "OperationGroup":
         name = yaml_data["language"]["python"]["name"]
         _LOGGER.debug("Parsing %s operation group", name)
 
         operations = []
         api_versions: Set[str] = set()
         for operation_yaml in yaml_data["operations"]:
-            operation = _get_operation(code_model, operation_yaml)
+            operation = _get_operation(operation_yaml, code_model)
             operations.append(operation)
             api_versions.update(operation.api_versions)
 
         return cls(
-            code_model=code_model,
             yaml_data=yaml_data,
+            code_model=code_model,
             name=name,
             class_name=yaml_data["language"]["python"]["className"],
             operations=operations,
-            api_versions=api_versions
+            api_versions=api_versions,
         )

package/autorest/codegen/models/paging_operation.py

@@ -4,7 +4,7 @@
 # license information.
 # --------------------------------------------------------------------------
 import logging
-from typing import cast, Dict, List, Any, Optional, Set
+from typing import cast, Dict, List, Any, Optional, Set, TYPE_CHECKING
 
 from .operation import Operation
 from .schema_response import SchemaResponse
@@ -14,14 +14,18 @@ from .object_schema import ObjectSchema
 from .schema_request import SchemaRequest
 from .parameter_list import ParameterList
 
+if TYPE_CHECKING:
+    from .code_model import CodeModel
+
 _LOGGER = logging.getLogger(__name__)
 
 
 class PagingOperation(Operation):
     def __init__(
         self,
-        code_model,
         yaml_data: Dict[str, Any],
+        code_model: "CodeModel",
+        request_builder: RequestBuilder,
         name: str,
         description: str,
         api_versions: Set[str],
@@ -34,11 +38,13 @@ class PagingOperation(Operation):
         want_description_docstring: bool = True,
         want_tracing: bool = True,
         *,
-        override_success_response_to_200: bool = False
+        abstract: bool = False,
+        override_success_response_to_200: bool = False,
     ) -> None:
-        super(PagingOperation, self).__init__(
-            code_model,
+        super().__init__(
             yaml_data,
+            code_model,
+            request_builder,
             name,
             description,
             api_versions,
@@ -49,11 +55,16 @@ class PagingOperation(Operation):
             responses,
             exceptions,
             want_description_docstring,
-            want_tracing
+            want_tracing=want_tracing,
+            abstract=abstract,
         )
         self._item_name: str = yaml_data["extensions"]["x-ms-pageable"].get("itemName")
-        self._next_link_name: str = yaml_data["extensions"]["x-ms-pageable"].get("nextLinkName")
-        self.operation_name: str = yaml_data["extensions"]["x-ms-pageable"].get("operationName")
+        self._next_link_name: str = yaml_data["extensions"]["x-ms-pageable"].get(
+            "nextLinkName"
+        )
+        self.operation_name: str = yaml_data["extensions"]["x-ms-pageable"].get(
+            "operationName"
+        )
         self.next_operation: Optional[Operation] = None
         self.override_success_response_to_200 = override_success_response_to_200
 
@@ -61,12 +72,13 @@ class PagingOperation(Operation):
         response = self.responses[0]
         if not isinstance(response.schema, ObjectSchema):
             raise ValueError(
-                "The response of a paging operation must be of type " + f"ObjectSchema but {response.schema} is not"
+                "The response of a paging operation must be of type "
+                + f"ObjectSchema but {response.schema} is not"
             )
         return response
 
     def _find_python_name(self, rest_api_name: str, log_name: str) -> str:
-        response = self._get_response()
+        response = self.responses[0]
         response_schema = cast(ObjectSchema, response.schema)
         if response_schema:
             for prop in response_schema.properties:
@@ -84,7 +96,8 @@ class PagingOperation(Operation):
         item_name = self._item_name or "value"
         try:
             return (
-                self._find_python_name(item_name, "itemName") if code_model.options["models_mode"]
+                self._find_python_name(item_name, "itemName")
+                if code_model.options["models_mode"]
                 else item_name
             )
         except ValueError:
@@ -125,12 +138,16 @@ class PagingOperation(Operation):
     def _imports_shared(self, async_mode: bool) -> FileImport:
         file_import = super()._imports_shared(async_mode)
         if async_mode:
-            file_import.add_submodule_import("typing", "AsyncIterable", ImportType.STDLIB, TypingSection.CONDITIONAL)
+            file_import.add_submodule_import(
+                "typing", "AsyncIterable", ImportType.STDLIB, TypingSection.CONDITIONAL
+            )
         else:
-            file_import.add_submodule_import("typing", "Iterable", ImportType.STDLIB, TypingSection.CONDITIONAL)
+            file_import.add_submodule_import(
+                "typing", "Iterable", ImportType.STDLIB, TypingSection.CONDITIONAL
+            )
         if (
-            self.next_request_builder and
-            self.code_model.options["builders_visibility"] == "embedded"
+            self.next_request_builder
+            and self.code_model.options["builders_visibility"] == "embedded"
             and not async_mode
         ):
             file_import.merge(self.next_request_builder.imports())
@@ -141,14 +158,20 @@ class PagingOperation(Operation):
         pager_import_path = ".".join(self.get_pager_path(async_mode).split(".")[:-1])
         pager = self.get_pager(async_mode)
 
-        file_import.add_submodule_import(pager_import_path, pager, ImportType.AZURECORE, TypingSection.CONDITIONAL)
+        file_import.add_submodule_import(
+            pager_import_path, pager, ImportType.AZURECORE, TypingSection.CONDITIONAL
+        )
 
         return file_import
 
-    def imports(self, async_mode: bool) -> FileImport:
-        file_import = super(PagingOperation, self).imports(async_mode)
+    def imports(self, async_mode: bool, is_python3_file: bool) -> FileImport:
+        file_import = self._imports_base(async_mode, is_python3_file)
         # operation adds an import for distributed_trace_async, we don't want it
-        file_import.imports = [i for i in file_import.imports if not i.submodule_name == "distributed_trace_async"]
+        file_import.imports = [
+            i
+            for i in file_import.imports
+            if not i.submodule_name == "distributed_trace_async"
+        ]
 
         pager_import_path = ".".join(self.get_pager_path(async_mode).split(".")[:-1])
         pager = self.get_pager(async_mode)
@@ -156,11 +179,15 @@ class PagingOperation(Operation):
         file_import.add_submodule_import(pager_import_path, pager, ImportType.AZURECORE)
 
         if async_mode:
-            file_import.add_submodule_import("azure.core.async_paging", "AsyncList", ImportType.AZURECORE)
+            file_import.add_submodule_import(
+                "azure.core.async_paging", "AsyncList", ImportType.AZURECORE
+            )
 
         if self.code_model.options["tracing"] and self.want_tracing:
             file_import.add_submodule_import(
-                "azure.core.tracing.decorator", "distributed_trace", ImportType.AZURECORE,
+                "azure.core.tracing.decorator",
+                "distributed_trace",
+                ImportType.AZURECORE,
             )
 
         return file_import