@autorest/python 6.13.16 → 6.13.17

package/autorest/codegen/models/code_model.py

@@ -57,17 +57,11 @@ class CodeModel:  # pylint: disable=too-many-public-methods, disable=too-many-in
         for type_yaml in yaml_data.get("types", []):
             build_type(yaml_data=type_yaml, code_model=self)
         self.clients: List[Client] = [
-            Client.from_yaml(client_yaml_data, self)
-            for client_yaml_data in yaml_data["clients"]
+            Client.from_yaml(client_yaml_data, self) for client_yaml_data in yaml_data["clients"]
         ]
         self.subnamespace_to_clients: Dict[str, List[Client]] = {
-            subnamespace: [
-                Client.from_yaml(client_yaml, self, is_subclient=True)
-                for client_yaml in client_yamls
-            ]
-            for subnamespace, client_yamls in yaml_data.get(
-                "subnamespaceToClients", {}
-            ).items()
+            subnamespace: [Client.from_yaml(client_yaml, self, is_subclient=True) for client_yaml in client_yamls]
+            for subnamespace, client_yamls in yaml_data.get("subnamespaceToClients", {}).items()
         }
         if self.options["models_mode"] and self.model_types:
             self.sort_model_types()
@@ -80,11 +74,7 @@ class CodeModel:  # pylint: disable=too-many-public-methods, disable=too-many-in
 
     @property
     def has_form_data(self) -> bool:
-        return any(
-            og.has_form_data_body
-            for client in self.clients
-            for og in client.operation_groups
-        )
+        return any(og.has_form_data_body for client in self.clients for og in client.operation_groups)
 
     @property
     def has_etag(self) -> bool:
@@ -94,25 +84,15 @@ class CodeModel:  # pylint: disable=too-many-public-methods, disable=too-many-in
     def has_operations(self) -> bool:
         if any(c for c in self.clients if c.has_operations):
             return True
-        return any(
-            c
-            for clients in self.subnamespace_to_clients.values()
-            for c in clients
-            if c.has_operations
-        )
+        return any(c for clients in self.subnamespace_to_clients.values() for c in clients if c.has_operations)
 
     @property
     def has_non_abstract_operations(self) -> bool:
         return any(c for c in self.clients if c.has_non_abstract_operations) or any(
-            c
-            for cs in self.subnamespace_to_clients.values()
-            for c in cs
-            if c.has_non_abstract_operations
+            c for cs in self.subnamespace_to_clients.values() for c in cs if c.has_non_abstract_operations
         )
 
-    def lookup_request_builder(
-        self, request_builder_id: int
-    ) -> Union[RequestBuilder, OverloadedRequestBuilder]:
+    def lookup_request_builder(self, request_builder_id: int) -> Union[RequestBuilder, OverloadedRequestBuilder]:
         """Find the request builder based off of id"""
         for client in self.clients:
             try:
@@ -140,12 +120,7 @@ class CodeModel:  # pylint: disable=too-many-public-methods, disable=too-many-in
             return True
         if async_mode:
             return self.need_mixin_abc
-        return (
-            self.need_request_converter
-            or self.need_mixin_abc
-            or self.has_etag
-            or self.has_form_data
-        )
+        return self.need_request_converter or self.need_mixin_abc or self.has_etag or self.has_form_data
 
     @property
     def need_request_converter(self) -> bool:
@@ -164,10 +139,7 @@ class CodeModel:  # pylint: disable=too-many-public-methods, disable=too-many-in
         """Get the name of the operations folder that holds operations."""
         name = "operations"
         if self.options["version_tolerant"] and not any(
-            og
-            for client in self.clients
-            for og in client.operation_groups
-            if not og.is_mixin
+            og for client in self.clients for og in client.operation_groups if not og.is_mixin
         ):
             name = f"_{name}"
         return name
@@ -196,8 +168,7 @@ class CodeModel:  # pylint: disable=too-many-public-methods, disable=too-many-in
             self._model_types = [
                 t
                 for t in self.types_map.values()
-                if isinstance(t, ModelType)
-                and not (self.options["models_mode"] == "dpg" and t.page_result_model)
+                if isinstance(t, ModelType) and not (self.options["models_mode"] == "dpg" and t.page_result_model)
             ]
         return self._model_types
 
@@ -227,9 +198,7 @@ class CodeModel:  # pylint: disable=too-many-public-methods, disable=too-many-in
         if current.id in seen_schema_yaml_ids:
             return []
         if current.name in seen_schema_names:
-            raise ValueError(
-                f"We have already generated a schema with name {current.name}"
-            )
+            raise ValueError(f"We have already generated a schema with name {current.name}")
         ancestors = [current]
         if current.parents:
             for parent in current.parents:
@@ -237,12 +206,7 @@ class CodeModel:  # pylint: disable=too-many-public-methods, disable=too-many-in
                     continue
                 seen_schema_names.add(current.name)
                 seen_schema_yaml_ids.add(current.id)
-                ancestors = (
-                    self._sort_model_types_helper(
-                        parent, seen_schema_names, seen_schema_yaml_ids
-                    )
-                    + ancestors
-                )
+                ancestors = self._sort_model_types_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
@@ -257,11 +221,7 @@ class CodeModel:  # pylint: disable=too-many-public-methods, disable=too-many-in
         seen_schema_yaml_ids: Set[int] = set()
         sorted_object_schemas: List[ModelType] = []
         for schema in sorted(self.model_types, key=lambda x: x.name.lower()):
-            sorted_object_schemas.extend(
-                self._sort_model_types_helper(
-                    schema, seen_schema_names, seen_schema_yaml_ids
-                )
-            )
+            sorted_object_schemas.extend(self._sort_model_types_helper(schema, seen_schema_names, seen_schema_yaml_ids))
         self.model_types = sorted_object_schemas
 
     @property

package/autorest/codegen/models/combined_type.py

@@ -51,9 +51,7 @@ class CombinedType(BaseType):
     def client_default_value(self) -> Any:
         return self.yaml_data.get("clientDefaultValue")
 
-    def description(
-        self, *, is_operation_file: bool  # pylint: disable=unused-argument
-    ) -> str:
+    def description(self, *, is_operation_file: bool) -> str:  # pylint: disable=unused-argument
         if len(self.types) == 2:
             return f"Is either a {self.types[0].type_description} type or a {self.types[1].type_description} type."
         return f"Is one of the following types: {', '.join([t.type_description for t in self.types])}"
@@ -75,9 +73,7 @@ class CombinedType(BaseType):
         Special case for enum, for instance: Union[str, "EnumName"]
         """
         # remove duplicates
-        inside_types = list(
-            dict.fromkeys([type.type_annotation(**kwargs) for type in self.types])
-        )
+        inside_types = list(dict.fromkeys([type.type_annotation(**kwargs) for type in self.types]))
         if len(inside_types) == 1:
             return inside_types[0]
         if self._is_union_of_literals:
@@ -135,9 +131,7 @@ class CombinedType(BaseType):
         return file_import
 
     @classmethod
-    def from_yaml(
-        cls, yaml_data: Dict[str, Any], code_model: "CodeModel"
-    ) -> "BaseType":
+    def from_yaml(cls, yaml_data: Dict[str, Any], code_model: "CodeModel") -> "BaseType":
         from . import build_type
 
         return cls(

package/autorest/codegen/models/constant_type.py

@@ -76,22 +76,14 @@ class ConstantType(BaseType):
         return self.value_type.docstring_type(**kwargs)
 
     def type_annotation(self, **kwargs: Any) -> str:
-        return (
-            f"Literal[{self.get_declaration()}]"
-            if self._is_literal
-            else self.value_type.type_annotation(**kwargs)
-        )
+        return f"Literal[{self.get_declaration()}]" if self._is_literal else self.value_type.type_annotation(**kwargs)
 
     @property
     def _is_literal(self) -> bool:
-        return isinstance(
-            self.value_type, (IntegerType, BinaryType, StringType, BooleanType)
-        )
+        return isinstance(self.value_type, (IntegerType, BinaryType, StringType, BooleanType))
 
     @classmethod
-    def from_yaml(
-        cls, yaml_data: Dict[str, Any], code_model: "CodeModel"
-    ) -> "ConstantType":
+    def from_yaml(cls, yaml_data: Dict[str, Any], code_model: "CodeModel") -> "ConstantType":
         """Constructs a ConstantType from yaml data.
 
         :param yaml_data: the yaml data from which we will construct this schema
@@ -134,9 +126,7 @@ class ConstantType(BaseType):
     def imports(self, **kwargs: Any) -> FileImport:
         file_import = self._imports_shared(**kwargs)
         if self._is_literal:
-            file_import.add_submodule_import(
-                "typing", "Literal", ImportType.STDLIB, TypingSection.REGULAR
-            )
+            file_import.add_submodule_import("typing", "Literal", ImportType.STDLIB, TypingSection.REGULAR)
         return file_import
 
     @property

package/autorest/codegen/models/credential_types.py

@@ -57,9 +57,7 @@ class BearerTokenCredentialPolicyType(_CredentialPolicyBaseType):
         return f"policies.{policy_name}(self.credential, *self.credential_scopes, **kwargs)"
 
     @classmethod
-    def from_yaml(
-        cls, yaml_data: Dict[str, Any], code_model: "CodeModel"
-    ) -> "BearerTokenCredentialPolicyType":
+    def from_yaml(cls, yaml_data: Dict[str, Any], code_model: "CodeModel") -> "BearerTokenCredentialPolicyType":
         return cls(yaml_data, code_model, yaml_data["credentialScopes"])
 
 
@@ -85,27 +83,17 @@ class KeyCredentialPolicyType(_CredentialPolicyBaseType):
 
     @property
     def credential_name(self) -> str:
-        return (
-            "AzureKeyCredential"
-            if self.code_model.is_azure_flavor
-            else "ServiceKeyCredential"
-        )
+        return "AzureKeyCredential" if self.code_model.is_azure_flavor else "ServiceKeyCredential"
 
     def call(self, async_mode: bool) -> str:
         params = f'"{self.key}", '
         if self.scheme:
             params += f'prefix="{self.scheme}", '
-        return (
-            f"policies.{self.credential_name}Policy(self.credential, {params}**kwargs)"
-        )
+        return f"policies.{self.credential_name}Policy(self.credential, {params}**kwargs)"
 
     @classmethod
-    def from_yaml(
-        cls, yaml_data: Dict[str, Any], code_model: "CodeModel"
-    ) -> "KeyCredentialPolicyType":
-        return cls(
-            yaml_data, code_model, yaml_data["key"], yaml_data.get("scheme", None)
-        )
+    def from_yaml(cls, yaml_data: Dict[str, Any], code_model: "CodeModel") -> "KeyCredentialPolicyType":
+        return cls(yaml_data, code_model, yaml_data["key"], yaml_data.get("scheme", None))
 
 
 CredentialPolicyType = TypeVar(
@@ -118,9 +106,7 @@ CredentialPolicyType = TypeVar(
 )
 
 
-class CredentialType(
-    Generic[CredentialPolicyType], BaseType
-):  # pylint:disable=abstract-method
+class CredentialType(Generic[CredentialPolicyType], BaseType):  # pylint:disable=abstract-method
     """Store info about the type of the credential. Can be either an KeyCredential or a TokenCredential"""
 
     def __init__(
@@ -132,9 +118,7 @@ class CredentialType(
         super().__init__(yaml_data, code_model)
         self.policy = policy
 
-    def description(
-        self, *, is_operation_file: bool  # pylint: disable=unused-argument
-    ) -> str:
+    def description(self, *, is_operation_file: bool) -> str:  # pylint: disable=unused-argument
         return ""
 
     def get_json_template_representation(
@@ -144,9 +128,7 @@ class CredentialType(
         client_default_value_declaration: Optional[str] = None,
         description: Optional[str] = None,
     ) -> Any:
-        raise TypeError(
-            "You should not try to get a JSON template representation of a CredentialSchema"
-        )
+        raise TypeError("You should not try to get a JSON template representation of a CredentialSchema")
 
     def docstring_text(self, **kwargs: Any) -> str:
         return "credential"
@@ -156,17 +138,13 @@ class CredentialType(
         return self.docstring_type()
 
     @classmethod
-    def from_yaml(
-        cls, yaml_data: Dict[str, Any], code_model: "CodeModel"
-    ) -> "CredentialType":
+    def from_yaml(cls, yaml_data: Dict[str, Any], code_model: "CodeModel") -> "CredentialType":
         from . import build_type
 
         return cls(
             yaml_data,
             code_model,
-            policy=cast(
-                CredentialPolicyType, build_type(yaml_data["policy"], code_model)
-            ),
+            policy=cast(CredentialPolicyType, build_type(yaml_data["policy"], code_model)),
         )
 
 
@@ -225,9 +203,7 @@ class KeyCredentialType(
     """Type for an KeyCredential"""
 
     def docstring_type(self, **kwargs: Any) -> str:  # pylint: disable=unused-argument
-        return (
-            f"~{self.code_model.core_library}.credentials.{self.policy.credential_name}"
-        )
+        return f"~{self.code_model.core_library}.credentials.{self.policy.credential_name}"
 
     def type_annotation(self, **kwargs: Any) -> str:  # pylint: disable=unused-argument
         return self.policy.credential_name

package/autorest/codegen/models/dictionary_type.py

@@ -89,19 +89,13 @@ class DictionaryType(BaseType):
 
         if isinstance(self.element_type, ModelType):
             is_polymorphic_subtype = (
-                self.element_type.discriminator_value
-                and not self.element_type.discriminated_subtypes
+                self.element_type.discriminator_value and not self.element_type.discriminated_subtypes
             )
-            if (
-                self.element_type.name not in (m.name for m in polymorphic_subtypes)
-                and is_polymorphic_subtype
-            ):
+            if self.element_type.name not in (m.name for m in polymorphic_subtypes) and is_polymorphic_subtype:
                 polymorphic_subtypes.append(self.element_type)
 
     @classmethod
-    def from_yaml(
-        cls, yaml_data: Dict[str, Any], code_model: "CodeModel"
-    ) -> "DictionaryType":
+    def from_yaml(cls, yaml_data: Dict[str, Any], code_model: "CodeModel") -> "DictionaryType":
         """Constructs a DictionaryType from yaml data.
 
         :param yaml_data: the yaml data from which we will construct this schema
@@ -124,9 +118,7 @@ class DictionaryType(BaseType):
 
     def imports(self, **kwargs: Any) -> FileImport:
         file_import = FileImport(self.code_model)
-        file_import.add_submodule_import(
-            "typing", "Dict", ImportType.STDLIB, TypingSection.CONDITIONAL
-        )
+        file_import.add_submodule_import("typing", "Dict", ImportType.STDLIB, TypingSection.CONDITIONAL)
         file_import.merge(self.element_type.imports(**kwargs))
         return file_import
 

package/autorest/codegen/models/enum_type.py

@@ -78,19 +78,13 @@ class EnumValue(BaseType):
     def imports(self, **kwargs: Any) -> FileImport:
         file_import = FileImport(self.code_model)
         file_import.merge(self.value_type.imports(**kwargs))
-        file_import.add_submodule_import(
-            "typing", "Literal", ImportType.STDLIB, TypingSection.REGULAR
-        )
-        file_import.add_submodule_import(
-            "._enums", self.enum_type.name, ImportType.LOCAL, TypingSection.REGULAR
-        )
+        file_import.add_submodule_import("typing", "Literal", ImportType.STDLIB, TypingSection.REGULAR)
+        file_import.add_submodule_import("._enums", self.enum_type.name, ImportType.LOCAL, TypingSection.REGULAR)
 
         return file_import
 
     @classmethod
-    def from_yaml(
-        cls, yaml_data: Dict[str, Any], code_model: "CodeModel"
-    ) -> "EnumValue":
+    def from_yaml(cls, yaml_data: Dict[str, Any], code_model: "CodeModel") -> "EnumValue":
         """Constructs an EnumValue from yaml data.
 
         :param yaml_data: the yaml data from which we will construct this object
@@ -133,9 +127,7 @@ class EnumType(BaseType):
         self.values = values
         self.value_type = value_type
         self.internal: bool = self.yaml_data.get("internal", False)
-        self.cross_language_definition_id: Optional[str] = self.yaml_data.get(
-            "crossLanguageDefinitionId"
-        )
+        self.cross_language_definition_id: Optional[str] = self.yaml_data.get("crossLanguageDefinitionId")
 
     def __lt__(self, other):
         return self.name.lower() < other.name.lower()
@@ -149,9 +141,7 @@ class EnumType(BaseType):
         """
         return self.value_type.serialization_type
 
-    def description(
-        self, *, is_operation_file: bool  # pylint: disable=unused-argument
-    ) -> str:
+    def description(self, *, is_operation_file: bool) -> str:  # pylint: disable=unused-argument
         possible_values = [self.get_declaration(v.value) for v in self.values]
         if not possible_values:
             return ""
@@ -161,8 +151,7 @@ class EnumType(BaseType):
             possible_values_str = " and ".join(possible_values)
         else:
             possible_values_str = (
-                ", ".join(possible_values[: len(possible_values) - 1])
-                + f", and {possible_values[-1]}"
+                ", ".join(possible_values[: len(possible_values) - 1]) + f", and {possible_values[-1]}"
             )
 
         enum_description = f"Known values are: {possible_values_str}."
@@ -219,16 +208,12 @@ class EnumType(BaseType):
     def instance_check_template(self) -> str:
         return self.value_type.instance_check_template
 
-    def fill_instance_from_yaml(
-        self, yaml_data: Dict[str, Any], code_model: "CodeModel"
-    ) -> None:
+    def fill_instance_from_yaml(self, yaml_data: Dict[str, Any], code_model: "CodeModel") -> None:
         for value in yaml_data["values"]:
             self.values.append(EnumValue.from_yaml(value, code_model))
 
     @classmethod
-    def from_yaml(
-        cls, yaml_data: Dict[str, Any], code_model: "CodeModel"
-    ) -> "EnumType":
+    def from_yaml(cls, yaml_data: Dict[str, Any], code_model: "CodeModel") -> "EnumType":
         raise ValueError(
             "You shouldn't call from_yaml for EnumType to avoid recursion. "
             "Please initial a blank EnumType, then call .fill_instance_from_yaml on the created type."
@@ -238,9 +223,7 @@ class EnumType(BaseType):
         operation = kwargs.pop("operation", False)
         file_import = FileImport(self.code_model)
         if self.code_model.options["models_mode"]:
-            file_import.add_submodule_import(
-                "typing", "Union", ImportType.STDLIB, TypingSection.CONDITIONAL
-            )
+            file_import.add_submodule_import("typing", "Union", ImportType.STDLIB, TypingSection.CONDITIONAL)
             if not operation:
                 file_import.add_submodule_import(
                     "..",
@@ -258,10 +241,6 @@ class EnumType(BaseType):
                 "models",
                 ImportType.LOCAL,
                 alias="_models",
-                typing_section=(
-                    TypingSection.TYPING
-                    if kwargs.get("model_typing")
-                    else TypingSection.REGULAR
-                ),
+                typing_section=(TypingSection.TYPING if kwargs.get("model_typing") else TypingSection.REGULAR),
             )
         return file_import

package/autorest/codegen/models/imports.py

@@ -30,12 +30,8 @@ class TypingSection(str, Enum):
 
 class MsrestImportType(Enum):
     Module = auto()  # import _serialization.py or msrest.serialization as Module
-    Serializer = (
-        auto()
-    )  # from _serialization.py or msrest.serialization import Serializer
-    SerializerDeserializer = (
-        auto()
-    )  # from _serialization.py or msrest.serialization import Serializer and Deserializer
+    Serializer = auto()  # from _serialization.py or msrest.serialization import Serializer
+    SerializerDeserializer = auto()  # from _serialization.py or msrest.serialization import Serializer and Deserializer
 
 
 class ImportModel:
@@ -47,9 +43,7 @@ class ImportModel:
         *,
         submodule_name: Optional[str] = None,
         alias: Optional[str] = None,
-        version_modules: Optional[
-            Tuple[Tuple[Tuple[int, int], str, Optional[str]]]
-        ] = None,
+        version_modules: Optional[Tuple[Tuple[Tuple[int, int], str, Optional[str]]]] = None,
     ):
         self.typing_section = typing_section
         self.import_type = import_type
@@ -109,23 +103,15 @@ class FileImport:
             ]
             if all(l not in mod_name for l in core_libraries):
                 # this is to make sure we don't tack on core libraries when we don't need to
-                import_model.module_name = (
-                    f"{self.code_model.core_library}{'.' if mod_name else ''}{mod_name}"
-                )
+                import_model.module_name = f"{self.code_model.core_library}{'.' if mod_name else ''}{mod_name}"
         if not any(
             i
             for i in self.imports
-            if all(
-                getattr(i, attr) == getattr(import_model, attr)
-                for attr in dir(i)
-                if attr[0] != "_"
-            )
+            if all(getattr(i, attr) == getattr(import_model, attr) for attr in dir(i) if attr[0] != "_")
         ):
             self.imports.append(import_model)
 
-    def get_imports_from_section(
-        self, typing_section: TypingSection
-    ) -> List[ImportModel]:
+    def get_imports_from_section(self, typing_section: TypingSection) -> List[ImportModel]:
         return [i for i in self.imports if i.typing_section == typing_section]
 
     def add_submodule_import(
@@ -135,9 +121,7 @@ class FileImport:
         import_type: ImportType,
         typing_section: TypingSection = TypingSection.REGULAR,
         alias: Optional[str] = None,
-        version_modules: Optional[
-            Tuple[Tuple[Tuple[int, int], str, Optional[str]]]
-        ] = None,
+        version_modules: Optional[Tuple[Tuple[Tuple[int, int], str, Optional[str]]]] = None,
     ) -> None:
         """Add an import to this import block."""
         self._append_import(
@@ -174,9 +158,7 @@ class FileImport:
         type_value: str,
         async_type_value: Optional[str] = None,
     ):
-        self.type_definitions[type_name] = TypeDefinition(
-            type_value, async_type_value or type_value
-        )
+        self.type_definitions[type_name] = TypeDefinition(type_value, async_type_value or type_value)
 
     def merge(self, file_import: "FileImport") -> None:
         """Merge the given file import format."""
@@ -269,9 +251,9 @@ class FileImport:
                     name_import = (i.submodule_name, i.alias)
                 else:
                     name_import = i.submodule_name
-            retval.setdefault(i.typing_section, {}).setdefault(
-                i.import_type, {}
-            ).setdefault(i.module_name, set()).add(name_import)
+            retval.setdefault(i.typing_section, {}).setdefault(i.import_type, {}).setdefault(i.module_name, set()).add(
+                name_import
+            )
         return retval
 
     def add_msrest_import(
@@ -283,24 +265,16 @@ class FileImport:
     ):
         if self.code_model.options["client_side_validation"]:
             if msrest_import_type == MsrestImportType.Module:
-                self.add_import(
-                    "msrest.serialization", ImportType.SDKCORE, typing_section
-                )
+                self.add_import("msrest.serialization", ImportType.SDKCORE, typing_section)
             else:
-                self.add_submodule_import(
-                    "msrest", "Serializer", ImportType.THIRDPARTY, typing_section
-                )
+                self.add_submodule_import("msrest", "Serializer", ImportType.THIRDPARTY, typing_section)
                 if msrest_import_type == MsrestImportType.SerializerDeserializer:
-                    self.add_submodule_import(
-                        "msrest", "Deserializer", ImportType.THIRDPARTY, typing_section
-                    )
+                    self.add_submodule_import("msrest", "Deserializer", ImportType.THIRDPARTY, typing_section)
         else:
             if self.code_model.options["multiapi"]:
                 relative_path += "."
             if msrest_import_type == MsrestImportType.Module:
-                self.add_submodule_import(
-                    relative_path, "_serialization", ImportType.LOCAL, typing_section
-                )
+                self.add_submodule_import(relative_path, "_serialization", ImportType.LOCAL, typing_section)
             else:
                 self.add_submodule_import(
                     f"{relative_path}_serialization",

package/autorest/codegen/models/list_type.py

@@ -69,19 +69,13 @@ class ListType(BaseType):
         return ", ".join(attrs_list)
 
     def docstring_type(self, **kwargs: Any) -> str:
-        if (
-            self.code_model.options["version_tolerant"]
-            and self.element_type.xml_metadata
-        ):
+        if self.code_model.options["version_tolerant"] and self.element_type.xml_metadata:
             # this means we're version tolerant XML, we just return the XML element
             return self.element_type.docstring_type(**kwargs)
         return f"list[{self.element_type.docstring_type(**kwargs)}]"
 
     def docstring_text(self, **kwargs: Any) -> str:
-        if (
-            self.code_model.options["version_tolerant"]
-            and self.element_type.xml_metadata
-        ):
+        if self.code_model.options["version_tolerant"] and self.element_type.xml_metadata:
             # this means we're version tolerant XML, we just return the XML element
             return self.element_type.docstring_text(**kwargs)
         return f"list of {self.element_type.docstring_text(**kwargs)}"
@@ -118,13 +112,9 @@ class ListType(BaseType):
 
         if isinstance(self.element_type, ModelType):
             is_polymorphic_subtype = (
-                self.element_type.discriminator_value
-                and not self.element_type.discriminated_subtypes
+                self.element_type.discriminator_value and not self.element_type.discriminated_subtypes
             )
-            if (
-                self.element_type.name not in (m.name for m in polymorphic_subtypes)
-                and is_polymorphic_subtype
-            ):
+            if self.element_type.name not in (m.name for m in polymorphic_subtypes) and is_polymorphic_subtype:
                 polymorphic_subtypes.append(self.element_type)
 
     @property
@@ -132,17 +122,13 @@ class ListType(BaseType):
         return "isinstance({}, list)"
 
     @classmethod
-    def from_yaml(
-        cls, yaml_data: Dict[str, Any], code_model: "CodeModel"
-    ) -> "ListType":
+    def from_yaml(cls, yaml_data: Dict[str, Any], code_model: "CodeModel") -> "ListType":
         from . import build_type
 
         return cls(
             yaml_data=yaml_data,
             code_model=code_model,
-            element_type=build_type(
-                yaml_data=yaml_data["elementType"], code_model=code_model
-            ),
+            element_type=build_type(yaml_data=yaml_data["elementType"], code_model=code_model),
         )
 
     def imports(self, **kwargs: Any) -> FileImport:
@@ -152,9 +138,7 @@ class ListType(BaseType):
             and self.element_type.is_xml
             and not self.code_model.options["models_mode"]
         ):
-            file_import.add_submodule_import(
-                "typing", "List", ImportType.STDLIB, TypingSection.CONDITIONAL
-            )
+            file_import.add_submodule_import("typing", "List", ImportType.STDLIB, TypingSection.CONDITIONAL)
         file_import.merge(self.element_type.imports(**kwargs))
         return file_import