@autorest/python 5.16.0 → 5.17.0

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.17.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.26"
     },
     "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/enum_schema.py

@@ -1,225 +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, List, Optional, Set, Type, TYPE_CHECKING
-from .base_schema import BaseSchema
-from .primitive_schemas import PrimitiveSchema, get_primitive_schema, StringSchema
-from .imports import FileImport, ImportType, TypingSection
-
-if TYPE_CHECKING:
-    from .code_model import CodeModel
-
-
-class EnumValue:
-    """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, name: str, value: str, description: Optional[str] = None
-    ) -> None:
-        self.name = name
-        self.value = value
-        self.description = description
-
-    @classmethod
-    def from_yaml(cls, yaml_data: Dict[str, Any]) -> "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(
-            name=yaml_data["language"]["python"]["name"],
-            value=yaml_data["value"],
-            description=yaml_data["language"]["python"].get("description"),
-        )
-
-
-class EnumSchema(BaseSchema):
-    """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.PrimitiveSchema
-    :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",
-        description: str,
-        name: str,
-        values: List["EnumValue"],
-        enum_type: PrimitiveSchema,
-    ) -> None:
-        super().__init__(yaml_data=yaml_data, code_model=code_model)
-        self.description = description
-        self.name = name
-        self.values = values
-        self.enum_type = enum_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.enum_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'Union[{self.enum_type.type_annotation(is_operation_file=is_operation_file)}, "_models.{self.name}"]'
-
-    def get_declaration(self, value: Any) -> str:
-        return self.enum_type.get_declaration(value)
-
-    @property
-    def docstring_text(self) -> str:
-        return self.name
-
-    @property
-    def docstring_type(self) -> str:
-        """The python type used for RST syntax input and type annotation."""
-        return f"{self.enum_type.type_annotation()} or ~{self.code_model.namespace}.models.{self.name}"
-
-    @staticmethod
-    def _get_enum_values(yaml_data: List[Dict[str, Any]]) -> List["EnumValue"]:
-        """Creates the list of values for this enum.
-
-        :param yaml_data: yaml data about the enum's values
-        :type yaml_data: dict[str, Any]
-        :return: The list of values for this enum
-        :rtype: list[~autorest.models.EnumValue]
-        """
-        values = []
-        seen_enums: Set[str] = set()
-
-        for enum in yaml_data:
-            enum_name = enum["language"]["python"]["name"]
-            if enum_name in seen_enums:
-                continue
-            values.append(EnumValue.from_yaml(enum))
-            seen_enums.add(enum_name)
-        return values
-
-    def _template_kwargs(self, **kwargs: Any) -> Any:
-        if len(self.values) == 1 and not kwargs.get("default_value_declaration"):
-            kwargs["default_value_declaration"] = self.enum_type.get_declaration(
-                self.values[0].value
-            )
-        description = kwargs.pop("description", "")
-        kwargs["description"] = description
-        return kwargs
-
-    def get_json_template_representation(self, **kwargs: Any) -> Any:
-        # for better display effect, use the only value instead of var type
-        return self.enum_type.get_json_template_representation(
-            **self._template_kwargs(**kwargs)
-        )
-
-    @classmethod
-    def from_yaml(
-        cls, yaml_data: Dict[str, Any], code_model: "CodeModel"
-    ) -> "EnumSchema":
-        """Constructs an EnumSchema 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 EnumSchema
-        :rtype: ~autorest.models.EnumSchema
-        """
-        name = yaml_data["language"]["python"]["name"]
-
-        # choice type doesn't always exist. if there is no choiceType, we default to string
-        if yaml_data.get("choiceType"):
-            enum_type = get_primitive_schema(yaml_data["choiceType"], code_model)
-        else:
-            enum_type = StringSchema({"type": "str"}, code_model)
-        values = EnumSchema._get_enum_values(yaml_data["choices"])
-        return cls(
-            yaml_data=yaml_data,
-            code_model=code_model,
-            description=yaml_data["language"]["python"]["description"],
-            name=name,
-            values=values,
-            enum_type=enum_type,
-        )
-
-    def imports(self) -> FileImport:
-        file_import = FileImport()
-        file_import.add_submodule_import(
-            "typing", "Union", ImportType.STDLIB, TypingSection.CONDITIONAL
-        )
-        file_import.merge(self.enum_type.imports())
-        return file_import
-
-
-class HiddenModelEnumSchema(EnumSchema):
-    def imports(self) -> FileImport:
-        file_import = FileImport()
-        file_import.merge(self.enum_type.imports())
-        return file_import
-
-    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 self.enum_type.type_annotation(is_operation_file=is_operation_file)
-
-    @property
-    def docstring_text(self) -> str:
-        return (
-            f"{self.enum_type.type_annotation()}. {self.extra_description_information}"
-        )
-
-    @property
-    def extra_description_information(self):
-        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 = " or ".join(possible_values)
-        else:
-            possible_values_str = (
-                ", ".join(possible_values[: len(possible_values) - 1])
-                + f", and {possible_values[-1]}"
-            )
-
-        return "Known values are: {}.".format(possible_values_str)
-
-    @property
-    def docstring_type(self) -> str:
-        """The python type used for RST syntax input and type annotation."""
-        return self.enum_type.type_annotation()
-
-
-def get_enum_schema(code_model) -> Type[EnumSchema]:
-    if code_model.options["models_mode"]:
-        return EnumSchema
-    return HiddenModelEnumSchema