@autorest/python 5.14.0 → 5.17.0

package/autorest/codegen/models/parameter_list.py

@@ -3,41 +3,92 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
-from collections.abc import MutableSequence
-from copy import copy
 import logging
-from typing import cast, List, Callable, Optional, TypeVar, Dict, TYPE_CHECKING
+from typing import (
+    Any,
+    Callable,
+    Dict,
+    List,
+    Optional,
+    TYPE_CHECKING,
+    Union,
+    Generic,
+    TypeVar,
+    cast,
+)
+from abc import abstractmethod
+from collections.abc import MutableSequence
+from enum import Enum
+
+from .request_builder_parameter import (
+    RequestBuilderBodyParameter,
+    RequestBuilderMultipartBodyParameter,
+    RequestBuilderParameter,
+    get_request_body_parameter,
+)
+from .parameter import (
+    MultipartBodyParameter,
+    ParameterLocation,
+    BodyParameter,
+    Parameter,
+    ParameterMethodLocation,
+    ClientParameter,
+    ConfigParameter,
+    get_body_parameter,
+)
+
+ParameterType = TypeVar(
+    "ParameterType", bound=Union[Parameter, RequestBuilderParameter]
+)
+BodyParameterType = TypeVar(
+    "BodyParameterType", bound=Union[BodyParameter, RequestBuilderBodyParameter]
+)
+RequestBuilderBodyParameterType = Union[
+    RequestBuilderBodyParameter, RequestBuilderMultipartBodyParameter
+]
 
-from .parameter import Parameter, ParameterLocation
-from .base_schema import BaseSchema
-from .dictionary_schema import DictionarySchema
-from .primitive_schemas import AnySchema, StringSchema
-from .utils import JSON_REGEXP
 
 if TYPE_CHECKING:
-    from .schema_request import SchemaRequest
+    from .code_model import CodeModel
+
+
+class ParameterImplementation(Enum):
+    METHOD = "method"
+    CLIENT = "client"
 
-T = TypeVar('T')
-OrderedSet = Dict[T, None]
 
 _LOGGER = logging.getLogger(__name__)
 
-def _method_signature_helper(positional: List[str], keyword_only: Optional[List[str]], kwarg_params: List[str]):
+
+def method_signature_helper(
+    positional: List[str], keyword_only: Optional[List[str]], kwarg_params: List[str]
+):
     keyword_only = keyword_only or []
     return positional + keyword_only + kwarg_params
 
 
-class ParameterList(MutableSequence):  # pylint: disable=too-many-public-methods
+def _sort(params):
+    return sorted(
+        params, key=lambda x: not (x.client_default_value or x.optional), reverse=True
+    )
+
+
+class _ParameterListBase(
+    MutableSequence, Generic[ParameterType, BodyParameterType]
+):  # pylint: disable=too-many-public-methods
+    """Base class for all of our different ParameterList classes"""
+
     def __init__(
         self,
-        code_model,
-        parameters: Optional[List[Parameter]] = None,
-        schema_requests: Optional[List["SchemaRequest"]] = None,
+        yaml_data: Dict[str, Any],
+        code_model: "CodeModel",
+        parameters: List[ParameterType],
+        body_parameter: Optional[BodyParameterType] = None,
     ) -> None:
+        self.yaml_data = yaml_data
         self.code_model = code_model
-        self.schema_requests = schema_requests or []
         self.parameters = parameters or []
-        self._json_body: Optional[BaseSchema] = None
+        self._body_parameter = body_parameter
 
     # MutableSequence
 
@@ -55,431 +106,389 @@ class ParameterList(MutableSequence):  # pylint: disable=too-many-public-methods
     def __delitem__(self, index):
         del self.parameters[index]
 
-    def insert(self, index: int, value: Parameter) -> None:
+    def insert(self, index: int, value: ParameterType) -> None:
         self.parameters.insert(index, value)
 
     # Parameter helpers
 
-    def has_any_location(self, location: ParameterLocation) -> bool:
-        return bool([parameter for parameter in self.parameters if parameter.location == location])
-
-    def get_from_predicate(self, predicate: Callable[[Parameter], bool]) -> List[Parameter]:
-        return [parameter for parameter in self.parameters if predicate(parameter)]
-
-    def get_from_location(self, location: ParameterLocation) -> List[Parameter]:
-        return self.get_from_predicate(lambda parameter: parameter.location == location)
-
-    @property
-    def content_types(self) -> List[str]:
-        ordered_set = {
-            m: None
-            for request in self.schema_requests
-            for m in request.content_types
-        }
-        return list(ordered_set.keys())
+    @staticmethod
+    @abstractmethod
+    def parameter_creator() -> Callable[[Dict[str, Any], "CodeModel"], ParameterType]:
+        """Callable for creating parameters"""
+        ...
 
-    @property
-    def default_content_type(self) -> str:
-        json_content_types = [c for c in self.content_types if JSON_REGEXP.match(c)]
-        if json_content_types:
-            if "application/json" in json_content_types:
-                return "application/json"
-            return json_content_types[0]
-
-        xml_content_types = [c for c in self.content_types if "xml" in c]
-        if xml_content_types:
-            if "application/xml" in xml_content_types:
-                return "application/xml"
-            return xml_content_types[0]
-        return self.content_types[0]
+    @staticmethod
+    @abstractmethod
+    def body_parameter_creator() -> Callable[
+        [Dict[str, Any], "CodeModel"], BodyParameterType
+    ]:
+        """Callable for creating body parameters"""
+        ...
 
     @property
-    def json_body(self) -> BaseSchema:
-        if not self._json_body:
-            self._json_body = self.body[0].schema
-        return self._json_body
+    def grouped(self) -> List[Union[ParameterType, BodyParameterType]]:
+        """All parameters that are inside a parameter group"""
+        params: List[Union[ParameterType, BodyParameterType]] = [
+            p for p in self.parameters if p.grouped_by
+        ]
+        if self.has_body and self.body_parameter.grouped_by:
+            params.append(self.body_parameter)
+        return params
 
     @property
     def has_body(self) -> bool:
-        return self.has_any_location(ParameterLocation.Body)
-
-    @property
-    def body(self) -> List[Parameter]:
-        if not self.has_body:
-            raise ValueError(f"Can't get body parameter")
-        # Should we check if there is two body? Modeler role right?
-        body_params = self.get_from_location(ParameterLocation.Body)
-        return body_params
-
-    @staticmethod
-    def _wanted_path_parameter(parameter: Parameter):
-        # TODO add 'and parameter.location == "Method"' as requirement to this check once
-        # I can use send_request on operations.
-        # Don't want to duplicate code from send_request.
-        return parameter.location == ParameterLocation.Uri and parameter.rest_api_name != "$host"
-
-    @property
-    def implementation(self) -> str:
-        return "Method"
+        """Whether there is a body parameter in the parameter list"""
+        return bool(self._body_parameter)
 
     @property
-    def path(self) -> List[Parameter]:
+    def path(self) -> List[ParameterType]:
+        """All path parameters"""
         return [
-            parameter
-            for parameter in self.parameters
-            if self._wanted_path_parameter(parameter)
+            p
+            for p in self.parameters
+            if p.location in (ParameterLocation.PATH, ParameterLocation.ENDPOINT_PATH)
         ]
 
     @property
-    def query(self) -> List[Parameter]:
-        return self.get_from_location(ParameterLocation.Query)
-
-    @property
-    def headers(self) -> List[Parameter]:
-        headers = self.get_from_location(ParameterLocation.Header)
-        if not headers:
-            return headers
-        return list({
-            header.serialized_name: header
-            for header in headers
-        }.values())
+    def query(self) -> List[ParameterType]:
+        """All query parameters"""
+        return [p for p in self.parameters if p.location == ParameterLocation.QUERY]
 
     @property
-    def grouped(self) -> List[Parameter]:
-        return self.get_from_predicate(lambda parameter: cast(bool, parameter.grouped_by))
+    def headers(self) -> List[ParameterType]:
+        """All header parameters"""
+        return [p for p in self.parameters if p.location == ParameterLocation.HEADER]
 
     @property
-    def groupers(self) -> List[Parameter]:
-        groupers: List[Parameter] = []
-        for parameter in self.parameters:
-            if any([
-                p for p in self.grouped
-                if p.grouped_by and id(p.grouped_by.yaml_data) == id(parameter.yaml_data)
-            ]):
-                groupers.append(parameter)
-        return groupers
+    def constant(self) -> List[Union[ParameterType, BodyParameterType]]:
+        """All constant parameters"""
+        return [p for p in self.parameters if p.constant]
 
     @property
-    def constant(self) -> List[Parameter]:
-        """Return the constants of this parameter list.
-
-        This excludes the constant from flatening on purpose, since technically they are not
-        constant from this set of parameters, they are constants on the models and hence they do
-        not have impact on any generation at this level
-        """
-        return self.get_from_predicate(
-            lambda parameter: parameter.constant
+    def positional(self) -> List[Union[ParameterType, BodyParameterType]]:
+        """All positional parameters"""
+        return _sort(
+            [
+                p
+                for p in self.unsorted_method_params
+                if p.method_location == ParameterMethodLocation.POSITIONAL
+            ]
         )
 
     @property
-    def multipart(self) -> List[Parameter]:
-        return self.get_from_predicate(
-            lambda parameter: parameter.is_multipart and not parameter.is_body_kwarg
+    def keyword_only(self) -> List[Union[ParameterType, BodyParameterType]]:
+        """All keyword only parameters"""
+        return _sort(
+            [
+                p
+                for p in self.unsorted_method_params
+                if p.method_location == ParameterMethodLocation.KEYWORD_ONLY
+            ]
         )
 
     @property
-    def data_inputs(self) -> List[Parameter]:
-        return self.get_from_predicate(
-            lambda parameter: parameter.is_data_input and not parameter.is_body_kwarg
+    def kwarg(self) -> List[Union[ParameterType, BodyParameterType]]:
+        """All kwargs"""
+        return _sort(
+            [
+                p
+                for p in self.unsorted_method_params
+                if p.method_location == ParameterMethodLocation.KWARG
+            ]
         )
 
-    def _filter_out_multiple_content_type(self, kwarg_params):
-        """We don't want multiple content type kwargs in the method signature"""
-        content_type_params = [k for k in kwarg_params if k.rest_api_name == "Content-Type"]
-        if len(content_type_params) > 1:
-            # we don't want multiple content type params in the method, just one
-            # we'll pick the one with the default content type
-            kwarg_params = [
-                k for k in kwarg_params
-                if not (
-                    k.rest_api_name == "Content-Type"
-                    and k.default_value_declaration != f'"{self.default_content_type}"'
-                )
-            ]
-        return kwarg_params
+    @property
+    def body_parameter(self) -> BodyParameterType:
+        """The body parameter of the parameter list. Will only ever be at most one."""
+        if not self._body_parameter:
+            raise ValueError("There is no body parameter")
+        return self._body_parameter
 
     @property
-    def method(self) -> List[Parameter]:
-        """The list of parameter used in method signature.
-        """
-        # Client level should not be on Method, etc.
-        parameters_of_this_implementation = self.get_from_predicate(
-            lambda parameter: parameter.implementation == self.implementation
-        )
-        positional = [p for p in parameters_of_this_implementation if p.is_positional]
-        keyword_only = self._filter_out_multiple_content_type(
-            [p for p in parameters_of_this_implementation if p.is_keyword_only]
-        )
-        kwargs = self._filter_out_multiple_content_type(
-            [p for p in parameters_of_this_implementation if p.is_kwarg]
-        )
-        def _sort(params):
-            return sorted(params, key=lambda x: not x.default_value and x.required, reverse=True)
-        signature_parameters = (
-            _sort(positional) + _sort(keyword_only) + _sort(kwargs)
-        )
-        return signature_parameters
+    @abstractmethod
+    def implementation(self) -> str:
+        """Whether this is a client or a method parameter"""
+        ...
 
+    @property
+    def unsorted_method_params(self) -> List[Union[ParameterType, BodyParameterType]]:
+        """Method params before sorting"""
+        method_params: List[Union[ParameterType, BodyParameterType]] = [
+            p
+            for p in self.parameters
+            if p.in_method_signature and p.implementation == self.implementation
+        ]
+        if self._body_parameter:
+            if self._body_parameter.in_method_signature:
+                method_params.append(self._body_parameter)
+            try:
+                # i am a multipart body parameter
+                # Only legacy generates operations with me, so I will follow the legacy rules
+                # I will splat out my entries as individual entries
+                method_params.extend(self._body_parameter.entries)  # type: ignore
+            except AttributeError:
+                pass
+        return method_params
 
-    def method_signature(self, is_python3_file: bool) -> List[str]:
-        return _method_signature_helper(
-            positional=self.method_signature_positional(is_python3_file),
-            keyword_only=self.method_signature_keyword_only(is_python3_file),
-            kwarg_params=self.method_signature_kwargs(is_python3_file)
+    @property
+    def method(self) -> List[Union[ParameterType, BodyParameterType]]:
+        """Sorted method params. First positional, then keyword only, then kwarg"""
+        return self.positional + self.keyword_only + self.kwarg
+
+    def method_signature(self, is_python3_file: bool, async_mode: bool) -> List[str]:
+        """Method signature for this parameter list."""
+        return method_signature_helper(
+            positional=self.method_signature_positional(is_python3_file, async_mode),
+            keyword_only=self.method_signature_keyword_only(
+                is_python3_file, async_mode
+            ),
+            kwarg_params=self.method_signature_kwargs(is_python3_file),
         )
 
-    def method_signature_positional(self, is_python3_file: bool) -> List[str]:
-        return [parameter.method_signature(is_python3_file) for parameter in self.positional]
+    def method_signature_positional(
+        self, is_python3_file: bool, async_mode: bool
+    ) -> List[str]:
+        """Signature for positional parameters"""
+        return [
+            parameter.method_signature(is_python3_file, async_mode)
+            for parameter in self.positional
+        ]
 
-    def method_signature_keyword_only(self, is_python3_file: bool) -> List[str]:
+    def method_signature_keyword_only(
+        self, is_python3_file: bool, async_mode: bool
+    ) -> List[str]:
+        """Signature for keyword only parameters"""
         if not (self.keyword_only and is_python3_file):
             return []
-        return ["*,"] + [parameter.method_signature(is_python3_file) for parameter in self.keyword_only]
+        return ["*,"] + [
+            parameter.method_signature(is_python3_file, async_mode)
+            for parameter in self.keyword_only
+        ]
 
     @staticmethod
     def method_signature_kwargs(is_python3_file: bool) -> List[str]:
+        """Signature for kwargs"""
         return ["**kwargs: Any"] if is_python3_file else ["**kwargs  # type: Any"]
 
-    @property
-    def positional(self) -> List[Parameter]:
-        return [p for p in self.method if p.is_positional]
-
-    @property
-    def keyword_only(self) -> List[Parameter]:
-        return [p for p in self.method if p.is_keyword_only]
-
-    @property
-    def kwargs(self) -> List[Parameter]:
-        return [p for p in self.method if p.is_kwarg]
-
-    def kwargs_to_pop(self, is_python3_file: bool) -> List[Parameter]:
-        kwargs_to_pop = self.kwargs
+    def kwargs_to_pop(
+        self, is_python3_file: bool
+    ) -> List[Union[ParameterType, BodyParameterType]]:
+        """Method kwargs we want to pop"""
+        # don't want to pop bodies unless it's a constant
+        kwargs_to_pop = self.kwarg
         if not is_python3_file:
             kwargs_to_pop += self.keyword_only
-        return kwargs_to_pop
+        return [
+            k
+            for k in kwargs_to_pop
+            if k.location != ParameterLocation.BODY or k.constant
+        ]
 
     @property
     def call(self) -> List[str]:
+        """How to pass in parameters to call the operation"""
         retval = [
-            p.serialized_name for p in self.positional
+            p.client_name
+            for p in self.method
+            if p.method_location == ParameterMethodLocation.POSITIONAL
         ]
-        retval.extend([
-            f"{p.serialized_name}={p.serialized_name}"
-            for p in self.keyword_only
-        ])
+        retval.extend(
+            [
+                f"{p.client_name}={p.client_name}"
+                for p in self.method
+                if p.method_location == ParameterMethodLocation.KEYWORD_ONLY
+            ]
+        )
         retval.append("**kwargs")
         return retval
 
-    @property
-    def is_flattened(self) -> bool:
-        return cast(bool, self.get_from_predicate(lambda parameter: parameter.flattened))
-
-def _create_files_or_data_param(
-    params: List[Parameter], serialized_name: str, description: str
-) -> Parameter:
-    params[0].need_import = False
-    param = copy(params[0])
-    param.serialized_name = serialized_name
-    param.schema = DictionarySchema(
-        namespace="",
-        yaml_data={},
-        element_type=AnySchema(namespace="", yaml_data={}),
-    )
-    param.description = description
-    return param
+    @classmethod
+    def from_yaml(cls, yaml_data: Dict[str, Any], code_model: "CodeModel"):
+        parameters = [
+            cls.parameter_creator()(parameter, code_model)
+            for parameter in yaml_data["parameters"]
+        ]
+        body_parameter = None
+        if yaml_data.get("bodyParameter"):
+            body_parameter = cls.body_parameter_creator()(
+                yaml_data["bodyParameter"], code_model
+            )
+        return cls(
+            yaml_data,
+            code_model,
+            parameters=parameters,
+            body_parameter=body_parameter,
+        )
+
+
+class _ParameterList(
+    _ParameterListBase[  # pylint: disable=unsubscriptable-object
+        Parameter, Union[MultipartBodyParameter, BodyParameter]
+    ]
+):
+    """Base Parameter class for the two operation ParameterLists"""
+
+    @staticmethod
+    def parameter_creator() -> Callable[[Dict[str, Any], "CodeModel"], Parameter]:
+        return Parameter.from_yaml
+
+    @staticmethod
+    def body_parameter_creator() -> Callable[
+        [Dict[str, Any], "CodeModel"], Union[MultipartBodyParameter, BodyParameter]
+    ]:
+        return get_body_parameter
 
-class ParameterOnlyPathAndBodyPositionalList(ParameterList):
-    # use this to change the files and data parameter in the method
+    @property
+    def implementation(self) -> str:
+        return "Method"
 
     @property
-    def method(self) -> List[Parameter]:
-        method_params = super().method
-        files_params = [p for p in method_params if p.is_multipart]
-        data_params = [p for p in method_params if p.is_data_input]
-        if not (files_params or data_params):
-            return method_params
-
-        # update files param
-        file_and_data_params = []
-        if files_params:
-            files_param = _create_files_or_data_param(
-                files_params,
-                serialized_name="files",
-                description="Multipart input for files. See the template in our example to find the input shape."
-            )
-            file_and_data_params.append(files_param)
-        if data_params:
-            data_param = _create_files_or_data_param(
-                data_params,
-                serialized_name="data",
-                description="Form-encoded input for data. See the template in our example to find the input shape."
-            )
-            file_and_data_params.append(data_param)
-        method_params = [p for p in method_params if not p.is_multipart and not p.is_data_input]
-        positional = [p for p in method_params if p.is_positional]
-        keyword_only = self._filter_out_multiple_content_type(
-            [p for p in method_params if p.is_keyword_only]
-        )
-        kwargs = self._filter_out_multiple_content_type(
-            [p for p in method_params if p.is_kwarg]
-        )
-        return positional + file_and_data_params + keyword_only + kwargs
+    def path(self) -> List[Parameter]:
+        return [
+            k for k in super().path if k.location == ParameterLocation.ENDPOINT_PATH
+        ]
+
+
+class ParameterList(_ParameterList):
+    """ParameterList is the parameter list for Operation classes"""
+
+    ...
+
+
+class _RequestBuilderParameterList(
+    _ParameterListBase[  # pylint: disable=unsubscriptable-object
+        RequestBuilderParameter, RequestBuilderBodyParameterType
+    ]
+):
+    """_RequestBuilderParameterList is base parameter list for RequestBuilder classes"""
 
-def get_parameter_list(code_model):
-    if code_model.options["only_path_and_body_params_positional"]:
-        return ParameterOnlyPathAndBodyPositionalList
-    return ParameterList
+    @staticmethod
+    def parameter_creator() -> Callable[
+        [Dict[str, Any], "CodeModel"], RequestBuilderParameter
+    ]:
+        return RequestBuilderParameter.from_yaml
 
-class GlobalParameterList(ParameterList):
+    @staticmethod
+    def body_parameter_creator() -> Callable[
+        [Dict[str, Any], "CodeModel"], RequestBuilderBodyParameterType
+    ]:
+        return get_request_body_parameter
 
     @property
     def implementation(self) -> str:
-        return "Client"
+        return "Method"
 
     @property
-    def method(self) -> List[Parameter]:
-        """The list of parameter used in method signature.
-        """
-        # Client level should not be on Method, etc.
-        positional = [p for p in self.parameters if p.is_positional]
-        keyword_only = self._filter_out_multiple_content_type(
-            [p for p in self.parameters if p.is_keyword_only]
-        )
-        kwargs = self._filter_out_multiple_content_type(
-            [p for p in self.parameters if p.is_kwarg]
-        )
-        def _sort(params):
-            return sorted(params, key=lambda x: not x.default_value and x.required, reverse=True)
-        signature_parameters = (
-            _sort(positional) + _sort(keyword_only) + _sort(kwargs)
+    def unsorted_method_params(
+        self,
+    ) -> List[Union[RequestBuilderParameter, RequestBuilderBodyParameterType]]:
+        # don't have access to client params in request builder
+        retval = [
+            p
+            for p in super().unsorted_method_params
+            if not (
+                p.location == ParameterLocation.BODY
+                and cast(RequestBuilderBodyParameterType, p).is_partial_body
+            )
+        ]
+        retval.extend(
+            [
+                p
+                for p in self.parameters
+                if p.implementation == "Client" and p.in_method_signature
+            ]
         )
-        return signature_parameters
+        return retval
 
     @property
-    def code_model(self):
-        try:
-            return self._code_model
-        except AttributeError:
-            raise ValueError("You need to first set the code model")
+    def path(self) -> List[RequestBuilderParameter]:
+        return [
+            p for p in super().path if p.location != ParameterLocation.ENDPOINT_PATH
+        ]
 
-    @code_model.setter
-    def code_model(self, val):
-        self._code_model = val
 
-    @property
-    def host_variable_name(self) -> str:
-        return (
-            "endpoint" if self.code_model.options["version_tolerant"]
-            or self.code_model.options["low_level_client"]
-            else "base_url"
-        )
+class RequestBuilderParameterList(_RequestBuilderParameterList):
+    """Parameter list for Request Builder"""
+
+    ...
+
+
+class OverloadedRequestBuilderParameterList(_RequestBuilderParameterList):
+    """Parameter list for OverloadedRequestBuilder"""
+
+    def method_signature(self, is_python3_file: bool, async_mode: bool) -> List[str]:
+        return self.method_signature_positional(
+            is_python3_file, async_mode
+        ) + self.method_signature_kwargs(is_python3_file)
+
+
+class _ClientGlobalParameterList(
+    # pylint: disable=unsubscriptable-object
+    _ParameterListBase[ParameterType, BodyParameter]
+):
+    """Base parameter list for client and config classes"""
 
     @staticmethod
-    def _wanted_path_parameter(parameter: Parameter) -> bool:
-        return (
-            parameter.location == ParameterLocation.Uri and
-            parameter.implementation == "Client" and
-            parameter.rest_api_name != "$host"
-        )
+    def body_parameter_creator() -> Callable[
+        [Dict[str, Any], "CodeModel"], BodyParameter
+    ]:
+        return BodyParameter.from_yaml
 
-    def add_host(self, host_value: Optional[str]) -> None:
-        # only adds if we don't have a parameterized host
-        host_param = Parameter(
-            self.code_model,
-            yaml_data={},
-            schema=StringSchema(namespace="", yaml_data={"type": "str"}),
-            rest_api_name=self.host_variable_name,
-            serialized_name=self.host_variable_name,
-            description=f"Service URL.",
-            implementation="Client",
-            required=True,
-            location=ParameterLocation.Other,
-            skip_url_encoding=False,
-            constraints=[],
-            client_default_value=host_value,
-            keyword_only=self.code_model.options["version_tolerant"] or self.code_model.options["low_level_client"],
-        )
-        self.parameters.append(host_param)
-
-    def add_credential_global_parameter(self) -> None:
-        credential_parameter = Parameter(
-            self.code_model,
-            yaml_data={},
-            schema=self.code_model.credential_schema_policy.credential,
-            serialized_name="credential",
-            rest_api_name="credential",
-            implementation="Client",
-            description="Credential needed for the client to connect to Azure.",
-            required=True,
-            location=ParameterLocation.Other,
-            skip_url_encoding=True,
-            constraints=[],
-        )
-        if self.code_model.options["version_tolerant"] or self.code_model.options["low_level_client"]:
-            self.parameters.append(credential_parameter)
-        else:
-            self.parameters.insert(0, credential_parameter)
+    @property
+    def implementation(self) -> str:
+        return "Client"
 
     @property
-    def host(self) -> Optional[Parameter]:
+    def credential(self) -> Optional[ParameterType]:
         try:
-            return next(p for p in self.parameters if p.serialized_name == self.host_variable_name)
+            return next(p for p in self.parameters if p.client_name == "credential")
         except StopIteration:
             return None
 
     @property
-    def host_value(self) -> Optional[str]:
-        if self.code_model.service_client.has_parameterized_host:
-            return None
-        return next(
-            p for p in self.parameters
-            if p.serialized_name == self.host_variable_name
-        ).default_value_declaration
+    def path(self) -> List[ParameterType]:
+        return [
+            p for p in super().path if p.location == ParameterLocation.ENDPOINT_PATH
+        ]
+
+
+class ClientGlobalParameterList(_ClientGlobalParameterList[ClientParameter]):
+    """Parameter list for Client class"""
+
+    @staticmethod
+    def parameter_creator() -> Callable[[Dict[str, Any], "CodeModel"], ClientParameter]:
+        return ClientParameter.from_yaml
 
     @property
-    def client_method(self) -> List[Parameter]:
-        return self.method
+    def path(self) -> List[ClientParameter]:
+        return [p for p in super().path if not p.is_host]
 
-    def _param_is_in_config_method(self, serialized_name):
-        if self.code_model.service_client.has_parameterized_host:
-            return True
-        return serialized_name != self.host_variable_name
+    @property
+    def host(self) -> Optional[ClientParameter]:
+        """Get the host parameter"""
+        try:
+            return next(p for p in self.parameters if p.is_host)
+        except StopIteration:
+            return None
 
-    def kwargs_to_pop(self, is_python3_file: bool) -> List[Parameter]:
+    def kwargs_to_pop(
+        self, is_python3_file: bool
+    ) -> List[Union[ClientParameter, BodyParameter]]:
+        """We only want to pass base url path parameters in the client"""
         return [
-            k for k in super().kwargs_to_pop(is_python3_file)
-            if not self._param_is_in_config_method(k.serialized_name)
+            k
+            for k in super().kwargs_to_pop(is_python3_file=is_python3_file)
+            if k.location == ParameterLocation.ENDPOINT_PATH
         ]
 
-    def config_kwargs_to_pop(self, is_python3_file: bool) -> List[Parameter]:
-        current_kwargs_to_pop = super().kwargs_to_pop(is_python3_file)
-        return [k for k in current_kwargs_to_pop if self._param_is_in_config_method(k.serialized_name)]
 
-    @property
-    def config_method(self) -> List[Parameter]:
-        return [p for p in self.method if self._param_is_in_config_method(p.serialized_name)]
-
-    def client_method_signature(self, is_python3_file: bool) -> List[str]:
-        return self.method_signature(is_python3_file)
+class ConfigGlobalParameterList(_ClientGlobalParameterList[ConfigParameter]):
+    """Parameter list for config"""
 
-    def config_method_signature(self, is_python3_file: bool) -> List[str]:
+    @staticmethod
+    def parameter_creator() -> Callable[[Dict[str, Any], "CodeModel"], ConfigParameter]:
+        return ConfigParameter.from_yaml
 
-        positional = [
-            p.method_signature(is_python3_file)
-            for p in self.positional
-            if self._param_is_in_config_method(p.serialized_name)
-        ]
-        keyword_only_params = [p for p in self.keyword_only if self._param_is_in_config_method(p.serialized_name)]
-        keyword_only_method_signature = []
-        if is_python3_file:
-            keyword_only_method_signature = (
-                ["*,"] +
-                [
-                    p.method_signature(is_python3_file) for p in keyword_only_params
-                ]
-            ) if keyword_only_params else []
-        return _method_signature_helper(
-            positional=positional,
-            keyword_only=keyword_only_method_signature,
-            kwarg_params=self.method_signature_kwargs(is_python3_file)
-        )
+    @property
+    def implementation(self) -> str:
+        return "Client"