@autorest/python 5.15.0 → 5.18.0

package/autorest/codegen/models/request_builder_parameter.py

@@ -3,109 +3,145 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
-from typing import Any, Dict, List, Optional
-from .parameter import ParameterOnlyPathAndBodyPositional, ParameterLocation, ParameterStyle, get_target_property_name
-from .utils import get_schema
+from typing import TYPE_CHECKING, Any, Dict, Union
+from .parameter import (
+    ParameterLocation,
+    ParameterMethodLocation,
+    Parameter,
+    BodyParameter,
+    _MultipartBodyParameter,
+)
+from .base_type import BaseType
+from .primitive_types import BinaryType, StringType
+from .combined_type import CombinedType
 
-def _make_public(name):
-    if name[0] == "_":
-        return name[1:]
-    return name
+if TYPE_CHECKING:
+    from .code_model import CodeModel
 
-class RequestBuilderParameter(ParameterOnlyPathAndBodyPositional):
+
+class RequestBuilderBodyParameter(BodyParameter):
+    """BOdy parmaeter for RequestBuilders"""
+
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+        if isinstance(self.type, (BinaryType, StringType)) or any(
+            "xml" in ct for ct in self.content_types
+        ):
+            self.client_name = "content"
+        else:
+            self.client_name = "json"
+
+    def type_annotation(self, **kwargs: Any) -> str:
+        if self.type.is_xml:
+            return "Any"  # xml type technically not in type signature for HttpRequest content param
+        return super().type_annotation(**kwargs)
 
     @property
     def in_method_signature(self) -> bool:
-        return not(
-            # if not inputtable, don't put in signature
-            not self.inputtable_by_user
-            # If i'm not in the method code, no point in being in signature
-            or not self.in_method_code
-            # If I'm a flattened property of a body, don't want me, want the body param
-            or self.target_property_name
-            or not self.in_method_code
-        )
+        return super().in_method_signature and not self.is_partial_body
 
     @property
-    def name_in_high_level_operation(self) -> str:
-        template = "{}" if self.code_model.options["version_tolerant"] else "_{}"
-        if self.is_multipart:
-            return template.format("files")
-        if self.is_data_input:
-            return template.format("data")
-        if self.is_body and not self.constant:
-            return f"_{self.serialized_name}"
-        name = self.yaml_data["language"]["python"]["name"]
-        if self.implementation == "Client" and self.in_method_code:
-            # for these, we're passing the client params to the request builder.
-            # Need the self._config prefix
-            name = f"self._config.{name}"
-        return name
+    def method_location(self) -> ParameterMethodLocation:
+        return (
+            ParameterMethodLocation.KWARG
+            if (self.constant or isinstance(self.type, CombinedType))
+            else ParameterMethodLocation.KEYWORD_ONLY
+        )
 
-    @property
-    def in_method_code(self) -> bool:
-        if self.location == ParameterLocation.Uri:
-            # don't want any base url path formatting arguments
-            return False
-        return super(RequestBuilderParameter, self).in_method_code
+    @classmethod
+    def from_yaml(
+        cls, yaml_data: Dict[str, Any], code_model: "CodeModel"
+    ) -> "RequestBuilderBodyParameter":
+        return super().from_yaml(yaml_data, code_model)  # type: ignore
 
     @property
-    def default_value_declaration(self) -> Optional[str]:
-        if self.serialized_name == "content_type":
-            # in request builders we're in a weird scenario
-            # we need to know what the types of content_type are
-            # but we want to serialize content_type with no default.
-            # So, we just return None in default_value_declaration for now
-            return "None"
-        return super().default_value_declaration
+    def name_in_high_level_operation(self) -> str:
+        if self.client_name == "json":
+            return "_json"
+        return "_content"
 
-    @property
-    def is_keyword_only(self) -> bool:
-        return not self.location == ParameterLocation.Path and not self.is_kwarg
 
-    @is_keyword_only.setter
-    def is_keyword_only(self, val: bool) -> None:
-        self._keyword_only = val
-        self.is_kwarg = False
+class RequestBuilderMultipartBodyParameter(
+    _MultipartBodyParameter[  # pylint: disable=unsubscriptable-object
+        RequestBuilderBodyParameter
+    ]
+):
+    """Multipart body parameter for Request BUilders"""
 
     @property
-    def full_serialized_name(self) -> str:
-        return self.serialized_name
+    def name_in_high_level_operation(self) -> str:
+        return f"_{self.client_name}"
 
     @classmethod
     def from_yaml(
-        cls, yaml_data: Dict[str, Any], *, code_model, content_types: Optional[List[str]] = None
-    ) -> "RequestBuilderParameter":
-        http_protocol = yaml_data["protocol"].get("http", {"in": ParameterLocation.Other})
-        name = yaml_data["language"]["python"]["name"]
-        location = ParameterLocation(http_protocol["in"])
-        serialized_name = yaml_data["language"]["python"]["name"]
-        schema = get_schema(
-            code_model, yaml_data.get("schema"), serialized_name
-        )
-        target_property = yaml_data.get("targetProperty")
-        target_property_name = get_target_property_name(code_model, id(target_property)) if target_property else None
+        cls, yaml_data: Dict[str, Any], code_model: "CodeModel"
+    ) -> "RequestBuilderMultipartBodyParameter":
         return cls(
-            code_model=code_model,
             yaml_data=yaml_data,
-            schema=schema,
-            # See also https://github.com/Azure/autorest.modelerfour/issues/80
-            rest_api_name=yaml_data["language"]["default"].get(
-                "serializedName", yaml_data["language"]["default"]["name"]
-            ),
-            serialized_name=_make_public(name),
-            description=yaml_data["language"]["python"]["description"],
-            implementation=yaml_data["implementation"],
-            required=yaml_data.get("required", False),
-            location=location,
-            skip_url_encoding=yaml_data.get("extensions", {}).get("x-ms-skip-url-encoding", False),
-            constraints=[],  # FIXME constraints
-            target_property_name=target_property_name,
-            style=ParameterStyle(http_protocol["style"]) if "style" in http_protocol else None,
-            explode=http_protocol.get("explode", False),
-            grouped_by=yaml_data.get("groupedBy", None),
-            original_parameter=yaml_data.get("originalParameter", None),
-            flattened=yaml_data.get("flattened", False),
-            client_default_value=yaml_data.get("clientDefaultValue"),
-            content_types=content_types,
+            code_model=code_model,
+            type=code_model.lookup_type(id(yaml_data["type"])),
+            entries=[
+                RequestBuilderBodyParameter.from_yaml(entry, code_model)
+                for entry in yaml_data["entries"]
+            ],
         )
+
+
+class RequestBuilderParameter(Parameter):
+    """Basic RequestBuilder Parameter."""
+
+    def __init__(
+        self, yaml_data: Dict[str, Any], code_model: "CodeModel", type: BaseType
+    ) -> None:
+        super().__init__(yaml_data, code_model, type)
+        # we don't want any default content type behavior in request builder
+        if self.rest_api_name == "Content-Type":
+            self.client_default_value = None
+        if self.grouped_by and self.client_name[0] == "_":
+            # we don't want hidden parameters for grouped by in request builders
+            self.client_name = self.client_name[1:]
+
+    @property
+    def in_method_signature(self) -> bool:
+        if self.grouped_by and not self.in_flattened_body:
+            return True
+        return super().in_method_signature and not (
+            self.location == ParameterLocation.ENDPOINT_PATH
+            or self.in_flattened_body
+            or self.grouper
+        )
+
+    @property
+    def full_client_name(self) -> str:
+        return self.client_name
+
+    @property
+    def method_location(self) -> ParameterMethodLocation:
+        super_method_location = super().method_location
+        if super_method_location == ParameterMethodLocation.KWARG:
+            return super_method_location
+        if (
+            self.in_overriden
+            and super_method_location == ParameterMethodLocation.KEYWORD_ONLY
+        ):
+            return ParameterMethodLocation.KWARG
+        if self.location != ParameterLocation.PATH:
+            return ParameterMethodLocation.KEYWORD_ONLY
+        return super_method_location
+
+    @property
+    def name_in_high_level_operation(self) -> str:
+        if self.grouped_by:
+            return f"_{self.client_name}"
+        if self.implementation == "Client":
+            return f"self._config.{self.client_name}"
+        return self.client_name
+
+
+def get_request_body_parameter(
+    yaml_data: Dict[str, Any], code_model: "CodeModel"
+) -> Union[RequestBuilderBodyParameter, RequestBuilderMultipartBodyParameter]:
+    """Get body parameter for a request builder"""
+    if yaml_data.get("entries"):
+        return RequestBuilderMultipartBodyParameter.from_yaml(yaml_data, code_model)
+    return RequestBuilderBodyParameter.from_yaml(yaml_data, code_model)

package/autorest/codegen/models/response.py

@@ -0,0 +1,325 @@
+# -------------------------------------------------------------------------
+# 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 Dict, Optional, List, Any, TYPE_CHECKING, Union
+
+from .base_model import BaseModel
+from .base_type import BaseType
+from .imports import FileImport, ImportType
+from .primitive_types import BinaryType, BinaryIteratorType
+from .dictionary_type import DictionaryType
+from .list_type import ListType
+from .model_type import ModelType
+
+if TYPE_CHECKING:
+    from .code_model import CodeModel
+
+
+class ResponseHeader(BaseModel):
+    def __init__(
+        self, yaml_data: Dict[str, Any], code_model: "CodeModel", type: BaseType
+    ) -> None:
+        super().__init__(yaml_data, code_model)
+        self.rest_api_name: str = yaml_data["restApiName"]
+        self.type = type
+
+    @property
+    def serialization_type(self) -> str:
+        return self.type.serialization_type
+
+    @classmethod
+    def from_yaml(
+        cls, yaml_data: Dict[str, Any], code_model: "CodeModel"
+    ) -> "ResponseHeader":
+        return cls(
+            yaml_data=yaml_data,
+            code_model=code_model,
+            type=code_model.lookup_type(id(yaml_data["type"])),
+        )
+
+
+class Response(BaseModel):
+    def __init__(
+        self,
+        yaml_data: Dict[str, Any],
+        code_model: "CodeModel",
+        *,
+        headers: List[ResponseHeader] = [],
+        type: Optional[BaseType] = None,
+    ) -> None:
+        super().__init__(yaml_data=yaml_data, code_model=code_model)
+        self.status_codes: List[Union[int, str]] = yaml_data["statusCodes"]
+        self.headers = headers
+        self.type = type
+        self.nullable = yaml_data.get("nullable")
+
+    def get_json_template_representation(self) -> Any:
+        if not self.type:
+            return None
+        if not isinstance(self.type, (DictionaryType, ListType, ModelType)):
+            return None
+        return self.type.get_json_template_representation()
+
+    @property
+    def is_stream_response(self) -> bool:
+        """Is the response expected to be streamable, like a download."""
+        return isinstance(self.type, BinaryIteratorType)
+
+    @property
+    def serialization_type(self) -> str:
+        if self.type:
+            return self.type.serialization_type
+        return "None"
+
+    def type_annotation(self, **kwargs: Any) -> str:
+        if self.type:
+            kwargs["is_operation_file"] = True
+            type_annot = self.type.type_annotation(**kwargs)
+            if self.nullable:
+                return f"Optional[{type_annot}]"
+            return type_annot
+        return "None"
+
+    def docstring_text(self, **kwargs: Any) -> str:
+        if self.nullable and self.type:
+            return f"{self.type.docstring_text(**kwargs)} or None"
+        return self.type.docstring_text(**kwargs) if self.type else "None"
+
+    def docstring_type(self, **kwargs: Any) -> str:
+        if self.nullable and self.type:
+            return f"{self.type.docstring_type(**kwargs)} or None"
+        return self.type.docstring_type(**kwargs) if self.type else "None"
+
+    def _imports_shared(self, **kwargs: Any) -> FileImport:
+        file_import = FileImport()
+        if self.type:
+            file_import.merge(self.type.imports(is_operation_file=True, **kwargs))
+        if self.nullable:
+            file_import.add_submodule_import("typing", "Optional", ImportType.STDLIB)
+        return file_import
+
+    def imports(self, **kwargs: Any) -> FileImport:
+        return self._imports_shared(**kwargs)
+
+    def imports_for_multiapi(self, **kwargs: Any) -> FileImport:
+        return self._imports_shared(**kwargs)
+
+    @classmethod
+    def from_yaml(
+        cls, yaml_data: Dict[str, Any], code_model: "CodeModel"
+    ) -> "Response":
+        type = (
+            code_model.lookup_type(id(yaml_data["type"]))
+            if yaml_data.get("type")
+            else None
+        )
+        # use ByteIteratorType if we are returning a binary type
+        if isinstance(type, BinaryType):
+            type = BinaryIteratorType(type.yaml_data, type.code_model)
+        return cls(
+            yaml_data=yaml_data,
+            code_model=code_model,
+            headers=[
+                ResponseHeader.from_yaml(header, code_model)
+                for header in yaml_data["headers"]
+            ],
+            type=type,
+        )
+
+    def __repr__(self) -> str:
+        return f"<{self.__class__.__name__} {self.status_codes}>"
+
+
+class PagingResponse(Response):
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+        self.item_type = self.code_model.lookup_type(id(self.yaml_data["itemType"]))
+
+    def get_json_template_representation(self) -> Any:
+        return self.item_type.get_json_template_representation()
+
+    def get_pager_path(self, async_mode: bool) -> str:
+        return (
+            self.yaml_data["pagerAsync"] if async_mode else self.yaml_data["pagerSync"]
+        )
+
+    def get_pager(self, async_mode: bool) -> str:
+        return self.get_pager_path(async_mode).split(".")[-1]
+
+    def type_annotation(self, **kwargs: Any) -> str:
+        iterable = "AsyncIterable" if kwargs["async_mode"] else "Iterable"
+        return f"{iterable}[{self.item_type.type_annotation(**kwargs)}]"
+
+    def docstring_text(self, **kwargs: Any) -> str:
+        base_description = "An iterator like instance of "
+        if not self.code_model.options["version_tolerant"]:
+            base_description += "either "
+        return base_description + self.item_type.docstring_text(**kwargs)
+
+    def docstring_type(self, **kwargs: Any) -> str:
+        return f"~{self.get_pager_path(kwargs['async_mode'])}[{self.item_type.docstring_type(**kwargs)}]"
+
+    def _imports_shared(self, **kwargs: Any) -> FileImport:
+        file_import = super()._imports_shared(**kwargs)
+        async_mode = kwargs.pop("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)
+        return file_import
+
+    def imports(self, **kwargs: Any) -> FileImport:
+        file_import = self._imports_shared(**kwargs)
+        async_mode = kwargs.pop("async_mode")
+        if async_mode:
+            file_import.add_submodule_import(
+                "azure.core.async_paging", "AsyncList", ImportType.AZURECORE
+            )
+
+        return file_import
+
+    def imports_for_multiapi(self, **kwargs: Any) -> FileImport:
+        return self._imports_shared(**kwargs)
+
+
+class LROResponse(Response):
+    def get_poller_path(self, async_mode: bool) -> str:
+        return (
+            self.yaml_data["pollerAsync"]
+            if async_mode
+            else self.yaml_data["pollerSync"]
+        )
+
+    def get_poller(self, async_mode: bool) -> str:
+        """Get the name of the poller. Default is LROPoller / AsyncLROPoller"""
+        return self.get_poller_path(async_mode).split(".")[-1]
+
+    def get_polling_method_path(self, async_mode: bool) -> str:
+        """Get the full name of the poller path. Default are the azure core pollers"""
+        return (
+            self.yaml_data["pollingMethodAsync"]
+            if async_mode
+            else self.yaml_data["pollingMethodSync"]
+        )
+
+    def get_polling_method(self, async_mode: bool) -> str:
+        """Get the default pollint method"""
+        return self.get_polling_method_path(async_mode).split(".")[-1]
+
+    @staticmethod
+    def get_no_polling_method_path(async_mode: bool) -> str:
+        """Get the path of the default of no polling method"""
+        return f"azure.core.polling.{'Async' if async_mode else ''}NoPolling"
+
+    def get_no_polling_method(self, async_mode: bool) -> str:
+        """Get the default no polling method"""
+        return self.get_no_polling_method_path(async_mode).split(".")[-1]
+
+    @staticmethod
+    def get_base_polling_method_path(async_mode: bool) -> str:
+        """Get the base polling method path. Used in docstrings and type annotations."""
+        return f"azure.core.polling.{'Async' if async_mode else ''}PollingMethod"
+
+    def get_base_polling_method(self, async_mode: bool) -> str:
+        """Get the base polling method."""
+        return self.get_base_polling_method_path(async_mode).split(".")[-1]
+
+    def type_annotation(self, **kwargs: Any) -> str:
+        return f"{self.get_poller(kwargs.pop('async_mode'))}[{super().type_annotation(**kwargs)}]"
+
+    def docstring_type(self, **kwargs: Any) -> str:
+        return f"~{self.get_poller_path(kwargs.pop('async_mode'))}[{super().docstring_type(**kwargs)}]"
+
+    def docstring_text(self, **kwargs) -> str:
+        super_text = super().docstring_text(**kwargs)
+        base_description = (
+            f"An instance of {self.get_poller(kwargs.pop('async_mode'))} that returns "
+        )
+        if not self.code_model.options["version_tolerant"]:
+            base_description += "either "
+        return base_description + super_text
+
+    def _imports_shared(self, **kwargs: Any) -> FileImport:
+        file_import = super()._imports_shared(**kwargs)
+        async_mode = kwargs["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
+        )
+        return file_import
+
+    def imports(self, **kwargs: Any) -> FileImport:
+        file_import = self._imports_shared(**kwargs)
+        async_mode = kwargs["async_mode"]
+
+        default_polling_method_import_path = ".".join(
+            self.get_polling_method_path(async_mode).split(".")[:-1]
+        )
+        default_polling_method = self.get_polling_method(async_mode)
+        file_import.add_submodule_import(
+            default_polling_method_import_path,
+            default_polling_method,
+            ImportType.AZURECORE,
+        )
+        default_no_polling_method_import_path = ".".join(
+            self.get_no_polling_method_path(async_mode).split(".")[:-1]
+        )
+        default_no_polling_method = self.get_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
+        )
+        return file_import
+
+    def imports_for_multiapi(self, **kwargs: Any) -> FileImport:
+        return self._imports_shared(**kwargs)
+
+
+class LROPagingResponse(LROResponse, PagingResponse):
+    def type_annotation(self, **kwargs: Any) -> str:
+        paging_type_annotation = PagingResponse.type_annotation(self, **kwargs)
+        return f"{self.get_poller(kwargs.pop('async_mode'))}[{paging_type_annotation}]"
+
+    def docstring_type(self, **kwargs: Any) -> str:
+        paging_docstring_type = PagingResponse.docstring_type(self, **kwargs)
+        return f"~{self.get_poller_path(kwargs.pop('async_mode'))}[{paging_docstring_type}]"
+
+    def docstring_text(self, **kwargs) -> str:
+        base_description = (
+            "An instance of LROPoller that returns an iterator like instance of "
+        )
+        if not self.code_model.options["version_tolerant"]:
+            base_description += "either "
+        return base_description + Response.docstring_text(self)
+
+    def imports_for_multiapi(self, **kwargs: Any) -> FileImport:
+        file_import = LROResponse.imports_for_multiapi(self, **kwargs)
+        file_import.merge(PagingResponse.imports_for_multiapi(self, **kwargs))
+        return file_import
+
+    def imports(self, **kwargs: Any) -> FileImport:
+        file_import = LROResponse.imports(self, **kwargs)
+        file_import.merge(PagingResponse.imports(self, **kwargs))
+        return file_import
+
+
+def get_response(yaml_data: Dict[str, Any], code_model: "CodeModel") -> Response:
+    if yaml_data["discriminator"] == "lropaging":
+        return LROPagingResponse.from_yaml(yaml_data, code_model)
+    if yaml_data["discriminator"] == "lro":
+        return LROResponse.from_yaml(yaml_data, code_model)
+    if yaml_data["discriminator"] == "paging":
+        return PagingResponse.from_yaml(yaml_data, code_model)
+    return Response.from_yaml(yaml_data, code_model)

package/autorest/codegen/models/utils.py

@@ -4,25 +4,21 @@
 # license information.
 # --------------------------------------------------------------------------
 import re
-from typing import Any, TYPE_CHECKING
-import logging
-from .base_schema import BaseSchema
+from typing import TypeVar, Dict
 
-if TYPE_CHECKING:
-    from .code_model import CodeModel
+JSON_REGEXP = re.compile(r"^(application|text)/(.+\+)?json$")
 
+T = TypeVar("T")
+OrderedSet = Dict[T, None]
 
-_LOGGER = logging.getLogger(__name__)
 
-JSON_REGEXP = re.compile(r'^(application|text)/(.+\+)?json$')
+def add_to_description(description: str, entry: str) -> str:
+    if description:
+        return f"{description} {entry}"
+    return entry
 
-def get_schema(code_model: "CodeModel", schema: Any, serialized_name: str = "unknown") -> BaseSchema:
-    if not isinstance(schema, dict):
-        return schema
-    schema_id = id(schema)
-    _LOGGER.debug("Looking for id %s for member %s", schema_id, serialized_name)
-    try:
-        return code_model.lookup_schema(schema_id)
-    except KeyError:
-        _LOGGER.critical("Unable to ref the object")
-        raise
+
+def add_to_pylint_disable(curr_str: str, entry: str) -> str:
+    if curr_str:
+        return f"{curr_str},{entry}"
+    return f"  # pylint: disable={entry}"