@autorest/python 6.2.0 → 6.2.1

package/autorest/codegen/models/operation.py

@@ -39,7 +39,7 @@ from .model_type import ModelType
 from .request_builder import OverloadedRequestBuilder, RequestBuilder
 
 if TYPE_CHECKING:
-    from .code_model import NamespaceModel
+    from .code_model import CodeModel
     from .client import Client
 
 ResponseType = TypeVar(
@@ -54,7 +54,7 @@ class OperationBase(  # pylint: disable=too-many-public-methods
     def __init__(
         self,
         yaml_data: Dict[str, Any],
-        namespace_model: "NamespaceModel",
+        code_model: "CodeModel",
         client: "Client",
         name: str,
         request_builder: Union[RequestBuilder, OverloadedRequestBuilder],
@@ -67,7 +67,7 @@ class OperationBase(  # pylint: disable=too-many-public-methods
         want_tracing: bool = True,
     ) -> None:
         super().__init__(
-            namespace_model=namespace_model,
+            code_model=code_model,
             client=client,
             yaml_data=yaml_data,
             name=name,
@@ -98,7 +98,7 @@ class OperationBase(  # pylint: disable=too-many-public-methods
 
     def response_type_annotation(self, **kwargs) -> str:
         if (
-            self.namespace_model.options["head_as_boolean"]
+            self.code_model.options["head_as_boolean"]
             and self.request_builder.method.lower() == "head"
         ):
             return "bool"
@@ -127,7 +127,7 @@ class OperationBase(  # pylint: disable=too-many-public-methods
     def cls_type_annotation(self, *, async_mode: bool) -> str:
         if (
             self.request_builder.method.lower() == "head"
-            and self.namespace_model.options["head_as_boolean"]
+            and self.code_model.options["head_as_boolean"]
         ):
             return "ClsType[None]"
         return f"ClsType[{self.response_type_annotation(async_mode=async_mode)}]"
@@ -136,7 +136,7 @@ class OperationBase(  # pylint: disable=too-many-public-methods
         responses_with_body = [r for r in self.responses if r.type]
         if (
             self.request_builder.method.lower() == "head"
-            and self.namespace_model.options["head_as_boolean"]
+            and self.code_model.options["head_as_boolean"]
         ):
             return "bool"
         if responses_with_body:
@@ -154,9 +154,9 @@ class OperationBase(  # pylint: disable=too-many-public-methods
 
     def response_docstring_text(self, **kwargs) -> str:
         retval = self._response_docstring_helper("docstring_text", **kwargs)
-        if not self.namespace_model.options["version_tolerant"]:
+        if not self.code_model.options["version_tolerant"]:
             retval += " or the result of cls(response)"
-        if self.namespace_model.options["models_mode"] == "dpg" and any(
+        if self.code_model.options["models_mode"] == "dpg" and any(
             isinstance(r.type, ModelType) for r in self.responses
         ):
             r = next(r for r in self.responses if isinstance(r.type, ModelType))
@@ -204,13 +204,13 @@ class OperationBase(  # pylint: disable=too-many-public-methods
             )
         )
 
-    def _imports_shared(self, async_mode: bool, **kwargs: Any) -> FileImport:
+    def _imports_shared(
+        self, async_mode: bool, **kwargs: Any  # pylint: disable=unused-argument
+    ) -> FileImport:
         file_import = FileImport()
         file_import.add_submodule_import(
             "typing", "Any", ImportType.STDLIB, TypingSection.CONDITIONAL
         )
-        for param in self.parameters.method:
-            file_import.merge(param.imports(async_mode, **kwargs))
 
         response_types = [
             r.type_annotation(async_mode=async_mode) for r in self.responses if r.type
@@ -231,11 +231,18 @@ class OperationBase(  # pylint: disable=too-many-public-methods
         if self.abstract:
             return FileImport()
         file_import = self._imports_shared(async_mode, **kwargs)
+        for param in self.parameters.method:
+            file_import.merge(
+                param.imports_for_multiapi(
+                    async_mode,
+                    **kwargs,
+                )
+            )
         for response in self.responses:
             file_import.merge(
                 response.imports_for_multiapi(async_mode=async_mode, **kwargs)
             )
-        if self.namespace_model.options["models_mode"]:
+        if self.code_model.options["models_mode"]:
             for exception in self.exceptions:
                 file_import.merge(
                     exception.imports_for_multiapi(async_mode=async_mode, **kwargs)
@@ -272,12 +279,12 @@ class OperationBase(  # pylint: disable=too-many-public-methods
     ) -> FileImport:
         """Helper method to get a request builder import."""
         file_import = FileImport()
-        if self.namespace_model.options["builders_visibility"] != "embedded":
+        if self.code_model.options["builders_visibility"] != "embedded":
             group_name = request_builder.group_name
             rest_import_path = "..." if async_mode else ".."
             if group_name:
                 file_import.add_submodule_import(
-                    f"{rest_import_path}{self.namespace_model.rest_layer_name}",
+                    f"{rest_import_path}{self.code_model.rest_layer_name}",
                     group_name,
                     import_type=ImportType.LOCAL,
                     alias=f"rest_{group_name}",
@@ -285,16 +292,13 @@ class OperationBase(  # pylint: disable=too-many-public-methods
             else:
                 file_import.add_submodule_import(
                     rest_import_path,
-                    self.namespace_model.rest_layer_name,
+                    self.code_model.rest_layer_name,
                     import_type=ImportType.LOCAL,
                     alias="rest",
                 )
-        if (
-            self.namespace_model.options["builders_visibility"] == "embedded"
-            and async_mode
-        ):
+        if self.code_model.options["builders_visibility"] == "embedded" and async_mode:
             file_import.add_submodule_import(
-                f"...{self.namespace_model.operations_folder_name}.{self.filename}",
+                f"...{self.code_model.operations_folder_name}.{self.filename}",
                 request_builder.name,
                 import_type=ImportType.LOCAL,
             )
@@ -305,9 +309,16 @@ class OperationBase(  # pylint: disable=too-many-public-methods
             return FileImport()
         file_import = self._imports_shared(async_mode, **kwargs)
 
+        for param in self.parameters.method:
+            file_import.merge(
+                param.imports(
+                    async_mode,
+                    **kwargs,
+                )
+            )
         for response in self.responses:
             file_import.merge(response.imports(async_mode=async_mode, **kwargs))
-        if self.namespace_model.options["models_mode"]:
+        if self.code_model.options["models_mode"]:
             for exception in self.exceptions:
                 file_import.merge(exception.imports(async_mode=async_mode, **kwargs))
 
@@ -327,7 +338,7 @@ class OperationBase(  # pylint: disable=too-many-public-methods
             file_import.add_submodule_import(
                 "azure.core.exceptions", error, ImportType.AZURECORE
             )
-        if self.namespace_model.options["azure_arm"]:
+        if self.code_model.options["azure_arm"]:
             file_import.add_submodule_import(
                 "azure.mgmt.core.exceptions", "ARMErrorFormat", ImportType.AZURECORE
             )
@@ -343,7 +354,7 @@ class OperationBase(  # pylint: disable=too-many-public-methods
         if self.deprecated:
             file_import.add_import("warnings", ImportType.STDLIB)
 
-        if self.namespace_model.need_request_converter:
+        if self.code_model.need_request_converter:
             relative_path = "..." if async_mode else ".."
             file_import.add_submodule_import(
                 f"{relative_path}_vendor", "_convert_request", ImportType.LOCAL
@@ -359,7 +370,7 @@ class OperationBase(  # pylint: disable=too-many-public-methods
                 "azure.core.pipeline.transport", "HttpResponse", ImportType.AZURECORE
             )
         if (
-            self.namespace_model.options["builders_visibility"] == "embedded"
+            self.code_model.options["builders_visibility"] == "embedded"
             and not async_mode
         ):
             file_import.merge(self.request_builder.imports())
@@ -381,11 +392,7 @@ class OperationBase(  # pylint: disable=too-many-public-methods
         file_import.add_submodule_import(
             "typing", "TypeVar", ImportType.STDLIB, TypingSection.CONDITIONAL
         )
-        if (
-            self.namespace_model.options["tracing"]
-            and self.want_tracing
-            and not async_mode
-        ):
+        if self.code_model.options["tracing"] and self.want_tracing and not async_mode:
             file_import.add_submodule_import(
                 f"azure.core.tracing.decorator",
                 f"distributed_trace",
@@ -418,11 +425,11 @@ class OperationBase(  # pylint: disable=too-many-public-methods
         basename = self.group_name
         if basename == "":
             # in a mixin
-            basename = self.namespace_model.clients[0].legacy_filename
+            basename = self.code_model.clients[0].legacy_filename
 
         if (
             basename == "operations"
-            or self.namespace_model.options["combine_operation_files"]
+            or self.code_model.options["combine_operation_files"]
         ):
             return f"_operations"
         return f"_{basename}_operations"
@@ -435,27 +442,27 @@ class OperationBase(  # pylint: disable=too-many-public-methods
     def from_yaml(
         cls,
         yaml_data: Dict[str, Any],
-        namespace_model: "NamespaceModel",
+        code_model: "CodeModel",
         client: "Client",
     ):
         name = yaml_data["name"]
-        request_builder = namespace_model.lookup_request_builder(id(yaml_data))
+        request_builder = client.lookup_request_builder(id(yaml_data))
         responses = [
-            cast(ResponseType, get_response(r, namespace_model))
+            cast(ResponseType, get_response(r, code_model))
             for r in yaml_data["responses"]
         ]
         exceptions = [
-            Response.from_yaml(e, namespace_model) for e in yaml_data["exceptions"]
+            Response.from_yaml(e, code_model) for e in yaml_data["exceptions"]
         ]
-        parameter_list = ParameterList.from_yaml(yaml_data, namespace_model)
+        parameter_list = ParameterList.from_yaml(yaml_data, code_model)
         overloads = [
-            cls.from_yaml(overload, namespace_model, client)
+            cls.from_yaml(overload, code_model, client)
             for overload in yaml_data.get("overloads", [])
         ]
 
         return cls(
             yaml_data=yaml_data,
-            namespace_model=namespace_model,
+            code_model=code_model,
             client=client,
             request_builder=request_builder,
             name=name,
@@ -481,10 +488,10 @@ class Operation(OperationBase[Response]):
         if (
             self.has_response_body
             and not self.has_optional_return_type
-            and not self.namespace_model.options["models_mode"]
+            and not self.code_model.options["models_mode"]
         ):
             file_import.add_submodule_import("typing", "cast", ImportType.STDLIB)
-        if self.namespace_model.options["models_mode"] == "dpg":
+        if self.code_model.options["models_mode"] == "dpg":
             relative_path = "..." if async_mode else ".."
             if self.parameters.has_body:
                 file_import.add_submodule_import(
@@ -502,7 +509,7 @@ class Operation(OperationBase[Response]):
 
 
 def get_operation(
-    yaml_data: Dict[str, Any], namespace_model: "NamespaceModel", client: "Client"
+    yaml_data: Dict[str, Any], code_model: "CodeModel", client: "Client"
 ) -> OperationBase:
     if yaml_data["discriminator"] == "lropaging":
         from .lro_paging_operation import LROPagingOperation as OperationCls
@@ -512,4 +519,4 @@ def get_operation(
         from .paging_operation import PagingOperation as OperationCls  # type: ignore
     else:
         from . import Operation as OperationCls  # type: ignore
-    return OperationCls.from_yaml(yaml_data, namespace_model, client)
+    return OperationCls.from_yaml(yaml_data, code_model, client)

package/autorest/codegen/models/operation_group.py

@@ -7,13 +7,13 @@ from typing import Dict, List, Any, TYPE_CHECKING
 
 from autorest.codegen.models.utils import OrderedSet
 
-from .base_model import BaseModel
+from .base import BaseModel
 from .operation import OperationBase, get_operation
 from .imports import FileImport, ImportType, TypingSection
 from .utils import add_to_pylint_disable
 
 if TYPE_CHECKING:
-    from .code_model import NamespaceModel
+    from .code_model import CodeModel
     from .client import Client
 
 
@@ -23,12 +23,12 @@ class OperationGroup(BaseModel):
     def __init__(
         self,
         yaml_data: Dict[str, Any],
-        namespace_model: "NamespaceModel",
+        code_model: "CodeModel",
         client: "Client",
         operations: List[OperationBase],
         api_versions: List[str],
     ) -> None:
-        super().__init__(yaml_data, namespace_model)
+        super().__init__(yaml_data, code_model)
         self.client = client
         self.class_name: str = yaml_data["className"]
         self.property_name: str = yaml_data["propertyName"]
@@ -42,7 +42,7 @@ class OperationGroup(BaseModel):
     @property
     def base_class(self) -> str:
         base_classes: List[str] = []
-        if self.is_mixin and self.namespace_model.need_mixin_abc:
+        if self.is_mixin and self.code_model.need_mixin_abc:
             base_classes.append(f"{self.client.name}MixinABC")
         return ", ".join(base_classes)
 
@@ -84,12 +84,12 @@ class OperationGroup(BaseModel):
             )
         # for multiapi
         if (
-            self.namespace_model.model_types or self.namespace_model.enums
-        ) and self.namespace_model.options["models_mode"] == "msrest":
+            self.code_model.model_types or self.code_model.enums
+        ) and self.code_model.options["models_mode"] == "msrest":
             file_import.add_submodule_import(
                 relative_path, "models", ImportType.LOCAL, alias="_models"
             )
-        if self.namespace_model.need_mixin_abc:
+        if self.code_model.need_mixin_abc:
             file_import.add_submodule_import(
                 ".._vendor", f"{self.client.name}MixinABC", ImportType.LOCAL
             )
@@ -122,11 +122,11 @@ class OperationGroup(BaseModel):
     def from_yaml(
         cls,
         yaml_data: Dict[str, Any],
-        namespace_model: "NamespaceModel",
+        code_model: "CodeModel",
         client: "Client",
     ) -> "OperationGroup":
         operations = [
-            get_operation(o, namespace_model, client) for o in yaml_data["operations"]
+            get_operation(o, code_model, client) for o in yaml_data["operations"]
         ]
         api_versions: OrderedSet[str] = {}
         for operation in operations:
@@ -134,7 +134,7 @@ class OperationGroup(BaseModel):
                 api_versions[api_version] = None
         return cls(
             yaml_data=yaml_data,
-            namespace_model=namespace_model,
+            code_model=code_model,
             client=client,
             operations=operations,
             api_versions=list(api_versions.keys()),

package/autorest/codegen/models/paging_operation.py

@@ -17,7 +17,7 @@ from .parameter_list import ParameterList
 from .model_type import ModelType
 
 if TYPE_CHECKING:
-    from .code_model import NamespaceModel
+    from .code_model import CodeModel
     from .client import Client
 
 PagingResponseType = TypeVar(
@@ -29,7 +29,7 @@ class PagingOperationBase(OperationBase[PagingResponseType]):
     def __init__(
         self,
         yaml_data: Dict[str, Any],
-        namespace_model: "NamespaceModel",
+        code_model: "CodeModel",
         client: "Client",
         name: str,
         request_builder: RequestBuilder,
@@ -43,7 +43,7 @@ class PagingOperationBase(OperationBase[PagingResponseType]):
         override_success_response_to_200: bool = False,
     ) -> None:
         super().__init__(
-            namespace_model=namespace_model,
+            code_model=code_model,
             client=client,
             yaml_data=yaml_data,
             name=name,
@@ -58,9 +58,7 @@ class PagingOperationBase(OperationBase[PagingResponseType]):
         self.next_request_builder: Optional[
             Union[RequestBuilder, OverloadedRequestBuilder]
         ] = (
-            get_request_builder(
-                self.yaml_data["nextOperation"], namespace_model, client
-            )
+            get_request_builder(self.yaml_data["nextOperation"], code_model, client)
             if self.yaml_data.get("nextOperation")
             else None
         )
@@ -90,14 +88,14 @@ class PagingOperationBase(OperationBase[PagingResponseType]):
         if not rest_api_name:
             # That's an ok scenario, it just means no next page possible
             return None
-        if self.namespace_model.options["models_mode"]:
+        if self.code_model.options["models_mode"]:
             return self._get_attr_name(rest_api_name)
         return rest_api_name
 
     @property
     def item_name(self) -> str:
         rest_api_name = self.yaml_data["itemName"]
-        if self.namespace_model.options["models_mode"]:
+        if self.code_model.options["models_mode"]:
             return self._get_attr_name(rest_api_name)
         return rest_api_name
 
@@ -120,7 +118,7 @@ class PagingOperationBase(OperationBase[PagingResponseType]):
             )
         if (
             self.next_request_builder
-            and self.namespace_model.options["builders_visibility"] == "embedded"
+            and self.code_model.options["builders_visibility"] == "embedded"
             and not async_mode
         ):
             file_import.merge(self.next_request_builder.imports())
@@ -135,7 +133,7 @@ class PagingOperationBase(OperationBase[PagingResponseType]):
             return FileImport()
         file_import = self._imports_shared(async_mode, **kwargs)
         file_import.merge(super().imports(async_mode, **kwargs))
-        if self.namespace_model.options["tracing"] and self.want_tracing:
+        if self.code_model.options["tracing"] and self.want_tracing:
             file_import.add_submodule_import(
                 "azure.core.tracing.decorator",
                 "distributed_trace",

package/autorest/codegen/models/parameter.py

@@ -19,15 +19,15 @@ from typing import (
 )
 
 from .imports import FileImport, ImportType
-from .base_model import BaseModel
-from .base_type import BaseType
+from .base import BaseModel
+from .base import BaseType
 from .constant_type import ConstantType
 from .model_type import ModelType
 from .combined_type import CombinedType
 from .utils import add_to_description
 
 if TYPE_CHECKING:
-    from .code_model import NamespaceModel
+    from .code_model import CodeModel
     from .request_builder_parameter import RequestBuilderBodyParameter
 
 
@@ -61,10 +61,10 @@ class _ParameterBase(
     def __init__(
         self,
         yaml_data: Dict[str, Any],
-        namespace_model: "NamespaceModel",
+        code_model: "CodeModel",
         type: BaseType,
     ) -> None:
-        super().__init__(yaml_data, namespace_model)
+        super().__init__(yaml_data, code_model)
         self.rest_api_name: str = yaml_data["restApiName"]
         self.client_name: str = self.yaml_data["clientName"]
         self.optional: bool = self.yaml_data["optional"]
@@ -149,11 +149,8 @@ class _ParameterBase(
     def serialization_type(self) -> str:
         return self.type.serialization_type
 
-    def imports(self, async_mode: bool, **kwargs: Any) -> FileImport:
+    def _imports_shared(self, async_mode: bool, **_: Any) -> FileImport:
         file_import = FileImport()
-        file_import.merge(
-            self.type.imports(is_operation_file=True, async_mode=async_mode, **kwargs)
-        )
         if self.optional and self.client_default_value is None:
             file_import.add_submodule_import("typing", "Optional", ImportType.STDLIB)
         if self.added_on:
@@ -164,6 +161,22 @@ class _ParameterBase(
             )
         return file_import
 
+    def imports(self, async_mode: bool, **kwargs: Any) -> FileImport:
+        file_import = self._imports_shared(async_mode, **kwargs)
+        file_import.merge(
+            self.type.imports(is_operation_file=True, async_mode=async_mode, **kwargs)
+        )
+        return file_import
+
+    def imports_for_multiapi(self, async_mode: bool, **kwargs: Any) -> FileImport:
+        file_import = self._imports_shared(async_mode, **kwargs)
+        file_import.merge(
+            self.type.imports_for_multiapi(
+                is_operation_file=True, async_mode=async_mode, **kwargs
+            )
+        )
+        return file_import
+
     @property
     def method_location(self) -> ParameterMethodLocation:
         raise NotImplementedError("Please implement in children")
@@ -230,18 +243,18 @@ class BodyParameter(_BodyParameterBase):
 
     @classmethod
     def from_yaml(
-        cls, yaml_data: Dict[str, Any], namespace_model: "NamespaceModel"
+        cls, yaml_data: Dict[str, Any], code_model: "CodeModel"
     ) -> "BodyParameter":
         return cls(
             yaml_data=yaml_data,
-            namespace_model=namespace_model,
-            type=namespace_model.lookup_type(id(yaml_data["type"])),
+            code_model=code_model,
+            type=code_model.lookup_type(id(yaml_data["type"])),
         )
 
     def type_annotation(self, **kwargs: Any) -> str:
         annotation = super().type_annotation(**kwargs)
         model_seq = BodyParameter.get_model_seq(self.type)
-        if self.namespace_model.options["models_mode"] == "dpg" and model_seq >= 0:
+        if self.code_model.options["models_mode"] == "dpg" and model_seq >= 0:
             pattern = re.compile(r"Union\[.*\]")
             union_content = (
                 annotation[6:-1] if pattern.match(annotation) else annotation
@@ -254,7 +267,7 @@ class BodyParameter(_BodyParameterBase):
     def docstring_type(self, **kwargs: Any) -> str:
         docstring = super().docstring_type(**kwargs)
         model_seq = BodyParameter.get_model_seq(self.type)
-        if self.namespace_model.options["models_mode"] == "dpg" and model_seq >= 0:
+        if self.code_model.options["models_mode"] == "dpg" and model_seq >= 0:
             items = docstring.split(" or ")
             items.insert(model_seq + 1, "JSON")
             docstring = " or ".join(items)
@@ -284,11 +297,11 @@ class _MultipartBodyParameter(Generic[EntryBodyParameterType], BodyParameter):
     def __init__(
         self,
         yaml_data: Dict[str, Any],
-        namespace_model: "NamespaceModel",
+        code_model: "CodeModel",
         type: BaseType,
         entries: List[EntryBodyParameterType],
     ) -> None:
-        super().__init__(yaml_data, namespace_model, type)
+        super().__init__(yaml_data, code_model, type)
         self.entries = entries
 
     @property
@@ -305,14 +318,14 @@ class MultipartBodyParameter(
 
     @classmethod
     def from_yaml(
-        cls, yaml_data: Dict[str, Any], namespace_model: "NamespaceModel"
+        cls, yaml_data: Dict[str, Any], code_model: "CodeModel"
     ) -> "MultipartBodyParameter":
         return cls(
             yaml_data=yaml_data,
-            namespace_model=namespace_model,
-            type=namespace_model.lookup_type(id(yaml_data["type"])),
+            code_model=code_model,
+            type=code_model.lookup_type(id(yaml_data["type"])),
             entries=[
-                BodyParameter.from_yaml(entry, namespace_model)
+                BodyParameter.from_yaml(entry, code_model)
                 for entry in yaml_data["entries"]
             ],
         )
@@ -324,10 +337,10 @@ class Parameter(_ParameterBase):
     def __init__(
         self,
         yaml_data: Dict[str, Any],
-        namespace_model: "NamespaceModel",
+        code_model: "CodeModel",
         type: BaseType,
     ) -> None:
-        super().__init__(yaml_data, namespace_model, type=type)
+        super().__init__(yaml_data, code_model, type=type)
 
         self.implementation: str = yaml_data["implementation"]
         self.skip_url_encoding: bool = self.yaml_data.get("skipUrlEncoding", False)
@@ -371,18 +384,18 @@ class Parameter(_ParameterBase):
             ParameterLocation.QUERY,
         )
         if (
-            self.namespace_model.options["only_path_and_body_params_positional"]
+            self.code_model.options["only_path_and_body_params_positional"]
             and query_or_header
         ):
             return ParameterMethodLocation.KEYWORD_ONLY
         return ParameterMethodLocation.POSITIONAL
 
     @classmethod
-    def from_yaml(cls, yaml_data: Dict[str, Any], namespace_model: "NamespaceModel"):
+    def from_yaml(cls, yaml_data: Dict[str, Any], code_model: "CodeModel"):
         return cls(
             yaml_data=yaml_data,
-            namespace_model=namespace_model,
-            type=namespace_model.lookup_type(id(yaml_data["type"])),
+            code_model=code_model,
+            type=code_model.lookup_type(id(yaml_data["type"])),
         )
 
 
@@ -398,8 +411,8 @@ class ClientParameter(Parameter):
         if self.constant:
             return ParameterMethodLocation.KWARG
         if self.is_host and (
-            self.namespace_model.options["version_tolerant"]
-            or self.namespace_model.options["low_level_client"]
+            self.code_model.options["version_tolerant"]
+            or self.code_model.options["low_level_client"]
         ):
             # this means i am the base url
             return ParameterMethodLocation.KEYWORD_ONLY
@@ -425,9 +438,9 @@ class ConfigParameter(Parameter):
 
 
 def get_body_parameter(
-    yaml_data: Dict[str, Any], namespace_model: "NamespaceModel"
+    yaml_data: Dict[str, Any], code_model: "CodeModel"
 ) -> Union[BodyParameter, MultipartBodyParameter]:
     """Creates a regular body parameter or Multipart body parameter"""
     if yaml_data.get("entries"):
-        return MultipartBodyParameter.from_yaml(yaml_data, namespace_model)
-    return BodyParameter.from_yaml(yaml_data, namespace_model)
+        return MultipartBodyParameter.from_yaml(yaml_data, code_model)
+    return BodyParameter.from_yaml(yaml_data, code_model)