@autorest/python 5.12.2 → 5.12.6

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,26 +141,26 @@ 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
 
     def imports(self, async_mode: bool) -> FileImport:
         file_import = super(PagingOperation, self).imports(async_mode)
+        # operation adds an import for distributed_trace_async, we don't want it
+        file_import.imports = [i for i in file_import.imports if not i.submodule_name == "distributed_trace_async"]
 
         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(
+        if self.code_model.options["tracing"] and self.want_tracing:
+            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")
 
         return file_import

package/autorest/codegen/models/parameter.py

@@ -98,6 +98,7 @@ class Parameter(BaseModel):  # pylint: disable=too-many-instance-attributes, too
         self.content_types = content_types or []
         self.body_kwargs: List[Parameter] = []
         self.is_body_kwarg = False
+        self.need_import = True
 
     def __hash__(self) -> int:
         return hash(self.serialized_name)
@@ -177,8 +178,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 +301,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 +310,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 +355,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/parameter_list.py

@@ -275,6 +275,7 @@ class ParameterList(MutableSequence):  # pylint: disable=too-many-public-methods
 def _create_files_or_data_param(
     params: List[Parameter], serialized_name: str, description: str
 ) -> Parameter:
+    params[0].need_import = False
     param = copy(params[0])
     param.serialized_name = serialized_name
     param.schema = DictionarySchema(

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

@@ -66,9 +66,10 @@ class RequestBuilder(BaseBuilder):
     def imports(self) -> FileImport:
         file_import = FileImport()
         for parameter in self.parameters:
-            file_import.merge(parameter.imports())
+            if parameter.need_import:
+                file_import.merge(parameter.imports())
 
-        file_import.add_from_import(
+        file_import.add_submodule_import(
             "azure.core.rest",
             "HttpRequest",
             ImportType.AZURECORE,
@@ -77,17 +78,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.THIRDPARTY)
         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/request_builder_parameter_list.py

@@ -198,6 +198,7 @@ class RequestBuilderParameterList(ParameterList):
         else:
             for kwarg in body_kwargs_added:
                 kwarg.required = False
+        first_body_param.need_import = False
         self.parameters = body_kwargs_added + self.parameters
 
     @property

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/builder_serializer.py

@@ -33,6 +33,9 @@ from . import utils
 T = TypeVar("T")
 OrderedSet = Dict[T, None]
 
+def _escape_str(input_str: str) -> str:
+    replace = input_str.replace("'", "\\'")
+    return f'"{replace}"'
 
 def _improve_json_string(template_representation: str) -> Any:
     origin = template_representation.split('\n')
@@ -110,7 +113,7 @@ def _pop_parameters_kwarg(
     function_name: str,
     kwarg_name: str,
 ) -> str:
-    return f'{function_name}_parameters = kwargs.pop("{kwarg_name}", {{}})  # type: Dict[str, Any]'
+    return f'_{function_name}_parameters = kwargs.pop("{kwarg_name}", {{}})  # type: Dict[str, Any]'
 
 def _serialize_grouped_body(builder) -> List[str]:
     retval: List[str] = []
@@ -180,11 +183,6 @@ class _BuilderSerializerProtocol(ABC):
         """Whether you want inline type hints. If false, your type hints will be commented'"""
         ...
 
-    @abstractmethod
-    def _method_signature(self, builder) -> str:
-        """Signature of the builder. Does not include return type annotation"""
-        ...
-
     @abstractmethod
     def _response_type_annotation(self, builder, modify_if_head_as_boolean: bool = True) -> str:
         """The mypy type annotation for the response"""
@@ -266,20 +264,22 @@ class _BuilderBaseSerializer(_BuilderSerializerProtocol):  # pylint: disable=abs
     def _cls_docstring_rtype(self) -> str:
         return "" if self.code_model.options["version_tolerant"] else " or the result of cls(response)"
 
-    def _method_signature(self, builder) -> str:
+    def _method_signature(self, builder: Operation, response_type_annotation: str) -> str:
         return utils.serialize_method(
             function_def=self._function_definition,
             method_name=builder.name,
             is_in_class=self._is_in_class,
             method_param_signatures=builder.parameters.method_signature(self._want_inline_type_hints),
+            ignore_inconsistent_return_statements=(response_type_annotation == "None")
         )
 
     def _response_type_annotation_wrapper(self, builder) -> List[str]:
         return []
 
     def method_signature_and_response_type_annotation(self, builder) -> str:
-        method_signature = self._method_signature(builder)
         response_type_annotation = self._response_type_annotation(builder)
+        # want pre-wrapped response type. As long as it's None, pylint will get mad about inconsistent return types
+        method_signature = self._method_signature(builder, response_type_annotation)
         for wrapper in self._response_type_annotation_wrapper(builder)[::-1]:
             response_type_annotation = f"{wrapper}[{response_type_annotation}]"
         return self._method_signature_and_response_type_annotation_template(method_signature, response_type_annotation)
@@ -402,7 +402,7 @@ class _BuilderBaseSerializer(_BuilderSerializerProtocol):  # pylint: disable=abs
     def _serialize_parameter(
         self, param: Parameter, function_name: str
     ) -> List[str]:
-        set_parameter = "{}_parameters['{}'] = {}".format(
+        set_parameter = "_{}_parameters['{}'] = {}".format(
             function_name,
             param.rest_api_name,
             utils.build_serialize_data_call(param, function_name, self.serializer_name)
@@ -499,11 +499,11 @@ class _RequestBuilderBaseSerializer(_BuilderBaseSerializer):  # pylint: disable=
     def create_http_request(self, builder) -> List[str]:
         retval = ["return HttpRequest("]
         retval.append(f'    method="{builder.method}",')
-        retval.append("    url=url,")
+        retval.append("    url=_url,")
         if builder.parameters.query:
-            retval.append("    params=query_parameters,")
+            retval.append("    params=_query_parameters,")
         if builder.parameters.headers:
-            retval.append("    headers=header_parameters,")
+            retval.append("    headers=_header_parameters,")
         if builder.parameters.has_body:
             retval.extend([
                 f"    {body_kwarg}={body_kwarg},"
@@ -533,6 +533,13 @@ class _RequestBuilderBaseSerializer(_BuilderBaseSerializer):  # pylint: disable=
             ))
         return retval
 
+    def construct_url(self, builder) -> str:
+        if any(o for o in ["low_level_client", "version_tolerant"] if self.code_model.options.get(o)):
+            url_value = _escape_str(builder.url)
+        else:
+            url_value = f'kwargs.pop("template_url", {_escape_str(builder.url)})'
+        return f"_url = {url_value}{'  # pylint: disable=line-too-long' if len(url_value) > 114 else ''}"
+
 class RequestBuilderGenericSerializer(_RequestBuilderBaseSerializer):
     @property
     def _want_inline_type_hints(self) -> bool:
@@ -711,7 +718,7 @@ class _OperationBaseSerializer(_BuilderBaseSerializer):  # pylint: disable=abstr
         )
         ser_ctxt_name = "serialization_ctxt"
         ser_ctxt = builder.parameters.body[0].xml_serialization_ctxt if send_xml else None
-        if ser_ctxt:
+        if ser_ctxt and self.code_model.options["models_mode"]:
             retval.append(f'{ser_ctxt_name} = {{"xml": {{{ser_ctxt}}}}}')
         serialize_body_call = self._serialize_body_call(
             builder,
@@ -986,7 +993,8 @@ class _OperationBaseSerializer(_BuilderBaseSerializer):  # pylint: disable=abstr
 
     @staticmethod
     def get_metadata_url(builder) -> str:
-        return f"{builder.python_name}.metadata = {{'url': '{ builder.request_builder.url }'}}  # type: ignore"
+        url = _escape_str(builder.request_builder.url)
+        return f"{builder.python_name}.metadata = {{'url': { url }}}  # type: ignore"
 
 class _SyncOperationBaseSerializer(_OperationBaseSerializer):  # pylint: disable=abstract-method
     @property
@@ -1114,7 +1122,7 @@ class _PagingOperationBaseSerializer(_OperationBaseSerializer):  # pylint: disab
         deserialized = (
             f'self._deserialize("{response.serialization_type}", pipeline_response)'
             if self.code_model.options["models_mode"] else
-            "_loads(pipeline_response.http_response.body())"
+            "pipeline_response.http_response.json()"
         )
         retval.append(f"    deserialized = {deserialized}")
         item_name = builder.item_name(self.code_model)
@@ -1137,10 +1145,11 @@ class _PagingOperationBaseSerializer(_OperationBaseSerializer):  # pylint: disab
         retval = [f"{self._def} get_next(next_link=None):"]
         retval.append("    request = prepare_request(next_link)")
         retval.append("")
-        retval.append(
-            f"    pipeline_response = {self._call_method}self._client._pipeline.run(request, "
-            f"stream={builder.is_stream_response}, **kwargs)"
-        )
+        retval.append(f"    pipeline_response = {self._call_method}self._client._pipeline.run(  # pylint: disable=protected-access")
+        retval.append("        request,")
+        retval.append(f"        stream={builder.is_stream_response},")
+        retval.append("        **kwargs")
+        retval.append("    )")
         retval.append("    response = pipeline_response.http_response")
         retval.append("")
         retval.extend([
@@ -1234,7 +1243,7 @@ class _LROOperationBaseSerializer(_OperationBaseSerializer):  # pylint: disable=
             "Pass in False for this operation to not poll, or pass in your own initialized polling object for a"
             " personal polling strategy."
         )
-        retval.append(f":paramtype polling: bool or ~{self._polling_method_type}")
+        retval.append(f":paramtype polling: bool or ~azure.core.polling.{self._polling_method_type}")
         retval.append(
             ":keyword int polling_interval: Default waiting time between two polls for LRO operations "
             "if no Retry-After header is present."
@@ -1287,9 +1296,8 @@ class _LROOperationBaseSerializer(_OperationBaseSerializer):  # pylint: disable=
         retval.append("        client=self._client,")
         retval.append("        deserialization_callback=get_long_running_output")
         retval.append("    )")
-        retval.append("else:")
         retval.append(
-            f"    return {self._poller(builder)}"
+            f"return {self._poller(builder)}"
             "(self._client, raw_result, get_long_running_output, polling_method)"
         )
         return retval
@@ -1335,7 +1343,7 @@ class _SyncLROOperationBaseSerializer(_LROOperationBaseSerializer, _SyncOperatio
 
     @property
     def _polling_method_type(self):
-        return "azure.core.polling.PollingMethod"
+        return "PollingMethod"
 
     def _poller(self, builder) -> str:
         return builder.get_poller(async_mode=False)
@@ -1368,7 +1376,7 @@ class AsyncLROOperationSerializer(_LROOperationBaseSerializer, AsyncOperationSer
 
     @property
     def _polling_method_type(self):
-        return "azure.core.polling.AsyncPollingMethod"
+        return "AsyncPollingMethod"
 
     def _poller(self, builder) -> str:
         return builder.get_poller(async_mode=True)
@@ -1383,8 +1391,7 @@ class _LROPagingOperationBaseSerializer(_LROOperationBaseSerializer, _PagingOper
         retval.append(f"    {self._def} internal_get_next(next_link=None):")
         retval.append("        if next_link is None:")
         retval.append("            return pipeline_response")
-        retval.append("        else:")
-        retval.append(f"            return {self._call_method}get_next(next_link)")
+        retval.append(f"        return {self._call_method}get_next(next_link)")
         retval.append("")
         retval.append(f"    return {self._pager(builder)}(")
         retval.append("        internal_get_next, extract_data")

package/autorest/codegen/serializers/client_serializer.py

@@ -44,9 +44,12 @@ class ClientSerializer:
             base_class = f"{class_name}OperationsMixin"
         elif not (async_mode or self.is_python3_file):
             base_class = "object"
+        disable = ""
+        if len(self.code_model.operation_groups) > 6:
+            disable = "    # pylint: disable=too-many-instance-attributes"
         if base_class:
-            return f"class {class_name}({base_class}):"
-        return f"class {class_name}:"
+            return f"class {class_name}({base_class}):{disable}"
+        return f"class {class_name}:{disable}"
 
     def property_descriptions(self, async_mode: bool) -> List[str]:
         retval: List[str] = []
@@ -113,7 +116,7 @@ class ClientSerializer:
             method_name=self.code_model.send_request_name,
             is_in_class=True,
             method_param_signatures=self.code_model.service_client.send_request_signature(
-                async_mode, async_mode or self.is_python3_file
+                async_mode or self.is_python3_file
             ),
         )
 
@@ -227,3 +230,11 @@ class ConfigSerializer:
             for p in self.code_model.global_parameters.config_method
             if p.required and not p.constant
         ]
+
+    def property_descriptions(self) -> List[str]:
+        retval: List[str] = []
+        for p in self.code_model.global_parameters.config_method:
+            retval.append(f":{p.description_keyword} {p.serialized_name}: {p.description}")
+            retval.append(f":{p.docstring_type_keyword} {p.serialized_name}: {p.docstring_type}")
+        retval.append('"""')
+        return retval

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()