@autorest/python 5.12.1 → 5.12.5

package/ChangeLog.md

@@ -1,5 +1,63 @@
 # Change Log
 
+### 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
+| --------------- | -------
+|`@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 installation of autorest python package #1118
+
 ### 2022-01-10 - 5.12.1
 
 | 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,27 @@ 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.AZURECORE)
+        file_import.add_submodule_import("msrest", "Deserializer", ImportType.AZURECORE)
+        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)
+            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,35 +63,37 @@ 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

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,10 @@ 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)
+            file_import.add_submodule_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("json", "loads", import_type=ImportType.STDLIB, alias="_loads")
         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())
 
@@ -160,10 +160,10 @@ class Operation(BaseBuilder):  # pylint: disable=too-many-public-methods, too-ma
                 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)
+            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,24 +174,24 @@ 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_submodule_import("azure.mgmt.core.exceptions", "ARMErrorFormat", ImportType.AZURECORE)
+        file_import.add_submodule_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("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("typing", "Generic", 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"
@@ -202,14 +202,14 @@ class Operation(BaseBuilder):  # pylint: disable=too-many-public-methods, too-ma
             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 +219,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 (

package/autorest/codegen/models/operation_group.py

@@ -58,23 +58,23 @@ 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(
+                file_import.add_submodule_import(
                     "azure.core.tracing.decorator_async", "distributed_trace_async", ImportType.AZURECORE,
                 )
             else:
-                file_import.add_from_import(
+                file_import.add_submodule_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 +88,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

package/autorest/codegen/models/paging_operation.py

@@ -125,9 +125,9 @@ class PagingOperation(Operation):
     def _imports_shared(self, async_mode: bool) -> FileImport:
         file_import = super()._imports_shared(async_mode)
         if async_mode:
-            file_import.add_from_import("typing", "AsyncIterable", ImportType.STDLIB, TypingSection.CONDITIONAL)
+            file_import.add_submodule_import("typing", "AsyncIterable", ImportType.STDLIB, TypingSection.CONDITIONAL)
         else:
-            file_import.add_from_import("typing", "Iterable", ImportType.STDLIB, TypingSection.CONDITIONAL)
+            file_import.add_submodule_import("typing", "Iterable", ImportType.STDLIB, TypingSection.CONDITIONAL)
         if (
             self.next_request_builder and
             self.code_model.options["builders_visibility"] == "embedded"
@@ -141,7 +141,7 @@ class PagingOperation(Operation):
         pager_import_path = ".".join(self.get_pager_path(async_mode).split(".")[:-1])
         pager = self.get_pager(async_mode)
 
-        file_import.add_from_import(pager_import_path, pager, ImportType.AZURECORE, TypingSection.CONDITIONAL)
+        file_import.add_submodule_import(pager_import_path, pager, ImportType.AZURECORE, TypingSection.CONDITIONAL)
 
         return file_import
 
@@ -151,16 +151,16 @@ class PagingOperation(Operation):
         pager_import_path = ".".join(self.get_pager_path(async_mode).split(".")[:-1])
         pager = self.get_pager(async_mode)
 
-        file_import.add_from_import(pager_import_path, pager, ImportType.AZURECORE)
+        file_import.add_submodule_import(pager_import_path, pager, ImportType.AZURECORE)
 
         if async_mode:
-            file_import.add_from_import("azure.core.async_paging", "AsyncList", ImportType.AZURECORE)
+            file_import.add_submodule_import("azure.core.async_paging", "AsyncList", ImportType.AZURECORE)
 
         if self.code_model.options["tracing"]:
-            file_import.add_from_import(
+            file_import.add_submodule_import(
                 "azure.core.tracing.decorator", "distributed_trace", ImportType.AZURECORE,
             )
         if not self.code_model.options["models_mode"]:
-            file_import.add_from_import("json", "loads", ImportType.STDLIB, alias="_loads")
+            file_import.add_submodule_import("json", "loads", ImportType.STDLIB, alias="_loads")
 
         return file_import

package/autorest/codegen/models/parameter.py

@@ -177,8 +177,6 @@ class Parameter(BaseModel):  # pylint: disable=too-many-instance-attributes, too
         return not(
             # don't put accept in signature
             self.rest_api_name == "Accept"
-            # if i'm multiapi, don't add constants
-            or (self.code_model.options["multiapi"] and self.constant)
             # If i'm not in the method code, no point in being in signature
             or not self.in_method_code
             # If I'm grouped, my grouper will be on signature, not me
@@ -302,8 +300,6 @@ class Parameter(BaseModel):  # pylint: disable=too-many-instance-attributes, too
     @property
     def is_kwarg(self) -> bool:
         # this means "am I in **kwargs?"
-        if self.code_model.options["multiapi"]:
-            return self.rest_api_name == "Content-Type"
         return self.rest_api_name == "Content-Type" or (self.constant and self.rest_api_name != "Accept")
 
     @property
@@ -313,7 +309,9 @@ class Parameter(BaseModel):  # pylint: disable=too-many-instance-attributes, too
 
     @property
     def is_hidden(self) -> bool:
-        return self.serialized_name in _HIDDEN_KWARGS
+        return self.serialized_name in _HIDDEN_KWARGS or (
+            self.yaml_data["implementation"] == "Client" and self.constant
+        )
 
     @property
     def is_positional(self) -> bool:
@@ -356,9 +354,9 @@ class Parameter(BaseModel):  # pylint: disable=too-many-instance-attributes, too
     def imports(self) -> FileImport:
         file_import = self.schema.imports()
         if not self.required:
-            file_import.add_from_import("typing", "Optional", ImportType.STDLIB, TypingSection.CONDITIONAL)
+            file_import.add_submodule_import("typing", "Optional", ImportType.STDLIB, TypingSection.CONDITIONAL)
         if self.has_multiple_content_types or self._is_io_json:
-            file_import.add_from_import("typing", "Union", ImportType.STDLIB, TypingSection.CONDITIONAL)
+            file_import.add_submodule_import("typing", "Union", ImportType.STDLIB, TypingSection.CONDITIONAL)
 
         return file_import
 

package/autorest/codegen/models/primitive_schemas.py

@@ -116,7 +116,7 @@ class IOSchema(PrimitiveSchema):
 
     def imports(self) -> FileImport:
         file_import = FileImport()
-        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
 
 class AnySchema(PrimitiveSchema):
@@ -138,7 +138,7 @@ class AnySchema(PrimitiveSchema):
 
     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
 
 class JSONSchema(AnySchema):

package/autorest/codegen/models/property.py

@@ -170,5 +170,5 @@ class Property(BaseModel):  # pylint: disable=too-many-instance-attributes
     def model_file_imports(self) -> FileImport:
         file_import = self.schema.model_file_imports()
         if not self.required:
-            file_import.add_from_import("typing", "Optional", ImportType.STDLIB, TypingSection.CONDITIONAL)
+            file_import.add_submodule_import("typing", "Optional", ImportType.STDLIB, TypingSection.CONDITIONAL)
         return file_import

package/autorest/codegen/models/request_builder.py

@@ -68,7 +68,7 @@ class RequestBuilder(BaseBuilder):
         for parameter in self.parameters:
             file_import.merge(parameter.imports())
 
-        file_import.add_from_import(
+        file_import.add_submodule_import(
             "azure.core.rest",
             "HttpRequest",
             ImportType.AZURECORE,
@@ -77,17 +77,17 @@ class RequestBuilder(BaseBuilder):
             relative_path = ".."
             if not self.code_model.options["builders_visibility"] == "embedded" and self.operation_group_name:
                 relative_path = "..." if self.operation_group_name else ".."
-            file_import.add_from_import(
+            file_import.add_submodule_import(
                 f"{relative_path}_vendor", "_format_url_section", ImportType.LOCAL
             )
         if self.parameters.headers or self.parameters.query:
-            file_import.add_from_import(
+            file_import.add_submodule_import(
                 "typing", "Dict", ImportType.STDLIB, typing_section=TypingSection.CONDITIONAL
             )
-        file_import.add_from_import(
+        file_import.add_submodule_import(
             "typing", "Any", ImportType.STDLIB, typing_section=TypingSection.CONDITIONAL
         )
-        file_import.add_from_import("msrest", "Serializer", ImportType.AZURECORE)
+        file_import.add_submodule_import("msrest", "Serializer", ImportType.AZURECORE)
         if self.parameters.has_body and (
             self.code_model.options["builders_visibility"] != "embedded" or
             self.code_model.options["add_python3_operation_files"]

package/autorest/codegen/models/request_builder_parameter.py

@@ -18,8 +18,6 @@ class RequestBuilderParameter(ParameterOnlyPathAndBodyPositional):
         return not(
             # don't put accept in method signature
             self.rest_api_name == "Accept"
-            # if i'm multiapi, don't add constants
-            or (self.code_model.options["multiapi"] and self.constant)
             # If i'm not in the method code, no point in being in signature
             or not self.in_method_code
             # If I'm a flattened property of a body, don't want me, want the body param

package/autorest/codegen/models/schema_response.py

@@ -99,7 +99,7 @@ class SchemaResponse(BaseModel):
     def imports(self, code_model) -> FileImport:
         file_import = FileImport()
         if not code_model.options["models_mode"] and self.is_xml:
-            file_import.add_from_import("xml.etree", "ElementTree", ImportType.STDLIB, alias="ET")
+            file_import.add_submodule_import("xml.etree", "ElementTree", ImportType.STDLIB, alias="ET")
         return file_import
 
     @classmethod

package/autorest/codegen/serializers/general_serializer.py

@@ -10,17 +10,17 @@ from .client_serializer import ClientSerializer, ConfigSerializer
 
 def config_imports(code_model, global_parameters: ParameterList, async_mode: bool) -> FileImport:
     file_import = FileImport()
-    file_import.add_from_import("azure.core.configuration", "Configuration", ImportType.AZURECORE)
-    file_import.add_from_import("azure.core.pipeline", "policies", ImportType.AZURECORE)
-    file_import.add_from_import("typing", "Any", ImportType.STDLIB, TypingSection.CONDITIONAL)
+    file_import.add_submodule_import("azure.core.configuration", "Configuration", ImportType.AZURECORE)
+    file_import.add_submodule_import("azure.core.pipeline", "policies", ImportType.AZURECORE)
+    file_import.add_submodule_import("typing", "Any", ImportType.STDLIB, TypingSection.CONDITIONAL)
     if code_model.options["package_version"]:
-        file_import.add_from_import(".._version" if async_mode else "._version", "VERSION", ImportType.LOCAL)
+        file_import.add_submodule_import(".._version" if async_mode else "._version", "VERSION", ImportType.LOCAL)
     for gp in global_parameters:
         file_import.merge(gp.imports())
     if code_model.options["azure_arm"]:
         policy = "AsyncARMChallengeAuthenticationPolicy" if async_mode else "ARMChallengeAuthenticationPolicy"
-        file_import.add_from_import("azure.mgmt.core.policies", "ARMHttpLoggingPolicy", ImportType.AZURECORE)
-        file_import.add_from_import("azure.mgmt.core.policies", policy, ImportType.AZURECORE)
+        file_import.add_submodule_import("azure.mgmt.core.policies", "ARMHttpLoggingPolicy", ImportType.AZURECORE)
+        file_import.add_submodule_import("azure.mgmt.core.policies", policy, ImportType.AZURECORE)
     return file_import
 
 
@@ -71,7 +71,7 @@ class GeneralSerializer:
         # configure imports
         file_import = FileImport()
         if self.code_model.need_request_converter:
-            file_import.add_from_import(
+            file_import.add_submodule_import(
                 "azure.core.pipeline.transport",
                 "HttpRequest",
                 ImportType.AZURECORE,

package/autorest/codegen/serializers/import_serializer.py

@@ -4,75 +4,73 @@
 # license information.
 # --------------------------------------------------------------------------
 from copy import deepcopy
-from typing import Dict, Set, Optional, List, Tuple, Union
-from ..models.imports import ImportType, FileImport, TypingSection
+from typing import List
+from ..models.imports import ImportType, FileImport, ImportModel, TypingSection
 
 def _serialize_package(
-    package_name: str, module_list: Set[Optional[Union[str, Tuple[str, str]]]], delimiter: str
+    imports: List[ImportModel], delimiter: str
 ) -> str:
     buffer = []
-    if None in module_list:
-        buffer.append(f"import {package_name}")
-    if module_list != {None}:
-        buffer.append(
-            "from {} import {}".format(
-                package_name, ", ".join(sorted([
-                    mod if isinstance(mod, str) else f"{mod[0]} as {mod[1]}" for mod in module_list if mod is not None
-                ]))
-            )
-        )
+    if any(i for i in imports if i.submodule_name is None):
+        buffer.append(f"import {imports[0].module_name}")
+    else:
+        import_str = ", ".join(sorted([
+            f"{i.submodule_name} as {i.alias}" if i.alias else i.submodule_name for i in imports # type: ignore
+        ]))
+        buffer.append(f"from {imports[0].module_name} import {import_str}")
     return delimiter.join(buffer)
 
-def _serialize_type(import_type_dict: Dict[str, Set[Optional[Union[str, Tuple[str, str]]]]], delimiter: str) -> str:
+def _serialize_import_type(imports: List[ImportModel], delimiter: str) -> str:
     """Serialize a given import type."""
     import_list = []
-    for package_name in sorted(list(import_type_dict.keys())):
-        module_list = import_type_dict[package_name]
-        import_list.append(_serialize_package(package_name, module_list, delimiter))
+    for module_name in sorted(set(i.module_name for i in imports)):
+
+        import_list.append(_serialize_package([
+            i for i in imports if i.module_name == module_name
+        ], delimiter))
     return delimiter.join(import_list)
 
 def _get_import_clauses(
-    imports: Dict[ImportType, Dict[str, Set[Optional[Union[str, Tuple[str, str]]]]]], delimiter: str
+    imports: List[ImportModel], delimiter: str
 ) -> List[str]:
     import_clause = []
     for import_type in ImportType:
-        if import_type in imports:
-            import_clause.append(_serialize_type(imports[import_type], delimiter))
+        imports_with_import_type = [i for i in imports if i.import_type == import_type]
+        if imports_with_import_type:
+            import_clause.append(_serialize_import_type(imports_with_import_type, delimiter))
     return import_clause
 
 
 class FileImportSerializer:
     def __init__(self, file_import: FileImport, is_python3_file: bool, async_mode: bool = False) -> None:
-        self._file_import = file_import
+        self.file_import = file_import
         self.is_python3_file = is_python3_file
         self.async_mode = async_mode
 
-    def _switch_typing_section_key(self, new_key: TypingSection):
-        switched_dictionary = {}
-        switched_dictionary[new_key] = self._file_import.imports[TypingSection.CONDITIONAL]
-        return switched_dictionary
-
-    def _get_imports_dict(self, baseline_typing_section: TypingSection, add_conditional_typing: bool):
+    def _get_imports_list(self, baseline_typing_section: TypingSection, add_conditional_typing: bool):
         # If this is a python 3 file, our regular imports include the CONDITIONAL category
         # If this is not a python 3 file, our typing imports include the CONDITIONAL category
-        file_import_copy = deepcopy(self._file_import)
-        if add_conditional_typing and self._file_import.imports.get(TypingSection.CONDITIONAL):
+        file_import_copy = deepcopy(self.file_import)
+        if add_conditional_typing and any(
+            self.file_import.get_imports_from_section(TypingSection.CONDITIONAL)
+        ):
             # we switch the TypingSection key for the CONDITIONAL typing imports so we can merge
             # the imports together
-            switched_imports_dictionary = self._switch_typing_section_key(baseline_typing_section)
-            switched_imports = FileImport(switched_imports_dictionary)
-            file_import_copy.merge(switched_imports)
-        return file_import_copy.imports.get(baseline_typing_section, {})
+            for i in file_import_copy.imports:
+                if i.typing_section == TypingSection.CONDITIONAL:
+                    i.typing_section = baseline_typing_section
+        return file_import_copy.get_imports_from_section(baseline_typing_section)
 
     def _add_type_checking_import(self):
-        if (
-            self._file_import.imports.get(TypingSection.TYPING) or
-            (not self.is_python3_file and self._file_import.imports.get(TypingSection.CONDITIONAL))
-        ):
-            self._file_import.add_from_import("typing", "TYPE_CHECKING", ImportType.STDLIB)
+        any_typing = any(self.file_import.get_imports_from_section(TypingSection.TYPING))
+        conditional_and_not_py3 = not self.is_python3_file and any(
+            self.file_import.get_imports_from_section(TypingSection.CONDITIONAL)
+        )
+        if any_typing or conditional_and_not_py3:
+            self.file_import.add_submodule_import("typing", "TYPE_CHECKING", ImportType.STDLIB)
 
     def _get_typing_definitions(self) -> str:
-        if not self._file_import.type_definitions:
+        if not self.file_import.type_definitions:
             return ""
         spacing = "" if self.is_python3_file else "    "
         declarations: List[str] = [f"\n{spacing}T = TypeVar('T')"]
@@ -82,27 +80,27 @@ class FileImportSerializer:
                 type_name,
                 values[1] if self.async_mode else values[0]
             )
-            for type_name, values in self._file_import.type_definitions.items()
+            for type_name, values in self.file_import.type_definitions.items()
         ])
         return "\n".join(declarations)
 
     def __str__(self) -> str:
         self._add_type_checking_import()
         regular_imports = ""
-        regular_imports_dict = self._get_imports_dict(
+        regular_imports_list = self._get_imports_list(
             baseline_typing_section=TypingSection.REGULAR, add_conditional_typing=self.is_python3_file
         )
 
-        if regular_imports_dict:
+        if regular_imports_list:
             regular_imports = "\n\n".join(
-                _get_import_clauses(regular_imports_dict, "\n")
+                _get_import_clauses(regular_imports_list, "\n")
             )
 
         typing_imports = ""
-        typing_imports_dict = self._get_imports_dict(
+        typing_imports_list = self._get_imports_list(
             baseline_typing_section=TypingSection.TYPING, add_conditional_typing=not self.is_python3_file
         )
-        if typing_imports_dict:
+        if typing_imports_list:
             typing_imports += "\n\nif TYPE_CHECKING:\n    # pylint: disable=unused-import,ungrouped-imports\n    "
-            typing_imports += "\n\n    ".join(_get_import_clauses(typing_imports_dict, "\n    "))
+            typing_imports += "\n\n    ".join(_get_import_clauses(typing_imports_list, "\n    "))
         return regular_imports + typing_imports + self._get_typing_definitions()

package/autorest/codegen/serializers/metadata_serializer.py

@@ -62,7 +62,7 @@ def _mixin_imports(mixin_operation_group: Optional[OperationGroup]) -> Tuple[Opt
     sync_mixin_imports = mixin_operation_group.imports_for_multiapi(async_mode=False)
     async_mixin_imports = mixin_operation_group.imports_for_multiapi(async_mode=True)
 
-    return _json_serialize_imports(sync_mixin_imports.imports), _json_serialize_imports(async_mixin_imports.imports)
+    return _json_serialize_imports(sync_mixin_imports.to_dict()), _json_serialize_imports(async_mixin_imports.to_dict())
 
 
 class MetadataSerializer:
@@ -102,20 +102,22 @@ class MetadataSerializer:
         file_import = FileImport()
         for gp in global_parameters:
             file_import.merge(gp.imports())
-        file_import.add_from_import("azure.profiles", "KnownProfiles", import_type=ImportType.AZURECORE)
-        file_import.add_from_import("azure.profiles", "ProfileDefinition", import_type=ImportType.AZURECORE)
-        file_import.add_from_import(
+        file_import.add_submodule_import("azure.profiles", "KnownProfiles", import_type=ImportType.AZURECORE)
+        file_import.add_submodule_import("azure.profiles", "ProfileDefinition", import_type=ImportType.AZURECORE)
+        file_import.add_submodule_import(
             "azure.profiles.multiapiclient", "MultiApiClientMixin", import_type=ImportType.AZURECORE
         )
-        file_import.add_from_import("._configuration", f"{self.code_model.class_name}Configuration", ImportType.LOCAL)
+        file_import.add_submodule_import(
+            "._configuration", f"{self.code_model.class_name}Configuration", ImportType.LOCAL
+        )
         # api_version and potentially endpoint require Optional typing
-        file_import.add_from_import("typing", "Optional", ImportType.STDLIB, TypingSection.CONDITIONAL)
+        file_import.add_submodule_import("typing", "Optional", ImportType.STDLIB, TypingSection.CONDITIONAL)
         if mixin_operation_group:
-            file_import.add_from_import(
+            file_import.add_submodule_import(
                 "._operations_mixin", f"{self.code_model.class_name}OperationsMixin", ImportType.LOCAL
             )
         file_import.merge(self.code_model.service_client.imports_for_multiapi(async_mode=async_mode))
-        return _json_serialize_imports(file_import.imports)
+        return _json_serialize_imports(file_import.to_dict())
 
     def serialize(self) -> str:
         def _is_lro(operation):
@@ -179,10 +181,10 @@ class MetadataSerializer:
             sync_client_imports=sync_client_imports,
             async_client_imports=async_client_imports,
             sync_config_imports=_json_serialize_imports(
-                config_imports(self.code_model, self.code_model.global_parameters, async_mode=False).imports
+                config_imports(self.code_model, self.code_model.global_parameters, async_mode=False).to_dict()
             ),
             async_config_imports=_json_serialize_imports(
-                config_imports(self.code_model, async_global_parameters, async_mode=True).imports
+                config_imports(self.code_model, async_global_parameters, async_mode=True).to_dict()
             ),
             get_async_operation_serializer=functools.partial(
                 get_operation_serializer, code_model=self.code_model, async_mode=True, is_python3_file=True

package/autorest/codegen/serializers/model_base_serializer.py

@@ -52,12 +52,12 @@ class ModelBaseSerializer:
     @staticmethod
     def get_properties_to_initialize(model: ObjectSchema) -> List[Property]:
         if model.base_models:
-            properties_to_initialize = []
-            for uncast_base_model in model.base_models:
-                base_model = cast(ObjectSchema, uncast_base_model)
-                for prop in model.properties:
-                    if prop not in base_model.properties or prop.is_discriminator or prop.constant:
-                        properties_to_initialize.append(prop)
+            properties_to_initialize = list({
+                p.name: p
+                for bm in model.base_models
+                for p in model.properties
+                if p not in cast(ObjectSchema, bm).properties or p.is_discriminator or p.constant
+            }.values())
         else:
             properties_to_initialize = model.properties
         return properties_to_initialize

package/autorest/codegen/templates/metadata.json.jinja2

@@ -18,7 +18,7 @@
     },
     "global_parameters": {
         "sync": {
-            {% for gp in sync_global_parameters.config_method %}
+            {% for gp in sync_global_parameters.config_method | rejectattr("serialized_name", "equalto", "api_version") %}
             {{ gp.serialized_name | tojson }}: {
                 "signature": {{ gp.method_signature(is_python3_file=False) | tojson }},
                 "description": {{ gp.description | tojson }},
@@ -28,7 +28,7 @@
             {% endfor %}
         },
         "async": {
-            {% for gp in async_global_parameters.config_method %}
+            {% for gp in async_global_parameters.config_method | rejectattr("serialized_name", "equalto", "api_version") %}
             {{ gp.serialized_name | tojson }}: {
                 "signature": {{ (gp.method_signature(is_python3_file=True)) | tojson }},
                 "description": {{ gp.description | tojson }},
@@ -42,7 +42,7 @@
             {{ gp.serialized_name | tojson }}: {{ gp.constant_declaration | tojson }}{{ "," if not loop.last else "" }}
             {% endfor %}
         },
-        "call": {{ code_model.global_parameters.config_method | map(attribute="serialized_name") | join(', ') | tojson }},
+        "call": {{ code_model.global_parameters.config_method | rejectattr("serialized_name", "equalto", "api_version") | map(attribute="serialized_name") | join(', ') | tojson }},
         "service_client_specific": {
             "sync": {
                 "api_version": {

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

@@ -20,4 +20,6 @@
     {{ op_tools.serialize(operation_serializer.call_request_builder(operation)) | indent }}
     pipeline_response = {{ keywords.await }}self._client._pipeline.run(request, {{ stream_request_parameter }}, **kwargs)
     {{ op_tools.serialize(operation_serializer.handle_response(operation)) | indent }}
+{% if not code_model.options["version_tolerant"] %}
 {{ operation.python_name }}.metadata = {'url': {{ keywords.escape_str(request_builder.url) }}}  # type: ignore
+{% endif %}

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

@@ -17,4 +17,6 @@
     return {{ operation.get_pager(async_mode) }}(
         get_next, extract_data
     )
-{{ operation.python_name }}.metadata = {'url': '{{ request_builder.url|replace("'", "\\'") }}'}  # type: ignore
+{% if not code_model.options["metadata"] %}
+{{ operation.python_name }}.metadata = {'url': '{{ request_builder.url|replace("'", "\\'") }}'}  # type: ignore
+{% endif %}

package/autorest/multiapi/models/imports.py

@@ -45,7 +45,7 @@ class FileImport:
                 from_section, set()
             ).add(name_import)
 
-    def add_from_import(
+    def add_submodule_import(
         self,
         from_section: str,
         name_import: str,

package/autorest/multiapi/serializers/import_serializer.py

@@ -62,7 +62,7 @@ class FileImportSerializer:
             self._file_import.imports.get(TypingSection.TYPING) or
             (not self.is_python3_file and self._file_import.imports.get(TypingSection.CONDITIONAL))
         ):
-            self._file_import.add_from_import("typing", "TYPE_CHECKING", ImportType.STDLIB)
+            self._file_import.add_submodule_import("typing", "TYPE_CHECKING", ImportType.STDLIB)
 
     def __str__(self) -> str:
         self._add_type_checking_import()

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@autorest/python",
-    "version": "5.12.1",
+    "version": "5.12.5",
     "description": "The Python extension for generators in AutoRest.",
     "scripts": {
         "prepare": "node run-python3.js prepare.py",
@@ -37,6 +37,7 @@
         "prepare.py",
         "start.py",
         "venvtools.py",
-        "run-python3.js"
+        "run-python3.js",
+        "requirements.txt"
     ]
 }

package/requirements.txt

@@ -0,0 +1,14 @@
+black==21.12b0
+click==8.0.3
+docutils==0.18.1
+Jinja2==3.0.3
+json-rpc==1.13.0
+m2r==0.2.1
+MarkupSafe==2.0.1
+mistune==0.8.4
+mypy-extensions==0.4.3
+pathspec==0.9.0
+platformdirs==2.4.0
+PyYAML==6.0
+tomli==1.2.2
+typing-extensions==4.0.1