@autorest/python 6.9.3 → 6.9.5

package/autorest/codegen/models/client.py

@@ -195,18 +195,19 @@ class Client(_ClientConfigBase[ClientGlobalParameterList]):
             raise KeyError(f"No operation with id {operation_id} found.") from exc
 
     def _imports_shared(self, async_mode: bool) -> FileImport:
-        file_import = FileImport()
-
+        file_import = self.init_file_import()
         file_import.add_submodule_import(
             "typing", "Any", ImportType.STDLIB, TypingSection.CONDITIONAL
         )
         if self.code_model.options["azure_arm"]:
             file_import.add_submodule_import(
-                "azure.mgmt.core", self.pipeline_class(async_mode), ImportType.AZURECORE
+                "azure.mgmt.core", self.pipeline_class(async_mode), ImportType.SDKCORE
             )
         else:
             file_import.add_submodule_import(
-                "azure.core", self.pipeline_class(async_mode), ImportType.AZURECORE
+                file_import.import_core_pipeline_client,
+                self.pipeline_class(async_mode),
+                ImportType.SDKCORE,
             )
 
         for gp in self.parameters:
@@ -225,20 +226,19 @@ class Client(_ClientConfigBase[ClientGlobalParameterList]):
             ImportType.LOCAL,
         )
         file_import.add_msrest_import(
-            self.code_model,
-            ".." if async_mode else ".",
-            MsrestImportType.SerializerDeserializer,
-            TypingSection.REGULAR,
+            relative_path=".." if async_mode else ".",
+            msrest_import_type=MsrestImportType.SerializerDeserializer,
+            typing_section=TypingSection.REGULAR,
         )
         file_import.add_submodule_import(
-            "azure.core.pipeline", "policies", ImportType.AZURECORE
+            file_import.import_core_policies, "policies", ImportType.SDKCORE
         )
         if self.code_model.options["azure_arm"]:
             async_prefix = "Async" if async_mode else ""
             file_import.add_submodule_import(
                 "azure.mgmt.core.policies",
                 f"{async_prefix}ARMAutoResourceProviderRegistrationPolicy",
-                ImportType.AZURECORE,
+                ImportType.SDKCORE,
             )
         return file_import
 
@@ -248,13 +248,19 @@ class Client(_ClientConfigBase[ClientGlobalParameterList]):
         return any(o for o in self.operation_groups if o.is_mixin)
 
     @property
-    def has_public_lro_operations(self) -> bool:
-        """Are there any LRO operations in this SDK?"""
-        return any(
-            operation.operation_type in ("lro", "lropaging") and not operation.internal
+    def lro_operations(self) -> List["OperationType"]:
+        """all LRO operations in this SDK?"""
+        return [
+            operation
             for operation_group in self.operation_groups
             for operation in operation_group.operations
-        )
+            if operation.operation_type in ("lro", "lropaging")
+        ]
+
+    @property
+    def has_public_lro_operations(self) -> bool:
+        """Are there any public LRO operations in this SDK?"""
+        return any(not operation.internal for operation in self.lro_operations)
 
     @property
     def has_operations(self) -> bool:
@@ -294,22 +300,22 @@ class Client(_ClientConfigBase[ClientGlobalParameterList]):
         if async_mode:
             file_import.add_submodule_import("typing", "Awaitable", ImportType.STDLIB)
             file_import.add_submodule_import(
-                "azure.core.rest",
+                file_import.import_core_rest,
                 "AsyncHttpResponse",
-                ImportType.AZURECORE,
+                ImportType.SDKCORE,
                 TypingSection.CONDITIONAL,
             )
         else:
             file_import.add_submodule_import(
-                "azure.core.rest",
+                file_import.import_core_rest,
                 "HttpResponse",
-                ImportType.AZURECORE,
+                ImportType.SDKCORE,
                 TypingSection.CONDITIONAL,
             )
         file_import.add_submodule_import(
-            "azure.core.rest",
+            file_import.import_core_rest,
             "HttpRequest",
-            ImportType.AZURECORE,
+            ImportType.SDKCORE,
             TypingSection.CONDITIONAL,
         )
         for og in self.operation_groups:
@@ -349,15 +355,15 @@ class Client(_ClientConfigBase[ClientGlobalParameterList]):
         except StopIteration:
             pass
         file_import.add_submodule_import(
-            "azure.profiles", "KnownProfiles", import_type=ImportType.AZURECORE
+            "azure.profiles", "KnownProfiles", import_type=ImportType.SDKCORE
         )
         file_import.add_submodule_import(
-            "azure.profiles", "ProfileDefinition", import_type=ImportType.AZURECORE
+            "azure.profiles", "ProfileDefinition", import_type=ImportType.SDKCORE
         )
         file_import.add_submodule_import(
             "azure.profiles.multiapiclient",
             "MultiApiClientMixin",
-            import_type=ImportType.AZURECORE,
+            import_type=ImportType.SDKCORE,
         )
         return file_import
 
@@ -406,9 +412,9 @@ class Config(_ClientConfigBase[ConfigGlobalParameterList]):
         return f"{super().name}Configuration"
 
     def _imports_shared(self, async_mode: bool) -> FileImport:
-        file_import = FileImport()
+        file_import = self.init_file_import()
         file_import.add_submodule_import(
-            "azure.core.pipeline", "policies", ImportType.AZURECORE
+            file_import.import_core_policies, "policies", ImportType.SDKCORE
         )
         file_import.add_submodule_import(
             "typing", "Any", ImportType.STDLIB, TypingSection.CONDITIONAL
@@ -424,10 +430,10 @@ class Config(_ClientConfigBase[ConfigGlobalParameterList]):
                 else "ARMChallengeAuthenticationPolicy"
             )
             file_import.add_submodule_import(
-                "azure.mgmt.core.policies", "ARMHttpLoggingPolicy", ImportType.AZURECORE
+                "azure.mgmt.core.policies", "ARMHttpLoggingPolicy", ImportType.SDKCORE
             )
             file_import.add_submodule_import(
-                "azure.mgmt.core.policies", policy, ImportType.AZURECORE
+                "azure.mgmt.core.policies", policy, ImportType.SDKCORE
             )
 
         return file_import

package/autorest/codegen/models/combined_type.py

@@ -103,7 +103,7 @@ class CombinedType(BaseType):
         raise ValueError("You shouldn't do instance checks on a multiple type")
 
     def imports(self, **kwargs: Any) -> FileImport:
-        file_import = FileImport()
+        file_import = self.init_file_import()
         if self.name and not kwargs.get("is_types_file"):
             file_import.add_submodule_import(
                 kwargs.pop("relative_path"),

package/autorest/codegen/models/constant_type.py

@@ -124,7 +124,7 @@ class ConstantType(BaseType):
         )
 
     def _imports_shared(self, **kwargs: Any):
-        file_import = FileImport()
+        file_import = self.init_file_import()
         file_import.merge(self.value_type.imports(**kwargs))
         return file_import
 

package/autorest/codegen/models/credential_types.py

@@ -26,7 +26,7 @@ if TYPE_CHECKING:
 class _CredentialPolicyBaseType:
     """Base class for our different credential policy types.
 
-    Inherited by our BearerTokenCredentialPolicy and AzureKeyCredentialPolicy types.
+    Inherited by our BearerTokenCredentialPolicy and KeyCredentialPolicy types.
     """
 
     def __init__(self, yaml_data: Dict[str, Any], code_model: "CodeModel") -> None:
@@ -71,7 +71,7 @@ class ARMChallengeAuthenticationPolicyType(BearerTokenCredentialPolicyType):
         return f"{policy_name}(self.credential, *self.credential_scopes, **kwargs)"
 
 
-class AzureKeyCredentialPolicyType(_CredentialPolicyBaseType):
+class KeyCredentialPolicyType(_CredentialPolicyBaseType):
     def __init__(
         self,
         yaml_data: Dict[str, Any],
@@ -83,16 +83,26 @@ class AzureKeyCredentialPolicyType(_CredentialPolicyBaseType):
         self.key = key
         self.scheme = scheme
 
+    @property
+    def credential_name(self) -> str:
+        return (
+            "AzureKeyCredential"
+            if not self.code_model.options["unbranded"]
+            else "ServiceKeyCredential"
+        )
+
     def call(self, async_mode: bool) -> str:
         params = f'"{self.key}", '
         if self.scheme:
             params += f'prefix="{self.scheme}", '
-        return f"policies.AzureKeyCredentialPolicy(self.credential, {params}**kwargs)"
+        return (
+            f"policies.{self.credential_name}Policy(self.credential, {params}**kwargs)"
+        )
 
     @classmethod
     def from_yaml(
         cls, yaml_data: Dict[str, Any], code_model: "CodeModel"
-    ) -> "AzureKeyCredentialPolicyType":
+    ) -> "KeyCredentialPolicyType":
         return cls(
             yaml_data, code_model, yaml_data["key"], yaml_data.get("scheme", None)
         )
@@ -103,7 +113,7 @@ CredentialPolicyType = TypeVar(
     bound=Union[
         BearerTokenCredentialPolicyType,
         ARMChallengeAuthenticationPolicyType,
-        AzureKeyCredentialPolicyType,
+        KeyCredentialPolicyType,
     ],
 )
 
@@ -111,7 +121,7 @@ CredentialPolicyType = TypeVar(
 class CredentialType(
     Generic[CredentialPolicyType], BaseType
 ):  # pylint:disable=abstract-method
-    """Store info about the type of the credential. Can be either an AzureKeyCredential or a TokenCredential"""
+    """Store info about the type of the credential. Can be either an KeyCredential or a TokenCredential"""
 
     def __init__(
         self,
@@ -178,23 +188,23 @@ class TokenCredentialType(
 
     def docstring_type(self, **kwargs: Any) -> str:
         if kwargs.get("async_mode"):
-            return "~azure.core.credentials_async.AsyncTokenCredential"
-        return "~azure.core.credentials.TokenCredential"
+            return f"~{self.init_file_import().import_core_credentials_async}.AsyncTokenCredential"
+        return f"~{self.init_file_import().import_core_credentials}.TokenCredential"
 
     def imports(self, **kwargs: Any) -> FileImport:
-        file_import = FileImport()
+        file_import = self.init_file_import()
         if kwargs.get("async_mode"):
             file_import.add_submodule_import(
-                "azure.core.credentials_async",
+                file_import.import_core_credentials_async,
                 "AsyncTokenCredential",
-                ImportType.AZURECORE,
+                ImportType.SDKCORE,
                 typing_section=TypingSection.TYPING,
             )
         else:
             file_import.add_submodule_import(
-                "azure.core.credentials",
+                file_import.import_core_credentials,
                 "TokenCredential",
-                ImportType.AZURECORE,
+                ImportType.SDKCORE,
                 typing_section=TypingSection.TYPING,
             )
         return file_import
@@ -204,28 +214,28 @@ class TokenCredentialType(
         return "hasattr({}, 'get_token')"
 
 
-class AzureKeyCredentialType(
+class KeyCredentialType(
     # pylint: disable=unsubscriptable-object
-    CredentialType[AzureKeyCredentialPolicyType]
+    CredentialType[KeyCredentialPolicyType]
 ):
-    """Type for an AzureKeyCredential"""
+    """Type for an KeyCredential"""
 
     def docstring_type(self, **kwargs: Any) -> str:  # pylint: disable=unused-argument
-        return "~azure.core.credentials.AzureKeyCredential"
+        return f"~{self.init_file_import().import_core}.credentials.{self.policy.credential_name}"
 
     def type_annotation(self, **kwargs: Any) -> str:  # pylint: disable=unused-argument
-        return "AzureKeyCredential"
+        return self.policy.credential_name
 
     @property
     def instance_check_template(self) -> str:
-        return "isinstance({}, AzureKeyCredential)"
+        return "isinstance({}, " + f"{self.policy.credential_name})"
 
     def imports(self, **kwargs: Any) -> FileImport:  # pylint: disable=unused-argument
-        file_import = FileImport()
+        file_import = self.init_file_import()
         file_import.add_submodule_import(
-            "azure.core.credentials",
-            "AzureKeyCredential",
-            ImportType.AZURECORE,
+            f"{file_import.import_core}.credentials",
+            self.policy.credential_name,
+            ImportType.SDKCORE,
             typing_section=TypingSection.CONDITIONAL,
         )
         return file_import

package/autorest/codegen/models/dictionary_type.py

@@ -123,7 +123,7 @@ class DictionaryType(BaseType):
         )
 
     def imports(self, **kwargs: Any) -> FileImport:
-        file_import = FileImport()
+        file_import = self.init_file_import()
         file_import.add_submodule_import(
             "typing", "Dict", ImportType.STDLIB, TypingSection.CONDITIONAL
         )

package/autorest/codegen/models/enum_type.py

@@ -76,7 +76,7 @@ class EnumValue(BaseType):
         return self.value_type.instance_check_template
 
     def imports(self, **kwargs: Any) -> FileImport:
-        file_import = FileImport()
+        file_import = self.init_file_import()
         file_import.merge(self.value_type.imports(**kwargs))
         file_import.add_literal_import()
         file_import.add_submodule_import(
@@ -230,7 +230,7 @@ class EnumType(BaseType):
 
     def imports(self, **kwargs: Any) -> FileImport:
         operation = kwargs.pop("operation", False)
-        file_import = FileImport()
+        file_import = self.init_file_import()
         if self.code_model.options["models_mode"]:
             file_import.add_submodule_import(
                 "typing", "Union", ImportType.STDLIB, TypingSection.CONDITIONAL

package/autorest/codegen/models/imports.py

@@ -13,7 +13,7 @@ if TYPE_CHECKING:
 class ImportType(str, Enum):
     STDLIB = "stdlib"
     THIRDPARTY = "thirdparty"
-    AZURECORE = "azurecore"
+    SDKCORE = "sdkcore"
     LOCAL = "local"
     BYVERSION = "by_version"
 
@@ -87,9 +87,10 @@ class TypeDefinition:
         self.async_definition = async_definition
 
 
-class FileImport:
-    def __init__(self, imports: Optional[List[ImportModel]] = None) -> None:
-        self.imports = imports or []
+class FileImport:  # pylint: disable=too-many-public-methods
+    def __init__(self, code_model: "CodeModel") -> None:
+        self.imports: List[ImportModel] = []
+        self.code_model = code_model
         # has sync and async type definitions
         self.type_definitions: Dict[str, TypeDefinition] = {}
 
@@ -272,15 +273,15 @@ class FileImport:
 
     def add_msrest_import(
         self,
-        code_model: "CodeModel",
+        *,
         relative_path: str,
         msrest_import_type: MsrestImportType,
         typing_section: TypingSection,
     ):
-        if code_model.options["client_side_validation"]:
+        if self.code_model.options["client_side_validation"]:
             if msrest_import_type == MsrestImportType.Module:
                 self.add_import(
-                    "msrest.serialization", ImportType.AZURECORE, typing_section
+                    "msrest.serialization", ImportType.SDKCORE, typing_section
                 )
             else:
                 self.add_submodule_import(
@@ -291,7 +292,7 @@ class FileImport:
                         "msrest", "Deserializer", ImportType.THIRDPARTY, typing_section
                     )
         else:
-            if code_model.options["multiapi"]:
+            if self.code_model.options["multiapi"]:
                 relative_path += "."
             if msrest_import_type == MsrestImportType.Module:
                 self.add_submodule_import(
@@ -311,3 +312,71 @@ class FileImport:
                         ImportType.LOCAL,
                         typing_section,
                     )
+
+    @property
+    def import_core(self) -> str:
+        return "azure.core" if not self.code_model.options["unbranded"] else "corehttp"
+
+    @property
+    def import_core_exceptions(self) -> str:
+        return f"{self.import_core}.exceptions"
+
+    @property
+    def import_core_rest(self) -> str:
+        return f"{self.import_core}.rest"
+
+    @property
+    def import_core_credentials(self) -> str:
+        return f"{self.import_core}.credentials"
+
+    @property
+    def import_core_credentials_async(self) -> str:
+        return self.import_core + (
+            ".credentials_async"
+            if not self.code_model.options["unbranded"]
+            else ".credentials"
+        )
+
+    @property
+    def import_core_paging(self) -> str:
+        return f"{self.import_core}.paging"
+
+    @property
+    def import_core_paging_async(self) -> str:
+        return self.import_core + (
+            ".async_paging" if not self.code_model.options["unbranded"] else ".paging"
+        )
+
+    @property
+    def import_core_utils(self) -> str:
+        return f"{self.import_core}.utils"
+
+    @property
+    def import_core_case_insensitive_enum(self) -> str:
+        return self.import_core + (
+            "" if not self.code_model.options["unbranded"] else ".utils"
+        )
+
+    @property
+    def import_core_pipeline(self) -> str:
+        return self.import_core + (
+            ".pipeline"
+            if not self.code_model.options["unbranded"]
+            else ".runtime.pipeline"
+        )
+
+    @property
+    def import_core_policies(self) -> str:
+        return self.import_core + (
+            ".pipeline" if not self.code_model.options["unbranded"] else ".runtime"
+        )
+
+    @property
+    def import_core_serialization(self) -> str:
+        return f"{self.import_core}.serialization"
+
+    @property
+    def import_core_pipeline_client(self) -> str:
+        return self.import_core + (
+            "" if not self.code_model.options["unbranded"] else ".runtime"
+        )

package/autorest/codegen/models/list_type.py

@@ -146,7 +146,7 @@ class ListType(BaseType):
         )
 
     def imports(self, **kwargs: Any) -> FileImport:
-        file_import = FileImport()
+        file_import = self.init_file_import()
         if not (
             self.code_model.options["version_tolerant"]
             and self.element_type.is_xml

package/autorest/codegen/models/lro_operation.py

@@ -104,6 +104,9 @@ class LROOperationBase(OperationBase[LROResponseType]):
         """We don't want the poller to show up in ClsType, so we call super() on resposne type annotation"""
         return f"ClsType[{Response.type_annotation(self.responses[0], async_mode=async_mode)}]"
 
+    def get_poller_with_response_type(self, async_mode: bool) -> str:
+        return self.response_type_annotation(async_mode=async_mode)
+
     def get_poller(self, async_mode: bool) -> str:
         return self.responses[0].get_poller(async_mode)
 
@@ -123,11 +126,11 @@ class LROOperationBase(OperationBase[LROResponseType]):
         file_import = super().imports(async_mode, **kwargs)
         if self.abstract:
             return file_import
-        if async_mode:
+        if async_mode and self.code_model.options["tracing"] and self.want_tracing:
             file_import.add_submodule_import(
                 "azure.core.tracing.decorator_async",
                 "distributed_trace_async",
-                ImportType.AZURECORE,
+                ImportType.SDKCORE,
             )
         if (
             self.code_model.options["models_mode"] == "dpg"

package/autorest/codegen/models/model_type.py

@@ -268,7 +268,7 @@ class JSONModelType(ModelType):
         return "isinstance({}, MutableMapping)"
 
     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
         )

package/autorest/codegen/models/operation.py

@@ -230,7 +230,7 @@ class OperationBase(  # pylint: disable=too-many-public-methods
     def _imports_shared(
         self, async_mode: bool, **kwargs: Any  # pylint: disable=unused-argument
     ) -> FileImport:
-        file_import = FileImport()
+        file_import = self.init_file_import()
         file_import.add_submodule_import(
             "typing", "Any", ImportType.STDLIB, TypingSection.CONDITIONAL
         )
@@ -254,7 +254,7 @@ class OperationBase(  # pylint: disable=too-many-public-methods
 
     def imports_for_multiapi(self, async_mode: bool, **kwargs: Any) -> FileImport:
         if self.abstract:
-            return FileImport()
+            return FileImport(self.code_model)
         file_import = self._imports_shared(async_mode, **kwargs)
         for param in self.parameters.method:
             file_import.merge(
@@ -308,7 +308,7 @@ class OperationBase(  # pylint: disable=too-many-public-methods
         async_mode: bool,
     ) -> FileImport:
         """Helper method to get a request builder import."""
-        file_import = FileImport()
+        file_import = self.init_file_import()
         if self.code_model.options["builders_visibility"] != "embedded":
             group_name = request_builder.group_name
             rest_import_path = "..." if async_mode else ".."
@@ -338,7 +338,7 @@ class OperationBase(  # pylint: disable=too-many-public-methods
         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)
 
         for param in self.parameters.method:
@@ -379,11 +379,11 @@ class OperationBase(  # pylint: disable=too-many-public-methods
         ]
         for error in errors:
             file_import.add_submodule_import(
-                "azure.core.exceptions", error, ImportType.AZURECORE
+                file_import.import_core_exceptions, error, ImportType.SDKCORE
             )
         if self.code_model.options["azure_arm"]:
             file_import.add_submodule_import(
-                "azure.mgmt.core.exceptions", "ARMErrorFormat", ImportType.AZURECORE
+                "azure.mgmt.core.exceptions", "ARMErrorFormat", ImportType.SDKCORE
             )
 
         if self.has_kwargs_to_pop_with_default(
@@ -392,7 +392,9 @@ class OperationBase(  # pylint: disable=too-many-public-methods
             self.parameters.kwargs_to_pop, ParameterLocation.QUERY  # type: ignore
         ):
             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.deprecated:
             file_import.add_import("warnings", ImportType.STDLIB)
@@ -404,7 +406,9 @@ class OperationBase(  # pylint: disable=too-many-public-methods
             )
         if self.has_etag:
             file_import.add_submodule_import(
-                "azure.core.exceptions", "ResourceModifiedError", ImportType.AZURECORE
+                file_import.import_core_exceptions,
+                "ResourceModifiedError",
+                ImportType.SDKCORE,
             )
             if not async_mode:
                 file_import.add_submodule_import(
@@ -418,24 +422,26 @@ class OperationBase(  # pylint: disable=too-many-public-methods
                 file_import.add_submodule_import(
                     "azure.core.pipeline.transport",
                     "AsyncHttpResponse",
-                    ImportType.AZURECORE,
+                    ImportType.SDKCORE,
                 )
             else:
                 file_import.add_submodule_import(
                     "azure.core.pipeline.transport",
                     "HttpResponse",
-                    ImportType.AZURECORE,
+                    ImportType.SDKCORE,
                 )
         else:
             if async_mode:
                 file_import.add_submodule_import(
-                    "azure.core.rest",
+                    file_import.import_core_rest,
                     "AsyncHttpResponse",
-                    ImportType.AZURECORE,
+                    ImportType.SDKCORE,
                 )
             else:
                 file_import.add_submodule_import(
-                    "azure.core.rest", "HttpResponse", ImportType.AZURECORE
+                    file_import.import_core_rest,
+                    "HttpResponse",
+                    ImportType.SDKCORE,
                 )
         if (
             self.code_model.options["builders_visibility"] == "embedded"
@@ -443,10 +449,12 @@ class OperationBase(  # pylint: disable=too-many-public-methods
         ):
             file_import.merge(self.request_builder.imports())
         file_import.add_submodule_import(
-            "azure.core.pipeline", "PipelineResponse", ImportType.AZURECORE
+            file_import.import_core_pipeline,
+            "PipelineResponse",
+            ImportType.SDKCORE,
         )
         file_import.add_submodule_import(
-            "azure.core.rest", "HttpRequest", ImportType.AZURECORE
+            file_import.import_core_rest, "HttpRequest", ImportType.SDKCORE
         )
         file_import.add_submodule_import(
             "typing", "Callable", ImportType.STDLIB, TypingSection.CONDITIONAL
@@ -464,7 +472,7 @@ class OperationBase(  # pylint: disable=too-many-public-methods
             file_import.add_submodule_import(
                 "azure.core.tracing.decorator",
                 "distributed_trace",
-                ImportType.AZURECORE,
+                ImportType.SDKCORE,
             )
         file_import.merge(
             self.get_request_builder_import(self.request_builder, async_mode)
@@ -552,11 +560,11 @@ class Operation(OperationBase[Response]):
         file_import = super().imports(async_mode, **kwargs)
         if self.abstract:
             return file_import
-        if async_mode:
+        if async_mode and self.code_model.options["tracing"] and self.want_tracing:
             file_import.add_submodule_import(
                 "azure.core.tracing.decorator_async",
                 "distributed_trace_async",
-                ImportType.AZURECORE,
+                ImportType.SDKCORE,
             )
         if (
             self.has_response_body

package/autorest/codegen/models/operation_group.py

@@ -48,7 +48,7 @@ class OperationGroup(BaseModel):
         return ", ".join(base_classes)
 
     def imports_for_multiapi(self, async_mode: bool) -> FileImport:
-        file_import = FileImport()
+        file_import = self.init_file_import()
         relative_path = ".." if async_mode else "."
         for operation in self.operations:
             file_import.merge(
@@ -79,7 +79,7 @@ class OperationGroup(BaseModel):
         return any(o for o in self.operations if o.need_validation)
 
     def imports(self, async_mode: bool) -> FileImport:
-        file_import = FileImport()
+        file_import = self.init_file_import()
 
         relative_path = ("..." if async_mode else "..") + (
             "." if self.client.is_subclient else ""