@autorest/python 5.16.0 → 5.17.0

package/autorest/codegen/models/enum_type.py

@@ -0,0 +1,195 @@
+# -------------------------------------------------------------------------
+# 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, List, TYPE_CHECKING, Optional
+
+from .base_type import BaseType
+from .imports import FileImport, ImportType, TypingSection
+from .base_model import BaseModel
+
+if TYPE_CHECKING:
+    from .code_model import CodeModel
+
+
+class EnumValue(BaseModel):
+    """Model containing necessary information for a single value of an enum.
+
+    :param str name: The name of this enum value
+    :param str value: The value of this enum value
+    :param str description: Optional. The description for this enum value
+    """
+
+    def __init__(self, yaml_data: Dict[str, Any], code_model: "CodeModel") -> None:
+        super().__init__(yaml_data=yaml_data, code_model=code_model)
+        self.name: str = self.yaml_data["name"]
+        self.value: str = self.yaml_data["value"]
+        self.description: Optional[str] = self.yaml_data.get("description")
+
+    @classmethod
+    def from_yaml(
+        cls, yaml_data: Dict[str, Any], code_model: "CodeModel"
+    ) -> "EnumValue":
+        """Constructs an EnumValue from yaml data.
+
+        :param yaml_data: the yaml data from which we will construct this object
+        :type yaml_data: dict[str, Any]
+
+        :return: A created EnumValue
+        :rtype: ~autorest.models.EnumValue
+        """
+        return cls(
+            yaml_data=yaml_data,
+            code_model=code_model,
+        )
+
+
+class EnumType(BaseType):
+    """Schema for enums that will be serialized.
+
+    :param yaml_data: the yaml data for this schema
+    :type yaml_data: dict[str, Any]
+    :param str description: The description of this enum
+    :param str name: The name of the enum.
+    :type element_type: ~autorest.models.PrimitiveType
+    :param values: List of the values for this enum
+    :type values: list[~autorest.models.EnumValue]
+    """
+
+    def __init__(
+        self,
+        yaml_data: Dict[str, Any],
+        code_model: "CodeModel",
+        values: List["EnumValue"],
+        value_type: BaseType,
+    ) -> None:
+        super().__init__(yaml_data=yaml_data, code_model=code_model)
+        self.name: str = yaml_data["name"]
+        self.values = values
+        self.value_type = value_type
+
+    def __lt__(self, other):
+        return self.name.lower() < other.name.lower()
+
+    @property
+    def serialization_type(self) -> str:
+        """Returns the serialization value for msrest.
+
+        :return: The serialization value for msrest
+        :rtype: str
+        """
+        return self.value_type.serialization_type
+
+    def description(
+        self, *, is_operation_file: bool  # pylint: disable=unused-argument
+    ) -> str:
+        possible_values = [self.get_declaration(v.value) for v in self.values]
+        if not possible_values:
+            return ""
+        if len(possible_values) == 1:
+            return possible_values[0]
+        if len(possible_values) == 2:
+            possible_values_str = " and ".join(possible_values)
+        else:
+            possible_values_str = (
+                ", ".join(possible_values[: len(possible_values) - 1])
+                + f", and {possible_values[-1]}"
+            )
+
+        enum_description = f"Known values are: {possible_values_str}."
+        return enum_description
+
+    def type_annotation(self, **kwargs: Any) -> str:
+        """The python type used for type annotation
+
+        :return: The type annotation for this schema
+        :rtype: str
+        """
+        if self.code_model.options["models_mode"]:
+            return (
+                f"Union[{self.value_type.type_annotation(**kwargs)},"
+                f' "_models.{self.name}"]'
+            )
+        return self.value_type.type_annotation(**kwargs)
+
+    def get_declaration(self, value: Any) -> str:
+        return self.value_type.get_declaration(value)
+
+    def docstring_text(self, **kwargs: Any) -> str:
+        if self.code_model.options["models_mode"]:
+            return self.name
+        return self.value_type.type_annotation(**kwargs)
+
+    def docstring_type(self, **kwargs: Any) -> str:
+        """The python type used for RST syntax input and type annotation."""
+        if self.code_model.options["models_mode"]:
+            return f"{self.value_type.type_annotation(**kwargs)} or ~{self.code_model.namespace}.models.{self.name}"
+        return self.value_type.type_annotation(**kwargs)
+
+    def get_json_template_representation(
+        self,
+        *,
+        optional: bool = True,
+        client_default_value_declaration: Optional[str] = None,
+        description: Optional[str] = None,
+    ) -> Any:
+        # for better display effect, use the only value instead of var type
+        return self.value_type.get_json_template_representation(
+            optional=optional,
+            client_default_value_declaration=client_default_value_declaration,
+            description=description,
+        )
+
+    @property
+    def instance_check_template(self) -> str:
+        return self.value_type.instance_check_template
+
+    @classmethod
+    def from_yaml(
+        cls, yaml_data: Dict[str, Any], code_model: "CodeModel"
+    ) -> "EnumType":
+        """Constructs an EnumType from yaml data.
+
+        :param yaml_data: the yaml data from which we will construct this schema
+        :type yaml_data: dict[str, Any]
+
+        :return: A created EnumType
+        :rtype: ~autorest.models.EnumType
+        """
+        from . import build_type
+
+        return cls(
+            yaml_data=yaml_data,
+            code_model=code_model,
+            value_type=build_type(yaml_data["valueType"], code_model),
+            values=[
+                EnumValue.from_yaml(value, code_model) for value in yaml_data["values"]
+            ],
+        )
+
+    def imports(self, **kwargs: Any) -> FileImport:
+        is_operation_file = kwargs.pop("is_operation_file", False)
+        file_import = FileImport()
+        if self.code_model.options["models_mode"]:
+            file_import.add_submodule_import(
+                "typing", "Union", ImportType.STDLIB, TypingSection.CONDITIONAL
+            )
+            if not is_operation_file:
+                file_import.add_submodule_import(
+                    "..",
+                    "models",
+                    ImportType.LOCAL,
+                    TypingSection.TYPING,
+                    alias="_models",
+                )
+        file_import.merge(
+            self.value_type.imports(is_operation_file=is_operation_file, **kwargs)
+        )
+        relative_path = kwargs.pop("relative_path", None)
+        if self.code_model.options["models_mode"] and relative_path:
+            # add import for enums in operations file
+            file_import.add_submodule_import(
+                relative_path, "models", ImportType.LOCAL, alias="_models"
+            )
+        return file_import

package/autorest/codegen/models/imports.py

@@ -147,6 +147,29 @@ class FileImport:
             self._append_import(i)
         self.type_definitions.update(file_import.type_definitions)
 
+    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[

package/autorest/codegen/models/list_type.py

@@ -0,0 +1,134 @@
+# -------------------------------------------------------------------------
+# 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
+from .base_type import BaseType
+from .imports import FileImport, ImportType, TypingSection
+
+if TYPE_CHECKING:
+    from .code_model import CodeModel
+
+
+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,
+            )
+        ]
+
+    @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,218 +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, TYPE_CHECKING
+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,
         yaml_data: Dict[str, Any],
         code_model: "CodeModel",
-        request_builder: RequestBuilder,
         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().__init__(
-            yaml_data,
-            code_model,
-            request_builder,
-            name,
-            description,
-            api_versions,
-            parameters,
-            multiple_content_type_parameters,
-            schema_requests,
-            summary,
-            responses,
-            exceptions,
-            want_description_docstring,
+            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 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 operation_type(self) -> str:
+        return "lro"
+
+    @property
+    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" 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(
-            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
-        )
+        return self.responses[0].get_poller(async_mode)
 
-    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
-        ]
-
-    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]
+        return self.responses[0].get_base_polling_method(async_mode)
 
-    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
-
-    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
-        )
-
-        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_base_polling_method_path(self, async_mode: bool) -> str:
+        return self.responses[0].get_base_polling_method_path(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,
-        )
+    def get_no_polling_method(self, async_mode: bool) -> str:
+        return self.responses[0].get_no_polling_method(async_mode)
 
-        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]):
+    ...