@autorest/python 5.14.0 → 5.17.0

package/autorest/codegen/models/code_model.py

@@ -3,32 +3,17 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
-from itertools import chain
-import logging
-from typing import cast, List, Dict, Optional, Any, Set, Type
+from typing import List, Dict, Optional, Any, Set, Union
 
-from .base_schema import BaseSchema
-from .credential_schema_policy import (
-    ARMChallengeAuthenticationPolicy, BearerTokenCredentialPolicy, CredentialSchemaPolicy
-)
-from .enum_schema import EnumSchema
-from .object_schema import ObjectSchema
+from .base_type import BaseType
+from .enum_type import EnumType
+from .model_type import ModelType
 from .operation_group import OperationGroup
-from .operation import Operation
-from .lro_operation import LROOperation
-from .paging_operation import PagingOperation
+from .client import Client, Config
+from .request_builder import OverloadedRequestBuilder, RequestBuilder
 from .parameter import Parameter
-from .client import Client
-from .parameter_list import GlobalParameterList
-from .schema_response import SchemaResponse
-from .property import Property
-from .primitive_schemas import IOSchema
-from .request_builder import RequestBuilder
-from .rest import Rest
 
 
-_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.
@@ -40,15 +25,15 @@ class CodeModel:  # pylint: disable=too-many-instance-attributes, too-many-publi
     :param str description: The description of the client
     :param str namespace: The namespace of our module
     :param schemas: The list of schemas we are going to serialize in the models files. Maps their yaml
-     id to our created ObjectSchema.
-    :type schemas: dict[int, ~autorest.models.ObjectSchema]
+     id to our created ModelType.
+    :type schemas: dict[int, ~autorest.models.ModelType]
     :param sorted_schemas: Our schemas in order by inheritance and alphabet
-    :type sorted_schemas: list[~autorest.models.ObjectSchema]
-    :param enums: The enums, if any, we are going to serialize. Maps their yaml id to our created EnumSchema.
-    :type enums: Dict[int, ~autorest.models.EnumSchema]
+    :type sorted_schemas: list[~autorest.models.ModelType]
+    :param enums: The enums, if any, we are going to serialize. Maps their yaml id to our created EnumType.
+    :type enums: Dict[int, ~autorest.models.EnumType]
     :param primitives: List of schemas we've created that are not EnumSchemas or ObjectSchemas. Maps their
      yaml id to our created schemas.
-    :type primitives: Dict[int, ~autorest.models.BaseSchema]
+    :type primitives: Dict[int, ~autorest.models.BaseType]
     :param operation_groups: The operation groups we are going to serialize
     :type operation_groups: list[~autorest.models.OperationGroup]
     :param package_dependency: All the dependencies needed in setup.py
@@ -57,63 +42,100 @@ 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.options = options
-        self.module_name: str = ""
-        self.class_name: str = ""
-        self.description: str = ""
-        self.namespace: str = ""
-        self.namespace_path: str = ""
-        self.schemas: Dict[int, ObjectSchema] = {}
-        self.sorted_schemas: List[ObjectSchema] = []
-        self.enums: Dict[int, EnumSchema] = {}
-        self.primitives: Dict[int, BaseSchema] = {}
+        self.types_map: Dict[int, BaseType] = {}  # map yaml id to schema
         self.operation_groups: List[OperationGroup] = []
-        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._credential_schema_policy: Optional[CredentialSchemaPolicy] = None
+        self._model_types: List[ModelType] = []
+        self._client: Optional[Client] = None
+        self._config: Optional[Config] = None
+        self.request_builders: List[
+            Union[RequestBuilder, OverloadedRequestBuilder]
+        ] = []
         self.package_dependency: Dict[str, str] = {}
+        self.namespace: str = yaml_data["client"]["namespace"].lower()
+        self.module_name: str = self.yaml_data["client"]["moduleName"]
+
+    def lookup_type(self, schema_id: int) -> BaseType:
+        """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.BaseType
+        :raises: KeyError if schema is not found
+        """
+        try:
+            return next(type for id, type in self.types_map.items() if id == schema_id)
+        except StopIteration:
+            raise KeyError(f"Couldn't find schema with id {schema_id}")
 
     @property
-    def global_parameters(self) -> GlobalParameterList:
-        return self.service_client.parameters
+    def credential(self) -> Optional[Parameter]:
+        """The credential param, if one exists"""
+        return self.client.parameters.credential
+
+    @property
+    def client(self) -> Client:
+        if not self._client:
+            raise ValueError("You haven't linked the client yet")
+        return self._client
+
+    @client.setter
+    def client(self, val: Client) -> None:
+        self._client = val
 
-    @global_parameters.setter
-    def global_parameters(self, val: GlobalParameterList) -> None:
-        self.service_client.parameters = val
+    @property
+    def config(self) -> Config:
+        if not self._config:
+            raise ValueError("You haven't linked the config yet")
+        return self._config
+
+    @config.setter
+    def config(self, val: Config) -> None:
+        self._config = val
+
+    def lookup_request_builder(
+        self, request_builder_id: int
+    ) -> Union[RequestBuilder, OverloadedRequestBuilder]:
+        """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 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
+    def model_types(self) -> List[ModelType]:
+        """All of the model types in this class"""
+        if not self._model_types:
+            self._model_types = [
+                t for t in self.types_map.values() if isinstance(t, ModelType)
+            ]
+        return self._model_types
 
-    @rest.setter
-    def rest(self, p: Rest) -> None:
-        self._rest = p
+    @model_types.setter
+    def model_types(self, val: List[ModelType]) -> None:
+        self._model_types = val
 
-    def lookup_schema(self, schema_id: int) -> BaseSchema:
-        """Looks to see if the schema has already been created.
+    @property
+    def public_model_types(self) -> List[ModelType]:
+        return [m for m in self.model_types if m.is_public]
 
-        :param int schema_id: The yaml id of the schema
-        :return: If created, we return the created schema, otherwise, we throw.
-        :rtype: ~autorest.models.BaseSchema
-        :raises: KeyError if schema is not found
-        """
-        for attr in [self.schemas, self.enums, self.primitives]:
-            for elt_key, elt_value in attr.items():  # type: ignore
-                if schema_id == elt_key:
-                    return elt_value
-        raise KeyError("Didn't find it!!!!!")
+    @property
+    def enums(self) -> List[EnumType]:
+        """All of the enums"""
+        return [t for t in self.types_map.values() if isinstance(t, EnumType)]
 
     @staticmethod
-    def _sort_schemas_helper(current, seen_schema_names, seen_schema_yaml_ids):
+    def _sort_model_types_helper(
+        current: ModelType, seen_schema_names: Set[str], seen_schema_yaml_ids: Set[int]
+    ):
         if current.id in seen_schema_yaml_ids:
             return []
         if current.name in seen_schema_names:
@@ -121,20 +143,23 @@ class CodeModel:  # pylint: disable=too-many-instance-attributes, too-many-publi
                 f"We have already generated a schema with name {current.name}"
             )
         ancestors = [current]
-        if current.base_models:
-            for base_model in current.base_models:
-                parent = cast(ObjectSchema, base_model)
+        if current.parents:
+            for parent in current.parents:
                 if parent.id in seen_schema_yaml_ids:
                     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_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
 
-
-    def sort_schemas(self) -> None:
+    def sort_model_types(self) -> None:
         """Sorts the final object schemas by inheritance and by alphabetical order.
 
         :return: None
@@ -142,29 +167,14 @@ class CodeModel:  # pylint: disable=too-many-instance-attributes, too-many-publi
         """
         seen_schema_names: Set[str] = set()
         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))
-        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
-            if parameter.rest_api_name == "$host"
-        ]
-        if not dollar_host:
-            # We don't want to support multi-api customurl YET (will see if that goes well....)
-            # 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]
-                self.service_client.parameterized_host_template = (
-                    first_req_of_first_op_of_first_grp["protocol"]["http"]["uri"]
+        sorted_object_schemas: List[ModelType] = []
+        for schema in sorted(self.model_types, key=lambda x: x.name.lower()):
+            sorted_object_schemas.extend(
+                CodeModel._sort_model_types_helper(
+                    schema, seen_schema_names, seen_schema_yaml_ids
                 )
-        else:
-            for host in dollar_host:
-                self.global_parameters.remove(host)
-            self.service_client.parameters.add_host(dollar_host[0].yaml_data["clientDefaultValue"])
+            )
+        self.model_types = sorted_object_schemas
 
     def format_lro_operations(self) -> None:
         """Adds operations and attributes needed for LROs.
@@ -175,228 +185,84 @@ class CodeModel:  # pylint: disable=too-many-instance-attributes, too-many-publi
             i = 0
             while i < len(operation_group.operations):
                 operation = operation_group.operations[i]
-                if isinstance(operation, LROOperation):
-                    operation_group.operations.insert(i, operation.initial_operation)
+                if operation.operation_type in ("lro", "lropaging"):
+                    operation_group.operations.insert(i, operation.initial_operation)  # type: ignore
                     i += 1
                 i += 1
 
-    def remove_next_operation(self) -> None:
-        """Linking paging operations together.
-        """
-        def _lookup_operation(yaml_id: int) -> Operation:
-            for operation_group in self.operation_groups:
-                for operation in operation_group.operations:
-                    if operation.id == yaml_id:
-                        return operation
-            raise KeyError("Didn't find it!!!!!")
-
-        for operation_group in self.operation_groups:
-            next_operations = []
-            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 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
-            ]
-
-    @property
-    def has_schemas(self):
-        return self.schemas or self.enums
-
-    @property
-    def default_authentication_policy(self) -> Type[CredentialSchemaPolicy]:
-        return ARMChallengeAuthenticationPolicy if self.options['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
-
-    @credential_schema_policy.setter
-    def credential_schema_policy(self, val: CredentialSchemaPolicy) -> None:
-        self._credential_schema_policy = val
-
-    @staticmethod
-    def _add_properties_from_inheritance_helper(schema, properties) -> List[Property]:
-        if not schema.base_models:
-            return properties
-        if schema.base_models:
-            for base_model in schema.base_models:
-                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])
-                chosen_parent_properties = [
-                    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
-                )
-
-        return properties
-
     @property
     def operations_folder_name(self) -> str:
+        """Get the name of the operations folder that holds operations."""
         name = "operations"
         if self.options["version_tolerant"] and not any(
-            og for og in self.operation_groups if not og.is_empty_operation_group
+            og for og in self.operation_groups if not og.is_mixin
         ):
             name = f"_{name}"
         return name
 
-    def _add_properties_from_inheritance(self) -> None:
-        """Adds properties from base classes to schemas with parents.
-
-        :return: None
-        :rtype: None
-        """
-        for schema in self.schemas.values():
-            schema.properties = CodeModel._add_properties_from_inheritance_helper(schema, schema.properties)
-
-    @staticmethod
-    def _add_exceptions_from_inheritance_helper(schema) -> bool:
-        if schema.is_exception:
-            return True
-        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))
-        return any(parent_is_exception)
-
-    def _add_exceptions_from_inheritance(self) -> None:
-        """Sets a class as an exception if it's parent is an exception.
+    def need_vendored_code(self, async_mode: bool) -> bool:
+        """Whether we need to vendor code in the _vendor.py file for this SDK"""
+        if async_mode:
+            return self.need_mixin_abc
+        return (
+            self.need_request_converter or self.need_format_url or self.need_mixin_abc
+        )
 
-        :return: None
-        :rtype: None
+    @property
+    def need_request_converter(self) -> bool:
         """
-        for schema in self.schemas.values():
-            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.
-
-        :return: None
-        :rtype: None
+        Whether we need to convert our created azure.core.rest.HttpRequests to
+        azure.core.pipeline.transport.HttpRequests
         """
-        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]
-        self._add_properties_from_inheritance()
-        self._add_exceptions_from_inheritance()
-
-    def _populate_target_property(self, parameter: Parameter) -> None:
-        for obj in self.schemas.values():
-            for prop in obj.properties:
-                if prop.id == parameter.target_property_name:
-                    parameter.target_property_name = prop.name
-                    return
-        raise KeyError("Didn't find the target property")
-
-    def _populate_schema(self, obj: Any) -> None:
-        schema_obj = obj.schema
-        if schema_obj and not isinstance(schema_obj, dict):
-            return
-
-        if schema_obj:
-            schema_obj_id = id(obj.schema)
-            _LOGGER.debug("Looking for id %s for member %s", schema_obj_id, obj)
-            try:
-                obj.schema = self.lookup_schema(schema_obj_id)
-            except KeyError:
-                _LOGGER.critical("Unable to ref the object")
-                raise
-        if isinstance(obj, Parameter) and obj.target_property_name:
-            self._populate_target_property(obj)
-        if isinstance(obj, SchemaResponse) and obj.is_stream_response:
-            obj.schema = IOSchema(namespace=None, yaml_data={})
-
-    def add_schema_link_to_operation(self) -> None:
-        """Puts created schemas into operation classes `schema` property
-
-        :return: None
-        :rtype: None
-        """
-        # Index schemas
-        for operation_group in self.operation_groups:
-            for operation in operation_group.operations:
-                for obj in chain(
-                    operation.parameters,
-                    operation.multiple_content_type_parameters or [],
-                    operation.responses,
-                    operation.exceptions,
-                    chain.from_iterable(response.headers for response in operation.responses),
-                ):
-                    self._populate_schema(obj)
-
-    def add_schema_link_to_request_builder(self) -> None:
-        for request_builder in self.rest.request_builders:
-            for obj in chain(
-                request_builder.parameters,
-                chain.from_iterable(request.parameters for request in request_builder.schema_requests),
-                request_builder.responses,
-            ):
-                self._populate_schema(obj)
-
-
-    def add_schema_link_to_global_parameters(self) -> None:
-        for parameter in self.global_parameters:
-            self._populate_schema(parameter)
-
-    def generate_single_parameter_from_multiple_content_types_operation(self) -> None:
-        for operation_group in self.operation_groups:
-            for operation in operation_group.operations:
-                if operation.multiple_content_type_parameters:
-                    operation.convert_multiple_content_type_parameters()
+        return (
+            self.options["show_operations"]
+            and bool(self.request_builders)
+            and not self.options["version_tolerant"]
+        )
 
     @property
-    def need_vendored_code(self) -> bool:
-        return self.need_request_converter or self.need_format_url
-
-    @property
-    def need_request_converter(self) -> bool:
-        return self.options["show_operations"] and not self.options["version_tolerant"]
+    def need_format_url(self) -> bool:
+        """Whether we need to format urls. If so, we need to vendor core."""
+        return any(rq for rq in self.request_builders if rq.parameters.path)
 
     @property
-    def need_format_url(self) -> bool:
-        return any(rq for rq in self.rest.request_builders if rq.parameters.path)
+    def need_mixin_abc(self) -> bool:
+        """Do we want a mixin ABC class for typing purposes?"""
+        return any(
+            o
+            for o in self.operation_groups
+            if o.is_mixin 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.
+        """Are there any LRO operations in this SDK?"""
+        return any(
+            [
+                operation.operation_type in ("lro", "lropaging")
+                for operation_group in self.operation_groups
+                for operation in operation_group.operations
+            ]
+        )
+
+    def get_models_filename(self, is_python3_file: bool) -> str:
+        """Get the names of the model file(s)"""
+        if (
+            self.options["version_tolerant"] or self.options["low_level_client"]
+        ) and self.options["python3_only"]:
+            return "_models"
+        if is_python3_file:
+            return "_models_py3"
+        return "_models"
 
-        :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!!!!!")
+    @property
+    def enums_filename(self) -> str:
+        """The name of the enums file"""
+        if self.options["version_tolerant"] or self.options["low_level_client"]:
+            return "_enums"
+        return f"_{self.module_name}_enums"
 
-    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))
-                if isinstance(operation, LROOperation):
-                    request_builder.name = request_builder.name + "_initial"
-                operation.request_builder = request_builder
-                operation.link_body_kwargs_to_body_params()
+    @property
+    def rest_layer_name(self) -> str:
+        """If we have a separate rest layer, what is its name?"""
+        return "rest" if self.options["builders_visibility"] == "public" else "_rest"

package/autorest/codegen/models/combined_type.py

@@ -0,0 +1,107 @@
+# -------------------------------------------------------------------------
+# 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, TYPE_CHECKING
+
+from autorest.codegen.models.imports import FileImport, ImportType
+from .base_type import BaseType
+
+if TYPE_CHECKING:
+    from .code_model import CodeModel
+
+
+class CombinedType(BaseType):
+    """A type that consists of multiple different types.
+
+    Used by body parameters that have multiple types, i.e. one that can be
+    a stream body or a JSON body.
+    """
+
+    def __init__(
+        self, yaml_data: Dict[str, Any], code_model: "CodeModel", types: List[BaseType]
+    ) -> None:
+        super().__init__(yaml_data, code_model)
+        self.types = types  # the types that this type is combining
+
+    @property
+    def serialization_type(self) -> str:
+        """The tag recognized by 'msrest' as a serialization/deserialization.
+
+        'str', 'int', 'float', 'bool' or
+        https://github.com/Azure/msrest-for-python/blob/b505e3627b547bd8fdc38327e86c70bdb16df061/msrest/serialization.py#L407-L416
+
+        or the object schema name (e.g. DotSalmon).
+
+        If list: '[str]'
+        If dict: '{str}'
+        """
+        ...
+
+    @property
+    def client_default_value(self) -> Any:
+        return self.yaml_data.get("clientDefaultValue")
+
+    def description(
+        self, *, is_operation_file: bool  # pylint: disable=unused-argument
+    ) -> str:
+        if len(self.types) == 2:
+            return (
+                f"Is either a {self.types[0].type} type or a {self.types[1].type} type."
+            )
+        return (
+            f"Is one of the following types: {', '.join([t.type for t in self.types])}"
+        )
+
+    def docstring_text(self, **kwargs: Any) -> str:
+        return " or ".join(t.docstring_text(**kwargs) for t in self.types)
+
+    def docstring_type(self, **kwargs: Any) -> str:
+        return " or ".join(t.docstring_type(**kwargs) for t in self.types)
+
+    def type_annotation(self, **kwargs: Any) -> str:
+        """The python type used for type annotation
+
+        Special case for enum, for instance: Union[str, "EnumName"]
+        """
+        kwargs["is_operation_file"] = True
+        return (
+            f'Union[{", ".join(type.type_annotation(**kwargs) for type in self.types)}]'
+        )
+
+    def get_json_template_representation(
+        self,
+        *,
+        optional: bool = True,
+        client_default_value_declaration: Optional[str] = None,
+        description: Optional[str] = None,
+    ) -> Any:
+        """Template of what this schema would look like as JSON input"""
+        raise ValueError(
+            "You shouldn't get a JSON template representation of multiple types"
+        )
+
+    @property
+    def instance_check_template(self) -> str:
+        """Template of what an instance check of a variable for this type would look like"""
+        raise ValueError("You shouldn't do instance checks on a multiple type")
+
+    def imports(self, **kwargs: Any) -> FileImport:
+        file_import = FileImport()
+        for type in self.types:
+            file_import.merge(type.imports(**kwargs))
+        file_import.add_submodule_import("typing", "Union", ImportType.STDLIB)
+        return file_import
+
+    @classmethod
+    def from_yaml(
+        cls, yaml_data: Dict[str, Any], code_model: "CodeModel"
+    ) -> "BaseType":
+        from . import build_type
+
+        return cls(
+            yaml_data,
+            code_model,
+            [build_type(t, code_model) for t in yaml_data["types"]],
+        )