@autorest/python 5.12.2 → 5.12.6

package/ChangeLog.md

@@ -1,5 +1,65 @@
 # Change Log
 
+### 2022-02-09 - 5.12.6
+
+| Library | Min Version
+| --------------- | -------
+|`@autorest/core` |  `3.6.2`
+|`@autorest/modelerfour` | `4.19.1`
+|`azure-core` dep of generated code | `1.20.1`
+|`msrest` dep of generated code | `0.6.21`
+|`azure-mgmt-core` dep of generated code (If generating mgmt plane code) | `1.3.0`
+
+**Bug Fixes**
+
+- Remove unused `metadata` value for paging and long running operations with `version-tolerant` generations #1131
+- Remove name conflicts with parameters called `url`, `header_parameters`, and `query_parameters` #1143
+- Make `--version-tolerant` generated code pylint compatible in the `azure-sdk-for-python` repo when generated with the `--black` flag #1147, #1144, #1130
+
+### 2022-01-26 - 5.12.5
+
+| Library | Min Version
+| --------------- | -------
+|`@autorest/core` |  `3.6.2`
+|`@autorest/modelerfour` | `4.19.1`
+|`azure-core` dep of generated code | `1.20.1`
+|`msrest` dep of generated code | `0.6.21`
+|`azure-mgmt-core` dep of generated code (If generating mgmt plane code) | `1.3.0`
+
+**Bug Fixes**
+
+- Fix usage of `--black` flag outside of repo  #1126
+- Remove unused `metadata` value for `version-tolerant` generations  #1127
+
+### 2022-01-14 - 5.12.4
+
+| Library | Min Version
+| --------------- | -------
+|`@autorest/core` |  `3.6.2`
+|`@autorest/modelerfour` | `4.19.1`
+|`azure-core` dep of generated code | `1.20.1`
+|`msrest` dep of generated code | `0.6.21`
+|`azure-mgmt-core` dep of generated code (If generating mgmt plane code) | `1.3.0`
+
+**Bug Fixes**
+
+- Remove duplicate generation of properties in classes that inherit from multiple classes  #1120
+
+### 2022-01-13 - 5.12.3
+
+| Library | Min Version
+| --------------- | -------
+|`@autorest/core` |  `3.6.2`
+|`@autorest/modelerfour` | `4.19.1`
+|`azure-core` dep of generated code | `1.20.1`
+|`msrest` dep of generated code | `0.6.21`
+|`azure-mgmt-core` dep of generated code (If generating mgmt plane code) | `1.3.0`
+
+**Bug Fixes**
+
+- Unify multiapi constant behavior with single API version  #1119
+- Clean up docstrings by removing descriptions for client constants on methods and request builders  #1119
+
 ### 2022-01-11 - 5.12.2
 
 | Library | Min Version

package/autorest/black/__init__.py

@@ -18,7 +18,10 @@ class BlackScriptPlugin(Plugin):
 
     def __init__(self, autorestapi):
         super(BlackScriptPlugin, self).__init__(autorestapi)
-        self.output_folder: Path = Path(self._autorestapi.get_value("output-folder")).resolve()
+        output_folder_uri = self._autorestapi.get_value("outputFolderUri")
+        if output_folder_uri.startswith("file:"):
+            output_folder_uri = output_folder_uri[5:]
+        self.output_folder = Path(output_folder_uri)
 
     def process(self) -> bool:
         # apply format_file on every file in the output folder

package/autorest/codegen/models/client.py

@@ -33,27 +33,28 @@ class Client:
     def _imports_shared(self, async_mode: bool) -> FileImport:
         file_import = FileImport()
 
-        file_import.add_from_import("msrest", "Serializer", ImportType.AZURECORE)
-        file_import.add_from_import("msrest", "Deserializer", ImportType.AZURECORE)
-        file_import.add_from_import("typing", "Any", ImportType.STDLIB, TypingSection.CONDITIONAL)
+        file_import.add_submodule_import("msrest", "Serializer", ImportType.THIRDPARTY)
+        file_import.add_submodule_import("msrest", "Deserializer", ImportType.THIRDPARTY)
+        file_import.add_submodule_import("typing", "Any", ImportType.STDLIB, TypingSection.CONDITIONAL)
 
         any_optional_gp = any(not gp.required for gp in self.parameters)
 
-        if any_optional_gp or self.code_model.service_client.parameters.host:
-            file_import.add_from_import("typing", "Optional", ImportType.STDLIB, TypingSection.CONDITIONAL)
+        legacy = not any(g for g in ["low_level_client", "version_tolerant"] if g in self.code_model.options)
+        if any_optional_gp or (legacy and self.code_model.service_client.parameters.host):
+            file_import.add_submodule_import("typing", "Optional", ImportType.STDLIB, TypingSection.CONDITIONAL)
 
         if self.code_model.options["azure_arm"]:
-            file_import.add_from_import(
+            file_import.add_submodule_import(
                 "azure.mgmt.core", self.pipeline_class(async_mode), ImportType.AZURECORE
             )
         else:
-            file_import.add_from_import(
+            file_import.add_submodule_import(
                 "azure.core", self.pipeline_class(async_mode), ImportType.AZURECORE
             )
 
         for gp in self.code_model.global_parameters:
             file_import.merge(gp.imports())
-        file_import.add_from_import(
+        file_import.add_submodule_import(
             "._configuration", f"{self.code_model.class_name}Configuration",
             ImportType.LOCAL
         )
@@ -63,39 +64,41 @@ class Client:
     def imports(self, async_mode: bool) -> FileImport:
         file_import = self._imports_shared(async_mode)
         if async_mode:
-            file_import.add_from_import("typing", "Awaitable", ImportType.STDLIB)
-            file_import.add_from_import(
+            file_import.add_submodule_import("typing", "Awaitable", ImportType.STDLIB)
+            file_import.add_submodule_import(
                 "azure.core.rest", "AsyncHttpResponse", ImportType.AZURECORE, TypingSection.CONDITIONAL
             )
         else:
-            file_import.add_from_import(
+            file_import.add_submodule_import(
                 "azure.core.rest", "HttpResponse", ImportType.AZURECORE, TypingSection.CONDITIONAL
             )
-        file_import.add_from_import("azure.core.rest", "HttpRequest", ImportType.AZURECORE, TypingSection.CONDITIONAL)
+        file_import.add_submodule_import(
+            "azure.core.rest", "HttpRequest", ImportType.AZURECORE, TypingSection.CONDITIONAL
+        )
         for og in self.code_model.operation_groups:
-            file_import.add_from_import(
+            file_import.add_submodule_import(
                 f".{self.code_model.operations_folder_name}", og.class_name, ImportType.LOCAL
             )
 
         if self.code_model.sorted_schemas:
             path_to_models = ".." if async_mode else "."
-            file_import.add_from_import(path_to_models, "models", ImportType.LOCAL)
+            file_import.add_submodule_import(path_to_models, "models", ImportType.LOCAL)
         else:
             # in this case, we have client_models = {} in the service client, which needs a type annotation
             # this import will always be commented, so will always add it to the typing section
-            file_import.add_from_import("typing", "Dict", ImportType.STDLIB, TypingSection.TYPING)
-        file_import.add_from_import("copy", "deepcopy", ImportType.STDLIB)
+            file_import.add_submodule_import("typing", "Dict", ImportType.STDLIB, TypingSection.TYPING)
+        file_import.add_submodule_import("copy", "deepcopy", ImportType.STDLIB)
         return file_import
 
     def imports_for_multiapi(self, async_mode: bool) -> FileImport:
         file_import = self._imports_shared(async_mode)
         try:
             mixin_operation = next(og for og in self.code_model.operation_groups if og.is_empty_operation_group)
-            file_import.add_from_import("._operations_mixin", mixin_operation.class_name, ImportType.LOCAL)
+            file_import.add_submodule_import("._operations_mixin", mixin_operation.class_name, ImportType.LOCAL)
         except StopIteration:
             pass
         return file_import
 
-    def send_request_signature(self, async_mode: bool, is_python3_file: bool) -> List[str]:
-        request_signature = ["request: HttpRequest," if async_mode else "request,  # type: HttpRequest"]
+    def send_request_signature(self, is_python3_file: bool) -> List[str]:
+        request_signature = ["request: HttpRequest," if is_python3_file else "request,  # type: HttpRequest"]
         return request_signature + self.parameters.method_signature_kwargs(is_python3_file)

package/autorest/codegen/models/credential_schema.py

@@ -44,7 +44,7 @@ class AzureKeyCredentialSchema(CredentialSchema):
 
     def imports(self) -> FileImport:
         file_import = FileImport()
-        file_import.add_from_import(
+        file_import.add_submodule_import(
             "azure.core.credentials",
             "AzureKeyCredential",
             ImportType.AZURECORE,
@@ -76,13 +76,13 @@ class TokenCredentialSchema(CredentialSchema):
     def imports(self) -> FileImport:
         file_import = FileImport()
         if self.async_mode:
-            file_import.add_from_import(
+            file_import.add_submodule_import(
                 "azure.core.credentials_async", "AsyncTokenCredential",
                 ImportType.AZURECORE,
                 typing_section=TypingSection.TYPING
             )
         else:
-            file_import.add_from_import(
+            file_import.add_submodule_import(
                 "azure.core.credentials", "TokenCredential",
                 ImportType.AZURECORE,
                 typing_section=TypingSection.TYPING

package/autorest/codegen/models/dictionary_schema.py

@@ -98,6 +98,6 @@ class DictionarySchema(BaseSchema):
 
     def imports(self) -> FileImport:
         file_import = FileImport()
-        file_import.add_from_import("typing", "Dict", ImportType.STDLIB, TypingSection.CONDITIONAL)
+        file_import.add_submodule_import("typing", "Dict", ImportType.STDLIB, TypingSection.CONDITIONAL)
         file_import.merge(self.element_type.imports())
         return file_import

package/autorest/codegen/models/enum_schema.py

@@ -178,7 +178,7 @@ class EnumSchema(BaseSchema):
 
     def imports(self) -> FileImport:
         file_import = FileImport()
-        file_import.add_from_import("typing", "Union", ImportType.STDLIB, TypingSection.CONDITIONAL)
+        file_import.add_submodule_import("typing", "Union", ImportType.STDLIB, TypingSection.CONDITIONAL)
         file_import.merge(self.enum_type.imports())
         return file_import
 
@@ -186,7 +186,7 @@ class EnumSchema(BaseSchema):
         imports = self.imports()
         # we import every enum since we can get extremely long imports
         # if we import my name
-        imports.add_from_import("." + self.enum_file_name, "*", ImportType.LOCAL)
+        imports.add_submodule_import("." + self.enum_file_name, "*", ImportType.LOCAL)
         return imports
 
 class HiddenModelEnumSchema(EnumSchema):

package/autorest/codegen/models/imports.py

@@ -4,8 +4,7 @@
 # license information.
 # --------------------------------------------------------------------------
 from enum import Enum
-from typing import Dict, Optional, Set, Tuple, Union
-
+from typing import Dict, List, Optional, Tuple, Union, Set
 
 class ImportType(str, Enum):
     STDLIB = "stdlib"
@@ -18,81 +17,122 @@ class TypingSection(str, Enum):
     CONDITIONAL = "conditional"  # is a typing import when we're dealing with files that py2 will use, else regular
     TYPING = "typing"  # never a typing import
 
+class ImportModel:
+    def __init__(
+        self,
+        typing_section: TypingSection,
+        import_type: ImportType,
+        module_name: str,
+        *,
+        submodule_name: Optional[str] = None,
+        alias: Optional[str] = None,
+    ):
+        self.typing_section = typing_section
+        self.import_type = import_type
+        self.module_name = module_name
+        self.submodule_name = submodule_name
+        self.alias = alias
+
+    def __eq__(self, other):
+        try:
+            return (
+                self.typing_section == other.typing_section and
+                self.import_type == other.import_type and
+                self.module_name == other.module_name and
+                self.submodule_name == other.submodule_name and
+                self.alias == other.alias
+            )
+        except AttributeError:
+            return False
+
+    def __hash__(self):
+        retval: int = 0
+        for attr in dir(self):
+            if attr[0] != "_":
+                retval += hash(getattr(self, attr))
+        return retval
 
 class FileImport:
     def __init__(
         self,
-        imports: Dict[
-            TypingSection,
-            Dict[ImportType, Dict[str, Set[Optional[Union[str, Tuple[str, str]]]]]]
-        ] = None
+        imports: List[ImportModel] = None
     ) -> None:
-        # Basic implementation
-        # First level dict: TypingSection
-        # Second level dict: ImportType
-        # Third level dict: the package name.
-        # Fourth level set: None if this import is a "import", the name to import if it's a "from"
-        self._imports: Dict[
-            TypingSection,
-            Dict[ImportType, Dict[str, Set[Optional[Union[str, Tuple[str, str]]]]]]
-        ] = imports or dict()
+        self.imports = imports or []
         # has sync and async type definitions
         self.type_definitions: Dict[str, Tuple[str, str]] = {}
 
-    def _add_import(
-        self,
-        from_section: str,
-        import_type: ImportType,
-        name_import: Optional[Union[str, Tuple[str, str]]] = None,
-        typing_section: TypingSection = TypingSection.REGULAR
-    ) -> None:
-        self._imports.setdefault(
-                typing_section, dict()
-            ).setdefault(
-                import_type, dict()
-            ).setdefault(
-                from_section, set()
-            ).add(name_import)
+    def _append_import(self, import_model: ImportModel) -> None:
+        if not any(
+            i for i in self.imports
+            if all(
+                getattr(i, attr) == getattr(import_model, attr)
+                for attr in dir(i)
+                if attr[0] != "_"
+            )
+        ):
+            self.imports.append(import_model)
+
+    def get_imports_from_section(self, typing_section: TypingSection) -> List[ImportModel]:
+        return [i for i in self.imports if i.typing_section == typing_section]
 
-    def add_from_import(
+    def add_submodule_import(
         self,
-        from_section: str,
-        name_import: str,
+        module_name: str,
+        submodule_name: str,
         import_type: ImportType,
         typing_section: TypingSection = TypingSection.REGULAR,
         alias: Optional[str] = None,
     ) -> None:
         """Add an import to this import block.
         """
-        self._add_import(
-            from_section, import_type, (name_import, alias) if alias else name_import, typing_section
-        )
+        self._append_import(ImportModel(
+            typing_section=typing_section,
+            import_type=import_type,
+            module_name=module_name,
+            submodule_name=submodule_name,
+            alias=alias,
+        ))
 
     def add_import(
         self,
-        name_import: str,
+        module_name: str,
         import_type: ImportType,
         typing_section: TypingSection = TypingSection.REGULAR
     ) -> None:
         # Implementation detail: a regular import is just a "from" with no from
-        self._add_import(name_import, import_type, None, typing_section)
-
-    @property
-    def imports(self) -> Dict[
-            TypingSection,
-            Dict[ImportType, Dict[str, Set[Optional[Union[str, Tuple[str, str]]]]]]
-        ]:
-        return self._imports
+        self._append_import(ImportModel(
+            typing_section=typing_section,
+            import_type=import_type,
+            module_name=module_name,
+        ))
 
     def define_mypy_type(self, type_name: str, type_value: str, async_type_value: Optional[str] = None):
-        self._add_import("typing", ImportType.STDLIB, "TypeVar", TypingSection.CONDITIONAL)
+        self.add_submodule_import("typing", "TypeVar", ImportType.STDLIB, TypingSection.CONDITIONAL)
         self.type_definitions[type_name] = (type_value, async_type_value or type_value)
 
     def merge(self, file_import: "FileImport") -> None:
         """Merge the given file import format."""
-        for typing_section, import_type_dict in file_import.imports.items():
-            for import_type, package_list in import_type_dict.items():
-                for package_name, module_list in package_list.items():
-                    for module_name in module_list:
-                        self._add_import(package_name, import_type, module_name, typing_section)
+        for i in file_import.imports:
+            self._append_import(i)
         self.type_definitions.update(file_import.type_definitions)
+
+    def to_dict(self) -> Dict[
+        TypingSection,
+        Dict[ImportType, Dict[str, Set[Optional[Union[str, Tuple[str, str]]]]]]
+    ]:
+        retval: Dict[
+            TypingSection,
+            Dict[ImportType, Dict[str, Set[Optional[Union[str, Tuple[str, str]]]]]]
+        ] = dict()
+        for i in self.imports:
+            name_import: Optional[Union[str, Tuple[str, str]]] = None
+            if i.submodule_name:
+                name_import = (i.submodule_name, i.alias) if i.alias else i.submodule_name
+            retval.setdefault(
+                    i.typing_section, dict()
+                ).setdefault(
+                    i.import_type, dict()
+                ).setdefault(
+                    i.module_name, set()
+                ).add(name_import)
+        return retval

package/autorest/codegen/models/list_schema.py

@@ -108,6 +108,6 @@ class ListSchema(BaseSchema):
 
     def imports(self) -> FileImport:
         file_import = FileImport()
-        file_import.add_from_import("typing", "List", ImportType.STDLIB, TypingSection.CONDITIONAL)
+        file_import.add_submodule_import("typing", "List", ImportType.STDLIB, TypingSection.CONDITIONAL)
         file_import.merge(self.element_type.imports())
         return file_import

package/autorest/codegen/models/lro_operation.py

@@ -140,28 +140,30 @@ class LROOperation(Operation):
         file_import = super().imports_for_multiapi(async_mode)
         poller_import_path = ".".join(self.get_poller_path(async_mode).split(".")[:-1])
         poller = self.get_poller(async_mode)
-        file_import.add_from_import(poller_import_path, poller, ImportType.AZURECORE, TypingSection.CONDITIONAL)
+        file_import.add_submodule_import(poller_import_path, poller, ImportType.AZURECORE, TypingSection.CONDITIONAL)
         return file_import
 
     def imports(self, async_mode: bool) -> FileImport:
         file_import = super().imports(async_mode)
-        file_import.add_from_import("typing", "Union", ImportType.STDLIB, TypingSection.CONDITIONAL)
+        file_import.add_submodule_import("typing", "Union", ImportType.STDLIB, TypingSection.CONDITIONAL)
 
         poller_import_path = ".".join(self.get_poller_path(async_mode).split(".")[:-1])
         poller = self.get_poller(async_mode)
-        file_import.add_from_import(poller_import_path, poller, ImportType.AZURECORE)
+        file_import.add_submodule_import(poller_import_path, poller, ImportType.AZURECORE)
 
         default_polling_method_import_path = ".".join(
             self.get_default_polling_method_path(async_mode, self.code_model.options['azure_arm']).split(".")[:-1]
         )
         default_polling_method = self.get_default_polling_method(async_mode, self.code_model.options['azure_arm'])
-        file_import.add_from_import(default_polling_method_import_path, default_polling_method, ImportType.AZURECORE)
+        file_import.add_submodule_import(
+            default_polling_method_import_path, default_polling_method, ImportType.AZURECORE
+        )
 
         default_no_polling_method_import_path = ".".join(
             self.get_default_no_polling_method_path(async_mode).split(".")[:-1]
         )
         default_no_polling_method = self.get_default_no_polling_method(async_mode)
-        file_import.add_from_import(
+        file_import.add_submodule_import(
             default_no_polling_method_import_path, default_no_polling_method, ImportType.AZURECORE
         )
 
@@ -169,10 +171,14 @@ class LROOperation(Operation):
             self.get_base_polling_method_path(async_mode).split(".")[:-1]
         )
         base_polling_method = self.get_base_polling_method(async_mode)
-        file_import.add_from_import(base_polling_method_import_path, base_polling_method, ImportType.AZURECORE)
+        file_import.add_submodule_import(base_polling_method_import_path, base_polling_method, ImportType.AZURECORE)
 
         if async_mode:
-            file_import.add_from_import("typing", "Optional", ImportType.STDLIB, TypingSection.CONDITIONAL)
-        if self.lro_response and self.lro_response.has_body and not self.code_model.options["models_mode"]:
-            file_import.add_from_import("json", "loads", import_type=ImportType.STDLIB, alias="_loads")
+            file_import.add_submodule_import("typing", "Optional", ImportType.STDLIB, TypingSection.CONDITIONAL)
+        if self.code_model.options["tracing"] and self.want_tracing:
+            file_import.add_submodule_import(
+                f"azure.core.tracing.decorator{'_async' if async_mode else ''}",
+                f"distributed_trace{'_async' if async_mode else ''}",
+                ImportType.AZURECORE,
+            )
         return file_import

package/autorest/codegen/models/object_schema.py

@@ -213,7 +213,7 @@ class ObjectSchema(BaseSchema):  # pylint: disable=too-many-instance-attributes
     def imports(self) -> FileImport:
         file_import = FileImport()
         if self.is_exception:
-            file_import.add_from_import("azure.core.exceptions", "HttpResponseError", ImportType.AZURECORE)
+            file_import.add_submodule_import("azure.core.exceptions", "HttpResponseError", ImportType.AZURECORE)
         return file_import
 
 class HiddenModelObjectSchema(ObjectSchema):
@@ -240,7 +240,7 @@ class HiddenModelObjectSchema(ObjectSchema):
 
     def imports(self) -> FileImport:
         file_import = FileImport()
-        file_import.add_from_import("typing", "Any", ImportType.STDLIB, TypingSection.CONDITIONAL)
+        file_import.add_submodule_import("typing", "Any", ImportType.STDLIB, TypingSection.CONDITIONAL)
         return file_import
 
 def get_object_schema(code_model) -> Type[ObjectSchema]:

package/autorest/codegen/models/operation.py

@@ -147,7 +147,7 @@ class Operation(BaseBuilder):  # pylint: disable=too-many-public-methods, too-ma
 
     def _imports_shared(self, async_mode: bool) -> FileImport: # pylint: disable=unused-argument
         file_import = FileImport()
-        file_import.add_from_import("typing", "Any", ImportType.STDLIB, TypingSection.CONDITIONAL)
+        file_import.add_submodule_import("typing", "Any", ImportType.STDLIB, TypingSection.CONDITIONAL)
         for param in self.parameters.method:
             file_import.merge(param.imports())
 
@@ -159,11 +159,12 @@ class Operation(BaseBuilder):  # pylint: disable=too-many-public-methods, too-ma
             if response.has_body:
                 file_import.merge(cast(BaseSchema, response.schema).imports())
 
-        if len([r for r in self.responses if r.has_body]) > 1:
-            file_import.add_from_import("typing", "Union", ImportType.STDLIB, TypingSection.CONDITIONAL)
+        response_types = [r.operation_type_annotation for r in self.responses if r.has_body]
+        if len(set(response_types)) > 1:
+            file_import.add_submodule_import("typing", "Union", ImportType.STDLIB, TypingSection.CONDITIONAL)
 
         if self.is_stream_response:
-            file_import.add_from_import("typing", "IO", ImportType.STDLIB, TypingSection.CONDITIONAL)
+            file_import.add_submodule_import("typing", "IO", ImportType.STDLIB, TypingSection.CONDITIONAL)
         return file_import
 
 
@@ -174,42 +175,37 @@ class Operation(BaseBuilder):  # pylint: disable=too-many-public-methods, too-ma
         file_import = self._imports_shared(async_mode)
 
         # Exceptions
-        file_import.add_from_import("azure.core.exceptions", "map_error", ImportType.AZURECORE)
+        file_import.add_submodule_import("azure.core.exceptions", "map_error", ImportType.AZURECORE)
         if self.code_model.options["azure_arm"]:
-            file_import.add_from_import("azure.mgmt.core.exceptions", "ARMErrorFormat", ImportType.AZURECORE)
-        file_import.add_from_import("azure.core.exceptions", "HttpResponseError", ImportType.AZURECORE)
-
-
-        file_import.add_import("functools", ImportType.STDLIB)
-        file_import.add_from_import("typing", "Callable", ImportType.STDLIB, TypingSection.CONDITIONAL)
-        file_import.add_from_import("typing", "Optional", ImportType.STDLIB, TypingSection.CONDITIONAL)
-        file_import.add_from_import("typing", "Dict", ImportType.STDLIB, TypingSection.CONDITIONAL)
-        file_import.add_from_import("typing", "TypeVar", ImportType.STDLIB, TypingSection.CONDITIONAL)
-        file_import.add_from_import("typing", "Generic", ImportType.STDLIB, TypingSection.CONDITIONAL)
-        file_import.add_from_import("azure.core.pipeline", "PipelineResponse", ImportType.AZURECORE)
-        file_import.add_from_import("azure.core.rest", "HttpRequest", ImportType.AZURECORE)
+            file_import.add_submodule_import("azure.mgmt.core.exceptions", "ARMErrorFormat", ImportType.AZURECORE)
+        file_import.add_submodule_import("azure.core.exceptions", "HttpResponseError", ImportType.AZURECORE)
+
+        file_import.add_submodule_import("typing", "Callable", ImportType.STDLIB, TypingSection.CONDITIONAL)
+        file_import.add_submodule_import("typing", "Optional", ImportType.STDLIB, TypingSection.CONDITIONAL)
+        file_import.add_submodule_import("typing", "Dict", ImportType.STDLIB, TypingSection.CONDITIONAL)
+        file_import.add_submodule_import("typing", "TypeVar", ImportType.STDLIB, TypingSection.CONDITIONAL)
+        file_import.add_submodule_import("azure.core.pipeline", "PipelineResponse", ImportType.AZURECORE)
+        file_import.add_submodule_import("azure.core.rest", "HttpRequest", ImportType.AZURECORE)
         if async_mode:
-            file_import.add_from_import("azure.core.pipeline.transport", "AsyncHttpResponse", ImportType.AZURECORE)
+            file_import.add_submodule_import("azure.core.pipeline.transport", "AsyncHttpResponse", ImportType.AZURECORE)
         else:
-            file_import.add_from_import("azure.core.pipeline.transport", "HttpResponse", ImportType.AZURECORE)
+            file_import.add_submodule_import("azure.core.pipeline.transport", "HttpResponse", ImportType.AZURECORE)
 
-        # Deprecation
-        # FIXME: Replace with "the YAML contains deprecated:true"
-        if True:  # pylint: disable=using-constant-test
+        if self.deprecated:
             file_import.add_import("warnings", ImportType.STDLIB)
 
         if self.code_model.options["builders_visibility"] != "embedded":
             builder_group_name = self.request_builder.builder_group_name
             rest_import_path = "..." if async_mode else ".."
             if builder_group_name:
-                file_import.add_from_import(
+                file_import.add_submodule_import(
                     f"{rest_import_path}{self.code_model.rest_layer_name}",
-                    name_import=builder_group_name,
+                    builder_group_name,
                     import_type=ImportType.LOCAL,
                     alias=f"rest_{builder_group_name}"
                 )
             else:
-                file_import.add_from_import(
+                file_import.add_submodule_import(
                     rest_import_path,
                     self.code_model.rest_layer_name,
                     import_type=ImportType.LOCAL,
@@ -219,7 +215,7 @@ class Operation(BaseBuilder):  # pylint: disable=too-many-public-methods, too-ma
             file_import.merge(self.request_builder.imports())
         if self.code_model.need_request_converter:
             relative_path = "..." if async_mode else ".."
-            file_import.add_from_import(
+            file_import.add_submodule_import(
                 f"{relative_path}_vendor", "_convert_request", ImportType.LOCAL
             )
         if self.code_model.options["version_tolerant"] and (
@@ -227,6 +223,12 @@ class Operation(BaseBuilder):  # pylint: disable=too-many-public-methods, too-ma
             any(r for r in self.responses if r.has_body)
         ):
             file_import.define_mypy_type("JSONType", "Any")
+        if self.code_model.options["tracing"] and self.want_tracing:
+            file_import.add_submodule_import(
+                f"azure.core.tracing.decorator{'_async' if async_mode else ''}",
+                f"distributed_trace{'_async' if async_mode else ''}",
+                ImportType.AZURECORE,
+            )
         return file_import
 
     def _get_body_param_from_body_kwarg(self, body_kwarg: Parameter) -> Parameter:

package/autorest/codegen/models/operation_group.py

@@ -58,23 +58,14 @@ class OperationGroup(BaseModel):
 
     def imports(self, async_mode: bool) -> FileImport:
         file_import = FileImport()
-        file_import.add_from_import("azure.core.exceptions", "ClientAuthenticationError", ImportType.AZURECORE)
-        file_import.add_from_import("azure.core.exceptions", "ResourceNotFoundError", ImportType.AZURECORE)
-        file_import.add_from_import("azure.core.exceptions", "ResourceExistsError", ImportType.AZURECORE)
+        file_import.add_submodule_import("azure.core.exceptions", "ClientAuthenticationError", ImportType.AZURECORE)
+        file_import.add_submodule_import("azure.core.exceptions", "ResourceNotFoundError", ImportType.AZURECORE)
+        file_import.add_submodule_import("azure.core.exceptions", "ResourceExistsError", ImportType.AZURECORE)
         for operation in self.operations:
             file_import.merge(operation.imports(async_mode))
-        if self.code_model.options["tracing"]:
-            if async_mode:
-                file_import.add_from_import(
-                    "azure.core.tracing.decorator_async", "distributed_trace_async", ImportType.AZURECORE,
-                )
-            else:
-                file_import.add_from_import(
-                    "azure.core.tracing.decorator", "distributed_trace", ImportType.AZURECORE,
-                )
         local_path = "..." if async_mode else ".."
         if self.code_model.has_schemas and self.code_model.options["models_mode"]:
-            file_import.add_from_import(local_path, "models", ImportType.LOCAL, alias="_models")
+            file_import.add_submodule_import(local_path, "models", ImportType.LOCAL, alias="_models")
         if self.code_model.options["builders_visibility"] == "embedded" and async_mode:
             if not self.code_model.options["combine_operation_files"]:
                 operation_group_name = "" if self.is_empty_operation_group else self.name
@@ -88,7 +79,7 @@ class OperationGroup(BaseModel):
                 python3_only = self.code_model.options["python3_only"]
                 typed_sync_operation_file = self.code_model.options["add_python3_operation_files"]
                 suffix = "_py3" if typed_sync_operation_file and not python3_only else ""
-                file_import.add_from_import(
+                file_import.add_submodule_import(
                     f"...{self.code_model.operations_folder_name}.{self.filename}{suffix}",
                     request_builder.name,
                     import_type=ImportType.LOCAL