@autorest/python 6.9.3 → 6.9.5

package/autorest/codegen/models/paging_operation.py

@@ -60,8 +60,14 @@ class PagingOperationBase(OperationBase[PagingResponseType]):
             else None
         )
         self.override_success_response_to_200 = override_success_response_to_200
-        self.pager_sync: str = yaml_data["pagerSync"]
-        self.pager_async: str = yaml_data["pagerAsync"]
+        self.pager_sync: str = (
+            yaml_data.get("pagerSync")
+            or f"{self.init_file_import().import_core_paging}.ItemPaged"
+        )
+        self.pager_async: str = (
+            yaml_data.get("pagerAsync")
+            or f"{self.init_file_import().import_core_paging_async}.AsyncItemPaged"
+        )
 
     def _get_attr_name(self, wire_name: str) -> str:
         response_type = self.responses[0].type
@@ -144,14 +150,14 @@ class PagingOperationBase(OperationBase[PagingResponseType]):
 
     def imports(self, async_mode: bool, **kwargs: Any) -> FileImport:
         if self.abstract:
-            return FileImport()
+            return self.init_file_import()
         file_import = self._imports_shared(async_mode, **kwargs)
         file_import.merge(super().imports(async_mode, **kwargs))
         if self.code_model.options["tracing"] and self.want_tracing:
             file_import.add_submodule_import(
                 "azure.core.tracing.decorator",
                 "distributed_trace",
-                ImportType.AZURECORE,
+                ImportType.SDKCORE,
             )
         if self.next_request_builder:
             file_import.merge(
@@ -160,7 +166,9 @@ class PagingOperationBase(OperationBase[PagingResponseType]):
         elif any(p.is_api_version for p in self.client.parameters):
             file_import.add_import("urllib.parse", ImportType.STDLIB)
             file_import.add_submodule_import(
-                "azure.core.utils", "case_insensitive_dict", ImportType.AZURECORE
+                file_import.import_core_utils,
+                "case_insensitive_dict",
+                ImportType.SDKCORE,
             )
         if self.code_model.options["models_mode"] == "dpg":
             relative_path = "..." if async_mode else ".."

package/autorest/codegen/models/parameter.py

@@ -168,7 +168,7 @@ class _ParameterBase(
         return self.type.serialization_type
 
     def _imports_shared(self, async_mode: bool, **_: Any) -> FileImport:
-        file_import = FileImport()
+        file_import = self.init_file_import()
         if self.optional and self.client_default_value is None:
             file_import.add_submodule_import("typing", "Optional", ImportType.STDLIB)
         if self.added_on:

package/autorest/codegen/models/primitive_types.py

@@ -107,7 +107,7 @@ class BinaryType(PrimitiveType):
         from .combined_type import CombinedType
         from .operation import OperationBase
 
-        file_import = FileImport()
+        file_import = self.init_file_import()
         file_import.add_submodule_import("typing", "IO", ImportType.STDLIB)
         operation = kwargs.get("operation")
         if (
@@ -145,7 +145,7 @@ class BinaryIteratorType(PrimitiveType):
         return self.get_declaration("Iterator[bytes]")
 
     def imports(self, **kwargs: Any) -> FileImport:
-        file_import = FileImport()
+        file_import = self.init_file_import()
         iterator = "AsyncIterator" if kwargs.get("async_mode") else "Iterator"
         file_import.add_submodule_import("typing", iterator, ImportType.STDLIB)
         return file_import
@@ -171,7 +171,7 @@ class AnyType(PrimitiveType):
         return self.get_declaration({})
 
     def imports(self, **kwargs: Any) -> FileImport:
-        file_import = FileImport()
+        file_import = self.init_file_import()
         file_import.add_submodule_import(
             "typing", "Any", ImportType.STDLIB, TypingSection.CONDITIONAL
         )
@@ -204,7 +204,7 @@ class AnyObjectType(PrimitiveType):
         return "isinstance({}, MutableMapping)"
 
     def imports(self, **kwargs: Any) -> FileImport:
-        file_import = FileImport()
+        file_import = self.init_file_import()
         file_import.define_mutable_mapping_type()
         return file_import
 
@@ -386,7 +386,7 @@ class DatetimeType(PrimitiveType):
         return f'"{value}"'
 
     def imports(self, **kwargs: Any) -> FileImport:
-        file_import = FileImport()
+        file_import = self.init_file_import()
         file_import.add_import("datetime", ImportType.STDLIB)
         return file_import
 
@@ -398,9 +398,8 @@ class DatetimeType(PrimitiveType):
     def instance_check_template(self) -> str:
         return "isinstance({}, datetime.datetime)"
 
-    @staticmethod
-    def imports_for_sample() -> FileImport:
-        file_import = super(DatetimeType, DatetimeType).imports_for_sample()
+    def imports_for_sample(self) -> FileImport:
+        file_import = super().imports_for_sample()
         file_import.add_import("isodate", ImportType.STDLIB)
         return file_import
 
@@ -430,7 +429,7 @@ class TimeType(PrimitiveType):
         return f'"{value}"'
 
     def imports(self, **kwargs: Any) -> FileImport:
-        file_import = FileImport()
+        file_import = self.init_file_import()
         file_import.add_import("datetime", ImportType.STDLIB)
         return file_import
 
@@ -442,9 +441,8 @@ class TimeType(PrimitiveType):
     def instance_check_template(self) -> str:
         return "isinstance({}, datetime.time)"
 
-    @staticmethod
-    def imports_for_sample() -> FileImport:
-        file_import = super(TimeType, TimeType).imports_for_sample()
+    def imports_for_sample(self) -> FileImport:
+        file_import = super().imports_for_sample()
         file_import.add_import("isodate", ImportType.STDLIB)
         return file_import
 
@@ -478,7 +476,7 @@ class UnixTimeType(PrimitiveType):
         return f'"{value}"'
 
     def imports(self, **kwargs: Any) -> FileImport:
-        file_import = FileImport()
+        file_import = self.init_file_import()
         file_import.add_import("datetime", ImportType.STDLIB)
         return file_import
 
@@ -490,9 +488,8 @@ class UnixTimeType(PrimitiveType):
     def instance_check_template(self) -> str:
         return "isinstance({}, datetime.time)"
 
-    @staticmethod
-    def imports_for_sample() -> FileImport:
-        file_import = super(UnixTimeType, UnixTimeType).imports_for_sample()
+    def imports_for_sample(self) -> FileImport:
+        file_import = super().imports_for_sample()
         file_import.add_import("datetime", ImportType.STDLIB)
         return file_import
 
@@ -522,7 +519,7 @@ class DateType(PrimitiveType):
         return f'"{value}"'
 
     def imports(self, **kwargs: Any) -> FileImport:
-        file_import = FileImport()
+        file_import = self.init_file_import()
         file_import.add_import("datetime", ImportType.STDLIB)
         return file_import
 
@@ -534,9 +531,8 @@ class DateType(PrimitiveType):
     def instance_check_template(self) -> str:
         return "isinstance({}, datetime.date)"
 
-    @staticmethod
-    def imports_for_sample() -> FileImport:
-        file_import = super(DateType, DateType).imports_for_sample()
+    def imports_for_sample(self) -> FileImport:
+        file_import = super().imports_for_sample()
         file_import.add_import("isodate", ImportType.STDLIB)
         return file_import
 
@@ -566,7 +562,7 @@ class DurationType(PrimitiveType):
         return f'"{value}"'
 
     def imports(self, **kwargs: Any) -> FileImport:
-        file_import = FileImport()
+        file_import = self.init_file_import()
         file_import.add_import("datetime", ImportType.STDLIB)
         return file_import
 
@@ -578,9 +574,8 @@ class DurationType(PrimitiveType):
     def instance_check_template(self) -> str:
         return "isinstance({}, datetime.timedelta)"
 
-    @staticmethod
-    def imports_for_sample() -> FileImport:
-        file_import = super(DurationType, DurationType).imports_for_sample()
+    def imports_for_sample(self) -> FileImport:
+        file_import = super().imports_for_sample()
         file_import.add_import("isodate", ImportType.STDLIB)
         return file_import
 
@@ -611,20 +606,24 @@ class ByteArraySchema(PrimitiveType):
         return "isinstance({}, bytes)"
 
 
-class AzureCoreType(PrimitiveType):
+class SdkCoreType(PrimitiveType):
     def __init__(self, yaml_data: Dict[str, Any], code_model: "CodeModel") -> None:
         super().__init__(yaml_data=yaml_data, code_model=code_model)
         self.name = yaml_data.get("name", "")
 
     def docstring_type(self, **kwargs: Any) -> str:
-        return "~azure.core." + self.type_annotation(**kwargs)
+        return f"~{self.init_file_import().import_core}" + self.type_annotation(
+            **kwargs
+        )
 
     def type_annotation(self, **kwargs: Any) -> str:
         return self.name
 
     def imports(self, **kwargs: Any) -> FileImport:
-        file_import = FileImport()
-        file_import.add_submodule_import("azure.core", self.name, ImportType.AZURECORE)
+        file_import = self.init_file_import()
+        file_import.add_submodule_import(
+            file_import.import_core, self.name, ImportType.SDKCORE
+        )
         return file_import
 
     @property

package/autorest/codegen/models/property.py

@@ -120,6 +120,8 @@ class Property(BaseModel):  # pylint: disable=too-many-instance-attributes
             )
         if self.description(is_operation_file=True):
             description = self.description(is_operation_file=True)
+        # make sure there is no \n otherwise the json template will be invalid
+        description = (description or "").replace("\n", " ")
         return self.type.get_json_template_representation(
             optional=self.optional,
             client_default_value_declaration=client_default_value_declaration,
@@ -145,7 +147,7 @@ class Property(BaseModel):  # pylint: disable=too-many-instance-attributes
         return retval or None
 
     def imports(self, **kwargs) -> FileImport:
-        file_import = FileImport()
+        file_import = self.init_file_import()
         if self.is_discriminator and isinstance(self.type, EnumType):
             return file_import
         file_import.merge(

package/autorest/codegen/models/request_builder.py

@@ -72,16 +72,16 @@ class RequestBuilderBase(BaseBuilder[ParameterListType]):
 
     def response_docstring_text(self, **kwargs) -> str:
         return (
-            "Returns an :class:`~azure.core.rest.HttpRequest` that you will pass to the client's "
+            f"Returns an :class:`~{self.response_docstring_type()}` that you will pass to the client's "
             + "`send_request` method. See https://aka.ms/azsdk/dpcodegen/python/send_request for how to "
             + "incorporate this response into your code flow."
         )
 
     def response_docstring_type(self, **kwargs) -> str:
-        return "~azure.core.rest.HttpRequest"
+        return f"~{self.init_file_import().import_core_rest}.HttpRequest"
 
     def imports(self) -> FileImport:
-        file_import = FileImport()
+        file_import = self.init_file_import()
         relative_path = ".."
         if (
             not self.code_model.options["builders_visibility"] == "embedded"
@@ -98,28 +98,29 @@ class RequestBuilderBase(BaseBuilder[ParameterListType]):
             )
 
         file_import.add_submodule_import(
-            "azure.core.rest",
+            file_import.import_core_rest,
             "HttpRequest",
-            ImportType.AZURECORE,
+            ImportType.SDKCORE,
         )
 
         if self.parameters.headers or self.parameters.query:
             file_import.add_submodule_import(
-                "azure.core.utils", "case_insensitive_dict", ImportType.AZURECORE
+                file_import.import_core_utils,
+                "case_insensitive_dict",
+                ImportType.SDKCORE,
             )
         file_import.add_submodule_import(
             "typing", "Any", ImportType.STDLIB, typing_section=TypingSection.CONDITIONAL
         )
         file_import.add_msrest_import(
-            self.code_model,
-            "..."
+            relative_path="..."
             if (
                 not self.code_model.options["builders_visibility"] == "embedded"
                 and self.group_name
             )
             else "..",
-            MsrestImportType.Serializer,
-            TypingSection.REGULAR,
+            msrest_import_type=MsrestImportType.Serializer,
+            typing_section=TypingSection.REGULAR,
         )
         if (
             self.overloads

package/autorest/codegen/models/response.py

@@ -8,7 +8,7 @@ from typing import Dict, Optional, List, Any, TYPE_CHECKING, Union
 from .base import BaseModel
 from .base import BaseType
 from .imports import FileImport, ImportType, TypingSection
-from .primitive_types import BinaryType, BinaryIteratorType
+from .primitive_types import BinaryType, BinaryIteratorType, ByteArraySchema
 from .dictionary_type import DictionaryType
 from .list_type import ListType
 from .model_type import ModelType
@@ -58,6 +58,7 @@ class Response(BaseModel):
         self.headers = headers or []
         self.type = type
         self.nullable = yaml_data.get("nullable")
+        self.default_content_type = yaml_data.get("defaultContentType")
 
     @property
     def result_property(self) -> str:
@@ -80,7 +81,12 @@ class Response(BaseModel):
     @property
     def is_stream_response(self) -> bool:
         """Is the response expected to be streamable, like a download."""
-        return isinstance(self.type, BinaryIteratorType)
+        retval = isinstance(self.type, BinaryIteratorType) or (
+            isinstance(self.type, ByteArraySchema)
+            and bool(self.default_content_type)
+            and self.default_content_type != "application/json"
+        )
+        return retval
 
     @property
     def serialization_type(self) -> str:
@@ -108,7 +114,7 @@ class Response(BaseModel):
         return self.type.docstring_type(**kwargs) if self.type else "None"
 
     def _imports_shared(self, **kwargs: Any) -> FileImport:
-        file_import = FileImport()
+        file_import = self.init_file_import()
         if self.type:
             file_import.merge(self.type.imports(**kwargs))
         if self.nullable:
@@ -158,6 +164,14 @@ 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.pager_sync: str = (
+            self.yaml_data.get("pagerSync")
+            or f"{self.init_file_import().import_core_paging}.ItemPaged"
+        )
+        self.pager_async: str = (
+            self.yaml_data.get("pagerAsync")
+            or f"{self.init_file_import().import_core_paging_async}.AsyncItemPaged"
+        )
 
     def get_polymorphic_subtypes(self, polymorphic_subtypes: List["ModelType"]) -> None:
         return self.item_type.get_polymorphic_subtypes(polymorphic_subtypes)
@@ -166,9 +180,7 @@ class PagingResponse(Response):
         return self.item_type.get_json_template_representation()
 
     def get_pager_path(self, async_mode: bool) -> str:
-        return (
-            self.yaml_data["pagerAsync"] if async_mode else self.yaml_data["pagerSync"]
-        )
+        return self.pager_async if async_mode else self.pager_sync
 
     def get_pager(self, async_mode: bool) -> str:
         return self.get_pager_path(async_mode).split(".")[-1]
@@ -192,7 +204,7 @@ class PagingResponse(Response):
         pager_import_path = ".".join(self.get_pager_path(async_mode).split(".")[:-1])
         pager = self.get_pager(async_mode)
 
-        file_import.add_submodule_import(pager_import_path, pager, ImportType.AZURECORE)
+        file_import.add_submodule_import(pager_import_path, pager, ImportType.SDKCORE)
         return file_import
 
     def imports(self, **kwargs: Any) -> FileImport:
@@ -200,7 +212,9 @@ class PagingResponse(Response):
         async_mode = kwargs.get("async_mode")
         if async_mode:
             file_import.add_submodule_import(
-                "azure.core.async_paging", "AsyncList", ImportType.AZURECORE
+                file_import.import_core_paging_async,
+                "AsyncList",
+                ImportType.SDKCORE,
             )
 
         return file_import
@@ -269,9 +283,7 @@ class LROResponse(Response):
         async_mode = kwargs["async_mode"]
         poller_import_path = ".".join(self.get_poller_path(async_mode).split(".")[:-1])
         poller = self.get_poller(async_mode)
-        file_import.add_submodule_import(
-            poller_import_path, poller, ImportType.AZURECORE
-        )
+        file_import.add_submodule_import(poller_import_path, poller, ImportType.SDKCORE)
         return file_import
 
     def imports(self, **kwargs: Any) -> FileImport:
@@ -285,7 +297,7 @@ class LROResponse(Response):
         file_import.add_submodule_import(
             default_polling_method_import_path,
             default_polling_method,
-            ImportType.AZURECORE,
+            ImportType.SDKCORE,
         )
         default_no_polling_method_import_path = ".".join(
             self.get_no_polling_method_path(async_mode).split(".")[:-1]
@@ -294,7 +306,7 @@ class LROResponse(Response):
         file_import.add_submodule_import(
             default_no_polling_method_import_path,
             default_no_polling_method,
-            ImportType.AZURECORE,
+            ImportType.SDKCORE,
         )
 
         base_polling_method_import_path = ".".join(
@@ -302,7 +314,7 @@ class LROResponse(Response):
         )
         base_polling_method = self.get_base_polling_method(async_mode)
         file_import.add_submodule_import(
-            base_polling_method_import_path, base_polling_method, ImportType.AZURECORE
+            base_polling_method_import_path, base_polling_method, ImportType.SDKCORE
         )
         return file_import
 

package/autorest/codegen/serializers/__init__.py

@@ -240,6 +240,11 @@ class JinjaSerializer(ReaderAndWriter):  # pylint: disable=abstract-method
         serializer = GeneralSerializer(self.code_model, env, async_mode=False)
         params = self.code_model.options["package_configuration"] or {}
         for template_name in package_files:
+            if (
+                self.code_model.options["unbranded"]
+                and template_name == "dev_requirements.txt.jinja2"
+            ):
+                continue
             file = template_name.replace(".jinja2", "")
             output_name = root_of_sdk / file
             if not self.read_file(output_name) or file in _REGENERATE_FILES:

package/autorest/codegen/serializers/base_serializer.py

@@ -0,0 +1,21 @@
+# -------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for
+# license information.
+# --------------------------------------------------------------------------
+from jinja2 import Environment
+from ..models import (
+    FileImport,
+    CodeModel,
+)
+
+
+class BaseSerializer:
+    """Base serializer for SDK root level files"""
+
+    def __init__(self, code_model: CodeModel, env: Environment):
+        self.code_model = code_model
+        self.env = env
+
+    def init_file_import(self) -> FileImport:
+        return FileImport(self.code_model)

package/autorest/codegen/serializers/builder_serializer.py

@@ -426,6 +426,12 @@ class _BuilderBaseSerializer(Generic[BuilderType]):  # pylint: disable=abstract-
             builder.parameters.path, self.serializer_name
         )
 
+    @property
+    def pipeline_name(self) -> str:
+        if not self.code_model.options["unbranded"]:
+            return "_pipeline"
+        return "pipeline"
+
 
 ############################## REQUEST BUILDERS ##############################
 
@@ -483,12 +489,13 @@ class RequestBuilderSerializer(
         return False
 
     def response_docstring(self, builder: RequestBuilderType) -> List[str]:
+        import_core_rest = builder.init_file_import().import_core_rest
         response_str = (
-            ":return: Returns an :class:`~azure.core.rest.HttpRequest` that you will pass to the client's "
+            f":return: Returns an :class:`~{import_core_rest}.HttpRequest` that you will pass to the client's "
             + "`send_request` method. See https://aka.ms/azsdk/dpcodegen/python/send_request for how to "
             + "incorporate this response into your code flow."
         )
-        rtype_str = ":rtype: ~azure.core.rest.HttpRequest"
+        rtype_str = f":rtype: ~{import_core_rest}.HttpRequest"
         return [response_str, rtype_str]
 
     def pop_kwargs_from_signature(self, builder: RequestBuilderType) -> List[str]:
@@ -637,13 +644,13 @@ class _OperationSerializer(
     def make_pipeline_call(self, builder: OperationType) -> List[str]:
         type_ignore = self.async_mode and builder.group_name == ""  # is in a mixin
         stream_value = (
-            'kwargs.pop("stream", False)'
+            f'kwargs.pop("stream", {builder.has_stream_response})'
             if builder.expose_stream_keyword
             else builder.has_stream_response
         )
         return [
             f"_stream = {stream_value}",
-            f"pipeline_response: PipelineResponse = {self._call_method}self._client._pipeline.run(  "
+            f"pipeline_response: PipelineResponse = {self._call_method}self._client.{self.pipeline_name}.run(  "
             + f"{'# type: ignore' if type_ignore else ''} # pylint: disable=protected-access",
             "    _request,",
             "    stream=_stream,",
@@ -723,7 +730,7 @@ class _OperationSerializer(
         return [
             response_str,
             rtype_str,
-            ":raises ~azure.core.exceptions.HttpResponseError:",
+            f":raises ~{builder.init_file_import().import_core_exceptions}.HttpResponseError:",
         ]
 
     def _serialize_body_parameter(self, builder: OperationType) -> List[str]:
@@ -1049,14 +1056,17 @@ class _OperationSerializer(
         if response.headers:
             retval.append("")
         deserialize_code: List[str] = []
-        if response.is_stream_response:
-            deserialize_code.append(
-                "deserialized = {}".format(
+        if builder.has_stream_response:
+            if isinstance(response.type, ByteArraySchema):
+                retval.append(f"{'await ' if self.async_mode else ''}response.read()")
+                deserialized = "response.content"
+            else:
+                deserialized = (
                     "response.iter_bytes()"
                     if self.code_model.options["version_tolerant"]
-                    else "response.stream_download(self._client._pipeline)"
+                    else f"response.stream_download(self._client.{self.pipeline_name})"
                 )
-            )
+            deserialize_code.append(f"deserialized = {deserialized}")
         elif response.type:
             pylint_disable = ""
             if isinstance(response.type, ModelType) and response.type.internal:
@@ -1069,14 +1079,18 @@ class _OperationSerializer(
                 deserialize_code.append("    pipeline_response")
                 deserialize_code.append(")")
             elif self.code_model.options["models_mode"] == "dpg":
-                deserialize_code.append("deserialized = _deserialize(")
-                deserialize_code.append(
-                    f"    {response.type.type_annotation(is_operation_file=True)},{pylint_disable}"
-                )
-                deserialize_code.append(
-                    f"    response.json(){response.result_property}"
-                )
-                deserialize_code.append(")")
+                if builder.has_stream_response:
+                    deserialize_code.append("deserialized = response.content")
+                else:
+                    deserialize_code.append("deserialized = _deserialize(")
+                    deserialize_code.append(
+                        f"    {response.type.type_annotation(is_operation_file=True)},{pylint_disable}"
+                    )
+                    deserialize_code.append(
+                        f"    response.json(){response.result_property}"
+                    )
+                    deserialize_code.append(")")
+
             else:
                 deserialized_value = (
                     "ET.fromstring(response.text())"
@@ -1088,7 +1102,7 @@ class _OperationSerializer(
                 deserialize_code.append("else:")
                 deserialize_code.append("    deserialized = None")
         if len(deserialize_code) > 0:
-            if builder.expose_stream_keyword:
+            if builder.expose_stream_keyword and not builder.has_stream_response:
                 retval.append("if _stream:")
                 retval.append("    deserialized = response.iter_bytes()")
                 retval.append("else:")
@@ -1565,7 +1579,7 @@ class _LROOperationSerializer(_OperationSerializer[LROOperationType]):
         retval.append("else: polling_method = polling")
         retval.append("if cont_token:")
         retval.append(
-            f"    return {builder.get_poller(self.async_mode)}.from_continuation_token("
+            f"    return {builder.get_poller_with_response_type(self.async_mode)}.from_continuation_token("
         )
         retval.append("        polling_method=polling_method,")
         retval.append("        continuation_token=cont_token,")
@@ -1573,9 +1587,12 @@ class _LROOperationSerializer(_OperationSerializer[LROOperationType]):
         retval.append("        deserialization_callback=get_long_running_output")
         retval.append("    )")
         retval.append(
-            f"return {builder.get_poller(self.async_mode)}"
-            "(self._client, raw_result, get_long_running_output, polling_method)  # type: ignore"
+            f"return {builder.get_poller_with_response_type(self.async_mode)}("
         )
+        retval.append(
+            "    self._client, raw_result, get_long_running_output, polling_method  # type: ignore"
+        )
+        retval.append("    )")
         return retval
 
     def get_long_running_output(self, builder: LROOperationType) -> List[str]:

package/autorest/codegen/serializers/client_serializer.py

@@ -111,19 +111,28 @@ class ClientSerializer:
     def initialize_pipeline_client(self, async_mode: bool) -> List[str]:
         result = []
         pipeline_client_name = self.client.pipeline_class(async_mode)
+        endpoint_name = (
+            "endpoint" if self.client.code_model.options["unbranded"] else "base_url"
+        )
         params = {
-            "base_url": self.host_variable_name,
+            endpoint_name: self.host_variable_name,
             "policies": "_policies",
         }
         if not self.client.code_model.is_legacy and self.client.request_id_header_name:
             result.append(
                 f'kwargs["request_id_header_name"] = "{self.client.request_id_header_name}"'
             )
+        policies = build_policies(
+            self.client.code_model.options["azure_arm"],
+            async_mode,
+            self.client.code_model.options["unbranded"],
+            self.client.code_model.options["tracing"],
+        )
         result.extend(
             [
                 "_policies = kwargs.pop('policies', None)",
                 "if _policies is None:",
-                f'    _policies = [{",".join(build_policies(self.client.code_model.options["azure_arm"], async_mode))}]',  # pylint: disable=line-too-long
+                f'    _policies = [{",".join(policies)}]',
                 f"self._client: {pipeline_client_name} = {pipeline_client_name}("
                 f"{', '.join(f'{k}={v}' for k, v in params.items())}, **kwargs)",
             ]
@@ -243,7 +252,9 @@ class ClientSerializer:
         return retval
 
     def _rest_request_example(self, async_mode: bool) -> List[str]:
-        retval = [">>> from azure.core.rest import HttpRequest"]
+        retval = [
+            f">>> from {self.client.init_file_import().import_core_rest} import HttpRequest"
+        ]
         retval.append('>>> request = HttpRequest("GET", "https://www.example.org/")')
         retval.append("<HttpRequest [GET], url: 'https://www.example.org/'>")
         retval.extend(self._example_make_call(async_mode))
@@ -262,7 +273,9 @@ class ClientSerializer:
         )
         retval.append("")
         retval.append(":param request: The network request you want to make. Required.")
-        retval.append(":type request: ~azure.core.rest.HttpRequest")
+        retval.append(
+            f":type request: ~{self.client.init_file_import().import_core_rest}.HttpRequest"
+        )
         retval.append(
             ":keyword bool stream: Whether the response payload will be streamed. Defaults to False."
         )
@@ -270,7 +283,9 @@ class ClientSerializer:
             ":return: The response of your network call. Does not do error handling on your response."
         )
         http_response = "AsyncHttpResponse" if async_mode else "HttpResponse"
-        retval.append(f":rtype: ~azure.core.rest.{http_response}")
+        retval.append(
+            f":rtype: ~{self.client.init_file_import().import_core_rest}.{http_response}"
+        )
         retval.append('"""')
         return retval