@autorest/python 5.15.0 → 5.16.0

package/autorest/codegen/models/code_model.py

@@ -18,11 +18,11 @@ from .client import Client
 from .parameter_list import GlobalParameterList
 from .property import Property
 from .request_builder import RequestBuilder
-from .rest import Rest
 from .credential_model import CredentialModel
 
 _LOGGER = logging.getLogger(__name__)
 
+
 class CodeModel:  # pylint: disable=too-many-instance-attributes, too-many-public-methods
     """Holds all of the information we have parsed out of the yaml file. The CodeModel is what gets
     serialized by the serializers.
@@ -53,10 +53,16 @@ class CodeModel:  # pylint: disable=too-many-instance-attributes, too-many-publi
 
     def __init__(
         self,
+        yaml_data: Dict[str, Any],
         options: Dict[str, Any],
     ) -> None:
-        self.send_request_name = "send_request" if options['show_send_request'] else "_send_request"
-        self.rest_layer_name = "rest" if options["builders_visibility"] == "public" else "_rest"
+        self.yaml_data = yaml_data
+        self.send_request_name = (
+            "send_request" if options["show_send_request"] else "_send_request"
+        )
+        self.rest_layer_name = (
+            "rest" if options["builders_visibility"] == "public" else "_rest"
+        )
         self.options = options
         self.module_name: str = ""
         self.class_name: str = ""
@@ -71,8 +77,7 @@ class CodeModel:  # pylint: disable=too-many-instance-attributes, too-many-publi
         params = GlobalParameterList(self)
         params.code_model = self
         self.service_client: Client = Client(self, params)
-        self._rest: Optional[Rest] = None
-        self.request_builder_ids: Dict[int, RequestBuilder] = {}
+        self.request_builders: List[RequestBuilder] = []
         self.package_dependency: Dict[str, str] = {}
         self._credential_model: Optional[CredentialModel] = None
 
@@ -84,16 +89,6 @@ class CodeModel:  # pylint: disable=too-many-instance-attributes, too-many-publi
     def global_parameters(self, val: GlobalParameterList) -> None:
         self.service_client.parameters = val
 
-    @property
-    def rest(self) -> Rest:
-        if not self._rest:
-            raise ValueError("rest is None. Can not call it, you first have to set it.")
-        return self._rest
-
-    @rest.setter
-    def rest(self, p: Rest) -> None:
-        self._rest = p
-
     def lookup_schema(self, schema_id: int) -> BaseSchema:
         """Looks to see if the schema has already been created.
 
@@ -108,6 +103,30 @@ class CodeModel:  # pylint: disable=too-many-instance-attributes, too-many-publi
                     return elt_value
         raise KeyError("Didn't find it!!!!!")
 
+    def lookup_request_builder(self, request_builder_id: int) -> RequestBuilder:
+        """Find the request builder based off of id"""
+        try:
+            return next(
+                rb
+                for rb in self.request_builders
+                if id(rb.yaml_data) == request_builder_id
+            )
+        except StopIteration:
+            raise KeyError(f"No request builder with id {request_builder_id} found.")
+
+    @property
+    def exception_ids(self) -> Set[int]:
+        exceptions_set = set()
+        for group in self.yaml_data["operationGroups"]:
+            for operation in group["operations"]:
+                if not operation.get("exceptions"):
+                    continue
+                for exception in operation["exceptions"]:
+                    if not exception.get("schema"):
+                        continue
+                    exceptions_set.add(id(exception["schema"]))
+        return exceptions_set
+
     @staticmethod
     def _sort_schemas_helper(current, seen_schema_names, seen_schema_yaml_ids):
         if current.id in seen_schema_yaml_ids:
@@ -124,12 +143,16 @@ class CodeModel:  # pylint: disable=too-many-instance-attributes, too-many-publi
                     continue
                 seen_schema_names.add(current.name)
                 seen_schema_yaml_ids.add(current.id)
-                ancestors = CodeModel._sort_schemas_helper(parent, seen_schema_names, seen_schema_yaml_ids) + ancestors
+                ancestors = (
+                    CodeModel._sort_schemas_helper(
+                        parent, seen_schema_names, seen_schema_yaml_ids
+                    )
+                    + ancestors
+                )
         seen_schema_names.add(current.name)
         seen_schema_yaml_ids.add(current.id)
         return ancestors
 
-
     def sort_schemas(self) -> None:
         """Sorts the final object schemas by inheritance and by alphabetical order.
 
@@ -140,12 +163,17 @@ class CodeModel:  # pylint: disable=too-many-instance-attributes, too-many-publi
         seen_schema_yaml_ids: Set[int] = set()
         sorted_schemas: List[ObjectSchema] = []
         for schema in sorted(self.schemas.values(), key=lambda x: x.name.lower()):
-            sorted_schemas.extend(CodeModel._sort_schemas_helper(schema, seen_schema_names, seen_schema_yaml_ids))
+            sorted_schemas.extend(
+                CodeModel._sort_schemas_helper(
+                    schema, seen_schema_names, seen_schema_yaml_ids
+                )
+            )
         self.sorted_schemas = sorted_schemas
 
     def setup_client_input_parameters(self, yaml_data: Dict[str, Any]):
         dollar_host = [
-            parameter for parameter in self.global_parameters
+            parameter
+            for parameter in self.global_parameters
             if parameter.rest_api_name == "$host"
         ]
         if not dollar_host:
@@ -153,14 +181,18 @@ class CodeModel:  # pylint: disable=too-many-instance-attributes, too-many-publi
             # So far now, let's get the first one in the first operation
             # UGLY as hell.....
             if yaml_data.get("operationGroups"):
-                first_req_of_first_op_of_first_grp = yaml_data["operationGroups"][0]["operations"][0]["requests"][0]
+                first_req_of_first_op_of_first_grp = yaml_data["operationGroups"][0][
+                    "operations"
+                ][0]["requests"][0]
                 self.service_client.parameterized_host_template = (
                     first_req_of_first_op_of_first_grp["protocol"]["http"]["uri"]
                 )
         else:
             for host in dollar_host:
                 self.global_parameters.remove(host)
-            self.service_client.parameters.add_host(dollar_host[0].yaml_data["clientDefaultValue"])
+            self.service_client.parameters.add_host(
+                dollar_host[0].yaml_data["clientDefaultValue"]
+            )
 
     def format_lro_operations(self) -> None:
         """Adds operations and attributes needed for LROs.
@@ -177,8 +209,8 @@ class CodeModel:  # pylint: disable=too-many-instance-attributes, too-many-publi
                 i += 1
 
     def remove_next_operation(self) -> None:
-        """Linking paging operations together.
-        """
+        """Linking paging operations together."""
+
         def _lookup_operation(yaml_id: int) -> Operation:
             for operation_group in self.operation_groups:
                 for operation in operation_group.operations:
@@ -191,15 +223,21 @@ class CodeModel:  # pylint: disable=too-many-instance-attributes, too-many-publi
             for operation in operation_group.operations:
                 # when we add in "LRO" functions we don't include yaml_data, so yaml_data can be empty in these cases
                 next_link_yaml = None
-                if operation.yaml_data and operation.yaml_data['language']['python'].get('paging'):
-                    next_link_yaml = operation.yaml_data['language']['python']['paging'].get('nextLinkOperation')
+                if operation.yaml_data and operation.yaml_data["language"][
+                    "python"
+                ].get("paging"):
+                    next_link_yaml = operation.yaml_data["language"]["python"][
+                        "paging"
+                    ].get("nextLinkOperation")
                 if isinstance(operation, PagingOperation) and next_link_yaml:
                     next_operation = _lookup_operation(id(next_link_yaml))
                     operation.next_operation = next_operation
                     next_operations.append(next_operation)
 
             operation_group.operations = [
-                operation for operation in operation_group.operations if operation not in next_operations
+                operation
+                for operation in operation_group.operations
+                if operation not in next_operations
             ]
 
     @property
@@ -209,7 +247,9 @@ class CodeModel:  # pylint: disable=too-many-instance-attributes, too-many-publi
     @property
     def credential_model(self) -> CredentialModel:
         if not self._credential_model:
-            raise ValueError("You want to find the Credential Model, but have not given a value")
+            raise ValueError(
+                "You want to find the Credential Model, but have not given a value"
+            )
         return self._credential_model
 
     @credential_model.setter
@@ -225,14 +265,17 @@ class CodeModel:  # pylint: disable=too-many-instance-attributes, too-many-publi
                 parent = cast(ObjectSchema, base_model)
                 # need to make sure that the properties we choose from our parent also don't contain
                 # any of our own properties
-                schema_property_names = set([p.name for p in properties] + [p.name for p in schema.properties])
+                schema_property_names = set(
+                    [p.name for p in properties] + [p.name for p in schema.properties]
+                )
                 chosen_parent_properties = [
-                    p for p in parent.properties
-                    if p.name not in schema_property_names
+                    p for p in parent.properties if p.name not in schema_property_names
                 ]
                 properties = (
-                    CodeModel._add_properties_from_inheritance_helper(parent, chosen_parent_properties) +
-                    properties
+                    CodeModel._add_properties_from_inheritance_helper(
+                        parent, chosen_parent_properties
+                    )
+                    + properties
                 )
 
         return properties
@@ -253,7 +296,9 @@ class CodeModel:  # pylint: disable=too-many-instance-attributes, too-many-publi
         :rtype: None
         """
         for schema in self.schemas.values():
-            schema.properties = CodeModel._add_properties_from_inheritance_helper(schema, schema.properties)
+            schema.properties = CodeModel._add_properties_from_inheritance_helper(
+                schema, schema.properties
+            )
 
     @staticmethod
     def _add_exceptions_from_inheritance_helper(schema) -> bool:
@@ -262,7 +307,9 @@ class CodeModel:  # pylint: disable=too-many-instance-attributes, too-many-publi
         parent_is_exception: List[bool] = []
         for base_model in schema.base_models:
             parent = cast(ObjectSchema, base_model)
-            parent_is_exception.append(CodeModel._add_exceptions_from_inheritance_helper(parent))
+            parent_is_exception.append(
+                CodeModel._add_exceptions_from_inheritance_helper(parent)
+            )
         return any(parent_is_exception)
 
     def _add_exceptions_from_inheritance(self) -> None:
@@ -272,7 +319,9 @@ class CodeModel:  # pylint: disable=too-many-instance-attributes, too-many-publi
         :rtype: None
         """
         for schema in self.schemas.values():
-            schema.is_exception = CodeModel._add_exceptions_from_inheritance_helper(schema)
+            schema.is_exception = CodeModel._add_exceptions_from_inheritance_helper(
+                schema
+            )
 
     def add_inheritance_to_models(self) -> None:
         """Adds base classes and properties from base classes to schemas with parents.
@@ -283,7 +332,9 @@ class CodeModel:  # pylint: disable=too-many-instance-attributes, too-many-publi
         for schema in self.schemas.values():
             if schema.base_models:
                 # right now, the base model property just holds the name of the parent class
-                schema.base_models = [b for b in self.schemas.values() if b.id in schema.base_models]
+                schema.base_models = [
+                    b for b in self.schemas.values() if b.id in schema.base_models
+                ]
         self._add_properties_from_inheritance()
         self._add_exceptions_from_inheritance()
 
@@ -304,49 +355,44 @@ class CodeModel:  # pylint: disable=too-many-instance-attributes, too-many-publi
     def need_vendored_code(self, async_mode: bool) -> bool:
         if async_mode:
             return self.need_mixin_abc
-        return self.need_request_converter or self.need_format_url or self.need_mixin_abc
+        return (
+            self.need_request_converter or self.need_format_url or self.need_mixin_abc
+        )
 
     @property
     def need_request_converter(self) -> bool:
         return (
-            self.options["show_operations"] and
-            bool(self.rest.request_builders) and
-            not self.options["version_tolerant"]
+            self.options["show_operations"]
+            and bool(self.request_builders)
+            and not self.options["version_tolerant"]
         )
 
     @property
     def need_format_url(self) -> bool:
-        return any(rq for rq in self.rest.request_builders if rq.parameters.path)
+        return any(rq for rq in self.request_builders if rq.parameters.path)
 
     @property
     def need_mixin_abc(self) -> bool:
-        return any(o for o in self.operation_groups if o.is_empty_operation_group and self.options["python3_only"])
+        return any(
+            o
+            for o in self.operation_groups
+            if o.is_empty_operation_group and self.options["python3_only"]
+        )
 
     @property
     def has_lro_operations(self) -> bool:
-        return any([
-            isinstance(operation, LROOperation)
-            for operation_group in self.operation_groups
-            for operation in operation_group.operations
-        ])
-
-    def _lookup_request_builder(self, schema_id: int) -> RequestBuilder:
-        """Looks to see if the schema has already been created.
-
-        :param int schema_id: The yaml id of the schema
-        :return: If created, we return the created schema, otherwise, we throw.
-        :rtype: ~autorest.models.RequestBuilder
-        :raises: KeyError if schema is not found
-        """
-        for elt_key, elt_value in self.request_builder_ids.items():  # type: ignore
-            if schema_id == elt_key:
-                return elt_value
-        raise KeyError("Didn't find it!!!!!")
+        return any(
+            [
+                isinstance(operation, LROOperation)
+                for operation_group in self.operation_groups
+                for operation in operation_group.operations
+            ]
+        )
 
     def link_operation_to_request_builder(self) -> None:
         for operation_group in self.operation_groups:
             for operation in operation_group.operations:
-                request_builder = self._lookup_request_builder(id(operation.yaml_data))
+                request_builder = operation.request_builder
                 if isinstance(operation, LROOperation):
                     request_builder.name = request_builder.name + "_initial"
                 operation.request_builder = request_builder

package/autorest/codegen/models/constant_schema.py

@@ -4,11 +4,14 @@
 # license information.
 # --------------------------------------------------------------------------
 import logging
-from typing import Dict, Any, Optional
+from typing import Dict, Any, Optional, TYPE_CHECKING
 from .base_schema import BaseSchema
 from .primitive_schemas import get_primitive_schema, PrimitiveSchema
 from .imports import FileImport
 
+if TYPE_CHECKING:
+    from .code_model import CodeModel
+
 _LOGGER = logging.getLogger(__name__)
 
 
@@ -23,9 +26,13 @@ class ConstantSchema(BaseSchema):
     """
 
     def __init__(
-        self, namespace: str, yaml_data: Dict[str, Any], schema: PrimitiveSchema, value: Optional[str],
+        self,
+        yaml_data: Dict[str, Any],
+        code_model: "CodeModel",
+        schema: PrimitiveSchema,
+        value: Optional[str],
     ) -> None:
-        super(ConstantSchema, self).__init__(namespace=namespace, yaml_data=yaml_data)
+        super().__init__(yaml_data=yaml_data, code_model=code_model)
         self.value = value
         self.schema = schema
 
@@ -33,7 +40,8 @@ class ConstantSchema(BaseSchema):
         if value != self.value:
             _LOGGER.warning(
                 "Passed in value of %s differs from constant value of %s. Choosing constant value",
-                str(value), str(self.value)
+                str(value),
+                str(self.value),
             )
         if self.value is None:
             return "None"
@@ -64,7 +72,9 @@ class ConstantSchema(BaseSchema):
         return self.schema.type_annotation(is_operation_file=is_operation_file)
 
     @classmethod
-    def from_yaml(cls, namespace: str, yaml_data: Dict[str, Any], **kwargs) -> "ConstantSchema":
+    def from_yaml(
+        cls, yaml_data: Dict[str, Any], code_model: "CodeModel"
+    ) -> "ConstantSchema":
         """Constructs a ConstantSchema from yaml data.
 
         :param yaml_data: the yaml data from which we will construct this schema
@@ -73,23 +83,25 @@ class ConstantSchema(BaseSchema):
         :return: A created ConstantSchema
         :rtype: ~autorest.models.ConstantSchema
         """
-        name = yaml_data["language"]["python"]["name"] if yaml_data["language"]["python"].get("name") else ""
+        name = (
+            yaml_data["language"]["python"]["name"]
+            if yaml_data["language"]["python"].get("name")
+            else ""
+        )
         _LOGGER.debug("Parsing %s constant", name)
         return cls(
-            namespace=namespace,
             yaml_data=yaml_data,
-            schema=get_primitive_schema(namespace=namespace, yaml_data=yaml_data["valueType"]),
+            code_model=code_model,
+            schema=get_primitive_schema(
+                yaml_data=yaml_data["valueType"], code_model=code_model
+            ),
             value=yaml_data.get("value", {}).get("value", None),
         )
 
     def get_json_template_representation(self, **kwargs: Any) -> Any:
-        kwargs['default_value_declaration'] = self.schema.get_declaration(self.value)
+        kwargs["default_value_declaration"] = self.schema.get_declaration(self.value)
         return self.schema.get_json_template_representation(**kwargs)
 
-    def get_files_and_data_template_representation(self, **kwargs: Any) -> Any:
-        kwargs['default_value_declaration'] = self.schema.get_declaration(self.value)
-        return self.schema.get_files_and_data_template_representation(**kwargs)
-
     def imports(self) -> FileImport:
         file_import = FileImport()
         file_import.merge(self.schema.imports())

package/autorest/codegen/models/credential_model.py

@@ -4,19 +4,18 @@
 # license information.
 # --------------------------------------------------------------------------
 from typing import Set, Optional, Type
-from .credential_schema_policy import CredentialSchemaPolicy, BearerTokenCredentialPolicy
+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.
-    """
+    """Store info about credential."""
 
-    def __init__(
-        self,
-        azure_arm: bool
-    ) -> None:
+    def __init__(self, azure_arm: bool) -> None:
         self.azure_arm: bool = azure_arm
         self.credential_scopes: Set[str] = set()
         self.key_header_name: str = ""
@@ -25,23 +24,32 @@ class CredentialModel:
 
     @property
     def default_authentication_policy(self) -> Type[CredentialSchemaPolicy]:
-        return ARMChallengeAuthenticationPolicy if self.azure_arm else BearerTokenCredentialPolicy
+        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")
+                "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),
+            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
+            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

@@ -7,6 +7,7 @@ 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
@@ -29,19 +30,19 @@ class CredentialSchema(BaseSchema):
         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")
-
-    def get_files_and_data_template_representation(self, **kwargs: Any) -> Any:
-        raise TypeError("You should not try to get a files template representation of a CredentialSchema")
+        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) -> str:  # pylint: disable=unused-argument
+    def type_annotation(
+        self, *, is_operation_file: bool = False  # pylint: disable=unused-argument
+    ) -> str:
         return "AzureKeyCredential"
 
     def imports(self) -> FileImport:
@@ -50,14 +51,14 @@ class AzureKeyCredentialSchema(CredentialSchema):
             "azure.core.credentials",
             "AzureKeyCredential",
             ImportType.AZURECORE,
-            typing_section=TypingSection.CONDITIONAL
+            typing_section=TypingSection.CONDITIONAL,
         )
         return file_import
 
 
 class TokenCredentialSchema(CredentialSchema):
     def __init__(self, async_mode) -> None:
-        super(TokenCredentialSchema, self).__init__()
+        super().__init__()
         self.async_mode = async_mode
         self.async_type = "~azure.core.credentials_async.AsyncTokenCredential"
         self.sync_type = "~azure.core.credentials.TokenCredential"
@@ -68,24 +69,27 @@ class TokenCredentialSchema(CredentialSchema):
             return self.async_type
         return self.sync_type
 
-    def type_annotation(self, *, is_operation_file: bool = False) -> str:  # pylint: disable=unused-argument
+    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",
+                "azure.core.credentials_async",
+                "AsyncTokenCredential",
                 ImportType.AZURECORE,
-                typing_section=TypingSection.TYPING
+                typing_section=TypingSection.TYPING,
             )
         else:
             file_import.add_submodule_import(
-                "azure.core.credentials", "TokenCredential",
+                "azure.core.credentials",
+                "TokenCredential",
                 ImportType.AZURECORE,
-                typing_section=TypingSection.TYPING
+                typing_section=TypingSection.TYPING,
             )
         return file_import

package/autorest/codegen/models/credential_schema_policy.py

@@ -7,9 +7,9 @@ from abc import abstractmethod
 from typing import List
 from .credential_schema import CredentialSchema
 
-class CredentialSchemaPolicy:
 
-    def __init__(self, credential: CredentialSchema, *args, **kwargs) -> None:  # pylint: disable=unused-argument
+class CredentialSchemaPolicy:
+    def __init__(self, credential: CredentialSchema) -> None:
         self.credential = credential
 
     @abstractmethod
@@ -22,11 +22,8 @@ class CredentialSchemaPolicy:
 
 
 class BearerTokenCredentialPolicy(CredentialSchemaPolicy):
-
     def __init__(
-        self,
-        credential: CredentialSchema,
-        credential_scopes: List[str]
+        self, credential: CredentialSchema, credential_scopes: List[str]
     ) -> None:
         super().__init__(credential)
         self._credential_scopes = credential_scopes
@@ -41,18 +38,14 @@ class BearerTokenCredentialPolicy(CredentialSchemaPolicy):
 
 
 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
+        self, credential: CredentialSchema, credential_key_header_name: str
     ) -> None:
         super().__init__(credential)
         self._credential_key_header_name = credential_key_header_name
@@ -64,14 +57,17 @@ class AzureKeyCredentialPolicy(CredentialSchemaPolicy):
     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]
+    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])
-            )
+            "{}".format(" or ".join([p.name() for p in policies]))
         )