@autorest/python 6.1.10 → 6.2.0

package/autorest/codegen/models/parameter_list.py

@@ -49,7 +49,7 @@ RequestBuilderBodyParameterType = Union[
 
 
 if TYPE_CHECKING:
-    from .code_model import CodeModel
+    from .code_model import NamespaceModel
 
 
 class ParameterImplementation(Enum):
@@ -81,12 +81,12 @@ class _ParameterListBase(
     def __init__(
         self,
         yaml_data: Dict[str, Any],
-        code_model: "CodeModel",
+        namespace_model: "NamespaceModel",
         parameters: List[ParameterType],
         body_parameter: Optional[BodyParameterType] = None,
     ) -> None:
         self.yaml_data = yaml_data
-        self.code_model = code_model
+        self.namespace_model = namespace_model
         self.parameters = parameters or []
         self._body_parameter = body_parameter
 
@@ -113,14 +113,16 @@ class _ParameterListBase(
 
     @staticmethod
     @abstractmethod
-    def parameter_creator() -> Callable[[Dict[str, Any], "CodeModel"], ParameterType]:
+    def parameter_creator() -> Callable[
+        [Dict[str, Any], "NamespaceModel"], ParameterType
+    ]:
         """Callable for creating parameters"""
         ...
 
     @staticmethod
     @abstractmethod
     def body_parameter_creator() -> Callable[
-        [Dict[str, Any], "CodeModel"], BodyParameterType
+        [Dict[str, Any], "NamespaceModel"], BodyParameterType
     ]:
         """Callable for creating body parameters"""
         ...
@@ -290,19 +292,19 @@ class _ParameterListBase(
         return retval
 
     @classmethod
-    def from_yaml(cls, yaml_data: Dict[str, Any], code_model: "CodeModel"):
+    def from_yaml(cls, yaml_data: Dict[str, Any], namespace_model: "NamespaceModel"):
         parameters = [
-            cls.parameter_creator()(parameter, code_model)
+            cls.parameter_creator()(parameter, namespace_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
+                yaml_data["bodyParameter"], namespace_model
             )
         return cls(
             yaml_data,
-            code_model,
+            namespace_model,
             parameters=parameters,
             body_parameter=body_parameter,
         )
@@ -316,12 +318,12 @@ class _ParameterList(
     """Base Parameter class for the two operation ParameterLists"""
 
     @staticmethod
-    def parameter_creator() -> Callable[[Dict[str, Any], "CodeModel"], Parameter]:
+    def parameter_creator() -> Callable[[Dict[str, Any], "NamespaceModel"], Parameter]:
         return Parameter.from_yaml
 
     @staticmethod
     def body_parameter_creator() -> Callable[
-        [Dict[str, Any], "CodeModel"], Union[MultipartBodyParameter, BodyParameter]
+        [Dict[str, Any], "NamespaceModel"], Union[MultipartBodyParameter, BodyParameter]
     ]:
         return get_body_parameter
 
@@ -351,13 +353,13 @@ class _RequestBuilderParameterList(
 
     @staticmethod
     def parameter_creator() -> Callable[
-        [Dict[str, Any], "CodeModel"], RequestBuilderParameter
+        [Dict[str, Any], "NamespaceModel"], RequestBuilderParameter
     ]:
         return RequestBuilderParameter.from_yaml
 
     @staticmethod
     def body_parameter_creator() -> Callable[
-        [Dict[str, Any], "CodeModel"], RequestBuilderBodyParameterType
+        [Dict[str, Any], "NamespaceModel"], RequestBuilderBodyParameterType
     ]:
         return get_request_body_parameter
 
@@ -422,7 +424,7 @@ class _ClientGlobalParameterList(
 
     @staticmethod
     def body_parameter_creator() -> Callable[
-        [Dict[str, Any], "CodeModel"], BodyParameter
+        [Dict[str, Any], "NamespaceModel"], BodyParameter
     ]:
         return BodyParameter.from_yaml
 
@@ -448,7 +450,9 @@ class ClientGlobalParameterList(_ClientGlobalParameterList[ClientParameter]):
     """Parameter list for Client class"""
 
     @staticmethod
-    def parameter_creator() -> Callable[[Dict[str, Any], "CodeModel"], ClientParameter]:
+    def parameter_creator() -> Callable[
+        [Dict[str, Any], "NamespaceModel"], ClientParameter
+    ]:
         return ClientParameter.from_yaml
 
     @property
@@ -477,7 +481,9 @@ class ConfigGlobalParameterList(_ClientGlobalParameterList[ConfigParameter]):
     """Parameter list for config"""
 
     @staticmethod
-    def parameter_creator() -> Callable[[Dict[str, Any], "CodeModel"], ConfigParameter]:
+    def parameter_creator() -> Callable[
+        [Dict[str, Any], "NamespaceModel"], ConfigParameter
+    ]:
         return ConfigParameter.from_yaml
 
     @property

package/autorest/codegen/models/primitive_types.py

@@ -12,7 +12,7 @@ from .imports import FileImport, ImportType, TypingSection
 from .utils import add_to_description
 
 if TYPE_CHECKING:
-    from .code_model import CodeModel
+    from .code_model import NamespaceModel
 
 
 class RawString(object):
@@ -83,8 +83,10 @@ class BooleanType(PrimitiveType):
 
 
 class BinaryType(PrimitiveType):
-    def __init__(self, yaml_data: Dict[str, Any], code_model: "CodeModel") -> None:
-        super().__init__(yaml_data=yaml_data, code_model=code_model)
+    def __init__(
+        self, yaml_data: Dict[str, Any], namespace_model: "NamespaceModel"
+    ) -> None:
+        super().__init__(yaml_data=yaml_data, namespace_model=namespace_model)
         self.type = "IO"
 
     @property
@@ -202,8 +204,10 @@ class AnyObjectType(PrimitiveType):
 
 
 class NumberType(PrimitiveType):  # pylint: disable=abstract-method
-    def __init__(self, yaml_data: Dict[str, Any], code_model: "CodeModel") -> None:
-        super().__init__(yaml_data=yaml_data, code_model=code_model)
+    def __init__(
+        self, yaml_data: Dict[str, Any], namespace_model: "NamespaceModel"
+    ) -> None:
+        super().__init__(yaml_data=yaml_data, namespace_model=namespace_model)
         self.precision: Optional[int] = yaml_data.get("precision")
         self.multiple: Optional[int] = yaml_data.get("multipleOf")
         self.maximum: Optional[int] = yaml_data.get("maximum")
@@ -294,8 +298,10 @@ class FloatType(NumberType):
 
 
 class StringType(PrimitiveType):
-    def __init__(self, yaml_data: Dict[str, Any], code_model: "CodeModel") -> None:
-        super().__init__(yaml_data=yaml_data, code_model=code_model)
+    def __init__(
+        self, yaml_data: Dict[str, Any], namespace_model: "NamespaceModel"
+    ) -> None:
+        super().__init__(yaml_data=yaml_data, namespace_model=namespace_model)
         self.max_length: Optional[int] = yaml_data.get("maxLength")
         self.min_length: Optional[int] = (
             yaml_data.get("minLength", 0)
@@ -341,8 +347,10 @@ class StringType(PrimitiveType):
 
 
 class DatetimeType(PrimitiveType):
-    def __init__(self, yaml_data: Dict[str, Any], code_model: "CodeModel") -> None:
-        super().__init__(yaml_data=yaml_data, code_model=code_model)
+    def __init__(
+        self, yaml_data: Dict[str, Any], namespace_model: "NamespaceModel"
+    ) -> None:
+        super().__init__(yaml_data=yaml_data, namespace_model=namespace_model)
         self.format = self.Formats(yaml_data["format"])
 
     class Formats(str, Enum):
@@ -523,8 +531,10 @@ class DurationType(PrimitiveType):
 
 
 class ByteArraySchema(PrimitiveType):
-    def __init__(self, yaml_data: Dict[str, Any], code_model: "CodeModel") -> None:
-        super().__init__(yaml_data=yaml_data, code_model=code_model)
+    def __init__(
+        self, yaml_data: Dict[str, Any], namespace_model: "NamespaceModel"
+    ) -> None:
+        super().__init__(yaml_data=yaml_data, namespace_model=namespace_model)
         self.format = yaml_data["format"]
 
     @property

package/autorest/codegen/models/property.py

@@ -12,7 +12,7 @@ from .imports import FileImport, ImportType, TypingSection
 from .utils import add_to_description, add_to_pylint_disable
 
 if TYPE_CHECKING:
-    from .code_model import CodeModel
+    from .code_model import NamespaceModel
     from .model_type import ModelType
 
 
@@ -20,10 +20,10 @@ class Property(BaseModel):  # pylint: disable=too-many-instance-attributes
     def __init__(
         self,
         yaml_data: Dict[str, Any],
-        code_model: "CodeModel",
+        namespace_model: "NamespaceModel",
         type: BaseType,
     ) -> None:
-        super().__init__(yaml_data, code_model)
+        super().__init__(yaml_data, namespace_model)
         self.rest_api_name: str = self.yaml_data["restApiName"]
         self.client_name: str = self.yaml_data["clientName"]
         self.type = type
@@ -139,7 +139,7 @@ class Property(BaseModel):  # pylint: disable=too-many-instance-attributes
                 TypingSection.TYPING,
                 alias="_models",
             )
-        if self.code_model.options["models_mode"] == "dpg":
+        if self.namespace_model.options["models_mode"] == "dpg":
             file_import.add_submodule_import(
                 ".._model_base",
                 "rest_discriminator" if self.is_discriminator else "rest_field",
@@ -151,12 +151,12 @@ class Property(BaseModel):  # pylint: disable=too-many-instance-attributes
     def from_yaml(
         cls,
         yaml_data: Dict[str, Any],
-        code_model: "CodeModel",
+        namespace_model: "NamespaceModel",
     ) -> "Property":
         from . import build_type  # pylint: disable=import-outside-toplevel
 
         return cls(
             yaml_data=yaml_data,
-            code_model=code_model,
-            type=build_type(yaml_data["type"], code_model),
+            namespace_model=namespace_model,
+            type=build_type(yaml_data["type"], namespace_model),
         )

package/autorest/codegen/models/request_builder.py

@@ -23,7 +23,8 @@ from .parameter_list import (
 from .imports import FileImport, ImportType, TypingSection, MsrestImportType
 
 if TYPE_CHECKING:
-    from .code_model import CodeModel
+    from .code_model import NamespaceModel
+    from .client import Client
 
 ParameterListType = TypeVar(
     "ParameterListType",
@@ -35,14 +36,16 @@ class RequestBuilderBase(BaseBuilder[ParameterListType]):
     def __init__(
         self,
         yaml_data: Dict[str, Any],
-        code_model: "CodeModel",
+        namespace_model: "NamespaceModel",
+        client: "Client",
         name: str,
         parameters: ParameterListType,
         *,
         overloads: Optional[List["RequestBuilder"]] = None,
     ) -> None:
         super().__init__(
-            code_model=code_model,
+            namespace_model=namespace_model,
+            client=client,
             yaml_data=yaml_data,
             name=name,
             parameters=parameters,
@@ -82,7 +85,7 @@ class RequestBuilderBase(BaseBuilder[ParameterListType]):
         if self.parameters.path:
             relative_path = ".."
             if (
-                not self.code_model.options["builders_visibility"] == "embedded"
+                not self.namespace_model.options["builders_visibility"] == "embedded"
                 and self.group_name
             ):
                 relative_path = "..." if self.group_name else ".."
@@ -97,10 +100,10 @@ class RequestBuilderBase(BaseBuilder[ParameterListType]):
             "typing", "Any", ImportType.STDLIB, typing_section=TypingSection.CONDITIONAL
         )
         file_import.add_msrest_import(
-            self.code_model,
+            self.namespace_model,
             "..."
             if (
-                not self.code_model.options["builders_visibility"] == "embedded"
+                not self.namespace_model.options["builders_visibility"] == "embedded"
                 and self.group_name
             )
             else "..",
@@ -109,7 +112,7 @@ class RequestBuilderBase(BaseBuilder[ParameterListType]):
         )
         if (
             self.overloads
-            and self.code_model.options["builders_visibility"] != "embedded"
+            and self.namespace_model.options["builders_visibility"] != "embedded"
         ):
             file_import.add_submodule_import("typing", "overload", ImportType.STDLIB)
         return file_import
@@ -117,20 +120,27 @@ class RequestBuilderBase(BaseBuilder[ParameterListType]):
     @staticmethod
     @abstractmethod
     def parameter_list_type() -> Callable[
-        [Dict[str, Any], "CodeModel"], ParameterListType
+        [Dict[str, Any], "NamespaceModel"], ParameterListType
     ]:
         ...
 
     @classmethod
-    def from_yaml(cls, yaml_data: Dict[str, Any], code_model: "CodeModel"):
+    def from_yaml(
+        cls,
+        yaml_data: Dict[str, Any],
+        namespace_model: "NamespaceModel",
+        client: "Client",
+    ):
         # when combine embedded builders into one operation file, we need to avoid duplicated build function name.
         # So add operation group name is effective method
         additional_mark = ""
         if (
-            code_model.options["combine_operation_files"]
-            and code_model.options["builders_visibility"] == "embedded"
+            namespace_model.options["combine_operation_files"]
+            and namespace_model.options["builders_visibility"] == "embedded"
         ):
-            additional_mark = yaml_data["groupName"]
+            additional_mark = (
+                yaml_data["groupName"] or client.yaml_data["builderPadName"]
+            )
         names = [
             "build",
             additional_mark,
@@ -139,14 +149,15 @@ class RequestBuilderBase(BaseBuilder[ParameterListType]):
         ]
         name = "_".join([n for n in names if n])
         overloads = [
-            RequestBuilder.from_yaml(rb_yaml_data, code_model)
+            RequestBuilder.from_yaml(rb_yaml_data, namespace_model, client)
             for rb_yaml_data in yaml_data.get("overloads", [])
         ]
-        parameter_list = cls.parameter_list_type()(yaml_data, code_model)
+        parameter_list = cls.parameter_list_type()(yaml_data, namespace_model)
 
         return cls(
             yaml_data=yaml_data,
-            code_model=code_model,
+            namespace_model=namespace_model,
+            client=client,
             name=name,
             parameters=parameter_list,
             overloads=overloads,
@@ -156,7 +167,7 @@ class RequestBuilderBase(BaseBuilder[ParameterListType]):
 class RequestBuilder(RequestBuilderBase[RequestBuilderParameterList]):
     @staticmethod
     def parameter_list_type() -> Callable[
-        [Dict[str, Any], "CodeModel"], RequestBuilderParameterList
+        [Dict[str, Any], "NamespaceModel"], RequestBuilderParameterList
     ]:
         return RequestBuilderParameterList.from_yaml
 
@@ -166,14 +177,14 @@ class OverloadedRequestBuilder(
 ):
     @staticmethod
     def parameter_list_type() -> Callable[
-        [Dict[str, Any], "CodeModel"], OverloadedRequestBuilderParameterList
+        [Dict[str, Any], "NamespaceModel"], OverloadedRequestBuilderParameterList
     ]:
         return OverloadedRequestBuilderParameterList.from_yaml
 
 
 def get_request_builder(
-    yaml_data: Dict[str, Any], code_model: "CodeModel"
+    yaml_data: Dict[str, Any], namespace_model: "NamespaceModel", client: "Client"
 ) -> Union[RequestBuilder, OverloadedRequestBuilder]:
     if yaml_data.get("overloads"):
-        return OverloadedRequestBuilder.from_yaml(yaml_data, code_model)
-    return RequestBuilder.from_yaml(yaml_data, code_model)
+        return OverloadedRequestBuilder.from_yaml(yaml_data, namespace_model, client)
+    return RequestBuilder.from_yaml(yaml_data, namespace_model, client)

package/autorest/codegen/models/request_builder_parameter.py

@@ -16,7 +16,7 @@ from .primitive_types import BinaryType, StringType
 from .combined_type import CombinedType
 
 if TYPE_CHECKING:
-    from .code_model import CodeModel
+    from .code_model import NamespaceModel
 
 
 class RequestBuilderBodyParameter(BodyParameter):
@@ -27,7 +27,7 @@ class RequestBuilderBodyParameter(BodyParameter):
         if (
             isinstance(self.type, (BinaryType, StringType))
             or any("xml" in ct for ct in self.content_types)
-            or self.code_model.options["models_mode"] == "dpg"
+            or self.namespace_model.options["models_mode"] == "dpg"
         ):
             self.client_name = "content"
         else:
@@ -52,9 +52,9 @@ class RequestBuilderBodyParameter(BodyParameter):
 
     @classmethod
     def from_yaml(
-        cls, yaml_data: Dict[str, Any], code_model: "CodeModel"
+        cls, yaml_data: Dict[str, Any], namespace_model: "NamespaceModel"
     ) -> "RequestBuilderBodyParameter":
-        return super().from_yaml(yaml_data, code_model)  # type: ignore
+        return super().from_yaml(yaml_data, namespace_model)  # type: ignore
 
     @property
     def name_in_high_level_operation(self) -> str:
@@ -76,14 +76,14 @@ class RequestBuilderMultipartBodyParameter(
 
     @classmethod
     def from_yaml(
-        cls, yaml_data: Dict[str, Any], code_model: "CodeModel"
+        cls, yaml_data: Dict[str, Any], namespace_model: "NamespaceModel"
     ) -> "RequestBuilderMultipartBodyParameter":
         return cls(
             yaml_data=yaml_data,
-            code_model=code_model,
-            type=code_model.lookup_type(id(yaml_data["type"])),
+            namespace_model=namespace_model,
+            type=namespace_model.lookup_type(id(yaml_data["type"])),
             entries=[
-                RequestBuilderBodyParameter.from_yaml(entry, code_model)
+                RequestBuilderBodyParameter.from_yaml(entry, namespace_model)
                 for entry in yaml_data["entries"]
             ],
         )
@@ -93,9 +93,12 @@ class RequestBuilderParameter(Parameter):
     """Basic RequestBuilder Parameter."""
 
     def __init__(
-        self, yaml_data: Dict[str, Any], code_model: "CodeModel", type: BaseType
+        self,
+        yaml_data: Dict[str, Any],
+        namespace_model: "NamespaceModel",
+        type: BaseType,
     ) -> None:
-        super().__init__(yaml_data, code_model, type)
+        super().__init__(yaml_data, namespace_model, type)
         # we don't want any default content type behavior in request builder
         if self.is_content_type:
             self.client_default_value = None
@@ -141,9 +144,11 @@ class RequestBuilderParameter(Parameter):
 
 
 def get_request_body_parameter(
-    yaml_data: Dict[str, Any], code_model: "CodeModel"
+    yaml_data: Dict[str, Any], namespace_model: "NamespaceModel"
 ) -> Union[RequestBuilderBodyParameter, RequestBuilderMultipartBodyParameter]:
     """Get body parameter for a request builder"""
     if yaml_data.get("entries"):
-        return RequestBuilderMultipartBodyParameter.from_yaml(yaml_data, code_model)
-    return RequestBuilderBodyParameter.from_yaml(yaml_data, code_model)
+        return RequestBuilderMultipartBodyParameter.from_yaml(
+            yaml_data, namespace_model
+        )
+    return RequestBuilderBodyParameter.from_yaml(yaml_data, namespace_model)

package/autorest/codegen/models/response.py

@@ -14,14 +14,17 @@ from .list_type import ListType
 from .model_type import ModelType
 
 if TYPE_CHECKING:
-    from .code_model import CodeModel
+    from .code_model import NamespaceModel
 
 
 class ResponseHeader(BaseModel):
     def __init__(
-        self, yaml_data: Dict[str, Any], code_model: "CodeModel", type: BaseType
+        self,
+        yaml_data: Dict[str, Any],
+        namespace_model: "NamespaceModel",
+        type: BaseType,
     ) -> None:
-        super().__init__(yaml_data, code_model)
+        super().__init__(yaml_data, namespace_model)
         self.rest_api_name: str = yaml_data["restApiName"]
         self.type = type
 
@@ -31,12 +34,12 @@ class ResponseHeader(BaseModel):
 
     @classmethod
     def from_yaml(
-        cls, yaml_data: Dict[str, Any], code_model: "CodeModel"
+        cls, yaml_data: Dict[str, Any], namespace_model: "NamespaceModel"
     ) -> "ResponseHeader":
         return cls(
             yaml_data=yaml_data,
-            code_model=code_model,
-            type=code_model.lookup_type(id(yaml_data["type"])),
+            namespace_model=namespace_model,
+            type=namespace_model.lookup_type(id(yaml_data["type"])),
         )
 
 
@@ -44,12 +47,12 @@ class Response(BaseModel):
     def __init__(
         self,
         yaml_data: Dict[str, Any],
-        code_model: "CodeModel",
+        namespace_model: "NamespaceModel",
         *,
         headers: List[ResponseHeader] = [],
         type: Optional[BaseType] = None,
     ) -> None:
-        super().__init__(yaml_data=yaml_data, code_model=code_model)
+        super().__init__(yaml_data=yaml_data, namespace_model=namespace_model)
         self.status_codes: List[Union[int, str]] = yaml_data["statusCodes"]
         self.headers = headers
         self.type = type
@@ -112,21 +115,21 @@ class Response(BaseModel):
 
     @classmethod
     def from_yaml(
-        cls, yaml_data: Dict[str, Any], code_model: "CodeModel"
+        cls, yaml_data: Dict[str, Any], namespace_model: "NamespaceModel"
     ) -> "Response":
         type = (
-            code_model.lookup_type(id(yaml_data["type"]))
+            namespace_model.lookup_type(id(yaml_data["type"]))
             if yaml_data.get("type")
             else None
         )
         # use ByteIteratorType if we are returning a binary type
         if isinstance(type, BinaryType):
-            type = BinaryIteratorType(type.yaml_data, type.code_model)
+            type = BinaryIteratorType(type.yaml_data, type.namespace_model)
         return cls(
             yaml_data=yaml_data,
-            code_model=code_model,
+            namespace_model=namespace_model,
             headers=[
-                ResponseHeader.from_yaml(header, code_model)
+                ResponseHeader.from_yaml(header, namespace_model)
                 for header in yaml_data["headers"]
             ],
             type=type,
@@ -139,7 +142,9 @@ class Response(BaseModel):
 class PagingResponse(Response):
     def __init__(self, *args, **kwargs) -> None:
         super().__init__(*args, **kwargs)
-        self.item_type = self.code_model.lookup_type(id(self.yaml_data["itemType"]))
+        self.item_type = self.namespace_model.lookup_type(
+            id(self.yaml_data["itemType"])
+        )
 
     def get_polymorphic_subtypes(self, polymorphic_subtypes: List["ModelType"]) -> None:
         return self.item_type.get_polymorphic_subtypes(polymorphic_subtypes)
@@ -161,7 +166,7 @@ class PagingResponse(Response):
 
     def docstring_text(self, **kwargs: Any) -> str:
         base_description = "An iterator like instance of "
-        if not self.code_model.options["version_tolerant"]:
+        if not self.namespace_model.options["version_tolerant"]:
             base_description += "either "
         return base_description + self.item_type.docstring_text(**kwargs)
 
@@ -242,7 +247,7 @@ class LROResponse(Response):
     def docstring_text(self, **kwargs) -> str:
         super_text = super().docstring_text(**kwargs)
         base_description = f"An instance of {self.get_poller(kwargs.get('async_mode', False))} that returns "
-        if not self.code_model.options["version_tolerant"]:
+        if not self.namespace_model.options["version_tolerant"]:
             base_description += "either "
         return base_description + super_text
 
@@ -305,7 +310,7 @@ class LROPagingResponse(LROResponse, PagingResponse):
         base_description = (
             "An instance of LROPoller that returns an iterator like instance of "
         )
-        if not self.code_model.options["version_tolerant"]:
+        if not self.namespace_model.options["version_tolerant"]:
             base_description += "either "
         return base_description + Response.docstring_text(self)
 
@@ -320,11 +325,13 @@ class LROPagingResponse(LROResponse, PagingResponse):
         return file_import
 
 
-def get_response(yaml_data: Dict[str, Any], code_model: "CodeModel") -> Response:
+def get_response(
+    yaml_data: Dict[str, Any], namespace_model: "NamespaceModel"
+) -> Response:
     if yaml_data["discriminator"] == "lropaging":
-        return LROPagingResponse.from_yaml(yaml_data, code_model)
+        return LROPagingResponse.from_yaml(yaml_data, namespace_model)
     if yaml_data["discriminator"] == "lro":
-        return LROResponse.from_yaml(yaml_data, code_model)
+        return LROResponse.from_yaml(yaml_data, namespace_model)
     if yaml_data["discriminator"] == "paging":
-        return PagingResponse.from_yaml(yaml_data, code_model)
-    return Response.from_yaml(yaml_data, code_model)
+        return PagingResponse.from_yaml(yaml_data, namespace_model)
+    return Response.from_yaml(yaml_data, namespace_model)