@autorest/python 5.16.0 → 5.17.0

package/autorest/codegen/models/property.py

@@ -3,13 +3,13 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
-from typing import cast, Any, Dict, Union, List, Optional, TYPE_CHECKING
+from typing import Any, Dict, Optional, TYPE_CHECKING, List
 
 from .base_model import BaseModel
-from .constant_schema import ConstantSchema
+from .constant_type import ConstantType
+from .base_type import BaseType
 from .imports import FileImport, ImportType, TypingSection
-from .base_schema import BaseSchema
-from .enum_schema import EnumSchema
+from .utils import add_to_description, add_to_pylint_disable
 
 if TYPE_CHECKING:
     from .code_model import CodeModel
@@ -20,173 +20,143 @@ class Property(BaseModel):  # pylint: disable=too-many-instance-attributes
         self,
         yaml_data: Dict[str, Any],
         code_model: "CodeModel",
-        name: str,
-        schema: BaseSchema,
-        original_swagger_name: str,
-        *,
-        flattened_names: Optional[List[str]] = None,
-        description: Optional[str] = None,
-        client_default_value: Optional[Any] = None,
+        type: BaseType,
     ) -> None:
         super().__init__(yaml_data, code_model)
-        self.name = name
-        self.schema = schema
-        self.original_swagger_name = original_swagger_name
-        self.flattened_names = flattened_names or []
-
-        self.required: bool = yaml_data.get("required", False)
-        self.readonly: bool = yaml_data.get("readOnly", False)
+        self.rest_api_name: str = self.yaml_data["restApiName"]
+        self.client_name: str = self.yaml_data["clientName"]
+        self.type = type
+        self.optional: bool = self.yaml_data["optional"]
+        self.readonly: bool = self.yaml_data.get("readonly", False)
         self.is_discriminator: bool = yaml_data.get("isDiscriminator", False)
-        self.client_default_value = client_default_value
-        self.description = self._create_description(description, yaml_data)
-
-    def _create_description(
-        self, description_input: Optional[str], yaml_data: Dict[str, Any]
-    ) -> str:
-        description: str = (
-            description_input or yaml_data["language"]["python"]["description"]
+        self.client_default_value = yaml_data.get("clientDefaultValue", None)
+        if self.client_default_value is None:
+            self.client_default_value = self.type.client_default_value
+        self.flattened_names: List[str] = yaml_data.get("flattenedNames", [])
+
+    @property
+    def pylint_disable(self) -> str:
+        retval: str = ""
+        if self.yaml_data.get("pylintDisable"):
+            retval = add_to_pylint_disable(retval, self.yaml_data["pylintDisable"])
+        return retval
+
+    def description(self, *, is_operation_file: bool) -> str:
+        from .model_type import ModelType
+
+        description = self.yaml_data["description"]
+        if not (self.optional or self.client_default_value):
+            description = add_to_description(description, "Required.")
+        # don't want model type documentation as part of property doc
+        type_description = (
+            ""
+            if isinstance(self.type, ModelType)
+            else self.type.description(is_operation_file=is_operation_file)
         )
-        if description and description[-1] != ".":
-            description += "."
-        if self.name == "tags":
-            description = "A set of tags. " + description
-        if self.constant:
-            description += f" Has constant value: {self.constant_declaration}."
-        elif self.required:
-            if description:
-                description = "Required. " + description
-            else:
-                description = "Required. "
-        elif isinstance(self.schema, ConstantSchema):
-            description += (
-                f" The only acceptable values to pass in are None and {self.constant_declaration}. "
-                + f"The default value is {self.default_value_declaration}."
-            )
-        if self.is_discriminator:
-            description += "Constant filled by server. "
-        if isinstance(self.schema, EnumSchema):
-            values = [
-                self.schema.enum_type.get_declaration(v.value)
-                for v in self.schema.values
-            ]
-            if description and description[-1] != " ":
-                description += " "
-            description += "Known values are: {}.".format(", ".join(values))
-            if self.schema.default_value:
-                description += f' Default value: "{self.schema.default_value}".'
-        return description
+        return add_to_description(description, type_description)
+
+    @property
+    def client_default_value_declaration(self) -> str:
+        if self.client_default_value is not None:
+            return self.type.get_declaration(self.client_default_value)
+        if self.type.client_default_value is not None:
+            return self.type.get_declaration(self.type.client_default_value)
+        return "None"
 
     @property
     def constant(self) -> bool:
         # this bool doesn't consider you to be constant if you are a discriminator
         # you also have to be required to be considered a constant
         return (
-            isinstance(self.schema, ConstantSchema)
-            and self.required
+            isinstance(self.type, ConstantType)
+            and not self.optional
             and not self.is_discriminator
         )
 
     @property
-    def validation_map(self) -> Optional[Dict[str, Union[bool, int, str]]]:
-        retval: Dict[str, Union[bool, int, str]] = {}
-        if self.required:
+    def is_input(self):
+        return not (self.constant or self.readonly or self.is_discriminator)
+
+    @property
+    def serialization_type(self) -> str:
+        return self.type.serialization_type
+
+    def type_annotation(self, *, is_operation_file: bool = False) -> str:
+        if self.optional and self.client_default_value is None:
+            return f"Optional[{self.type.type_annotation(is_operation_file=is_operation_file)}]"
+        return self.type.type_annotation(is_operation_file=is_operation_file)
+
+    def get_json_template_representation(
+        self,
+        *,
+        optional: bool = True,  # pylint: disable=unused-argument
+        client_default_value_declaration: Optional[str] = None,
+        description: Optional[str] = None,
+    ) -> Any:
+        if self.client_default_value:
+            client_default_value_declaration = self.type.get_declaration(
+                self.client_default_value
+            )
+        if self.description(is_operation_file=True):
+            description = self.description(is_operation_file=True)
+        return self.type.get_json_template_representation(
+            optional=self.optional,
+            client_default_value_declaration=client_default_value_declaration,
+            description=description,
+        )
+
+    @property
+    def validation(self) -> Optional[Dict[str, Any]]:
+        retval: Dict[str, Any] = {}
+        if not self.optional:
             retval["required"] = True
         if self.readonly:
             retval["readonly"] = True
         if self.constant:
             retval["constant"] = True
-        if self.schema.validation_map:
-            validation_map_from_schema = cast(
-                Dict[str, Union[bool, int, str]], self.schema.validation_map
-            )
-            retval.update(validation_map_from_schema)
+        retval.update(self.type.validation or {})
         return retval or None
 
     @property
-    def escaped_swagger_name(self) -> str:
-        """Return the RestAPI name correctly escaped for serialization."""
+    def attribute_map(self) -> str:
         if self.flattened_names:
-            return ".".join(n.replace(".", "\\\\.") for n in self.flattened_names)
-        return self.original_swagger_name.replace(".", "\\\\.")
+            attribute_key = ".".join(
+                n.replace(".", "\\\\.") for n in self.flattened_names
+            )
+        else:
+            attribute_key = self.rest_api_name.replace(".", "\\\\.")
+        if self.type.xml_serialization_ctxt:
+            xml_metadata = f", 'xml': {{{self.type.xml_serialization_ctxt}}}"
+        else:
+            xml_metadata = ""
+        return f'"{self.client_name}": {{"key": "{attribute_key}", "type": "{self.serialization_type}"{xml_metadata}}},'
+
+    def imports(self) -> FileImport:
+        from .model_type import ModelType
+
+        file_import = self.type.imports(is_operation_file=False)
+        if self.optional and self.client_default_value is None:
+            file_import.add_submodule_import("typing", "Optional", ImportType.STDLIB)
+        if isinstance(self.type, ModelType):
+            file_import.add_submodule_import(
+                "..",
+                "models",
+                ImportType.LOCAL,
+                TypingSection.TYPING,
+                alias="_models",
+            )
+        return file_import
 
     @classmethod
     def from_yaml(
         cls,
         yaml_data: Dict[str, Any],
         code_model: "CodeModel",
-        *,
-        has_additional_properties: Optional[bool] = None,
     ) -> "Property":
-        from . import build_schema  # pylint: disable=import-outside-toplevel
+        from . import build_type  # pylint: disable=import-outside-toplevel
 
-        name = yaml_data["language"]["python"]["name"]
-        if name == "additional_properties" and has_additional_properties:
-            name = "additional_properties1"
-        schema = build_schema(yaml_data=yaml_data["schema"], code_model=code_model)
         return cls(
             yaml_data=yaml_data,
             code_model=code_model,
-            name=name,
-            schema=schema,
-            original_swagger_name=yaml_data["serializedName"],
-            flattened_names=yaml_data.get("flattenedNames", []),
-            client_default_value=yaml_data.get("clientDefaultValue"),
+            type=build_type(yaml_data["type"], code_model),
         )
-
-    @property
-    def is_input(self):
-        return not (self.constant or self.readonly or self.is_discriminator)
-
-    @property
-    def constant_declaration(self) -> str:
-        if self.schema:
-            if isinstance(self.schema, ConstantSchema):
-                return self.schema.get_declaration(self.schema.value)
-            raise ValueError(
-                "Trying to get constant declaration for a schema that is not ConstantSchema"
-            )
-        raise ValueError("Trying to get a declaration for a schema that doesn't exist")
-
-    @property
-    def serialization_type(self) -> str:
-        return self.schema.serialization_type
-
-    @property
-    def xml_metadata(self) -> str:
-        if self.schema.has_xml_serialization_ctxt:
-            return f", 'xml': {{{self.schema.xml_serialization_ctxt()}}}"
-        return ""
-
-    @property
-    def default_value(self) -> Any:
-        return self.client_default_value or self.schema.default_value
-
-    @property
-    def default_value_declaration(self) -> Any:
-        if self.client_default_value:
-            return self.schema.get_declaration(self.client_default_value)
-        return self.schema.default_value_declaration
-
-    def type_annotation(self, *, is_operation_file: bool = False) -> str:
-        if self.required:
-            return self.schema.type_annotation(is_operation_file=is_operation_file)
-        return f"Optional[{self.schema.type_annotation(is_operation_file=is_operation_file)}]"
-
-    def get_json_template_representation(self, **kwargs: Any) -> Any:
-        kwargs["optional"] = not self.required
-        if self.default_value:
-            kwargs["default_value_declaration"] = self.schema.get_declaration(
-                self.default_value
-            )
-        if self.description:
-            kwargs["description"] = self.description
-        return self.schema.get_json_template_representation(**kwargs)
-
-    def model_file_imports(self) -> FileImport:
-        file_import = self.schema.model_file_imports()
-        if not self.required:
-            file_import.add_submodule_import(
-                "typing", "Optional", ImportType.STDLIB, TypingSection.CONDITIONAL
-            )
-        file_import.merge(self.schema.model_file_imports())
-        return file_import

package/autorest/codegen/models/request_builder.py

@@ -3,82 +3,79 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
-from typing import Any, Dict, List, TypeVar, Optional, TYPE_CHECKING
 import logging
-
-from .base_builder import BaseBuilder, create_parameters
-from .request_builder_parameter import RequestBuilderParameter
-from .request_builder_parameter_list import RequestBuilderParameterList
-from .schema_request import SchemaRequest
-from .schema_response import SchemaResponse
+from typing import (
+    Any,
+    Callable,
+    Dict,
+    List,
+    TypeVar,
+    TYPE_CHECKING,
+    Union,
+    Optional,
+)
+from abc import abstractmethod
+
+from .base_builder import BaseBuilder
+from .parameter_list import (
+    RequestBuilderParameterList,
+    OverloadedRequestBuilderParameterList,
+)
 from .imports import FileImport, ImportType, TypingSection
-from .parameter import Parameter
+from .request_builder_parameter import RequestBuilderMultipartBodyParameter
 
 if TYPE_CHECKING:
     from .code_model import CodeModel
 
 _LOGGER = logging.getLogger(__name__)
-
-T = TypeVar("T")
-OrderedSet = Dict[T, None]
+ParameterListType = TypeVar(
+    "ParameterListType",
+    bound=Union[RequestBuilderParameterList, OverloadedRequestBuilderParameterList],
+)
 
 
-class RequestBuilder(BaseBuilder):
+class RequestBuilderBase(BaseBuilder[ParameterListType]):
     def __init__(
         self,
         yaml_data: Dict[str, Any],
         code_model: "CodeModel",
         name: str,
-        url: str,
-        method: str,
-        multipart: bool,
-        schema_requests: List[SchemaRequest],
-        parameters: RequestBuilderParameterList,
-        description: str,
-        summary: str,
-        responses: Optional[List[SchemaResponse]] = None,
+        parameters: ParameterListType,
         *,
+        overloads: Optional[List["RequestBuilder"]] = None,
         abstract: bool = False,
-    ):
+    ) -> None:
         super().__init__(
-            yaml_data=yaml_data,
             code_model=code_model,
+            yaml_data=yaml_data,
             name=name,
-            description=description,
             parameters=parameters,
-            responses=responses,
-            schema_requests=schema_requests,
-            summary=summary,
+            overloads=overloads,
             abstract=abstract,
             want_tracing=False,
         )
-        self.url = url
-        self.method = method
-        self.multipart = multipart
-
-    @property
-    def is_stream(self) -> bool:
-        """Is the request we're preparing a stream, like an upload."""
-        return any(request.is_stream_request for request in self.schema_requests)
-
-    @property
-    def body_kwargs_to_get(self) -> List[Parameter]:
-        return self.parameters.body_kwargs_to_get
-
-    @property
-    def operation_group_name(self) -> str:
-        return self.yaml_data["language"]["python"]["operationGroupName"]
+        self.overloads: List["RequestBuilder"] = overloads or []
+        self.url: str = yaml_data["url"]
+        self.method: str = yaml_data["method"]
+
+    def response_type_annotation(self, **kwargs) -> str:
+        return "HttpRequest"
+
+    def response_docstring_text(self, **kwargs) -> str:
+        return (
+            "Returns an :class:`~azure.core.rest.HttpRequest` that you will pass to the client's "
+            + "`send_request` method. See https://aka.ms/azsdk/python/protocol/quickstart for how to "
+            + "incorporate this response into your code flow."
+        )
 
-    @property
-    def builder_group_name(self) -> str:
-        return self.yaml_data["language"]["python"]["builderGroupName"]
+    def response_docstring_type(self, **kwargs) -> str:
+        return "~azure.core.rest.HttpRequest"
 
     def imports(self) -> FileImport:
         file_import = FileImport()
-        for parameter in self.parameters.method:
-            if self.abstract and (parameter.is_multipart or parameter.is_data_input):
-                continue
-            file_import.merge(parameter.imports())
+        if not self.abstract:
+            for parameter in self.parameters.method:
+                file_import.merge(parameter.imports(async_mode=False))
 
         file_import.add_submodule_import(
             "azure.core.rest",
@@ -90,9 +87,9 @@ class RequestBuilder(BaseBuilder):
                 relative_path = ".."
                 if (
                     not self.code_model.options["builders_visibility"] == "embedded"
-                    and self.operation_group_name
+                    and self.group_name
                 ):
-                    relative_path = "..." if self.operation_group_name else ".."
+                    relative_path = "..." if self.group_name else ".."
                 file_import.add_submodule_import(
                     f"{relative_path}_vendor", "_format_url_section", ImportType.LOCAL
                 )
@@ -104,70 +101,90 @@ class RequestBuilder(BaseBuilder):
             "typing", "Any", ImportType.STDLIB, typing_section=TypingSection.CONDITIONAL
         )
         file_import.add_submodule_import("msrest", "Serializer", ImportType.THIRDPARTY)
+        if (
+            self.overloads
+            and self.code_model.options["builders_visibility"] != "embedded"
+        ):
+            file_import.add_submodule_import("typing", "overload", ImportType.STDLIB)
         return file_import
 
-    @classmethod
-    def from_yaml(
-        cls, yaml_data: Dict[str, Any], code_model: "CodeModel"
-    ) -> "RequestBuilder":
+    @staticmethod
+    @abstractmethod
+    def parameter_list_type() -> Callable[
+        [Dict[str, Any], "CodeModel"], ParameterListType
+    ]:
+        ...
 
-        # when combine embeded builders into one operation file, we need to avoid duplicated build function name.
+    @classmethod
+    def from_yaml(cls, yaml_data: Dict[str, Any], code_model: "CodeModel"):
+        # when combine embedded builders into one operation file, we need to avoid duplicated build function name.
         # So add operation group name is effective method
         additional_mark = ""
         if (
             code_model.options["combine_operation_files"]
             and code_model.options["builders_visibility"] == "embedded"
         ):
-            additional_mark = yaml_data["language"]["python"]["builderGroupName"]
+            additional_mark = yaml_data["groupName"]
         names = [
             "build",
             additional_mark,
-            yaml_data["language"]["python"]["name"],
+            yaml_data["name"],
             "request",
         ]
         name = "_".join([n for n in names if n])
-
-        first_request = yaml_data["requests"][0]
-        schema_requests = [
-            SchemaRequest.from_yaml(yaml, code_model=code_model)
-            for yaml in yaml_data["requests"]
+        overloads = [
+            RequestBuilder.from_yaml(rb_yaml_data, code_model)
+            for rb_yaml_data in yaml_data.get("overloads", [])
         ]
-        parameters, multiple_content_type_parameters = create_parameters(
-            yaml_data, code_model, RequestBuilderParameter.from_yaml
-        )
-        parameter_list = RequestBuilderParameterList(
-            code_model, parameters + multiple_content_type_parameters, schema_requests
-        )
         abstract = False
+        parameter_list = cls.parameter_list_type()(yaml_data, code_model)
         if (
             code_model.options["version_tolerant"]
-            or code_model.options["low_level_client"]
-        ) and any(p for p in parameter_list if p.is_multipart or p.is_data_input):
+            and parameter_list.has_body
+            and isinstance(
+                parameter_list.body_parameter, RequestBuilderMultipartBodyParameter
+            )
+        ):
             _LOGGER.warning(
-                'Not going to generate request_builder "%s" because it has multipart / urlencoded '
-                "body parameters. Multipart / urlencoded body parameters are not supported for version "
-                "tolerant and low level generations right now. Please write your own custom operation "
-                "in the _patch.py file following https://aka.ms/azsdk/python/dpcodegen/python/customize.",
+                '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
 
-        request_builder_class = cls(
+        return cls(
             yaml_data=yaml_data,
             code_model=code_model,
             name=name,
-            url=first_request["protocol"]["http"]["path"],
-            method=first_request["protocol"]["http"]["method"].upper(),
-            multipart=first_request["protocol"]["http"].get("multipart", False),
-            schema_requests=schema_requests,
             parameters=parameter_list,
-            description=yaml_data["language"]["python"]["description"],
-            responses=[
-                SchemaResponse.from_yaml(yaml, code_model=code_model)
-                for yaml in yaml_data.get("responses", [])
-            ],
-            summary=yaml_data["language"]["python"].get("summary"),
+            overloads=overloads,
             abstract=abstract,
         )
-        parameter_list.add_body_kwargs()
-        return request_builder_class
+
+
+class RequestBuilder(RequestBuilderBase[RequestBuilderParameterList]):
+    @staticmethod
+    def parameter_list_type() -> Callable[
+        [Dict[str, Any], "CodeModel"], RequestBuilderParameterList
+    ]:
+        return RequestBuilderParameterList.from_yaml
+
+
+class OverloadedRequestBuilder(
+    RequestBuilderBase[OverloadedRequestBuilderParameterList]
+):
+    @staticmethod
+    def parameter_list_type() -> Callable[
+        [Dict[str, Any], "CodeModel"], OverloadedRequestBuilderParameterList
+    ]:
+        return OverloadedRequestBuilderParameterList.from_yaml
+
+
+def get_request_builder(
+    yaml_data: Dict[str, Any], code_model: "CodeModel"
+) -> Union[RequestBuilder, OverloadedRequestBuilder]:
+    if yaml_data.get("overloads"):
+        return OverloadedRequestBuilder.from_yaml(yaml_data, code_model)
+    return RequestBuilder.from_yaml(yaml_data, code_model)