@autorest/python 5.14.0 → 5.17.0

package/autorest/codegen/models/parameter.py

@@ -3,141 +3,85 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
-import logging
-from enum import Enum
-
-from typing import Dict, Optional, List, Any, Union, Tuple, cast
-
-from .imports import FileImport, ImportType, TypingSection
+import abc
+from enum import Enum, auto
+
+from typing import (
+    Dict,
+    Any,
+    TYPE_CHECKING,
+    List,
+    Optional,
+    TypeVar,
+    Union,
+    Generic,
+)
+
+from .imports import FileImport, ImportType
 from .base_model import BaseModel
-from .base_schema import BaseSchema
-from .constant_schema import ConstantSchema
-from .object_schema import ObjectSchema
-from .property import Property
-from .primitive_schemas import IOSchema
+from .base_type import BaseType
+from .constant_type import ConstantType
+from .utils import add_to_description
+
+if TYPE_CHECKING:
+    from .code_model import CodeModel
+    from .request_builder_parameter import RequestBuilderBodyParameter
 
 
-_LOGGER = logging.getLogger(__name__)
+class ParameterLocation(str, Enum):
+    HEADER = "header"
+    PATH = "path"
+    ENDPOINT_PATH = "endpointPath"
+    QUERY = "query"
+    BODY = "body"
+    OTHER = "other"
 
-_HIDDEN_KWARGS = ["content_type"]
 
+class ParameterMethodLocation(Enum):
+    POSITIONAL = auto()
+    KEYWORD_ONLY = auto()
+    KWARG = auto()
 
-class ParameterLocation(Enum):
-    Path = "path"
-    Body = "body"
-    Query = "query"
-    Header = "header"
-    Uri = "uri"
-    Other = "other"
 
+class ParameterDelimeter(str, Enum):
+    SPACE = "space"
+    PIPE = "pipe"
+    TAB = "tab"
+    COMMA = "comma"
 
-class ParameterStyle(Enum):
-    simple = "simple"
-    label = "label"
-    matrix = "matrix"
-    form = "form"
-    spaceDelimited = "spaceDelimited"
-    pipeDelimited = "pipeDelimited"
-    deepObject = "deepObject"
-    tabDelimited = "tabDelimited"
-    json = "json"
-    binary = "binary"
-    xml = "xml"
-    multipart = "multipart"
 
+class _ParameterBase(
+    BaseModel, abc.ABC
+):  # pylint: disable=too-many-instance-attributes
+    """Base class for all parameters"""
 
-class Parameter(BaseModel):  # pylint: disable=too-many-instance-attributes, too-many-public-methods
     def __init__(
         self,
-        code_model,
         yaml_data: Dict[str, Any],
-        schema: BaseSchema,
-        rest_api_name: str,
-        serialized_name: str,
-        description: str,
-        implementation: str,
-        required: bool,
-        location: ParameterLocation,
-        skip_url_encoding: bool,
-        constraints: List[Any],
-        target_property_name: Optional[Union[int, str]] = None,  # first uses id as placeholder
-        style: Optional[ParameterStyle] = None,
-        explode: Optional[bool] = False,
-        *,
-        flattened: bool = False,
-        grouped_by: Optional["Parameter"] = None,
-        original_parameter: Optional["Parameter"] = None,
-        client_default_value: Optional[Any] = None,
-        keyword_only: Optional[bool] = None,
-        content_types: Optional[List[str]] = None,
+        code_model: "CodeModel",
+        type: BaseType,
     ) -> None:
-        super().__init__(yaml_data)
-        self.code_model = code_model
-        self.schema = schema
-        self.rest_api_name = rest_api_name
-        self.serialized_name = serialized_name
-        self._description = description
-        self._implementation = implementation
-        self.required = required
-        self.location = location
-        self.skip_url_encoding = skip_url_encoding
-        self.constraints = constraints
-        self.target_property_name = target_property_name
-        self.style = style
-        self.explode = explode
-        self.flattened = flattened
-        self.grouped_by = grouped_by
-        self.original_parameter = original_parameter
-        self.client_default_value = client_default_value
-        self.has_multiple_content_types: bool = False
-        self.multiple_content_types_type_annot: Optional[str] = None
-        self.multiple_content_types_docstring_type: Optional[str] = None
-        self._keyword_only = keyword_only
-        self.is_multipart = yaml_data.get("language", {}).get("python", {}).get("multipart", False)
-        self.is_data_input = yaml_data.get("isPartialBody", False) and not self.is_multipart
-        self.content_types = content_types or []
-        self.body_kwargs: List[Parameter] = []
-        self.is_body_kwarg = False
-        self.need_import = True
-        self.is_kwarg = (self.rest_api_name == "Content-Type" or (self.constant and self.rest_api_name != "Accept"))
-
-    def __hash__(self) -> int:
-        return hash(self.serialized_name)
-
-    @property
-    def description(self):
-        try:
-            description = self._description
-            if self.schema.extra_description_information:
-                if description:
-                    description += " "
-                description += f"{self.schema.extra_description_information}"
-            if isinstance(self.schema, ConstantSchema) and not self.constant:
-                if description:
-                    description += " "
-                description += f"Possible values are {self.schema.get_declaration(self.schema.value)} or {None}."
-            if self.has_default_value and not any(
-                l for l in ["default value is", "default is"] if l in description.lower()
-            ):
-                description += f" Default value is {self.default_value_declaration}."
-            if self.constant:
-                description += " Note that overriding this default value may result in unsupported behavior."
-            return description
-        except AttributeError:
-            pass
-        return self._description
-
-    @description.setter
-    def description(self, val: str):
-        self._description = val
-
-    @property
-    def is_json_parameter(self) -> bool:
-        if self.is_multipart or self.is_data_input:
-            return False
-        if self.style == ParameterStyle.xml:
-            return False
-        return True
+        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"]
+        self.location: ParameterLocation = self.yaml_data["location"]
+        self.client_default_value = self.yaml_data.get("clientDefaultValue", None)
+        self.in_docstring = self.yaml_data.get("inDocstring", True)
+        self.type = type
+        if self.client_default_value is None:
+            self.client_default_value = self.type.client_default_value
+        # name of grouper if it is grouped by another parameter
+        self.grouped_by: Optional[str] = self.yaml_data.get("groupedBy")
+        # property matching property name to parameter name for grouping params
+        # and flattened body params
+        self.property_to_parameter_name: Optional[Dict[str, str]] = self.yaml_data.get(
+            "propertyToParameterName"
+        )
+        self.flattened: bool = self.yaml_data.get("flattened", False)
+        self.in_flattened_body: bool = self.yaml_data.get("inFlattenedBody", False)
+        self.grouper: bool = self.yaml_data.get("grouper", False)
+        self.check_client_input: bool = self.yaml_data.get("checkClientInput", False)
 
     @property
     def constant(self) -> bool:
@@ -145,260 +89,301 @@ class Parameter(BaseModel):  # pylint: disable=too-many-instance-attributes, too
         Checking to see if it's required, because if not, we don't consider it
         a constant because it can have a value of None.
         """
-        if isinstance(self.schema, dict):
-            if not self.schema.get("type") == "constant":
-                return False
-        else:
-            if not isinstance(self.schema, ConstantSchema):
-                return False
-        return self.required
+        return not self.optional and isinstance(self.type, ConstantType)
 
     @property
-    def constant_declaration(self) -> str:
-        if self.schema:
-            if isinstance(self.schema, ConstantSchema):
-                return self.schema.get_declaration(self.schema.value)
-            raise ValueError(
-                "Trying to get constant declaration for a schema that is not ConstantSchema"
-                )
-        raise ValueError("Trying to get a declaration for a schema that doesn't exist")
+    def description(self) -> str:
+        base_description = self.yaml_data["description"]
+        type_description = self.type.description(is_operation_file=True)
+        if type_description:
+            base_description = add_to_description(base_description, type_description)
+        if self.optional and isinstance(self.type, ConstantType):
+            base_description = add_to_description(
+                base_description,
+                f"Known values are {self.type.get_declaration()} and None.",
+            )
+        if not (self.optional or self.client_default_value):
+            base_description = add_to_description(base_description, "Required.")
+        if self.client_default_value is not None:
+            base_description = add_to_description(
+                base_description,
+                f"Default value is {self.client_default_value_declaration}.",
+            )
+        if self.optional and self.client_default_value is None:
+            base_description = add_to_description(
+                base_description,
+                f"Default value is {self.client_default_value_declaration}.",
+            )
+        if self.constant:
+            base_description = add_to_description(
+                base_description,
+                "Note that overriding this default value may result in unsupported behavior.",
+            )
+        return base_description
 
     @property
-    def serialization_formats(self) -> List[str]:
-        return self.yaml_data.get('serializationFormats', [])
+    def client_default_value_declaration(self):
+        """Declaration of parameter's client default value"""
+        if self.client_default_value is None:
+            return None
+        return self.type.get_declaration(self.client_default_value)
 
-    @property
-    def xml_serialization_ctxt(self) -> str:
-        return self.schema.xml_serialization_ctxt() or ""
+    def type_annotation(self, **kwargs: Any) -> str:
+        kwargs["is_operation_file"] = True
+        type_annot = self.type.type_annotation(**kwargs)
+        if self.optional and self.client_default_value is None:
+            return f"Optional[{type_annot}]"
+        return type_annot
 
-    @property
-    def is_body(self) -> bool:
-        return self.location == ParameterLocation.Body
+    def docstring_text(self, **kwargs: Any) -> str:
+        return self.type.docstring_text(**kwargs)
 
-    @property
-    def pre_semicolon_content_types(self) -> List[str]:
-        """Splits on semicolon of media types and returns the first half.
-        I.e. ["text/plain; charset=UTF-8"] -> ["text/plain"]
-        """
-        return [content_type.split(";")[0] for content_type in self.content_types]
+    def docstring_type(self, **kwargs: Any) -> str:
+        return self.type.docstring_type(**kwargs)
 
     @property
-    def in_method_signature(self) -> bool:
-        return not(
-            # don't put accept in signature
-            self.rest_api_name == "Accept"
-            # If i'm not in the method code, no point in being in signature
-            or not self.in_method_code
-            # If I'm grouped, my grouper will be on signature, not me
-            or self.grouped_by
-            # If I'm body and it's flattened, I'm not either
-            or (self.is_body and self.flattened)
+    def serialization_type(self) -> str:
+        return self.type.serialization_type
+
+    def imports(self, async_mode: bool, **kwargs: 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)
+        return file_import
 
     @property
-    def corresponding_grouped_property(self) -> Property:
-        if not self.grouped_by:
-            raise ValueError("Should only be calling if your parameter is grouped")
-        try:
-            return next(
-                p for p in cast(ObjectSchema, self.grouped_by.schema).properties
-                if any(op for op in p.yaml_data['originalParameter'] if id(op) == self.id)
-            )
-        except StopIteration:
-            raise ValueError("There is not a corresponding grouped property for your parameter.")
+    def method_location(self) -> ParameterMethodLocation:
+        raise NotImplementedError("Please implement in children")
 
     @property
-    def in_method_code(self) -> bool:
-        return self.rest_api_name != '$host'
+    def description_keyword(self) -> str:
+        return (
+            "param"
+            if self.method_location == ParameterMethodLocation.POSITIONAL
+            else "keyword"
+        )
 
     @property
-    def implementation(self) -> str:
-        # https://github.com/Azure/autorest.modelerfour/issues/81
-        if self.serialized_name == "api_version":
-            return "Method"
-        return self._implementation
+    def docstring_type_keyword(self) -> str:
+        return (
+            "type"
+            if self.method_location == ParameterMethodLocation.POSITIONAL
+            else "paramtype"
+        )
 
     @property
-    def _is_io_json(self):
-        return any(
-            k for k in self.body_kwargs if k.serialized_name == "json"
-        ) and isinstance(self.schema, IOSchema)
-
-    def _default_value(self) -> Tuple[Optional[Any], str, str]:
-        type_annot = self.multiple_content_types_type_annot or self.schema.operation_type_annotation
-        if self._is_io_json:
-            type_annot = f"Union[{type_annot}, JSONType]"
-        any_types = ["Any", "JSONType"]
-        if not self.required and type_annot not in any_types and not self._is_io_json:
-            type_annot = f"Optional[{type_annot}]"
+    @abc.abstractmethod
+    def in_method_signature(self) -> bool:
+        ...
 
-        if self.client_default_value is not None:
-            return self.client_default_value, self.schema.get_declaration(self.client_default_value), type_annot
-
-        if self.multiple_content_types_type_annot:
-            # means this parameter has multiple media types. We force default value to be None.
-            default_value = None
-            default_value_declaration = "None"
-        else:
-            if isinstance(self.schema, ConstantSchema):
-                if (self.required or
-                    self.is_content_type or
-                    not self.code_model.options["default_optional_constants_to_none"]):
-                    default_value = self.schema.get_declaration(self.schema.value)
-                else:
-                    default_value = None
-                default_value_declaration = default_value
-            else:
-                default_value = self.schema.default_value
-                default_value_declaration = self.schema.default_value_declaration
-        if default_value is not None and self.required:
-            _LOGGER.warning(
-                "Parameter '%s' is required and has a default value, this combination is not recommended",
-                self.rest_api_name
-            )
+    def method_signature(self, is_python3_file: bool, async_mode: bool) -> str:
+        type_annot = self.type_annotation(async_mode=async_mode)
+        if is_python3_file:
+            if self.client_default_value is not None or self.optional:
+                return f"{self.client_name}: {type_annot} = {self.client_default_value_declaration},"
+            return f"{self.client_name}: {type_annot},"
+        if self.client_default_value is not None or self.optional:
+            return f"{self.client_name}={self.client_default_value_declaration},  # type: {type_annot}"
+        return f"{self.client_name},  # type: {type_annot}"
 
-        return default_value, default_value_declaration, type_annot
 
-    @property
-    def description_keyword(self) -> str:
-        return "keyword" if self.is_kwarg or self.is_keyword_only else "param"
+class _BodyParameterBase(_ParameterBase):
+    """Base class for body parameters"""
 
     @property
-    def docstring_type_keyword(self) -> str:
-        return "paramtype" if self.is_kwarg or self.is_keyword_only else "type"
+    def is_partial_body(self) -> bool:
+        """Whether it's part of a bigger body parameter, i.e. a MultipartBodyParameter"""
+        return self.yaml_data.get("isPartialBody", False)
 
     @property
-    def default_value(self) -> Optional[Any]:
-        # exposing default_value because client_default_value doesn't get updated with
-        # default values we bubble up from the schema
-        return self._default_value()[0]
+    def method_location(self) -> ParameterMethodLocation:
+        return (
+            ParameterMethodLocation.KWARG
+            if self.constant
+            else ParameterMethodLocation.POSITIONAL
+        )
 
     @property
-    def default_value_declaration(self) -> Optional[Any]:
-        return self._default_value()[1]
+    def in_method_signature(self) -> bool:
+        return not (self.flattened or self.grouped_by)
 
-    @property
-    def type_annotation(self) -> str:
-        return self._default_value()[2]
 
-    @property
-    def serialization_type(self) -> str:
-        return self.schema.serialization_type
+class BodyParameter(_BodyParameterBase):
+    """Body parameter."""
 
     @property
-    def docstring_type(self) -> str:
-        retval = self.multiple_content_types_docstring_type or self.schema.docstring_type
-        if self._is_io_json:
-            retval += " or JSONType"
-        return retval
+    def content_types(self) -> List[str]:
+        return self.yaml_data["contentTypes"]
 
     @property
-    def has_default_value(self):
-        return self.default_value is not None or not self.required
+    def default_content_type(self) -> str:
+        return self.yaml_data["defaultContentType"]
 
-    def method_signature(self, is_python3_file: bool) -> str:
-        if is_python3_file:
-            if self.has_default_value:
-                return f"{self.serialized_name}: {self.type_annotation} = {self.default_value_declaration},"
-            return f"{self.serialized_name}: {self.type_annotation},"
-        if self.has_default_value:
-            return f"{self.serialized_name}={self.default_value_declaration},  # type: {self.type_annotation}"
-        return f"{self.serialized_name},  # type: {self.type_annotation}"
+    @classmethod
+    def from_yaml(
+        cls, yaml_data: Dict[str, Any], code_model: "CodeModel"
+    ) -> "BodyParameter":
+        return cls(
+            yaml_data=yaml_data,
+            code_model=code_model,
+            type=code_model.lookup_type(id(yaml_data["type"])),
+        )
 
-    @property
-    def full_serialized_name(self) -> str:
-        origin_name = self.serialized_name
-        if self.implementation == "Client":
-            origin_name = f"self._config.{self.serialized_name}"
-        return origin_name
 
-    @property
-    def is_keyword_only(self) -> bool:
-        # this means in async mode, I am documented like def hello(positional_1, *, me!)
-        return self._keyword_only or False
+EntryBodyParameterType = TypeVar(
+    "EntryBodyParameterType", bound=Union[BodyParameter, "RequestBuilderBodyParameter"]
+)
+
 
-    @is_keyword_only.setter
-    def is_keyword_only(self, val: bool) -> None:
-        self._keyword_only = val
-        self.is_kwarg = False
+class _MultipartBodyParameter(Generic[EntryBodyParameterType], BodyParameter):
+    """Base class for MultipartBodyParameter and RequestBuilderMultipartBodyParameter"""
+
+    def __init__(
+        self,
+        yaml_data: Dict[str, Any],
+        code_model: "CodeModel",
+        type: BaseType,
+        entries: List[EntryBodyParameterType],
+    ) -> None:
+        super().__init__(yaml_data, code_model, type)
+        self.entries = entries
 
     @property
-    def is_hidden(self) -> bool:
-        return self.serialized_name in _HIDDEN_KWARGS and self.is_kwarg or (
-            self.yaml_data["implementation"] == "Client" and self.constant
+    def in_method_signature(self) -> bool:
+        # Right now, only legacy generates with multipart bodies
+        # and legacy generates with the multipart body arguments splatted out
+        return False
+
+
+class MultipartBodyParameter(
+    _MultipartBodyParameter[BodyParameter]  # pylint: disable=unsubscriptable-object
+):
+    """Multipart body parameter for Operation. Used for files and data input."""
+
+    @classmethod
+    def from_yaml(
+        cls, yaml_data: Dict[str, Any], code_model: "CodeModel"
+    ) -> "MultipartBodyParameter":
+        return cls(
+            yaml_data=yaml_data,
+            code_model=code_model,
+            type=code_model.lookup_type(id(yaml_data["type"])),
+            entries=[
+                BodyParameter.from_yaml(entry, code_model)
+                for entry in yaml_data["entries"]
+            ],
         )
 
+
+class Parameter(_ParameterBase):
+    """Basic Parameter class"""
+
+    def __init__(
+        self,
+        yaml_data: Dict[str, Any],
+        code_model: "CodeModel",
+        type: BaseType,
+    ) -> None:
+        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)
+        self.explode: bool = self.yaml_data.get("explode", False)
+        self.in_overload: bool = self.yaml_data["inOverload"]
+        self.in_overriden: bool = self.yaml_data.get("inOverriden", False)
+        self.delimiter: Optional[ParameterDelimeter] = self.yaml_data.get("delimiter")
+
+    @property
+    def in_method_signature(self) -> bool:
+        return not (self.rest_api_name == "Accept" or self.grouped_by or self.flattened)
+
+    @property
+    def full_client_name(self) -> str:
+        if self.implementation == "Client":
+            return f"self._config.{self.client_name}"
+        return self.client_name
+
     @property
-    def is_content_type(self) -> bool:
-        return self.rest_api_name == "Content-Type" and self.location == ParameterLocation.Header
+    def xml_serialization_ctxt(self) -> str:
+        return self.type.xml_serialization_ctxt or ""
 
     @property
-    def is_positional(self) -> bool:
-        return self.in_method_signature and not (self.is_keyword_only or self.is_kwarg)
+    def method_location(self) -> ParameterMethodLocation:
+        if not self.in_method_signature:
+            raise ValueError(f"Parameter '{self.client_name}' is not in the method.")
+        if self.grouper:
+            return ParameterMethodLocation.POSITIONAL
+        if self.constant:
+            return ParameterMethodLocation.KWARG
+        if self.rest_api_name == "Content-Type":
+            if self.in_overload:
+                return ParameterMethodLocation.KEYWORD_ONLY
+            return ParameterMethodLocation.KWARG
+        query_or_header = self.location in (
+            ParameterLocation.HEADER,
+            ParameterLocation.QUERY,
+        )
+        if (
+            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],
-        *,
-        code_model,
-        content_types: Optional[List[str]] = None
-    ) -> "Parameter":
-        http_protocol = yaml_data["protocol"].get("http", {"in": ParameterLocation.Other})
+    def from_yaml(cls, yaml_data: Dict[str, Any], code_model: "CodeModel"):
         return cls(
-            code_model=code_model,
             yaml_data=yaml_data,
-            schema=yaml_data.get("schema", None),  # FIXME replace by operation model
-            # See also https://github.com/Azure/autorest.modelerfour/issues/80
-            rest_api_name=yaml_data["language"]["default"].get(
-                "serializedName", yaml_data["language"]["default"]["name"]
-            ),
-            serialized_name=yaml_data["language"]["python"]["name"],
-            description=yaml_data["language"]["python"]["description"],
-            implementation=yaml_data["implementation"],
-            required=yaml_data.get("required", False),
-            location=ParameterLocation(http_protocol["in"]),
-            skip_url_encoding=yaml_data.get("extensions", {}).get("x-ms-skip-url-encoding", False),
-            constraints=[],  # FIXME constraints
-            target_property_name=id(yaml_data["targetProperty"]) if yaml_data.get("targetProperty") else None,
-            style=ParameterStyle(http_protocol["style"]) if "style" in http_protocol else None,
-            explode=http_protocol.get("explode", False),
-            grouped_by=yaml_data.get("groupedBy", None),
-            original_parameter=yaml_data.get("originalParameter", None),
-            flattened=yaml_data.get("flattened", False),
-            client_default_value=yaml_data.get("clientDefaultValue"),
-            content_types=content_types
+            code_model=code_model,
+            type=code_model.lookup_type(id(yaml_data["type"])),
         )
 
-    def imports(self) -> FileImport:
-        file_import = self.schema.imports()
-        if not self.required:
-            file_import.add_submodule_import("typing", "Optional", ImportType.STDLIB, TypingSection.CONDITIONAL)
-        if self.has_multiple_content_types or self._is_io_json:
-            file_import.add_submodule_import("typing", "Union", ImportType.STDLIB, TypingSection.CONDITIONAL)
 
-        return file_import
+class ClientParameter(Parameter):
+    """Client parameter"""
 
-class ParameterOnlyPathAndBodyPositional(Parameter):
+    @property
+    def is_host(self) -> bool:
+        return self.rest_api_name == "$host"
 
     @property
-    def is_keyword_only(self) -> bool:
-        if self._keyword_only is not None:
-            return self._keyword_only
-        return self.in_method_signature and not (
-            self.is_hidden or
-            self.location == ParameterLocation.Path or
-            self.location == ParameterLocation.Uri or
-            self.location == ParameterLocation.Body or
-            self.is_kwarg
-        )
+    def method_location(self) -> ParameterMethodLocation:
+        if self.constant:
+            return ParameterMethodLocation.KWARG
+        if self.is_host and (
+            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
+        return ParameterMethodLocation.POSITIONAL
+
 
-    @is_keyword_only.setter
-    def is_keyword_only(self, val: bool) -> None:
-        self._keyword_only = val
-        self.is_kwarg = False
+class ConfigParameter(Parameter):
+    """Config Parameter"""
 
-def get_parameter(code_model):
-    if code_model.options["only_path_and_body_params_positional"]:
-        return ParameterOnlyPathAndBodyPositional
-    return Parameter
+    @property
+    def in_method_signature(self) -> bool:
+        return not self.is_host
+
+    @property
+    def is_host(self) -> bool:
+        return self.rest_api_name == "$host"
+
+    @property
+    def method_location(self) -> ParameterMethodLocation:
+        if self.constant:
+            return ParameterMethodLocation.KWARG
+        return ParameterMethodLocation.POSITIONAL
+
+
+def get_body_parameter(
+    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, code_model)
+    return BodyParameter.from_yaml(yaml_data, code_model)