@autorest/python 5.15.0 → 5.18.0

package/autorest/codegen/models/imports.py

@@ -4,7 +4,8 @@
 # license information.
 # --------------------------------------------------------------------------
 from enum import Enum
-from typing import Dict, List, Optional, Tuple, Union, Set
+from typing import Dict, List, Optional, Tuple, Union, Set, Mapping
+
 
 class ImportType(str, Enum):
     STDLIB = "stdlib"
@@ -12,11 +13,13 @@ class ImportType(str, Enum):
     AZURECORE = "azurecore"
     LOCAL = "local"
 
+
 class TypingSection(str, Enum):
     REGULAR = "regular"  # this import is always a typing import
     CONDITIONAL = "conditional"  # is a typing import when we're dealing with files that py2 will use, else regular
     TYPING = "typing"  # never a typing import
 
+
 class ImportModel:
     def __init__(
         self,
@@ -36,11 +39,11 @@ class ImportModel:
     def __eq__(self, other):
         try:
             return (
-                self.typing_section == other.typing_section and
-                self.import_type == other.import_type and
-                self.module_name == other.module_name and
-                self.submodule_name == other.submodule_name and
-                self.alias == other.alias
+                self.typing_section == other.typing_section
+                and self.import_type == other.import_type
+                and self.module_name == other.module_name
+                and self.submodule_name == other.submodule_name
+                and self.alias == other.alias
             )
         except AttributeError:
             return False
@@ -52,18 +55,32 @@ class ImportModel:
                 retval += hash(getattr(self, attr))
         return retval
 
-class FileImport:
+
+class TypeDefinition:
     def __init__(
         self,
-        imports: List[ImportModel] = None
-    ) -> None:
+        sync_definition: str,
+        async_definition: str,
+        version_imports: Mapping[Optional[Tuple[int, int]], ImportModel] = None,
+    ):
+        # version_imports: a map of "python version -> ImportModel".
+        #                  The python version is in form of (major, minor), for instance (3, 9) stands for py3.9.
+        #                  If the python version is None, it's a default ImportModel.
+        self.sync_definition = sync_definition
+        self.async_definition = async_definition
+        self.version_imports = version_imports
+
+
+class FileImport:
+    def __init__(self, imports: List[ImportModel] = None) -> None:
         self.imports = imports or []
         # has sync and async type definitions
-        self.type_definitions: Dict[str, Tuple[str, str]] = {}
+        self.type_definitions: Dict[str, TypeDefinition] = {}
 
     def _append_import(self, import_model: ImportModel) -> None:
         if not any(
-            i for i in self.imports
+            i
+            for i in self.imports
             if all(
                 getattr(i, attr) == getattr(import_model, attr)
                 for attr in dir(i)
@@ -72,7 +89,9 @@ class FileImport:
         ):
             self.imports.append(import_model)
 
-    def get_imports_from_section(self, typing_section: TypingSection) -> List[ImportModel]:
+    def get_imports_from_section(
+        self, typing_section: TypingSection
+    ) -> List[ImportModel]:
         return [i for i in self.imports if i.typing_section == typing_section]
 
     def add_submodule_import(
@@ -83,15 +102,16 @@ class FileImport:
         typing_section: TypingSection = TypingSection.REGULAR,
         alias: Optional[str] = None,
     ) -> None:
-        """Add an import to this import block.
-        """
-        self._append_import(ImportModel(
-            typing_section=typing_section,
-            import_type=import_type,
-            module_name=module_name,
-            submodule_name=submodule_name,
-            alias=alias,
-        ))
+        """Add an import to this import block."""
+        self._append_import(
+            ImportModel(
+                typing_section=typing_section,
+                import_type=import_type,
+                module_name=module_name,
+                submodule_name=submodule_name,
+                alias=alias,
+            )
+        )
 
     def add_import(
         self,
@@ -101,16 +121,25 @@ class FileImport:
         alias: Optional[str] = None,
     ) -> None:
         # Implementation detail: a regular import is just a "from" with no from
-        self._append_import(ImportModel(
-            typing_section=typing_section,
-            import_type=import_type,
-            module_name=module_name,
-            alias=alias,
-        ))
+        self._append_import(
+            ImportModel(
+                typing_section=typing_section,
+                import_type=import_type,
+                module_name=module_name,
+                alias=alias,
+            )
+        )
 
-    def define_mypy_type(self, type_name: str, type_value: str, async_type_value: Optional[str] = None):
-        self.add_submodule_import("typing", "TypeVar", ImportType.STDLIB, TypingSection.CONDITIONAL)
-        self.type_definitions[type_name] = (type_value, async_type_value or type_value)
+    def define_mypy_type(
+        self,
+        type_name: str,
+        type_value: str,
+        async_type_value: Optional[str] = None,
+        version_imports: Mapping[Optional[Tuple[int, int]], ImportModel] = None,
+    ):
+        self.type_definitions[type_name] = TypeDefinition(
+            type_value, async_type_value or type_value, version_imports
+        )
 
     def merge(self, file_import: "FileImport") -> None:
         """Merge the given file import format."""
@@ -118,23 +147,46 @@ class FileImport:
             self._append_import(i)
         self.type_definitions.update(file_import.type_definitions)
 
-    def to_dict(self) -> Dict[
+    def define_mutable_mapping_type(self) -> None:
+        """Helper function for defining the mutable mapping type"""
+        self.define_mypy_type(
+            "JSON",
+            "MutableMapping[str, Any] # pylint: disable=unsubscriptable-object",
+            None,
+            {
+                (3, 9): ImportModel(
+                    TypingSection.CONDITIONAL,
+                    ImportType.STDLIB,
+                    "collections.abc",
+                    submodule_name="MutableMapping",
+                ),
+                None: ImportModel(
+                    TypingSection.CONDITIONAL,
+                    ImportType.STDLIB,
+                    "typing",
+                    submodule_name="MutableMapping",
+                ),
+            },
+        )
+        self.add_submodule_import("typing", "Any", ImportType.STDLIB)
+
+    def to_dict(
+        self,
+    ) -> Dict[
         TypingSection,
-        Dict[ImportType, Dict[str, Set[Optional[Union[str, Tuple[str, str]]]]]]
+        Dict[ImportType, Dict[str, Set[Optional[Union[str, Tuple[str, str]]]]]],
     ]:
         retval: Dict[
             TypingSection,
-            Dict[ImportType, Dict[str, Set[Optional[Union[str, Tuple[str, str]]]]]]
+            Dict[ImportType, Dict[str, Set[Optional[Union[str, Tuple[str, str]]]]]],
         ] = dict()
         for i in self.imports:
             name_import: Optional[Union[str, Tuple[str, str]]] = None
             if i.submodule_name:
-                name_import = (i.submodule_name, i.alias) if i.alias else i.submodule_name
-            retval.setdefault(
-                    i.typing_section, dict()
-                ).setdefault(
-                    i.import_type, dict()
-                ).setdefault(
-                    i.module_name, set()
-                ).add(name_import)
+                name_import = (
+                    (i.submodule_name, i.alias) if i.alias else i.submodule_name
+                )
+            retval.setdefault(i.typing_section, dict()).setdefault(
+                i.import_type, dict()
+            ).setdefault(i.module_name, set()).add(name_import)
         return retval

package/autorest/codegen/models/list_type.py

@@ -0,0 +1,149 @@
+# -------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for
+# license information.
+# --------------------------------------------------------------------------
+from typing import Any, Dict, Optional, Union, TYPE_CHECKING, List
+from .base_type import BaseType
+from .imports import FileImport, ImportType, TypingSection
+
+if TYPE_CHECKING:
+    from .code_model import CodeModel
+    from .model_type import ModelType
+
+
+class ListType(BaseType):
+    def __init__(
+        self,
+        yaml_data: Dict[str, Any],
+        code_model: "CodeModel",
+        element_type: BaseType,
+    ) -> None:
+        super().__init__(yaml_data=yaml_data, code_model=code_model)
+        self.element_type = element_type
+        self.max_items: Optional[int] = yaml_data.get("maxItems")
+        self.min_items: Optional[int] = yaml_data.get("minItems")
+        self.unique_items: bool = yaml_data.get("uniqueItems", False)
+
+    @property
+    def serialization_type(self) -> str:
+        return f"[{self.element_type.serialization_type}]"
+
+    def type_annotation(self, **kwargs: Any) -> str:
+        if self.code_model.options["version_tolerant"] and self.element_type.is_xml:
+            # this means we're version tolerant XML, we just return the XML element
+            return self.element_type.type_annotation(**kwargs)
+        return f"List[{self.element_type.type_annotation(**kwargs)}]"
+
+    def description(self, *, is_operation_file: bool) -> str:
+        return "" if is_operation_file else self.yaml_data.get("description", "")
+
+    @property
+    def xml_serialization_ctxt(self) -> Optional[str]:
+        attrs_list = []
+        base_xml_map = super().xml_serialization_ctxt
+        if base_xml_map:
+            attrs_list.append(base_xml_map)
+
+        # Attribute at the list level
+        if self.xml_metadata.get("wrapped", False):
+            attrs_list.append("'wrapped': True")
+
+        # Attributes of the items
+        item_xml_metadata = self.element_type.xml_metadata
+        if item_xml_metadata.get("name"):
+            attrs_list.append(f"'itemsName': '{item_xml_metadata['name']}'")
+        if item_xml_metadata.get("prefix", False):
+            attrs_list.append(f"'itemsPrefix': '{item_xml_metadata['prefix']}'")
+        if item_xml_metadata.get("namespace", False):
+            attrs_list.append(f"'itemsNs': '{item_xml_metadata['namespace']}'")
+
+        return ", ".join(attrs_list)
+
+    def docstring_type(self, **kwargs: Any) -> str:
+        if (
+            self.code_model.options["version_tolerant"]
+            and self.element_type.xml_metadata
+        ):
+            # this means we're version tolerant XML, we just return the XML element
+            return self.element_type.docstring_type(**kwargs)
+        return f"list[{self.element_type.docstring_type(**kwargs)}]"
+
+    def docstring_text(self, **kwargs: Any) -> str:
+        if (
+            self.code_model.options["version_tolerant"]
+            and self.element_type.xml_metadata
+        ):
+            # this means we're version tolerant XML, we just return the XML element
+            return self.element_type.docstring_text(**kwargs)
+        return f"list of {self.element_type.docstring_text(**kwargs)}"
+
+    @property
+    def validation(self) -> Optional[Dict[str, Union[bool, int, str]]]:
+        validation: Dict[str, Union[bool, int, str]] = {}
+        if self.max_items:
+            validation["max_items"] = self.max_items
+            validation["min_items"] = self.min_items or 0
+        if self.min_items:
+            validation["min_items"] = self.min_items
+        if self.unique_items:
+            validation["unique"] = True
+        return validation or None
+
+    def get_json_template_representation(
+        self,
+        *,
+        optional: bool = True,
+        client_default_value_declaration: Optional[str] = None,
+        description: Optional[str] = None,
+    ) -> Any:
+        return [
+            self.element_type.get_json_template_representation(
+                optional=optional,
+                client_default_value_declaration=client_default_value_declaration,
+                description=description,
+            )
+        ]
+
+    def get_polymorphic_subtypes(self, polymorphic_subtypes: List["ModelType"]) -> None:
+        from .model_type import ModelType
+
+        if isinstance(self.element_type, ModelType):
+            is_polymorphic_subtype = (
+                self.element_type.discriminator_value
+                and not self.element_type.discriminated_subtypes
+            )
+            if (
+                self.element_type.name not in (m.name for m in polymorphic_subtypes)
+                and is_polymorphic_subtype
+            ):
+                polymorphic_subtypes.append(self.element_type)
+
+    @property
+    def instance_check_template(self) -> str:
+        return "isinstance({}, list)"
+
+    @classmethod
+    def from_yaml(
+        cls, yaml_data: Dict[str, Any], code_model: "CodeModel"
+    ) -> "ListType":
+        from . import build_type
+
+        return cls(
+            yaml_data=yaml_data,
+            code_model=code_model,
+            element_type=build_type(
+                yaml_data=yaml_data["elementType"], code_model=code_model
+            ),
+        )
+
+    def imports(self, **kwargs: Any) -> FileImport:
+        file_import = FileImport()
+        if not (
+            self.code_model.options["version_tolerant"] and self.element_type.is_xml
+        ):
+            file_import.add_submodule_import(
+                "typing", "List", ImportType.STDLIB, TypingSection.CONDITIONAL
+            )
+        file_import.merge(self.element_type.imports(**kwargs))
+        return file_import

package/autorest/codegen/models/lro_operation.py

@@ -3,182 +3,139 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
-import logging
-from typing import Dict, List, Any, Optional, Set, cast
+from typing import Any, Dict, Optional, List, TYPE_CHECKING, TypeVar, Union
 from .imports import FileImport
-from .operation import Operation
-from .parameter_list import ParameterList
-from .schema_response import SchemaResponse
+from .operation import OperationBase, Operation
+from .response import LROPagingResponse, LROResponse, Response
 from .imports import ImportType, TypingSection
-from .base_schema import BaseSchema
-from .schema_request import SchemaRequest
+from .request_builder import RequestBuilder
+from .parameter_list import ParameterList
+
+if TYPE_CHECKING:
+    from .code_model import CodeModel
 
-_LOGGER = logging.getLogger(__name__)
+LROResponseType = TypeVar(
+    "LROResponseType", bound=Union[LROResponse, LROPagingResponse]
+)
 
 
-class LROOperation(Operation):
+class LROOperationBase(OperationBase[LROResponseType]):
     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[LROResponseType],
+        exceptions: List[Response],
+        *,
+        overloads: Optional[List[Operation]] = None,
+        public: bool = True,
+        want_tracing: bool = True,
+        abstract: bool = False,
     ) -> None:
-        super(LROOperation, 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.lro_options = yaml_data.get("extensions", {}).get("x-ms-long-running-operation-options", {})
         self.name = "begin_" + self.name
+        self.lro_options: Dict[str, Any] = self.yaml_data.get("lroOptions", {})
+
+    @property
+    def operation_type(self) -> str:
+        return "lro"
 
     @property
-    def lro_response(self) -> Optional[SchemaResponse]:
-        if not self.responses:
-            return None
-        responses_with_bodies = [r for r in self.responses if r.has_body]
-        num_response_schemas = {r.schema for r in responses_with_bodies}
+    def has_optional_return_type(self) -> bool:
+        return False
+
+    @property
+    def lro_response(self) -> Optional[LROResponseType]:
+        responses_with_bodies = [r for r in self.responses if r.type]
+        num_response_schemas = {
+            id(r.type.yaml_data) for r in responses_with_bodies if r.type
+        }
         response = None
         if len(num_response_schemas) > 1:
             # choose the response that has a status code of 200
-            responses_with_200_status_codes = [
-                r for r in responses_with_bodies if 200 in r.status_codes
-            ]
             try:
-                response = responses_with_200_status_codes[0]
-                schema_types = {r.schema for r in responses_with_bodies}
-                response_schema = cast(BaseSchema, response.schema).serialization_type
-                _LOGGER.warning(
-                    "Multiple schema types in responses: %s. Choosing: %s", schema_types, response_schema
+                response = next(
+                    r for r in responses_with_bodies if 200 in r.status_codes
                 )
-            except IndexError:
+            except StopIteration:
                 raise ValueError(
-                    f"Your swagger is invalid because you have multiple response schemas for LRO" +
-                    f" method {self.python_name} and none of them have a 200 status code."
+                    f"Your swagger is invalid because you have multiple response schemas for LRO"
+                    + f" method {self.name} and none of them have a 200 status code."
                 )
 
         elif num_response_schemas:
             response = responses_with_bodies[0]
         return response
 
+    def cls_type_annotation(self, *, async_mode: bool) -> str:
+        """We don't want the poller to show up in ClsType, so we call super() on resposne type annotation"""
+        return f"ClsType[{Response.type_annotation(self.responses[0], async_mode=async_mode)}]"
+
     @property
     def initial_operation(self) -> Operation:
-        operation = Operation(
-            self.code_model,
-            yaml_data={},
+        """Initial operation that creates the first call for LRO polling"""
+        return Operation(
+            yaml_data=self.yaml_data,
+            code_model=self.code_model,
+            request_builder=self.code_model.lookup_request_builder(id(self.yaml_data)),
             name=self.name[5:] + "_initial",
-            description="",
-            api_versions=self.api_versions,
+            overloads=self.overloads,
             parameters=self.parameters,
-            schema_requests=self.schema_requests,
-            multiple_content_type_parameters=self.multiple_content_type_parameters,
-            summary=self.summary,
-            responses=self.responses,
-            want_description_docstring=False,
+            responses=[
+                Response(r.yaml_data, self.code_model, headers=r.headers, type=r.type)
+                for r in self.responses
+            ],
+            exceptions=self.exceptions,
+            public=False,
             want_tracing=False,
         )
-        operation.request_builder = self.request_builder
-        return operation
-
-    @property
-    def has_optional_return_type(self) -> bool:
-        """An LROOperation will never have an optional return type, we will always return a poller"""
-        return False
-
-    def _get_lro_extension(self, extension_base, async_mode, *, azure_arm=None):
-        extension_name = extension_base + ("-async" if async_mode else "-sync")
-        extension = self.yaml_data["extensions"][extension_name]
-        arm_extension = None
-        if azure_arm is not None:
-            arm_extension = "azure-arm" if azure_arm else "data-plane"
-        return extension[arm_extension] if arm_extension else extension
-
-    def get_poller_path(self, async_mode: bool) -> str:
-        return self._get_lro_extension("poller", async_mode)
 
     def get_poller(self, async_mode: bool) -> str:
-        return self.get_poller_path(async_mode).split(".")[-1]
-
-    def get_default_polling_method_path(self, async_mode: bool, azure_arm: bool) -> str:
-        return self._get_lro_extension("default-polling-method", async_mode, azure_arm=azure_arm)
-
-    def get_default_polling_method(self, async_mode: bool, azure_arm: bool) -> str:
-        return self.get_default_polling_method_path(async_mode, azure_arm).split(".")[-1]
+        return self.responses[0].get_poller(async_mode)
 
-    def get_default_no_polling_method_path(self, async_mode: bool) -> str:
-        return self._get_lro_extension("default-no-polling-method", async_mode)
-
-    def get_default_no_polling_method(self, async_mode: bool) -> str:
-        return self.get_default_no_polling_method_path(async_mode).split(".")[-1]
-
-    def get_base_polling_method_path(self, async_mode: bool) -> str:
-        return self._get_lro_extension("base-polling-method", async_mode)
+    def get_polling_method(self, async_mode: bool) -> str:
+        return self.responses[0].get_polling_method(async_mode)
 
     def get_base_polling_method(self, async_mode: bool) -> str:
-        return self.get_base_polling_method_path(async_mode).split(".")[-1]
-
-    def imports_for_multiapi(self, async_mode: bool) -> FileImport:
-        file_import = super().imports_for_multiapi(async_mode)
-        poller_import_path = ".".join(self.get_poller_path(async_mode).split(".")[:-1])
-        poller = self.get_poller(async_mode)
-        file_import.add_submodule_import(poller_import_path, poller, ImportType.AZURECORE, TypingSection.CONDITIONAL)
-        return file_import
+        return self.responses[0].get_base_polling_method(async_mode)
 
-    def imports(self, async_mode: bool, is_python3_file: bool) -> FileImport:
-        file_import = self._imports_base(async_mode, is_python3_file)
-        file_import.add_submodule_import("typing", "Union", ImportType.STDLIB, TypingSection.CONDITIONAL)
-
-        poller_import_path = ".".join(self.get_poller_path(async_mode).split(".")[:-1])
-        poller = self.get_poller(async_mode)
-        file_import.add_submodule_import(poller_import_path, poller, ImportType.AZURECORE)
+    def get_base_polling_method_path(self, async_mode: bool) -> str:
+        return self.responses[0].get_base_polling_method_path(async_mode)
 
-        default_polling_method_import_path = ".".join(
-            self.get_default_polling_method_path(async_mode, self.code_model.options['azure_arm']).split(".")[:-1]
-        )
-        default_polling_method = self.get_default_polling_method(async_mode, self.code_model.options['azure_arm'])
-        file_import.add_submodule_import(
-            default_polling_method_import_path, default_polling_method, ImportType.AZURECORE
-        )
+    def get_no_polling_method(self, async_mode: bool) -> str:
+        return self.responses[0].get_no_polling_method(async_mode)
 
-        default_no_polling_method_import_path = ".".join(
-            self.get_default_no_polling_method_path(async_mode).split(".")[:-1]
-        )
-        default_no_polling_method = self.get_default_no_polling_method(async_mode)
-        file_import.add_submodule_import(
-            default_no_polling_method_import_path, default_no_polling_method, ImportType.AZURECORE
-        )
-
-        base_polling_method_import_path = ".".join(
-            self.get_base_polling_method_path(async_mode).split(".")[:-1]
-        )
-        base_polling_method = self.get_base_polling_method(async_mode)
-        file_import.add_submodule_import(base_polling_method_import_path, base_polling_method, ImportType.AZURECORE)
-        file_import.add_submodule_import("typing", "cast", ImportType.STDLIB)
+    def imports(
+        self, async_mode: bool, is_python3_file: bool, **kwargs: Any
+    ) -> FileImport:
+        file_import = super().imports(async_mode, is_python3_file, **kwargs)
         if async_mode:
-            file_import.add_submodule_import("typing", "Optional", ImportType.STDLIB, TypingSection.CONDITIONAL)
-        if self.code_model.options["tracing"] and self.want_tracing:
             file_import.add_submodule_import(
-                f"azure.core.tracing.decorator{'_async' if async_mode else ''}",
-                f"distributed_trace{'_async' if async_mode else ''}",
+                f"azure.core.tracing.decorator_async",
+                f"distributed_trace_async",
                 ImportType.AZURECORE,
             )
+        file_import.add_submodule_import(
+            "typing", "Union", ImportType.STDLIB, TypingSection.CONDITIONAL
+        )
+        file_import.add_submodule_import("typing", "cast", ImportType.STDLIB)
         return file_import
+
+
+class LROOperation(LROOperationBase[LROResponse]):
+    ...