@autorest/python 5.15.0 → 5.18.0

package/autorest/codegen/models/operation_group.py

@@ -3,134 +3,123 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
-import logging
-from typing import Dict, List, Any, Set
-
-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 typing import Dict, List, Any, TYPE_CHECKING
 
+from autorest.codegen.models.utils import OrderedSet
 
-_LOGGER = logging.getLogger(__name__)
+from .base_model import BaseModel
+from .operation import OperationBase, get_operation
+from .imports import FileImport, ImportType, TypingSection
+from .utils import add_to_pylint_disable
 
-def _get_operation(code_model, yaml_data: Dict[str, Any]) -> 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
-    if lro_operation and paging_operation:
-        operation_schema = LROPagingOperation
-    elif lro_operation:
-        operation_schema = LROOperation
-    elif paging_operation:
-        operation_schema = PagingOperation
-    operation = operation_schema.from_yaml(yaml_data, code_model=code_model)
-    return operation
+if TYPE_CHECKING:
+    from .code_model import CodeModel
 
 
 class OperationGroup(BaseModel):
-    """Represent an operation group.
+    """Represent an operation group."""
 
-    """
     def __init__(
         self,
-        code_model,
         yaml_data: Dict[str, Any],
-        name: str,
-        class_name: str,
-        operations: List[Operation],
-        api_versions: Set[str]
+        code_model: "CodeModel",
+        operations: List[OperationBase],
+        api_versions: List[str],
     ) -> None:
-        super().__init__(yaml_data)
-        self.code_model = code_model
-        self.name = name
-        self.class_name = class_name
+        super().__init__(yaml_data, code_model)
+        self.class_name: str = yaml_data["className"]
+        self.property_name: str = yaml_data["propertyName"]
         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_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:
         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")
+            file_import.merge(
+                operation.imports_for_multiapi(
+                    async_mode, relative_path=".." if async_mode else "."
+                )
+            )
         return file_import
 
+    @property
+    def pylint_disable(self) -> str:
+        retval: str = ""
+        if self.has_abstract_operations:
+            retval = add_to_pylint_disable(retval, "abstract-class-instantiated")
+        return retval
+
+    @property
+    def mypy_ignore(self) -> str:
+        if self.has_abstract_operations:
+            return "  # type: ignore"
+        return ""
+
     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)
+
+        relative_path = "..." if async_mode else ".."
         for operation in self.operations:
-            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")
-        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_builders = [
-                    r for r in self.code_model.rest.request_builders
-                    if r.operation_group_name == operation_group_name
-                ]
-            else:
-                operation_group_builders = self.code_model.rest.request_builders
-            for request_builder in operation_group_builders:
-                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 ""
+            file_import.merge(
+                operation.imports(
+                    async_mode, is_python3_file, relative_path=relative_path
+                )
+            )
+        # for multiapi
+        if not self.code_model.options["version_tolerant"]:
+            if (
+                self.code_model.model_types or self.code_model.enums
+            ) and self.code_model.options["models_mode"]:
                 file_import.add_submodule_import(
-                    f"...{self.code_model.operations_folder_name}.{self.filename}{suffix}",
-                    request_builder.name,
-                    import_type=ImportType.LOCAL
+                    relative_path, "models", ImportType.LOCAL, alias="_models"
                 )
         if self.code_model.need_mixin_abc:
-            file_import.add_submodule_import(
-                ".._vendor", "MixinABC", ImportType.LOCAL
-            )
+            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"]:
-            return f"_operations"
-        return f"_{basename}_operations"
+        return self.operations[0].filename
 
     @property
-    def is_empty_operation_group(self) -> bool:
-        """The operation group with no name is the direct client methods.
-        """
-        return not self.yaml_data["language"]["default"]["name"]
+    def is_mixin(self) -> bool:
+        """The operation group with no name is the direct client methods."""
+        return self.property_name == ""
 
     @classmethod
-    def from_yaml(cls, code_model, yaml_data: Dict[str, Any]) -> "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)
-            operations.append(operation)
-            api_versions.update(operation.api_versions)
-
+    def from_yaml(
+        cls, yaml_data: Dict[str, Any], code_model: "CodeModel"
+    ) -> "OperationGroup":
+        operations = [get_operation(o, code_model) for o in yaml_data["operations"]]
+        api_versions: OrderedSet[str] = {}
+        for operation in operations:
+            for api_version in operation.api_versions:
+                api_versions[api_version] = None
         return cls(
-            code_model=code_model,
             yaml_data=yaml_data,
-            name=name,
-            class_name=yaml_data["language"]["python"]["className"],
+            code_model=code_model,
             operations=operations,
-            api_versions=api_versions
+            api_versions=list(api_versions.keys()),
         )

package/autorest/codegen/models/paging_operation.py

@@ -3,164 +3,148 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
-import logging
-from typing import cast, Dict, List, Any, Optional, Set
-
-from .operation import Operation
-from .schema_response import SchemaResponse
-from .request_builder import RequestBuilder
+from typing import Dict, List, Any, Optional, Union, TYPE_CHECKING, cast, TypeVar
+
+from .operation import Operation, OperationBase
+from .response import PagingResponse, LROPagingResponse, Response
+from .request_builder import (
+    OverloadedRequestBuilder,
+    RequestBuilder,
+    get_request_builder,
+)
 from .imports import ImportType, FileImport, TypingSection
-from .object_schema import ObjectSchema
-from .schema_request import SchemaRequest
 from .parameter_list import ParameterList
+from .model_type import ModelType
+
+if TYPE_CHECKING:
+    from .code_model import CodeModel
 
-_LOGGER = logging.getLogger(__name__)
+PagingResponseType = TypeVar(
+    "PagingResponseType", bound=Union[PagingResponse, LROPagingResponse]
+)
 
 
-class PagingOperation(Operation):
+class PagingOperationBase(OperationBase[PagingResponseType]):
     def __init__(
         self,
-        code_model,
         yaml_data: Dict[str, Any],
+        code_model: "CodeModel",
         name: str,
-        description: str,
-        api_versions: Set[str],
+        request_builder: RequestBuilder,
         parameters: ParameterList,
-        multiple_content_type_parameters: ParameterList,
-        schema_requests: List[SchemaRequest],
-        summary: Optional[str] = None,
-        responses: Optional[List[SchemaResponse]] = None,
-        exceptions: Optional[List[SchemaResponse]] = None,
-        want_description_docstring: bool = True,
-        want_tracing: bool = True,
+        responses: List[PagingResponseType],
+        exceptions: List[Response],
         *,
-        override_success_response_to_200: bool = False
+        overloads: Optional[List[Operation]] = None,
+        public: bool = True,
+        want_tracing: bool = True,
+        abstract: bool = False,
+        override_success_response_to_200: bool = False,
     ) -> None:
-        super(PagingOperation, self).__init__(
-            code_model,
-            yaml_data,
-            name,
-            description,
-            api_versions,
-            parameters,
-            multiple_content_type_parameters,
-            schema_requests,
-            summary,
-            responses,
-            exceptions,
-            want_description_docstring,
-            want_tracing
+        super().__init__(
+            code_model=code_model,
+            yaml_data=yaml_data,
+            name=name,
+            request_builder=request_builder,
+            parameters=parameters,
+            responses=responses,
+            exceptions=exceptions,
+            overloads=overloads,
+            public=public,
+            want_tracing=want_tracing,
+            abstract=abstract,
+        )
+        self.next_request_builder: Optional[
+            Union[RequestBuilder, OverloadedRequestBuilder]
+        ] = (
+            get_request_builder(self.yaml_data["nextOperation"], code_model)
+            if self.yaml_data.get("nextOperation")
+            else None
         )
-        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_operation: Optional[Operation] = None
         self.override_success_response_to_200 = override_success_response_to_200
+        self.pager_sync: str = yaml_data["pagerSync"]
+        self.pager_async: str = yaml_data["pagerAsync"]
 
-    def _get_response(self) -> SchemaResponse:
+    def _get_attr_name(self, rest_api_name: str) -> str:
         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"
-            )
-        return response
-
-    def _find_python_name(self, rest_api_name: str, log_name: str) -> str:
-        response = self.responses[0]
-        response_schema = cast(ObjectSchema, response.schema)
-        if response_schema:
-            for prop in response_schema.properties:
-                if prop.original_swagger_name == rest_api_name:
-                    return prop.name
-        raise ValueError(
-            f"While scanning x-ms-pageable, was unable to find "
-            + f"{log_name}:{rest_api_name} in model {response_schema.name}"
-        )
-
-    def _get_paging_extension(self, extension_name):
-        return self.yaml_data["extensions"][extension_name]
-
-    def item_name(self, code_model) -> str:
-        item_name = self._item_name or "value"
         try:
-            return (
-                self._find_python_name(item_name, "itemName") if code_model.options["models_mode"]
-                else item_name
+            return next(
+                p.client_name
+                for p in cast(ModelType, response.type).properties
+                if p.rest_api_name == rest_api_name
             )
-        except ValueError:
-            response = self._get_response()
+        except StopIteration:
             raise ValueError(
-                f"While scanning x-ms-pageable, itemName was not defined and object"
-                + f" {cast(ObjectSchema, response.schema).name} has no array called 'value'"
+                f"Can't find a matching property in response for {rest_api_name}"
             )
 
+    def get_pager(self, async_mode: bool) -> str:
+        return self.responses[0].get_pager(async_mode)
+
     @property
-    def next_link_name(self) -> Optional[str]:
-        if not self._next_link_name:
+    def continuation_token_name(self) -> Optional[str]:
+        rest_api_name = self.yaml_data["continuationTokenName"]
+        if not rest_api_name:
             # That's an ok scenario, it just means no next page possible
             return None
         if self.code_model.options["models_mode"]:
-            return self._find_python_name(self._next_link_name, "nextLinkName")
-        return self._next_link_name
+            return self._get_attr_name(rest_api_name)
+        return rest_api_name
 
     @property
-    def has_optional_return_type(self) -> bool:
-        """A paging will never have an optional return type, we will always return a pager"""
-        return False
-
-    def get_pager_path(self, async_mode: bool) -> str:
-        extension_name = "pager-async" if async_mode else "pager-sync"
-        return self._get_paging_extension(extension_name)
-
-    def get_pager(self, async_mode: bool) -> str:
-        return self.get_pager_path(async_mode).split(".")[-1]
+    def item_name(self) -> str:
+        rest_api_name = self.yaml_data["itemName"]
+        if self.code_model.options["models_mode"]:
+            return self._get_attr_name(rest_api_name)
+        return rest_api_name
 
     @property
-    def next_request_builder(self) -> Optional[RequestBuilder]:
-        if not self.next_operation:
-            return None
-        next_request_builder = self.next_operation.request_builder
-        return next_request_builder
+    def operation_type(self) -> str:
+        return "paging"
+
+    def cls_type_annotation(self, *, async_mode: bool) -> str:
+        return f"ClsType[{Response.type_annotation(self.responses[0], async_mode=async_mode)}]"
 
-    def _imports_shared(self, async_mode: bool) -> FileImport:
-        file_import = super()._imports_shared(async_mode)
+    def _imports_shared(self, async_mode: bool, **kwargs: Any) -> FileImport:
+        file_import = super()._imports_shared(async_mode, **kwargs)
         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())
         return file_import
 
-    def imports_for_multiapi(self, async_mode: bool) -> FileImport:
-        file_import = super().imports_for_multiapi(async_mode)
-        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)
-
-        return file_import
-
-    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"]
-
-        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)
-
-        if async_mode:
-            file_import.add_submodule_import("azure.core.async_paging", "AsyncList", ImportType.AZURECORE)
+    @property
+    def has_optional_return_type(self) -> bool:
+        return False
 
+    def imports(
+        self, async_mode: bool, is_python3_file: bool, **kwargs: Any
+    ) -> FileImport:
+        file_import = self._imports_shared(async_mode, **kwargs)
+        file_import.merge(super().imports(async_mode, is_python3_file, **kwargs))
         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,
+            )
+        if self.next_request_builder:
+            file_import.merge(
+                self.get_request_builder_import(self.next_request_builder, async_mode)
             )
 
         return file_import
+
+
+class PagingOperation(PagingOperationBase[PagingResponse]):
+    ...