@autorest/python 6.9.6 → 6.9.8

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 = self.init_file_import()
+        file_import = FileImport(self.code_model)
         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 = self.init_file_import()
+        file_import = FileImport(self.code_model)
         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 = self.init_file_import()
+        file_import = FileImport(self.code_model)
         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 = self.init_file_import()
+        file_import = FileImport(self.code_model)
         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 = self.init_file_import()
+        file_import = FileImport(self.code_model)
         file_import.add_import("datetime", ImportType.STDLIB)
         return file_import
 
@@ -429,7 +429,7 @@ class TimeType(PrimitiveType):
         return f'"{value}"'
 
     def imports(self, **kwargs: Any) -> FileImport:
-        file_import = self.init_file_import()
+        file_import = FileImport(self.code_model)
         file_import.add_import("datetime", ImportType.STDLIB)
         return file_import
 
@@ -476,7 +476,7 @@ class UnixTimeType(PrimitiveType):
         return f'"{value}"'
 
     def imports(self, **kwargs: Any) -> FileImport:
-        file_import = self.init_file_import()
+        file_import = FileImport(self.code_model)
         file_import.add_import("datetime", ImportType.STDLIB)
         return file_import
 
@@ -519,7 +519,7 @@ class DateType(PrimitiveType):
         return f'"{value}"'
 
     def imports(self, **kwargs: Any) -> FileImport:
-        file_import = self.init_file_import()
+        file_import = FileImport(self.code_model)
         file_import.add_import("datetime", ImportType.STDLIB)
         return file_import
 
@@ -562,7 +562,7 @@ class DurationType(PrimitiveType):
         return f'"{value}"'
 
     def imports(self, **kwargs: Any) -> FileImport:
-        file_import = self.init_file_import()
+        file_import = FileImport(self.code_model)
         file_import.add_import("datetime", ImportType.STDLIB)
         return file_import
 
@@ -612,18 +612,14 @@ class SdkCoreType(PrimitiveType):
         self.name = yaml_data.get("name", "")
 
     def docstring_type(self, **kwargs: Any) -> str:
-        return f"~{self.init_file_import().import_core}" + self.type_annotation(
-            **kwargs
-        )
+        return f"~{self.code_model.core_library}.{self.type_annotation(**kwargs)}"
 
     def type_annotation(self, **kwargs: Any) -> str:
         return self.name
 
     def imports(self, **kwargs: Any) -> FileImport:
-        file_import = self.init_file_import()
-        file_import.add_submodule_import(
-            file_import.import_core, self.name, ImportType.SDKCORE
-        )
+        file_import = super().imports(**kwargs)
+        file_import.add_submodule_import("", self.name, ImportType.SDKCORE)
         return file_import
 
     @property

package/autorest/codegen/models/property.py

@@ -147,7 +147,7 @@ class Property(BaseModel):  # pylint: disable=too-many-instance-attributes
         return retval or None
 
     def imports(self, **kwargs) -> FileImport:
-        file_import = self.init_file_import()
+        file_import = FileImport(self.code_model)
         if self.is_discriminator and isinstance(self.type, EnumType):
             return file_import
         file_import.merge(

package/autorest/codegen/models/request_builder.py

@@ -78,10 +78,10 @@ class RequestBuilderBase(BaseBuilder[ParameterListType]):
         )
 
     def response_docstring_type(self, **kwargs) -> str:
-        return f"~{self.init_file_import().import_core_rest}.HttpRequest"
+        return f"~{self.code_model.core_library}.rest.HttpRequest"
 
     def imports(self) -> FileImport:
-        file_import = self.init_file_import()
+        file_import = FileImport(self.code_model)
         relative_path = ".."
         if (
             not self.code_model.options["builders_visibility"] == "embedded"
@@ -98,14 +98,14 @@ class RequestBuilderBase(BaseBuilder[ParameterListType]):
             )
 
         file_import.add_submodule_import(
-            file_import.import_core_rest,
+            "rest",
             "HttpRequest",
             ImportType.SDKCORE,
         )
 
         if self.parameters.headers or self.parameters.query:
             file_import.add_submodule_import(
-                file_import.import_core_utils,
+                "utils",
                 "case_insensitive_dict",
                 ImportType.SDKCORE,
             )

package/autorest/codegen/models/response.py

@@ -114,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 = self.init_file_import()
+        file_import = FileImport(self.code_model)
         if self.type:
             file_import.merge(self.type.imports(**kwargs))
         if self.nullable:
@@ -134,6 +134,16 @@ class Response(BaseModel):
     def imports_for_multiapi(self, **kwargs: Any) -> FileImport:
         return self._imports_shared(**kwargs)
 
+    def _get_import_type(self, input_path: str) -> ImportType:
+        # helper function to return imports for responses based off
+        # of whether we're importing from the core library, or users
+        # are customizing responses
+        return (
+            ImportType.SDKCORE
+            if self.code_model.core_library.split(".")[0] in input_path
+            else ImportType.THIRDPARTY
+        )
+
     @classmethod
     def from_yaml(
         cls, yaml_data: Dict[str, Any], code_model: "CodeModel"
@@ -166,11 +176,14 @@ class PagingResponse(Response):
         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"
+            or f"{self.code_model.core_library}.paging.ItemPaged"
+        )
+        default_paging_submodule = (
+            f"{'' if self.code_model.options['unbranded'] else 'async_'}paging"
         )
         self.pager_async: str = (
             self.yaml_data.get("pagerAsync")
-            or f"{self.init_file_import().import_core_paging_async}.AsyncItemPaged"
+            or f"{self.code_model.core_library}.{default_paging_submodule}.AsyncItemPaged"
         )
 
     def get_polymorphic_subtypes(self, polymorphic_subtypes: List["ModelType"]) -> None:
@@ -179,6 +192,9 @@ class PagingResponse(Response):
     def get_json_template_representation(self) -> Any:
         return self.item_type.get_json_template_representation()
 
+    def get_pager_import_path(self, async_mode: bool) -> str:
+        return ".".join(self.get_pager_path(async_mode).split(".")[:-1])
+
     def get_pager_path(self, async_mode: bool) -> str:
         return self.pager_async if async_mode else self.pager_sync
 
@@ -201,10 +217,12 @@ class PagingResponse(Response):
     def _imports_shared(self, **kwargs: Any) -> FileImport:
         file_import = super()._imports_shared(**kwargs)
         async_mode = kwargs.get("async_mode", False)
-        pager_import_path = ".".join(self.get_pager_path(async_mode).split(".")[:-1])
         pager = self.get_pager(async_mode)
+        pager_path = self.get_pager_import_path(async_mode)
 
-        file_import.add_submodule_import(pager_import_path, pager, ImportType.SDKCORE)
+        file_import.add_submodule_import(
+            pager_path, pager, self._get_import_type(pager_path)
+        )
         return file_import
 
     def imports(self, **kwargs: Any) -> FileImport:
@@ -212,7 +230,7 @@ class PagingResponse(Response):
         async_mode = kwargs.get("async_mode")
         if async_mode:
             file_import.add_submodule_import(
-                file_import.import_core_paging_async,
+                f"{'' if self.code_model.options['unbranded'] else 'async_'}paging",
                 "AsyncList",
                 ImportType.SDKCORE,
             )
@@ -283,7 +301,9 @@ 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.SDKCORE)
+        file_import.add_submodule_import(
+            poller_import_path, poller, self._get_import_type(poller_import_path)
+        )
         return file_import
 
     def imports(self, **kwargs: Any) -> FileImport:
@@ -297,7 +317,7 @@ class LROResponse(Response):
         file_import.add_submodule_import(
             default_polling_method_import_path,
             default_polling_method,
-            ImportType.SDKCORE,
+            self._get_import_type(default_polling_method_import_path),
         )
         default_no_polling_method_import_path = ".".join(
             self.get_no_polling_method_path(async_mode).split(".")[:-1]
@@ -306,7 +326,7 @@ class LROResponse(Response):
         file_import.add_submodule_import(
             default_no_polling_method_import_path,
             default_no_polling_method,
-            ImportType.SDKCORE,
+            self._get_import_type(default_no_polling_method_import_path),
         )
 
         base_polling_method_import_path = ".".join(
@@ -314,7 +334,9 @@ 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.SDKCORE
+            base_polling_method_import_path,
+            base_polling_method,
+            self._get_import_type(base_polling_method_import_path),
         )
         return file_import
 

package/autorest/codegen/serializers/__init__.py

@@ -238,7 +238,7 @@ class JinjaSerializer(ReaderAndWriter):  # pylint: disable=abstract-method
         else:
             return
         serializer = GeneralSerializer(self.code_model, env, async_mode=False)
-        params = self.code_model.options["package_configuration"] or {}
+        params = self.code_model.options["packaging_files_config"] or {}
         for template_name in package_files:
             if (
                 self.code_model.options["unbranded"]

package/autorest/codegen/serializers/builder_serializer.py

@@ -428,9 +428,7 @@ class _BuilderBaseSerializer(Generic[BuilderType]):  # pylint: disable=abstract-
 
     @property
     def pipeline_name(self) -> str:
-        if not self.code_model.options["unbranded"]:
-            return "_pipeline"
-        return "pipeline"
+        return f"{'' if self.code_model.options['unbranded'] else '_'}pipeline"
 
 
 ############################## REQUEST BUILDERS ##############################
@@ -489,13 +487,13 @@ class RequestBuilderSerializer(
         return False
 
     def response_docstring(self, builder: RequestBuilderType) -> List[str]:
-        import_core_rest = builder.init_file_import().import_core_rest
+        request_full_path = f"{self.code_model.core_library}.rest.HttpRequest"
         response_str = (
-            f":return: Returns an :class:`~{import_core_rest}.HttpRequest` that you will pass to the client's "
+            f":return: Returns an :class:`~{request_full_path}` 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 = f":rtype: ~{import_core_rest}.HttpRequest"
+        rtype_str = f":rtype: ~{request_full_path}"
         return [response_str, rtype_str]
 
     def pop_kwargs_from_signature(self, builder: RequestBuilderType) -> List[str]:
@@ -645,7 +643,7 @@ class _OperationSerializer(
         type_ignore = self.async_mode and builder.group_name == ""  # is in a mixin
         stream_value = (
             f'kwargs.pop("stream", {builder.has_stream_response})'
-            if builder.expose_stream_keyword
+            if builder.expose_stream_keyword and builder.has_response_body
             else builder.has_stream_response
         )
         return [
@@ -730,7 +728,7 @@ class _OperationSerializer(
         return [
             response_str,
             rtype_str,
-            f":raises ~{builder.init_file_import().import_core_exceptions}.HttpResponseError:",
+            f":raises ~{self.code_model.core_library}.exceptions.HttpResponseError:",
         ]
 
     def _serialize_body_parameter(self, builder: OperationType) -> List[str]:
@@ -763,13 +761,13 @@ class _OperationSerializer(
             if hasattr(body_param.type, "encode") and body_param.type.encode:  # type: ignore
                 create_body_call = (
                     f"_{body_kwarg_name} = json.dumps({body_param.client_name}, "
-                    "cls=AzureJSONEncoder, exclude_readonly=True, "
+                    "cls=SdkJSONEncoder, exclude_readonly=True, "
                     f"format='{body_param.type.encode}')  # type: ignore"  # type: ignore
                 )
             else:
                 create_body_call = (
                     f"_{body_kwarg_name} = json.dumps({body_param.client_name}, "
-                    "cls=AzureJSONEncoder, exclude_readonly=True)  # type: ignore"
+                    "cls=SdkJSONEncoder, exclude_readonly=True)  # type: ignore"
                 )
         else:
             create_body_call = f"_{body_kwarg_name} = {body_param.client_name}"
@@ -1082,12 +1080,18 @@ class _OperationSerializer(
                 if builder.has_stream_response:
                     deserialize_code.append("deserialized = response.content")
                 else:
+                    format_filed = (
+                        f', format="{response.type.encode}"'
+                        if isinstance(response.type, ByteArraySchema)
+                        and response.default_content_type == "application/json"
+                        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}"
+                        f"    response.json(){response.result_property}{format_filed}"
                     )
                     deserialize_code.append(")")
 

package/autorest/codegen/serializers/client_serializer.py

@@ -253,7 +253,7 @@ class ClientSerializer:
 
     def _rest_request_example(self, async_mode: bool) -> List[str]:
         retval = [
-            f">>> from {self.client.init_file_import().import_core_rest} import HttpRequest"
+            f">>> from {self.client.code_model.core_library}.rest import HttpRequest"
         ]
         retval.append('>>> request = HttpRequest("GET", "https://www.example.org/")')
         retval.append("<HttpRequest [GET], url: 'https://www.example.org/'>")
@@ -261,6 +261,7 @@ class ClientSerializer:
         return retval
 
     def send_request_description(self, async_mode: bool) -> List[str]:
+        rest_library = f"{self.client.code_model.core_library}.rest"
         retval = ['"""Runs the network request through the client\'s chained policies.']
         retval.append("")
         if self.client.code_model.options["builders_visibility"] != "embedded":
@@ -273,9 +274,7 @@ class ClientSerializer:
         )
         retval.append("")
         retval.append(":param request: The network request you want to make. Required.")
-        retval.append(
-            f":type request: ~{self.client.init_file_import().import_core_rest}.HttpRequest"
-        )
+        retval.append(f":type request: ~{rest_library}.HttpRequest")
         retval.append(
             ":keyword bool stream: Whether the response payload will be streamed. Defaults to False."
         )
@@ -283,9 +282,7 @@ 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: ~{self.client.init_file_import().import_core_rest}.{http_response}"
-        )
+        retval.append(f":rtype: ~{rest_library}.{http_response}")
         retval.append('"""')
         return retval
 

package/autorest/codegen/serializers/enum_serializer.py

@@ -5,6 +5,7 @@
 # --------------------------------------------------------------------------
 
 from .base_serializer import BaseSerializer
+from ..models import FileImport
 
 
 class EnumSerializer(BaseSerializer):
@@ -12,5 +13,5 @@ class EnumSerializer(BaseSerializer):
         # Generate the enum file
         template = self.env.get_template("enum_container.py.jinja2")
         return template.render(
-            code_model=self.code_model, file_import=self.init_file_import()
+            code_model=self.code_model, file_import=FileImport(self.code_model)
         )

package/autorest/codegen/serializers/general_serializer.py

@@ -6,7 +6,7 @@
 from typing import Any, List
 from jinja2 import Environment
 from .import_serializer import FileImportSerializer, TypingSection
-from ..models.imports import MsrestImportType
+from ..models.imports import MsrestImportType, FileImport
 from ..models import (
     ImportType,
     CodeModel,
@@ -59,7 +59,7 @@ class GeneralSerializer(BaseSerializer):
         }
         params.update(self.code_model.options)
         params.update(kwargs)
-        return template.render(file_import=self.init_file_import(), **params)
+        return template.render(file_import=FileImport(self.code_model), **params)
 
     def serialize_pkgutil_init_file(self) -> str:
         template = self.env.get_template("pkgutil_init.py.jinja2")
@@ -76,7 +76,7 @@ class GeneralSerializer(BaseSerializer):
     def serialize_service_client_file(self, clients: List[Client]) -> str:
         template = self.env.get_template("client_container.py.jinja2")
 
-        imports = self.init_file_import()
+        imports = FileImport(self.code_model)
         for client in clients:
             imports.merge(client.imports(self.async_mode))
 
@@ -92,7 +92,7 @@ class GeneralSerializer(BaseSerializer):
         template = self.env.get_template("vendor.py.jinja2")
 
         # configure imports
-        file_import = self.init_file_import()
+        file_import = FileImport(self.code_model)
         if self.code_model.need_request_converter:
             file_import.add_submodule_import(
                 "azure.core.pipeline.transport",
@@ -107,7 +107,7 @@ class GeneralSerializer(BaseSerializer):
                 ImportType.STDLIB,
             )
             file_import.add_submodule_import(
-                file_import.import_core_pipeline_client,
+                "runtime" if self.code_model.options["unbranded"] else "",
                 f"{'Async' if self.async_mode else ''}PipelineClient",
                 ImportType.SDKCORE,
                 TypingSection.TYPING,
@@ -126,7 +126,7 @@ class GeneralSerializer(BaseSerializer):
         if self.code_model.has_etag:
             file_import.add_submodule_import("typing", "Optional", ImportType.STDLIB)
             file_import.add_submodule_import(
-                file_import.import_core,
+                "",
                 "MatchConditions",
                 ImportType.SDKCORE,
             )
@@ -142,7 +142,7 @@ class GeneralSerializer(BaseSerializer):
 
     def serialize_config_file(self, clients: List[Client]) -> str:
         template = self.env.get_template("config_container.py.jinja2")
-        imports = self.init_file_import()
+        imports = FileImport(self.code_model)
         for client in self.code_model.clients:
             imports.merge(client.config.imports(self.async_mode))
         return template.render(
@@ -160,14 +160,13 @@ class GeneralSerializer(BaseSerializer):
     def serialize_serialization_file(self) -> str:
         template = self.env.get_template("serialization.py.jinja2")
         return template.render(
-            import_core_exceptions=self.init_file_import().import_core_exceptions,
-            import_core_serialization=self.init_file_import().import_core_serialization,
+            code_model=self.code_model,
         )
 
     def serialize_model_base_file(self) -> str:
         template = self.env.get_template("model_base.py.jinja2")
         return template.render(
-            code_model=self.code_model, file_import=self.init_file_import()
+            code_model=self.code_model, file_import=FileImport(self.code_model)
         )
 
     def serialize_validation_file(self) -> str:

package/autorest/codegen/serializers/model_serializer.py

@@ -129,7 +129,7 @@ class _ModelSerializer(BaseSerializer, ABC):
 
 class MsrestModelSerializer(_ModelSerializer):
     def imports(self) -> FileImport:
-        file_import = self.init_file_import()
+        file_import = FileImport(self.code_model)
         file_import.add_msrest_import(
             relative_path="..",
             msrest_import_type=MsrestImportType.Module,
@@ -198,7 +198,7 @@ class MsrestModelSerializer(_ModelSerializer):
 
 class DpgModelSerializer(_ModelSerializer):
     def imports(self) -> FileImport:
-        file_import = self.init_file_import()
+        file_import = FileImport(self.code_model)
         file_import.add_submodule_import(
             "..",
             "_model_base",

package/autorest/codegen/serializers/operation_groups_serializer.py

@@ -13,6 +13,7 @@ from ..models import (
     RequestBuilder,
     OverloadedRequestBuilder,
     Client,
+    FileImport,
 )
 from .import_serializer import FileImportSerializer
 from .builder_serializer import (
@@ -56,7 +57,7 @@ class OperationGroupsSerializer(BaseSerializer):
             if self.operation_group
             else [og for client in self.clients for og in client.operation_groups]
         )
-        imports = self.init_file_import()
+        imports = FileImport(self.code_model)
         for operation_group in operation_groups:
             imports.merge(
                 operation_group.imports(

package/autorest/codegen/serializers/patch_serializer.py

@@ -4,14 +4,14 @@
 # license information.
 # --------------------------------------------------------------------------
 from .import_serializer import FileImportSerializer
-from ..models import ImportType
+from ..models import ImportType, FileImport
 from .base_serializer import BaseSerializer
 
 
 class PatchSerializer(BaseSerializer):
     def serialize(self) -> str:
         template = self.env.get_template("patch.py.jinja2")
-        imports = self.init_file_import()
+        imports = FileImport(self.code_model)
         imports.add_submodule_import("typing", "List", ImportType.STDLIB)
         return template.render(
             code_model=self.code_model,

package/autorest/codegen/serializers/request_builders_serializer.py

@@ -26,7 +26,7 @@ class RequestBuildersSerializer(BaseSerializer):
 
     @property
     def imports(self) -> FileImport:
-        file_import = self.init_file_import()
+        file_import = FileImport(self.code_model)
         for request_builder in self.request_builders:
             if request_builder.group_name == self.group_name:
                 file_import.merge(request_builder.imports())

package/autorest/codegen/serializers/sample_serializer.py

@@ -8,15 +8,19 @@ import logging
 from typing import Dict, Any, Union, Tuple
 from jinja2 import Environment
 
-from autorest.codegen.models.credential_types import KeyCredentialType
-from autorest.codegen.models.credential_types import TokenCredentialType
-from autorest.codegen.models.imports import ImportType
 from autorest.codegen.models.operation import OperationBase
-from autorest.codegen.models.operation_group import OperationGroup
-from autorest.codegen.models.parameter import Parameter, BodyParameter
-from autorest.codegen.serializers.import_serializer import FileImportSerializer
-from autorest.codegen.serializers.base_serializer import BaseSerializer
-from ..models import CodeModel
+from .import_serializer import FileImportSerializer
+from .base_serializer import BaseSerializer
+from ..models import (
+    CodeModel,
+    KeyCredentialType,
+    TokenCredentialType,
+    ImportType,
+    OperationGroup,
+    Parameter,
+    BodyParameter,
+    FileImport,
+)
 from .utils import get_namespace_config, get_namespace_from_package_name
 from ..._utils import to_snake_case
 
@@ -43,7 +47,7 @@ class SampleSerializer(BaseSerializer):
         }
 
     def _imports(self) -> FileImportSerializer:
-        imports = self.init_file_import()
+        imports = FileImport(self.code_model)
         namespace_from_package_name = get_namespace_from_package_name(
             self.code_model.options["package_name"]
         )
@@ -57,18 +61,18 @@ class SampleSerializer(BaseSerializer):
         ) > namespace_from_package_name.count("."):
             namespace = namespace_config
         client = self.code_model.clients[0]
-        imports.add_submodule_import(namespace, client.name, ImportType.THIRDPARTY)
+        imports.add_submodule_import(namespace, client.name, ImportType.LOCAL)
         credential_type = getattr(client.credential, "type", None)
         if isinstance(credential_type, TokenCredentialType):
             imports.add_submodule_import(
-                "azure.identity", "DefaultAzureCredential", ImportType.THIRDPARTY
+                "azure.identity", "DefaultAzureCredential", ImportType.SDKCORE
             )
         elif isinstance(credential_type, KeyCredentialType):
             imports.add_import("os", ImportType.STDLIB)
             imports.add_submodule_import(
-                f"{imports.import_core}.credentials",
+                "credentials",
                 "AzureKeyCredential",
-                ImportType.THIRDPARTY,
+                ImportType.SDKCORE,
             )
         for param in self.operation.parameters.positional:
             if (

package/autorest/codegen/serializers/types_serializer.py

@@ -10,7 +10,7 @@ from .base_serializer import BaseSerializer
 
 class TypesSerializer(BaseSerializer):
     def imports(self) -> FileImport:
-        file_import = self.init_file_import()
+        file_import = FileImport(self.code_model)
         if self.code_model.named_unions:
             file_import.add_submodule_import(
                 "typing",

package/autorest/codegen/templates/enum_container.py.jinja2

@@ -2,7 +2,7 @@
 {{ code_model.options['license_header'] }}
 
 from enum import Enum
-from {{ file_import.import_core_case_insensitive_enum }} import CaseInsensitiveEnumMeta
+from {{ code_model.core_library }}{{ ".utils" if code_model.options["unbranded"] else "" }} import CaseInsensitiveEnumMeta
 
 {% for enum in code_model.enums | sort %}
 {% include "enum.py.jinja2" %}