@autorest/python 6.2.0 → 6.2.2

package/autorest/codegen/models/parameter_list.py

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

package/autorest/codegen/models/primitive_types.py

@@ -7,12 +7,12 @@ import datetime
 from enum import Enum
 from typing import Any, Dict, List, Optional, Union, TYPE_CHECKING
 
-from .base_type import BaseType
+from .base import BaseType
 from .imports import FileImport, ImportType, TypingSection
 from .utils import add_to_description
 
 if TYPE_CHECKING:
-    from .code_model import NamespaceModel
+    from .code_model import CodeModel
 
 
 class RawString(object):
@@ -83,10 +83,8 @@ class BooleanType(PrimitiveType):
 
 
 class BinaryType(PrimitiveType):
-    def __init__(
-        self, yaml_data: Dict[str, Any], namespace_model: "NamespaceModel"
-    ) -> None:
-        super().__init__(yaml_data=yaml_data, namespace_model=namespace_model)
+    def __init__(self, yaml_data: Dict[str, Any], code_model: "CodeModel") -> None:
+        super().__init__(yaml_data=yaml_data, code_model=code_model)
         self.type = "IO"
 
     @property
@@ -199,15 +197,12 @@ class AnyObjectType(PrimitiveType):
     def imports(self, **kwargs: Any) -> FileImport:
         file_import = FileImport()
         file_import.define_mutable_mapping_type()
-        file_import.add_import("sys", ImportType.STDLIB)
         return file_import
 
 
 class NumberType(PrimitiveType):  # pylint: disable=abstract-method
-    def __init__(
-        self, yaml_data: Dict[str, Any], namespace_model: "NamespaceModel"
-    ) -> None:
-        super().__init__(yaml_data=yaml_data, namespace_model=namespace_model)
+    def __init__(self, yaml_data: Dict[str, Any], code_model: "CodeModel") -> None:
+        super().__init__(yaml_data=yaml_data, code_model=code_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")
@@ -298,10 +293,8 @@ class FloatType(NumberType):
 
 
 class StringType(PrimitiveType):
-    def __init__(
-        self, yaml_data: Dict[str, Any], namespace_model: "NamespaceModel"
-    ) -> None:
-        super().__init__(yaml_data=yaml_data, namespace_model=namespace_model)
+    def __init__(self, yaml_data: Dict[str, Any], code_model: "CodeModel") -> None:
+        super().__init__(yaml_data=yaml_data, code_model=code_model)
         self.max_length: Optional[int] = yaml_data.get("maxLength")
         self.min_length: Optional[int] = (
             yaml_data.get("minLength", 0)
@@ -347,10 +340,8 @@ class StringType(PrimitiveType):
 
 
 class DatetimeType(PrimitiveType):
-    def __init__(
-        self, yaml_data: Dict[str, Any], namespace_model: "NamespaceModel"
-    ) -> None:
-        super().__init__(yaml_data=yaml_data, namespace_model=namespace_model)
+    def __init__(self, yaml_data: Dict[str, Any], code_model: "CodeModel") -> None:
+        super().__init__(yaml_data=yaml_data, code_model=code_model)
         self.format = self.Formats(yaml_data["format"])
 
     class Formats(str, Enum):
@@ -531,10 +522,8 @@ class DurationType(PrimitiveType):
 
 
 class ByteArraySchema(PrimitiveType):
-    def __init__(
-        self, yaml_data: Dict[str, Any], namespace_model: "NamespaceModel"
-    ) -> None:
-        super().__init__(yaml_data=yaml_data, namespace_model=namespace_model)
+    def __init__(self, yaml_data: Dict[str, Any], code_model: "CodeModel") -> None:
+        super().__init__(yaml_data=yaml_data, code_model=code_model)
         self.format = yaml_data["format"]
 
     @property

package/autorest/codegen/models/property.py

@@ -5,14 +5,14 @@
 # --------------------------------------------------------------------------
 from typing import Any, Dict, Optional, TYPE_CHECKING, List
 
-from .base_model import BaseModel
+from .base import BaseModel
 from .constant_type import ConstantType
-from .base_type import BaseType
+from .base import BaseType
 from .imports import FileImport, ImportType, TypingSection
 from .utils import add_to_description, add_to_pylint_disable
 
 if TYPE_CHECKING:
-    from .code_model import NamespaceModel
+    from .code_model import CodeModel
     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],
-        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 = self.yaml_data["restApiName"]
         self.client_name: str = self.yaml_data["clientName"]
         self.type = type
@@ -125,10 +125,10 @@ class Property(BaseModel):  # pylint: disable=too-many-instance-attributes
         retval.update(self.type.validation or {})
         return retval or None
 
-    def imports(self) -> FileImport:
+    def imports(self, **kwargs) -> FileImport:
         from .model_type import ModelType
 
-        file_import = self.type.imports(is_operation_file=False)
+        file_import = self.type.imports(**kwargs, is_operation_file=False)
         if self.optional and self.client_default_value is None:
             file_import.add_submodule_import("typing", "Optional", ImportType.STDLIB)
         if isinstance(self.type, ModelType):
@@ -139,7 +139,7 @@ class Property(BaseModel):  # pylint: disable=too-many-instance-attributes
                 TypingSection.TYPING,
                 alias="_models",
             )
-        if self.namespace_model.options["models_mode"] == "dpg":
+        if self.code_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],
-        namespace_model: "NamespaceModel",
+        code_model: "CodeModel",
     ) -> "Property":
         from . import build_type  # pylint: disable=import-outside-toplevel
 
         return cls(
             yaml_data=yaml_data,
-            namespace_model=namespace_model,
-            type=build_type(yaml_data["type"], namespace_model),
+            code_model=code_model,
+            type=build_type(yaml_data["type"], code_model),
         )

package/autorest/codegen/models/request_builder.py

@@ -23,7 +23,7 @@ from .parameter_list import (
 from .imports import FileImport, ImportType, TypingSection, MsrestImportType
 
 if TYPE_CHECKING:
-    from .code_model import NamespaceModel
+    from .code_model import CodeModel
     from .client import Client
 
 ParameterListType = TypeVar(
@@ -36,7 +36,7 @@ class RequestBuilderBase(BaseBuilder[ParameterListType]):
     def __init__(
         self,
         yaml_data: Dict[str, Any],
-        namespace_model: "NamespaceModel",
+        code_model: "CodeModel",
         client: "Client",
         name: str,
         parameters: ParameterListType,
@@ -44,7 +44,7 @@ class RequestBuilderBase(BaseBuilder[ParameterListType]):
         overloads: Optional[List["RequestBuilder"]] = None,
     ) -> None:
         super().__init__(
-            namespace_model=namespace_model,
+            code_model=code_model,
             client=client,
             yaml_data=yaml_data,
             name=name,
@@ -85,7 +85,7 @@ class RequestBuilderBase(BaseBuilder[ParameterListType]):
         if self.parameters.path:
             relative_path = ".."
             if (
-                not self.namespace_model.options["builders_visibility"] == "embedded"
+                not self.code_model.options["builders_visibility"] == "embedded"
                 and self.group_name
             ):
                 relative_path = "..." if self.group_name else ".."
@@ -100,10 +100,10 @@ class RequestBuilderBase(BaseBuilder[ParameterListType]):
             "typing", "Any", ImportType.STDLIB, typing_section=TypingSection.CONDITIONAL
         )
         file_import.add_msrest_import(
-            self.namespace_model,
+            self.code_model,
             "..."
             if (
-                not self.namespace_model.options["builders_visibility"] == "embedded"
+                not self.code_model.options["builders_visibility"] == "embedded"
                 and self.group_name
             )
             else "..",
@@ -112,7 +112,7 @@ class RequestBuilderBase(BaseBuilder[ParameterListType]):
         )
         if (
             self.overloads
-            and self.namespace_model.options["builders_visibility"] != "embedded"
+            and self.code_model.options["builders_visibility"] != "embedded"
         ):
             file_import.add_submodule_import("typing", "overload", ImportType.STDLIB)
         return file_import
@@ -120,7 +120,7 @@ class RequestBuilderBase(BaseBuilder[ParameterListType]):
     @staticmethod
     @abstractmethod
     def parameter_list_type() -> Callable[
-        [Dict[str, Any], "NamespaceModel"], ParameterListType
+        [Dict[str, Any], "CodeModel"], ParameterListType
     ]:
         ...
 
@@ -128,15 +128,15 @@ class RequestBuilderBase(BaseBuilder[ParameterListType]):
     def from_yaml(
         cls,
         yaml_data: Dict[str, Any],
-        namespace_model: "NamespaceModel",
+        code_model: "CodeModel",
         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 (
-            namespace_model.options["combine_operation_files"]
-            and namespace_model.options["builders_visibility"] == "embedded"
+            code_model.options["combine_operation_files"]
+            and code_model.options["builders_visibility"] == "embedded"
         ):
             additional_mark = (
                 yaml_data["groupName"] or client.yaml_data["builderPadName"]
@@ -149,14 +149,14 @@ class RequestBuilderBase(BaseBuilder[ParameterListType]):
         ]
         name = "_".join([n for n in names if n])
         overloads = [
-            RequestBuilder.from_yaml(rb_yaml_data, namespace_model, client)
+            RequestBuilder.from_yaml(rb_yaml_data, code_model, client)
             for rb_yaml_data in yaml_data.get("overloads", [])
         ]
-        parameter_list = cls.parameter_list_type()(yaml_data, namespace_model)
+        parameter_list = cls.parameter_list_type()(yaml_data, code_model)
 
         return cls(
             yaml_data=yaml_data,
-            namespace_model=namespace_model,
+            code_model=code_model,
             client=client,
             name=name,
             parameters=parameter_list,
@@ -167,7 +167,7 @@ class RequestBuilderBase(BaseBuilder[ParameterListType]):
 class RequestBuilder(RequestBuilderBase[RequestBuilderParameterList]):
     @staticmethod
     def parameter_list_type() -> Callable[
-        [Dict[str, Any], "NamespaceModel"], RequestBuilderParameterList
+        [Dict[str, Any], "CodeModel"], RequestBuilderParameterList
     ]:
         return RequestBuilderParameterList.from_yaml
 
@@ -177,14 +177,14 @@ class OverloadedRequestBuilder(
 ):
     @staticmethod
     def parameter_list_type() -> Callable[
-        [Dict[str, Any], "NamespaceModel"], OverloadedRequestBuilderParameterList
+        [Dict[str, Any], "CodeModel"], OverloadedRequestBuilderParameterList
     ]:
         return OverloadedRequestBuilderParameterList.from_yaml
 
 
 def get_request_builder(
-    yaml_data: Dict[str, Any], namespace_model: "NamespaceModel", client: "Client"
+    yaml_data: Dict[str, Any], code_model: "CodeModel", client: "Client"
 ) -> Union[RequestBuilder, OverloadedRequestBuilder]:
     if yaml_data.get("overloads"):
-        return OverloadedRequestBuilder.from_yaml(yaml_data, namespace_model, client)
-    return RequestBuilder.from_yaml(yaml_data, namespace_model, client)
+        return OverloadedRequestBuilder.from_yaml(yaml_data, code_model, client)
+    return RequestBuilder.from_yaml(yaml_data, code_model, client)

package/autorest/codegen/models/request_builder_parameter.py

@@ -11,12 +11,12 @@ from .parameter import (
     BodyParameter,
     _MultipartBodyParameter,
 )
-from .base_type import BaseType
+from .base import BaseType
 from .primitive_types import BinaryType, StringType
 from .combined_type import CombinedType
 
 if TYPE_CHECKING:
-    from .code_model import NamespaceModel
+    from .code_model import CodeModel
 
 
 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.namespace_model.options["models_mode"] == "dpg"
+            or self.code_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], namespace_model: "NamespaceModel"
+        cls, yaml_data: Dict[str, Any], code_model: "CodeModel"
     ) -> "RequestBuilderBodyParameter":
-        return super().from_yaml(yaml_data, namespace_model)  # type: ignore
+        return super().from_yaml(yaml_data, code_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], namespace_model: "NamespaceModel"
+        cls, yaml_data: Dict[str, Any], code_model: "CodeModel"
     ) -> "RequestBuilderMultipartBodyParameter":
         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=[
-                RequestBuilderBodyParameter.from_yaml(entry, namespace_model)
+                RequestBuilderBodyParameter.from_yaml(entry, code_model)
                 for entry in yaml_data["entries"]
             ],
         )
@@ -95,10 +95,10 @@ class RequestBuilderParameter(Parameter):
     def __init__(
         self,
         yaml_data: Dict[str, Any],
-        namespace_model: "NamespaceModel",
+        code_model: "CodeModel",
         type: BaseType,
     ) -> None:
-        super().__init__(yaml_data, namespace_model, type)
+        super().__init__(yaml_data, code_model, type)
         # we don't want any default content type behavior in request builder
         if self.is_content_type:
             self.client_default_value = None
@@ -144,11 +144,9 @@ class RequestBuilderParameter(Parameter):
 
 
 def get_request_body_parameter(
-    yaml_data: Dict[str, Any], namespace_model: "NamespaceModel"
+    yaml_data: Dict[str, Any], code_model: "CodeModel"
 ) -> Union[RequestBuilderBodyParameter, RequestBuilderMultipartBodyParameter]:
     """Get body parameter for a request builder"""
     if yaml_data.get("entries"):
-        return RequestBuilderMultipartBodyParameter.from_yaml(
-            yaml_data, namespace_model
-        )
-    return RequestBuilderBodyParameter.from_yaml(yaml_data, namespace_model)
+        return RequestBuilderMultipartBodyParameter.from_yaml(yaml_data, code_model)
+    return RequestBuilderBodyParameter.from_yaml(yaml_data, code_model)

package/autorest/codegen/models/response.py

@@ -5,8 +5,8 @@
 # --------------------------------------------------------------------------
 from typing import Dict, Optional, List, Any, TYPE_CHECKING, Union
 
-from .base_model import BaseModel
-from .base_type import BaseType
+from .base import BaseModel
+from .base import BaseType
 from .imports import FileImport, ImportType
 from .primitive_types import BinaryType, BinaryIteratorType
 from .dictionary_type import DictionaryType
@@ -14,17 +14,17 @@ from .list_type import ListType
 from .model_type import ModelType
 
 if TYPE_CHECKING:
-    from .code_model import NamespaceModel
+    from .code_model import CodeModel
 
 
 class ResponseHeader(BaseModel):
     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.type = type
 
@@ -34,12 +34,12 @@ class ResponseHeader(BaseModel):
 
     @classmethod
     def from_yaml(
-        cls, yaml_data: Dict[str, Any], namespace_model: "NamespaceModel"
+        cls, yaml_data: Dict[str, Any], code_model: "CodeModel"
     ) -> "ResponseHeader":
         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"])),
         )
 
 
@@ -47,12 +47,12 @@ class Response(BaseModel):
     def __init__(
         self,
         yaml_data: Dict[str, Any],
-        namespace_model: "NamespaceModel",
+        code_model: "CodeModel",
         *,
         headers: List[ResponseHeader] = [],
         type: Optional[BaseType] = None,
     ) -> None:
-        super().__init__(yaml_data=yaml_data, namespace_model=namespace_model)
+        super().__init__(yaml_data=yaml_data, code_model=code_model)
         self.status_codes: List[Union[int, str]] = yaml_data["statusCodes"]
         self.headers = headers
         self.type = type
@@ -115,21 +115,21 @@ class Response(BaseModel):
 
     @classmethod
     def from_yaml(
-        cls, yaml_data: Dict[str, Any], namespace_model: "NamespaceModel"
+        cls, yaml_data: Dict[str, Any], code_model: "CodeModel"
     ) -> "Response":
         type = (
-            namespace_model.lookup_type(id(yaml_data["type"]))
+            code_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.namespace_model)
+            type = BinaryIteratorType(type.yaml_data, type.code_model)
         return cls(
             yaml_data=yaml_data,
-            namespace_model=namespace_model,
+            code_model=code_model,
             headers=[
-                ResponseHeader.from_yaml(header, namespace_model)
+                ResponseHeader.from_yaml(header, code_model)
                 for header in yaml_data["headers"]
             ],
             type=type,
@@ -142,9 +142,7 @@ class Response(BaseModel):
 class PagingResponse(Response):
     def __init__(self, *args, **kwargs) -> None:
         super().__init__(*args, **kwargs)
-        self.item_type = self.namespace_model.lookup_type(
-            id(self.yaml_data["itemType"])
-        )
+        self.item_type = self.code_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)
@@ -166,7 +164,7 @@ class PagingResponse(Response):
 
     def docstring_text(self, **kwargs: Any) -> str:
         base_description = "An iterator like instance of "
-        if not self.namespace_model.options["version_tolerant"]:
+        if not self.code_model.options["version_tolerant"]:
             base_description += "either "
         return base_description + self.item_type.docstring_text(**kwargs)
 
@@ -247,7 +245,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.namespace_model.options["version_tolerant"]:
+        if not self.code_model.options["version_tolerant"]:
             base_description += "either "
         return base_description + super_text
 
@@ -310,7 +308,7 @@ class LROPagingResponse(LROResponse, PagingResponse):
         base_description = (
             "An instance of LROPoller that returns an iterator like instance of "
         )
-        if not self.namespace_model.options["version_tolerant"]:
+        if not self.code_model.options["version_tolerant"]:
             base_description += "either "
         return base_description + Response.docstring_text(self)
 
@@ -325,13 +323,11 @@ class LROPagingResponse(LROResponse, PagingResponse):
         return file_import
 
 
-def get_response(
-    yaml_data: Dict[str, Any], namespace_model: "NamespaceModel"
-) -> Response:
+def get_response(yaml_data: Dict[str, Any], code_model: "CodeModel") -> Response:
     if yaml_data["discriminator"] == "lropaging":
-        return LROPagingResponse.from_yaml(yaml_data, namespace_model)
+        return LROPagingResponse.from_yaml(yaml_data, code_model)
     if yaml_data["discriminator"] == "lro":
-        return LROResponse.from_yaml(yaml_data, namespace_model)
+        return LROResponse.from_yaml(yaml_data, code_model)
     if yaml_data["discriminator"] == "paging":
-        return PagingResponse.from_yaml(yaml_data, namespace_model)
-    return Response.from_yaml(yaml_data, namespace_model)
+        return PagingResponse.from_yaml(yaml_data, code_model)
+    return Response.from_yaml(yaml_data, code_model)