@autorest/python 5.16.0 → 5.19.0

package/autorest/preprocess/__init__.py

@@ -0,0 +1,210 @@
+# -------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for
+# license information.
+# --------------------------------------------------------------------------
+"""The preprocessing autorest plugin.
+"""
+from typing import Callable, Dict, Any, List, Optional
+from .helpers import to_snake_case, pad_reserved_words, add_redefined_builtin_info
+from .python_mappings import PadType
+
+from .. import YamlUpdatePlugin
+
+
+def update_description(
+    description: Optional[str], default_description: str = ""
+) -> str:
+    if not description:
+        description = default_description
+    description.rstrip(" ")
+    if description and description[-1] != ".":
+        description += "."
+    return description
+
+
+def update_operation_group_class_name(
+    yaml_data: Dict[str, Any], class_name: str
+) -> str:
+    if class_name == "":
+        return yaml_data["client"]["name"] + "OperationsMixin"
+    if class_name == "Operations":
+        return "Operations"
+    return class_name + "Operations"
+
+
+def update_parameter(yaml_data: Dict[str, Any]) -> None:
+    yaml_data["description"] = update_description(yaml_data["description"])
+    if not (
+        yaml_data["location"] == "header"
+        and yaml_data["clientName"] in ("content_type", "accept")
+    ):
+        yaml_data["clientName"] = pad_reserved_words(
+            yaml_data["clientName"].lower(), PadType.PARAMETER
+        )
+    if yaml_data.get("propertyToParameterName"):
+        # need to create a new one with padded keys and values
+        yaml_data["propertyToParameterName"] = {
+            pad_reserved_words(prop, PadType.PROPERTY)
+            .lower(): pad_reserved_words(param_name, PadType.PARAMETER)
+            .lower()
+            for prop, param_name in yaml_data["propertyToParameterName"].items()
+        }
+
+
+def update_types(yaml_data: List[Dict[str, Any]]) -> None:
+    for type in yaml_data:
+        for property in type.get("properties", []):
+            property["description"] = update_description(property["description"])
+            property["clientName"] = pad_reserved_words(
+                property["clientName"].lower(), PadType.PROPERTY
+            )
+            add_redefined_builtin_info(property["clientName"], property)
+        if type.get("name"):
+            type["description"] = update_description(type["description"], type["name"])
+            type["snakeCaseName"] = to_snake_case(type["name"])
+
+
+def update_client(yaml_data: Dict[str, Any]) -> None:
+    yaml_data["description"] = update_description(
+        yaml_data["description"], default_description=yaml_data["name"]
+    )
+    yaml_data["moduleName"] = to_snake_case(yaml_data["name"].replace(" ", "_"))
+    for parameter in yaml_data["parameters"]:
+        update_parameter(parameter)
+
+
+def update_paging_response(yaml_data: Dict[str, Any]) -> None:
+    yaml_data["discriminator"] = "paging"
+    yaml_data["pagerSync"] = yaml_data.get("pagerSync") or "azure.core.paging.ItemPaged"
+    yaml_data["pagerAsync"] = (
+        yaml_data.get("pagerAsync") or "azure.core.async_paging.AsyncItemPaged"
+    )
+
+
+class PreProcessPlugin(YamlUpdatePlugin):
+    """Add Python naming information."""
+
+    def get_operation_updater(
+        self, yaml_data: Dict[str, Any]
+    ) -> Callable[[Dict[str, Any]], None]:
+        if yaml_data["discriminator"] == "lropaging":
+            return self.update_lro_paging_operation
+        if yaml_data["discriminator"] == "lro":
+            return self.update_lro_operation
+        if yaml_data["discriminator"] == "paging":
+            return self.update_paging_operation
+        return self.update_operation
+
+    def update_operation(self, yaml_data: Dict[str, Any]) -> None:
+        yaml_data["groupName"] = pad_reserved_words(
+            yaml_data["groupName"], PadType.OPERATION_GROUP
+        )
+        yaml_data["groupName"] = to_snake_case(yaml_data["groupName"])
+        yaml_data["name"] = yaml_data["name"].lower()
+        yaml_data["name"] = pad_reserved_words(yaml_data["name"], PadType.METHOD)
+        yaml_data["description"] = update_description(
+            yaml_data["description"], yaml_data["name"]
+        )
+        yaml_data["summary"] = update_description(yaml_data.get("summary", ""))
+        for parameter in yaml_data["parameters"]:
+            update_parameter(parameter)
+        if yaml_data.get("bodyParameter"):
+            update_parameter(yaml_data["bodyParameter"])
+            for entry in yaml_data["bodyParameter"].get("entries", []):
+                update_parameter(entry)
+        for overload in yaml_data.get("overloads", []):
+            self.update_operation(overload)
+        for response in yaml_data.get("responses", []):
+            response["discriminator"] = "operation"
+
+    def _update_lro_operation_helper(self, yaml_data: Dict[str, Any]) -> None:
+        azure_arm = self._autorestapi.get_boolean_value("azure-arm", False)
+        for response in yaml_data.get("responses", []):
+            response["discriminator"] = "lro"
+            response["pollerSync"] = (
+                response.get("pollerSync") or "azure.core.polling.LROPoller"
+            )
+            response["pollerAsync"] = (
+                response.get("pollerAsync") or "azure.core.polling.AsyncLROPoller"
+            )
+            if not response.get("pollingMethodSync"):
+                response["pollingMethodSync"] = (
+                    "azure.mgmt.core.polling.arm_polling.ARMPolling"
+                    if azure_arm
+                    else "azure.core.polling.base_polling.LROBasePolling"
+                )
+            if not response.get("pollingMethodAsync"):
+                response["pollingMethodAsync"] = (
+                    "azure.mgmt.core.polling.async_arm_polling.AsyncARMPolling"
+                    if azure_arm
+                    else "azure.core.polling.async_base_polling.AsyncLROBasePolling"
+                )
+
+    def update_lro_paging_operation(self, yaml_data: Dict[str, Any]) -> None:
+        self.update_lro_operation(yaml_data)
+        self.update_paging_operation(yaml_data)
+        for response in yaml_data.get("responses", []):
+            response["discriminator"] = "lropaging"
+
+    def update_lro_operation(self, yaml_data: Dict[str, Any]) -> None:
+        self.update_operation(yaml_data)
+        self._update_lro_operation_helper(yaml_data)
+        for overload in yaml_data["overloads"]:
+            self._update_lro_operation_helper(overload)
+
+    def update_paging_operation(self, yaml_data: Dict[str, Any]) -> None:
+        self.update_operation(yaml_data)
+        if not yaml_data.get("pagerSync"):
+            yaml_data["pagerSync"] = "azure.core.paging.ItemPaged"
+        if not yaml_data.get("pagerAsync"):
+            yaml_data["pagerAsync"] = "azure.core.async_paging.AsyncItemPaged"
+        returned_response_object = (
+            yaml_data["nextOperation"]["responses"][0]
+            if yaml_data.get("nextOperation")
+            else yaml_data["responses"][0]
+        )
+        # if we're in version tolerant, hide the paging model
+        if self._autorestapi.get_boolean_value("version-tolerant"):
+            returned_response_object["type"]["isPublic"] = False
+        item_type = next(
+            p["type"]["elementType"]
+            for p in returned_response_object["type"]["properties"]
+            if p["restApiName"] == yaml_data["itemName"]
+        )
+        if yaml_data.get("nextOperation"):
+            yaml_data["nextOperation"]["groupName"] = pad_reserved_words(
+                yaml_data["nextOperation"]["groupName"], PadType.OPERATION_GROUP
+            )
+            yaml_data["nextOperation"]["groupName"] = to_snake_case(
+                yaml_data["nextOperation"]["groupName"]
+            )
+            for response in yaml_data["nextOperation"].get("responses", []):
+                update_paging_response(response)
+                response["itemType"] = item_type
+        for response in yaml_data.get("responses", []):
+            update_paging_response(response)
+            response["itemType"] = item_type
+        for overload in yaml_data.get("overloads", []):
+            self.update_paging_operation(overload)
+
+    def update_operation_groups(self, yaml_data: Dict[str, Any]) -> None:
+        operation_groups_yaml_data = yaml_data["operationGroups"]
+        for operation_group in operation_groups_yaml_data:
+            operation_group["propertyName"] = pad_reserved_words(
+                operation_group["propertyName"], PadType.OPERATION_GROUP
+            )
+            operation_group["propertyName"] = to_snake_case(
+                operation_group["propertyName"]
+            )
+            operation_group["className"] = update_operation_group_class_name(
+                yaml_data, operation_group["className"]
+            )
+            for operation in operation_group["operations"]:
+                self.get_operation_updater(operation)(operation)
+
+    def update_yaml(self, yaml_data: Dict[str, Any]) -> None:
+        """Convert in place the YAML str."""
+        update_client(yaml_data["client"])
+        update_types(yaml_data["types"])
+        self.update_operation_groups(yaml_data)

package/autorest/preprocess/helpers.py

@@ -0,0 +1,54 @@
+# -------------------------------------------------------------------------
+# 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
+import re
+from .python_mappings import PadType, RESERVED_WORDS, REDEFINED_BUILTINS
+
+
+def to_snake_case(name: str) -> str:
+    def replace_upper_characters(m) -> str:
+        match_str = m.group().lower()
+        if m.start() > 0 and name[m.start() - 1] == "_":
+            # we are good if a '_' already exists
+            return match_str
+        # the first letter should not have _
+        prefix = "_" if m.start() > 0 else ""
+
+        # we will add an extra _ if there are multiple upper case chars together
+        next_non_upper_case_char_location = m.start() + len(match_str)
+        if (
+            len(match_str) > 2
+            and len(name) - next_non_upper_case_char_location > 1
+            and name[next_non_upper_case_char_location].isalpha()
+        ):
+
+            return (
+                prefix
+                + match_str[: len(match_str) - 1]
+                + "_"
+                + match_str[len(match_str) - 1]
+            )
+
+        return prefix + match_str
+
+    return re.sub("[A-Z]+", replace_upper_characters, name)
+
+
+def pad_reserved_words(name: str, pad_type: PadType):
+    # we want to pad hidden variables as well
+    if not name:
+        # we'll pass in empty operation groups sometime etc.
+        return name
+    name_prefix = "_" if name[0] == "_" else ""
+    name = name[1:] if name[0] == "_" else name
+    if name.lower() in RESERVED_WORDS[pad_type]:
+        return name_prefix + name + pad_type
+    return name_prefix + name
+
+
+def add_redefined_builtin_info(name: str, yaml_data: Dict[str, Any]) -> None:
+    if name in REDEFINED_BUILTINS:
+        yaml_data["pylintDisable"] = "redefined-builtin"

package/autorest/{namer → preprocess}/python_mappings.py

@@ -51,14 +51,13 @@ basic_latin_chars = {
 }
 
 
-class PadType(Enum):
-    Model = "Model"
-    Method = "Method"
-    Parameter = "Parameter"
-    Enum = "Enum"
-    Property = "Property"
-    OperationGroup = "Operations"
-    BuilderGroup = "Builders"
+class PadType(str, Enum):
+    MODEL = "Model"
+    METHOD = "_method"
+    PARAMETER = "_parameter"
+    ENUM = "_enum"
+    PROPERTY = "_property"
+    OPERATION_GROUP = "Operations"
 
 
 _always_reserved = [
@@ -96,9 +95,9 @@ _always_reserved = [
     "await",
 ]
 
-reserved_words = {
-    PadType.Method: [*_always_reserved],
-    PadType.Parameter: [
+RESERVED_WORDS = {
+    PadType.METHOD: [*_always_reserved],
+    PadType.PARAMETER: [
         "self",
         # these are kwargs we've reserved for our autorest generated operations
         "content_type",
@@ -163,9 +162,15 @@ reserved_words = {
         "retry_on_status_codes",
         *_always_reserved,
     ],
-    PadType.Model: [*_always_reserved],
-    PadType.Property: ["self", *_always_reserved],
-    PadType.Enum: ["mro", *_always_reserved],
-    PadType.OperationGroup: [*_always_reserved],
-    PadType.BuilderGroup: [*_always_reserved],
+    PadType.MODEL: [*_always_reserved],
+    PadType.PROPERTY: ["self", *_always_reserved],
+    PadType.ENUM: ["mro", *_always_reserved],
+    PadType.OPERATION_GROUP: [*_always_reserved],
 }
+
+REDEFINED_BUILTINS = [  # we don't pad, but we need to do lint ignores
+    "id",
+    "min",
+    "max",
+    "filter",
+]

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@autorest/python",
-    "version": "5.16.0",
+    "version": "5.19.0",
     "description": "The Python extension for generators in AutoRest.",
     "scripts": {
         "prepare": "node run-python3.js prepare.py",
@@ -27,7 +27,7 @@
         "@autorest/system-requirements": "~1.0.0"
     },
     "devDependencies": {
-        "@microsoft.azure/autorest.testserver": "3.3.23"
+        "@microsoft.azure/autorest.testserver": "^3.3.28"
     },
     "files": [
         "autorest/**/*.py",

package/autorest/codegen/models/credential_model.py

@@ -1,55 +0,0 @@
-# -------------------------------------------------------------------------
-# 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 Set, Optional, Type
-from .credential_schema_policy import (
-    CredentialSchemaPolicy,
-    BearerTokenCredentialPolicy,
-)
-from .credential_schema_policy import ARMChallengeAuthenticationPolicy
-from .credential_schema import TokenCredentialSchema, AzureKeyCredentialSchema
-
-
-class CredentialModel:
-    """Store info about credential."""
-
-    def __init__(self, azure_arm: bool) -> None:
-        self.azure_arm: bool = azure_arm
-        self.credential_scopes: Set[str] = set()
-        self.key_header_name: str = ""
-        self.policy_type: Optional[Type[CredentialSchemaPolicy]] = None
-        self._credential_schema_policy: Optional[CredentialSchemaPolicy] = None
-
-    @property
-    def default_authentication_policy(self) -> Type[CredentialSchemaPolicy]:
-        return (
-            ARMChallengeAuthenticationPolicy
-            if self.azure_arm
-            else BearerTokenCredentialPolicy
-        )
-
-    @property
-    def credential_schema_policy(self) -> CredentialSchemaPolicy:
-        if not self._credential_schema_policy:
-            raise ValueError(
-                "You want to find the Credential Schema Policy, but have not given a value"
-            )
-        return self._credential_schema_policy
-
-    def build_authentication_policy(self):
-        if hasattr(self.policy_type, "credential_scopes"):
-            self._credential_schema_policy = (
-                self.policy_type(  # pylint: disable=not-callable
-                    credential=TokenCredentialSchema(async_mode=False),
-                    credential_scopes=list(self.credential_scopes),
-                )
-            )
-        elif hasattr(self.policy_type, "credential_key_header_name"):
-            self._credential_schema_policy = (
-                self.policy_type(  # pylint: disable=not-callable
-                    credential=AzureKeyCredentialSchema(),
-                    credential_key_header_name=self.key_header_name,
-                )
-            )

package/autorest/codegen/models/credential_schema.py

@@ -1,95 +0,0 @@
-# -------------------------------------------------------------------------
-# 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
-from .base_schema import BaseSchema
-from .imports import FileImport, ImportType, TypingSection
-
-
-class CredentialSchema(BaseSchema):
-    def __init__(self) -> None:  # pylint: disable=super-init-not-called
-        self.default_value = None
-
-    def type_annotation(self, *, is_operation_file: bool = False) -> str:
-        raise ValueError("Children classes should set their own type annotation")
-
-    @property
-    def docstring_type(self) -> str:
-        return self.serialization_type
-
-    @property
-    def docstring_text(self) -> str:
-        return "credential"
-
-    @property
-    def serialization_type(self) -> str:
-        # this property is added, because otherwise pylint says that
-        # abstract serialization_type in BaseSchema is not overridden
-        pass
-
-    def get_json_template_representation(self, **kwargs: Any) -> Any:
-        raise TypeError(
-            "You should not try to get a JSON template representation of a CredentialSchema"
-        )
-
-
-class AzureKeyCredentialSchema(CredentialSchema):
-    @property
-    def serialization_type(self) -> str:
-        return "~azure.core.credentials.AzureKeyCredential"
-
-    def type_annotation(
-        self, *, is_operation_file: bool = False  # pylint: disable=unused-argument
-    ) -> str:
-        return "AzureKeyCredential"
-
-    def imports(self) -> FileImport:
-        file_import = FileImport()
-        file_import.add_submodule_import(
-            "azure.core.credentials",
-            "AzureKeyCredential",
-            ImportType.AZURECORE,
-            typing_section=TypingSection.CONDITIONAL,
-        )
-        return file_import
-
-
-class TokenCredentialSchema(CredentialSchema):
-    def __init__(self, async_mode) -> None:
-        super().__init__()
-        self.async_mode = async_mode
-        self.async_type = "~azure.core.credentials_async.AsyncTokenCredential"
-        self.sync_type = "~azure.core.credentials.TokenCredential"
-
-    @property
-    def serialization_type(self) -> str:
-        if self.async_mode:
-            return self.async_type
-        return self.sync_type
-
-    def type_annotation(
-        self, *, is_operation_file: bool = False  # pylint: disable=unused-argument
-    ) -> str:
-        if self.async_mode:
-            return '"AsyncTokenCredential"'
-        return '"TokenCredential"'
-
-    def imports(self) -> FileImport:
-        file_import = FileImport()
-        if self.async_mode:
-            file_import.add_submodule_import(
-                "azure.core.credentials_async",
-                "AsyncTokenCredential",
-                ImportType.AZURECORE,
-                typing_section=TypingSection.TYPING,
-            )
-        else:
-            file_import.add_submodule_import(
-                "azure.core.credentials",
-                "TokenCredential",
-                ImportType.AZURECORE,
-                typing_section=TypingSection.TYPING,
-            )
-        return file_import

package/autorest/codegen/models/credential_schema_policy.py

@@ -1,73 +0,0 @@
-# -------------------------------------------------------------------------
-# Copyright (c) Microsoft Corporation. All rights reserved.
-# Licensed under the MIT License. See License.txt in the project root for
-# license information.
-# --------------------------------------------------------------------------
-from abc import abstractmethod
-from typing import List
-from .credential_schema import CredentialSchema
-
-
-class CredentialSchemaPolicy:
-    def __init__(self, credential: CredentialSchema) -> None:
-        self.credential = credential
-
-    @abstractmethod
-    def call(self, async_mode: bool) -> str:
-        ...
-
-    @classmethod
-    def name(cls):
-        return cls.__name__
-
-
-class BearerTokenCredentialPolicy(CredentialSchemaPolicy):
-    def __init__(
-        self, credential: CredentialSchema, credential_scopes: List[str]
-    ) -> None:
-        super().__init__(credential)
-        self._credential_scopes = credential_scopes
-
-    @property
-    def credential_scopes(self):
-        return self._credential_scopes
-
-    def call(self, async_mode: bool) -> str:
-        policy_name = f"Async{self.name()}" if async_mode else self.name()
-        return f"policies.{policy_name}(self.credential, *self.credential_scopes, **kwargs)"
-
-
-class ARMChallengeAuthenticationPolicy(BearerTokenCredentialPolicy):
-    def call(self, async_mode: bool) -> str:
-        policy_name = f"Async{self.name()}" if async_mode else self.name()
-        return f"{policy_name}(self.credential, *self.credential_scopes, **kwargs)"
-
-
-class AzureKeyCredentialPolicy(CredentialSchemaPolicy):
-    def __init__(
-        self, credential: CredentialSchema, credential_key_header_name: str
-    ) -> None:
-        super().__init__(credential)
-        self._credential_key_header_name = credential_key_header_name
-
-    @property
-    def credential_key_header_name(self):
-        return self._credential_key_header_name
-
-    def call(self, async_mode: bool) -> str:
-        return f'policies.AzureKeyCredentialPolicy(self.credential, "{self.credential_key_header_name}", **kwargs)'
-
-
-def get_credential_schema_policy_type(name):
-    policies = [
-        ARMChallengeAuthenticationPolicy,
-        BearerTokenCredentialPolicy,
-        AzureKeyCredentialPolicy,
-    ]
-    try:
-        return next(p for p in policies if p.name().lower() == name.lower())
-    except StopIteration:
-        raise ValueError(
-            "The credential policy you pass in with --credential-default-policy-type must be either "
-            "{}".format(" or ".join([p.name() for p in policies]))
-        )

package/autorest/codegen/models/dictionary_schema.py

@@ -1,106 +0,0 @@
-# -------------------------------------------------------------------------
-# 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, TYPE_CHECKING
-from .base_schema import BaseSchema
-from .imports import FileImport, ImportType, TypingSection
-
-if TYPE_CHECKING:
-    from .code_model import CodeModel
-
-
-class DictionarySchema(BaseSchema):
-    """Schema for dictionaries that will be serialized.
-
-    :param yaml_data: the yaml data for this schema
-    :type yaml_data: dict[str, Any]
-    :param element_type: The type of the value for the dictionary
-    :type element_type: ~autorest.models.BaseSchema
-    """
-
-    def __init__(
-        self,
-        yaml_data: Dict[str, Any],
-        code_model: "CodeModel",
-        element_type: "BaseSchema",
-    ) -> None:
-        super().__init__(yaml_data=yaml_data, code_model=code_model)
-        self.element_type = element_type
-
-    @property
-    def serialization_type(self) -> str:
-        """Returns the serialization value for msrest.
-
-        :return: The serialization value for msrest
-        :rtype: str
-        """
-        return f"{{{self.element_type.serialization_type}}}"
-
-    def type_annotation(self, *, is_operation_file: bool = False) -> str:
-        """The python type used for type annotation
-
-        :return: The type annotation for this schema
-        :rtype: str
-        """
-        return f"Dict[str, {self.element_type.type_annotation(is_operation_file=is_operation_file)}]"
-
-    @property
-    def docstring_text(self) -> str:
-        return f"dict mapping str to {self.element_type.docstring_text}"
-
-    @property
-    def docstring_type(self) -> str:
-        """The python type used for RST syntax input and type annotation.
-
-        :param str namespace: Optional. The namespace for the models.
-        """
-        return f"dict[str, {self.element_type.docstring_type}]"
-
-    def xml_serialization_ctxt(self) -> Optional[str]:
-        raise NotImplementedError(
-            "Dictionary schema does not support XML serialization."
-        )
-
-    def get_json_template_representation(self, **kwargs: Any) -> Any:
-        return {
-            f'"{"str"}"': self.element_type.get_json_template_representation(**kwargs)
-        }
-
-    @classmethod
-    def from_yaml(
-        cls, yaml_data: Dict[str, Any], code_model: "CodeModel"
-    ) -> "DictionarySchema":
-        """Constructs a DictionarySchema 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 DictionarySchema
-        :rtype: ~autorest.models.DictionarySchema
-        """
-        element_schema = yaml_data["elementType"]
-
-        from . import build_schema  # pylint: disable=import-outside-toplevel
-
-        element_type = build_schema(yaml_data=element_schema, code_model=code_model)
-
-        return cls(
-            yaml_data=yaml_data,
-            code_model=code_model,
-            element_type=element_type,
-        )
-
-    def imports(self) -> FileImport:
-        file_import = FileImport()
-        file_import.add_submodule_import(
-            "typing", "Dict", ImportType.STDLIB, TypingSection.CONDITIONAL
-        )
-        file_import.merge(self.element_type.imports())
-        return file_import
-
-    def model_file_imports(self) -> FileImport:
-        file_import = self.imports()
-        file_import.merge(self.element_type.model_file_imports())
-        return file_import