@azure-tools/typespec-python 0.33.0 → 0.34.0

package/generator/pygen/codegen/serializers/client_serializer.py

@@ -1,295 +0,0 @@
-# -------------------------------------------------------------------------
-# Copyright (c) Microsoft Corporation. All rights reserved.
-# Licensed under the MIT License. See License.txt in the project root for
-# license information.
-# --------------------------------------------------------------------------
-from typing import List
-
-from . import utils
-from ..models import Client, ParameterMethodLocation
-from .parameter_serializer import ParameterSerializer, PopKwargType
-from ...utils import build_policies
-
-
-class ClientSerializer:
-    def __init__(self, client: Client) -> None:
-        self.client = client
-        self.parameter_serializer = ParameterSerializer()
-
-    def _init_signature(self, async_mode: bool) -> str:
-        pylint_disable = ""
-        if not self.client.parameters.credential:
-            pylint_disable = "  # pylint: disable=missing-client-constructor-parameter-credential"
-        return self.parameter_serializer.serialize_method(
-            function_def="def",
-            method_name="__init__",
-            need_self_param=True,
-            method_param_signatures=self.client.parameters.method_signature(async_mode),
-            pylint_disable=pylint_disable,
-        )
-
-    def init_signature_and_response_type_annotation(self, async_mode: bool) -> str:
-        init_signature = self._init_signature(async_mode)
-        return utils.method_signature_and_response_type_annotation_template(
-            method_signature=init_signature,
-            response_type_annotation="None",
-        )
-
-    def pop_kwargs_from_signature(self) -> List[str]:
-        return self.parameter_serializer.pop_kwargs_from_signature(
-            self.client.parameters.kwargs_to_pop,
-            check_kwarg_dict=False,
-            pop_headers_kwarg=PopKwargType.NO,
-            pop_params_kwarg=PopKwargType.NO,
-        )
-
-    @property
-    def class_definition(self) -> str:
-        class_name = self.client.name
-        base_class = ""
-        if self.client.has_mixin:
-            base_class = f"{class_name}OperationsMixin"
-        pylint_disable = self.client.pylint_disable
-        if base_class:
-            return f"class {class_name}({base_class}):{pylint_disable}"
-        return f"class {class_name}:{pylint_disable}"
-
-    def property_descriptions(self, async_mode: bool) -> List[str]:
-        retval: List[str] = []
-        operations_folder = ".aio.operations." if async_mode else ".operations."
-        for og in [og for og in self.client.operation_groups if not og.is_mixin]:
-            retval.append(f":ivar {og.property_name}: {og.class_name} operations")
-            property_type = f"{self.client.code_model.namespace}{operations_folder}{og.class_name}"
-            retval.append(f":vartype {og.property_name}: {property_type}")
-        for param in self.client.parameters.method:
-            retval.append(f":{param.description_keyword} {param.client_name}: {param.description}")
-            retval.append(
-                f":{param.docstring_type_keyword} {param.client_name}: {param.docstring_type(async_mode=async_mode)}"
-            )
-        if self.client.has_public_lro_operations:
-            retval.append(
-                ":keyword int polling_interval: Default waiting time between two polls for LRO operations "
-                "if no Retry-After header is present."
-            )
-        retval = [s.replace("\\", "\\\\") for s in retval]
-        retval.append('"""')
-        return retval
-
-    def initialize_config(self) -> str:
-        config_name = f"{self.client.name}Configuration"
-        config_call = ", ".join(
-            [
-                f"{p.client_name}={p.client_name}"
-                for p in self.client.config.parameters.method
-                if p.method_location != ParameterMethodLocation.KWARG
-            ]
-            + ["**kwargs"]
-        )
-        return f"self._config = {config_name}({config_call})"
-
-    @property
-    def host_variable_name(self) -> str:
-        try:
-            return next(p for p in self.client.parameters if p.is_host).client_name
-        except StopIteration:
-            return "_endpoint"
-
-    @property
-    def should_init_super(self) -> bool:
-        return any(og for og in self.client.operation_groups if og.is_mixin and og.has_abstract_operations)
-
-    def initialize_pipeline_client(self, async_mode: bool) -> List[str]:
-        result = []
-        pipeline_client_name = self.client.pipeline_class(async_mode)
-        endpoint_name = "base_url" if self.client.code_model.is_azure_flavor else "endpoint"
-        params = {
-            endpoint_name: self.host_variable_name,
-            "policies": "_policies",
-        }
-        if not self.client.code_model.is_legacy and self.client.request_id_header_name:
-            result.append(f'kwargs["request_id_header_name"] = "{self.client.request_id_header_name}"')
-        policies = build_policies(
-            self.client.code_model.options["azure_arm"],
-            async_mode,
-            is_azure_flavor=self.client.code_model.is_azure_flavor,
-            tracing=self.client.code_model.options["tracing"],
-        )
-        result.extend(
-            [
-                "_policies = kwargs.pop('policies', None)",
-                "if _policies is None:",
-                f'    _policies = [{",".join(policies)}]',
-                f"self._client: {pipeline_client_name} = {pipeline_client_name}("
-                f"{', '.join(f'{k}={v}' for k, v in params.items())}, **kwargs)",
-            ]
-        )
-        return result
-
-    def serializers_and_operation_groups_properties(self) -> List[str]:
-        retval = []
-
-        def _get_client_models_value(models_dict_name: str) -> str:
-            if self.client.code_model.model_types:
-                return f"{{k: v for k, v in {models_dict_name}.__dict__.items() if isinstance(v, type)}}"
-            return "{}"
-
-        is_msrest_model = self.client.code_model.options["models_mode"] == "msrest"
-        if is_msrest_model:
-            add_private_models = len(self.client.code_model.model_types) != len(
-                self.client.code_model.public_model_types
-            )
-            model_dict_name = f"_models.{self.client.code_model.models_filename}" if add_private_models else "_models"
-            retval.append(
-                f"client_models{': Dict[str, Any]' if not self.client.code_model.model_types else ''}"
-                f" = {_get_client_models_value(model_dict_name)}"
-            )
-            if add_private_models and self.client.code_model.model_types:
-                update_dict = "{k: v for k, v in _models.__dict__.items() if isinstance(v, type)}"
-                retval.append(f"client_models.update({update_dict})")
-        client_models_str = "client_models" if is_msrest_model else ""
-        retval.append(f"self._serialize = Serializer({client_models_str})")
-        retval.append(f"self._deserialize = Deserializer({client_models_str})")
-        if not self.client.code_model.options["client_side_validation"]:
-            retval.append("self._serialize.client_side_validation = False")
-        operation_groups = [og for og in self.client.operation_groups if not og.is_mixin]
-        for og in operation_groups:
-            if og.code_model.options["multiapi"]:
-                api_version = f", '{og.api_versions[0]}'" if og.api_versions else ", None"
-            else:
-                api_version = ""
-            retval.extend(
-                [
-                    f"self.{og.property_name} = {og.class_name}(",
-                    f"    self._client, self._config, self._serialize, self._deserialize{api_version}",
-                    ")",
-                ]
-            )
-        return retval
-
-    def _send_request_signature(self) -> str:
-        send_request_signature = [
-            "request: HttpRequest, *, stream: bool = False,"
-        ] + self.client.parameters.method_signature_kwargs
-        return self.parameter_serializer.serialize_method(
-            function_def="def",
-            method_name=self.client.send_request_name,
-            need_self_param=True,
-            method_param_signatures=send_request_signature,
-        )
-
-    def send_request_signature_and_response_type_annotation(self, async_mode: bool) -> str:
-        send_request_signature = self._send_request_signature()
-        return utils.method_signature_and_response_type_annotation_template(
-            method_signature=send_request_signature,
-            response_type_annotation=("Awaitable[AsyncHttpResponse]" if async_mode else "HttpResponse"),
-        )
-
-    def _example_make_call(self, async_mode: bool) -> List[str]:
-        http_response = "AsyncHttpResponse" if async_mode else "HttpResponse"
-        retval = [f">>> response = {'await ' if async_mode else ''}client.{self.client.send_request_name}(request)"]
-        retval.append(f"<{http_response}: 200 OK>")
-        return retval
-
-    def _request_builder_example(self, async_mode: bool) -> List[str]:
-        retval = [
-            "We have helper methods to create requests specific to this service in "
-            + f"`{self.client.code_model.namespace}.{self.client.code_model.rest_layer_name}`."
-        ]
-        retval.append("Use these helper methods to create the request you pass to this method.")
-        retval.append("")
-
-        request_builder = self.client.request_builders[0]
-        request_builder_signature = ", ".join(request_builder.parameters.call)
-        if request_builder.group_name:
-            rest_imported = request_builder.group_name
-            request_builder_name = f"{request_builder.group_name}.{request_builder.name}"
-        else:
-            rest_imported = request_builder.name
-            request_builder_name = request_builder.name
-        full_path = f"{self.client.code_model.namespace}.{self.client.code_model.rest_layer_name}"
-        retval.append(f">>> from {full_path} import {rest_imported}")
-        retval.append(f">>> request = {request_builder_name}({request_builder_signature})")
-        retval.append(f"<HttpRequest [{request_builder.method}], url: '{request_builder.url}'>")
-        retval.extend(self._example_make_call(async_mode))
-        return retval
-
-    def _rest_request_example(self, async_mode: bool) -> List[str]:
-        retval = [f">>> from {self.client.code_model.core_library}.rest import HttpRequest"]
-        retval.append('>>> request = HttpRequest("GET", "https://www.example.org/")')
-        retval.append("<HttpRequest [GET], url: 'https://www.example.org/'>")
-        retval.extend(self._example_make_call(async_mode))
-        return retval
-
-    def send_request_description(self, async_mode: bool) -> List[str]:
-        rest_library = f"{self.client.code_model.core_library}.rest"
-        retval = ['"""Runs the network request through the client\'s chained policies.']
-        retval.append("")
-        if self.client.code_model.options["builders_visibility"] != "embedded":
-            retval.extend(self._request_builder_example(async_mode))
-        else:
-            retval.extend(self._rest_request_example(async_mode))
-        retval.append("")
-        retval.append("For more information on this code flow, see https://aka.ms/azsdk/dpcodegen/python/send_request")
-        retval.append("")
-        retval.append(":param request: The network request you want to make. Required.")
-        retval.append(f":type request: ~{rest_library}.HttpRequest")
-        retval.append(":keyword bool stream: Whether the response payload will be streamed. Defaults to False.")
-        retval.append(":return: The response of your network call. Does not do error handling on your response.")
-        http_response = "AsyncHttpResponse" if async_mode else "HttpResponse"
-        retval.append(f":rtype: ~{rest_library}.{http_response}")
-        retval.append('"""')
-        return retval
-
-    def serialize_path(self) -> List[str]:
-        return self.parameter_serializer.serialize_path(self.client.parameters.path, "self._serialize")
-
-
-class ConfigSerializer:
-    def __init__(self, client: Client) -> None:
-        self.client = client
-        self.parameter_serializer = ParameterSerializer()
-
-    def _init_signature(self, async_mode: bool) -> str:
-        return self.parameter_serializer.serialize_method(
-            function_def="def",
-            method_name="__init__",
-            need_self_param=True,
-            method_param_signatures=self.client.config.parameters.method_signature(async_mode),
-        )
-
-    def init_signature_and_response_type_annotation(self, async_mode: bool) -> str:
-        init_signature = self._init_signature(async_mode)
-        return utils.method_signature_and_response_type_annotation_template(
-            method_signature=init_signature,
-            response_type_annotation="None",
-        )
-
-    def pop_kwargs_from_signature(self) -> List[str]:
-        return self.parameter_serializer.pop_kwargs_from_signature(
-            self.client.config.parameters.kwargs_to_pop,
-            check_kwarg_dict=False,
-            pop_headers_kwarg=PopKwargType.NO,
-            pop_params_kwarg=PopKwargType.NO,
-        )
-
-    def set_constants(self) -> List[str]:
-        return [
-            f"self.{p.client_name} = {p.client_default_value_declaration}"
-            for p in self.client.config.parameters.constant
-            if p not in self.client.config.parameters.method
-        ]
-
-    def check_required_parameters(self) -> List[str]:
-        return [
-            f"if {p.client_name} is None:\n" f"    raise ValueError(\"Parameter '{p.client_name}' must not be None.\")"
-            for p in self.client.config.parameters.method
-            if not (p.optional or p.constant)
-        ]
-
-    def property_descriptions(self, async_mode: bool) -> List[str]:
-        retval: List[str] = []
-        for p in self.client.config.parameters.method:
-            retval.append(f":{p.description_keyword} {p.client_name}: {p.description}")
-            retval.append(f":{p.docstring_type_keyword} {p.client_name}: {p.docstring_type(async_mode=async_mode)}")
-        retval.append('"""')
-        return retval

package/generator/pygen/codegen/serializers/enum_serializer.py

@@ -1,15 +0,0 @@
-# -------------------------------------------------------------------------
-# Copyright (c) Microsoft Corporation. All rights reserved.
-# Licensed under the MIT License. See License.txt in the project root for
-# license information.
-# --------------------------------------------------------------------------
-
-from .base_serializer import BaseSerializer
-from ..models import FileImport
-
-
-class EnumSerializer(BaseSerializer):
-    def serialize(self) -> str:
-        # Generate the enum file
-        template = self.env.get_template("enum_container.py.jinja2")
-        return template.render(code_model=self.code_model, file_import=FileImport(self.code_model))

package/generator/pygen/codegen/serializers/general_serializer.py

@@ -1,213 +0,0 @@
-# -------------------------------------------------------------------------
-# Copyright (c) Microsoft Corporation. All rights reserved.
-# Licensed under the MIT License. See License.txt in the project root for
-# license information.
-# --------------------------------------------------------------------------
-import json
-from typing import Any, List
-from jinja2 import Environment
-from .import_serializer import FileImportSerializer, TypingSection
-from ..models.imports import MsrestImportType, FileImport
-from ..models import (
-    ImportType,
-    CodeModel,
-    TokenCredentialType,
-    Client,
-)
-from .client_serializer import ClientSerializer, ConfigSerializer
-from .base_serializer import BaseSerializer
-
-
-class GeneralSerializer(BaseSerializer):
-    """General serializer for SDK root level files"""
-
-    def __init__(self, code_model: CodeModel, env: Environment, async_mode: bool):
-        super().__init__(code_model, env)
-        self.async_mode = async_mode
-
-    def serialize_setup_file(self) -> str:
-        template = self.env.get_template("packaging_templates/setup.py.jinja2")
-        params = {}
-        params.update(self.code_model.options)
-        return template.render(code_model=self.code_model, **params)
-
-    def serialize_package_file(self, template_name: str, **kwargs: Any) -> str:
-        template = self.env.get_template(template_name)
-        package_parts = (self.code_model.options["package_name"] or "").split("-")[:-1]
-        token_credential = any(
-            c for c in self.code_model.clients if isinstance(getattr(c.credential, "type", None), TokenCredentialType)
-        )
-        version = self.code_model.options["package_version"]
-        if any(x in version for x in ["a", "b", "rc"]) or version[0] == "0":
-            dev_status = "4 - Beta"
-        else:
-            dev_status = "5 - Production/Stable"
-        params = {
-            "code_model": self.code_model,
-            "dev_status": dev_status,
-            "token_credential": token_credential,
-            "pkgutil_names": [".".join(package_parts[: i + 1]) for i in range(len(package_parts))],
-            "init_names": ["/".join(package_parts[: i + 1]) + "/__init__.py" for i in range(len(package_parts))],
-            "client_name": self.code_model.clients[0].name,
-            "namespace": self.code_model.namespace,
-        }
-        params.update(self.code_model.options)
-        params.update(kwargs)
-        return template.render(file_import=FileImport(self.code_model), **params)
-
-    def serialize_pkgutil_init_file(self) -> str:
-        template = self.env.get_template("pkgutil_init.py.jinja2")
-        return template.render()
-
-    def serialize_init_file(self, clients: List[Client]) -> str:
-        template = self.env.get_template("init.py.jinja2")
-        return template.render(
-            code_model=self.code_model,
-            clients=clients,
-            async_mode=self.async_mode,
-        )
-
-    def serialize_service_client_file(self, clients: List[Client]) -> str:
-        template = self.env.get_template("client_container.py.jinja2")
-
-        imports = FileImport(self.code_model)
-        for client in clients:
-            imports.merge(client.imports(self.async_mode))
-
-        return template.render(
-            code_model=self.code_model,
-            clients=clients,
-            async_mode=self.async_mode,
-            get_serializer=ClientSerializer,
-            imports=FileImportSerializer(imports),
-        )
-
-    def serialize_vendor_file(self, clients: List[Client]) -> str:
-        template = self.env.get_template("vendor.py.jinja2")
-
-        # configure imports
-        file_import = FileImport(self.code_model)
-        if self.code_model.need_mixin_abc:
-            file_import.add_submodule_import(
-                "abc",
-                "ABC",
-                ImportType.STDLIB,
-            )
-            file_import.add_submodule_import(
-                "" if self.code_model.is_azure_flavor else "runtime",
-                f"{'Async' if self.async_mode else ''}PipelineClient",
-                ImportType.SDKCORE,
-                TypingSection.TYPING,
-            )
-            file_import.add_msrest_import(
-                relative_path=".." if self.async_mode else ".",
-                msrest_import_type=MsrestImportType.SerializerDeserializer,
-                typing_section=TypingSection.TYPING,
-            )
-            for client in clients:
-                if client.has_mixin:
-                    file_import.add_submodule_import(
-                        "._configuration",
-                        f"{client.name}Configuration",
-                        ImportType.LOCAL,
-                    )
-        if self.code_model.has_etag:
-            file_import.add_submodule_import("typing", "Optional", ImportType.STDLIB)
-            file_import.add_submodule_import(
-                "",
-                "MatchConditions",
-                ImportType.SDKCORE,
-            )
-        if self.code_model.has_form_data and self.code_model.options["models_mode"] == "dpg" and not self.async_mode:
-            file_import.add_submodule_import("typing", "IO", ImportType.STDLIB)
-            file_import.add_submodule_import("typing", "Tuple", ImportType.STDLIB)
-            file_import.add_submodule_import("typing", "Union", ImportType.STDLIB)
-            file_import.add_submodule_import("typing", "Optional", ImportType.STDLIB)
-            file_import.add_submodule_import("typing", "Mapping", ImportType.STDLIB)
-            file_import.add_submodule_import("typing", "Dict", ImportType.STDLIB)
-            file_import.add_submodule_import("typing", "Any", ImportType.STDLIB)
-            file_import.add_submodule_import("typing", "List", ImportType.STDLIB)
-            file_import.add_submodule_import(
-                "._model_base",
-                "SdkJSONEncoder",
-                ImportType.LOCAL,
-            )
-            file_import.add_submodule_import(
-                "._model_base",
-                "Model",
-                ImportType.LOCAL,
-            )
-            file_import.add_import("json", ImportType.STDLIB)
-
-        return template.render(
-            code_model=self.code_model,
-            imports=FileImportSerializer(
-                file_import,
-            ),
-            async_mode=self.async_mode,
-            clients=clients,
-        )
-
-    def serialize_config_file(self, clients: List[Client]) -> str:
-        template = self.env.get_template("config_container.py.jinja2")
-        imports = FileImport(self.code_model)
-        for client in self.code_model.clients:
-            imports.merge(client.config.imports(self.async_mode))
-        return template.render(
-            code_model=self.code_model,
-            async_mode=self.async_mode,
-            imports=FileImportSerializer(imports),
-            get_serializer=ConfigSerializer,
-            clients=clients,
-        )
-
-    def serialize_version_file(self) -> str:
-        template = self.env.get_template("version.py.jinja2")
-        return template.render(code_model=self.code_model)
-
-    def serialize_serialization_file(self) -> str:
-        template = self.env.get_template("serialization.py.jinja2")
-        return template.render(
-            code_model=self.code_model,
-        )
-
-    def serialize_model_base_file(self) -> str:
-        template = self.env.get_template("model_base.py.jinja2")
-        return template.render(code_model=self.code_model, file_import=FileImport(self.code_model))
-
-    def serialize_validation_file(self) -> str:
-        template = self.env.get_template("validation.py.jinja2")
-        return template.render(code_model=self.code_model)
-
-    def serialize_cross_language_definition_file(self) -> str:
-        cross_langauge_def_dict = {
-            f"{self.code_model.namespace}.models.{model.name}": model.cross_language_definition_id
-            for model in self.code_model.public_model_types
-        }
-        cross_langauge_def_dict.update(
-            {
-                f"{self.code_model.namespace}.models.{enum.name}": enum.cross_language_definition_id
-                for enum in self.code_model.enums
-                if not enum.internal
-            }
-        )
-        cross_langauge_def_dict.update(
-            {
-                (
-                    f"{self.code_model.namespace}.{client.name}."
-                    + ("" if operation_group.is_mixin else f"{operation_group.property_name}.")
-                    + f"{operation.name}"
-                ): operation.cross_language_definition_id
-                for client in self.code_model.clients
-                for operation_group in client.operation_groups
-                for operation in operation_group.operations
-                if not operation.name.startswith("_")
-            }
-        )
-        return json.dumps(
-            {
-                "CrossLanguagePackageId": self.code_model.cross_language_package_id,
-                "CrossLanguageDefinitionId": cross_langauge_def_dict,
-            },
-            indent=4,
-        )

package/generator/pygen/codegen/serializers/import_serializer.py

@@ -1,127 +0,0 @@
-# -------------------------------------------------------------------------
-# Copyright (c) Microsoft Corporation. All rights reserved.
-# Licensed under the MIT License. See License.txt in the project root for
-# license information.
-# --------------------------------------------------------------------------
-from copy import deepcopy
-from typing import List
-from ..models.imports import (
-    ImportType,
-    FileImport,
-    ImportModel,
-    TypingSection,
-    TypeDefinition,
-)
-
-
-def _serialize_package(imports: List[ImportModel], delimiter: str) -> str:
-    buffer = []
-    if any(i for i in imports if i.submodule_name is None):
-        buffer.append(f"import {imports[0].module_name}{f' as {imports[0].alias}' if imports[0].alias else ''}")
-    else:
-        import_str = ", ".join(
-            sorted(
-                set(
-                    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_versioned_package(i: ImportModel, delimiter: str) -> str:
-    if not i.version_modules:
-        return ""
-    buffer = []
-    for n, (version, module_name, comment) in enumerate(i.version_modules):
-        buffer.append("{} sys.version_info >= {}:".format("if" if n == 0 else "elif", version))
-        buffer.append(
-            f"    from {module_name} import {i.submodule_name}{f' as {i.alias}' if i.alias else ''}"
-            f"{f' # {comment}' if comment else ''}"
-        )
-    buffer.append("else:")
-    buffer.append(
-        f"    from {i.module_name} import {i.submodule_name}{f' as {i.alias}' if i.alias else ''}"
-        "  # type: ignore  # pylint: disable=ungrouped-imports"
-    )
-    return delimiter.join(buffer)
-
-
-def _serialize_import_type(imports: List[ImportModel], delimiter: str) -> str:
-    """Serialize a given import type."""
-    import_list = []
-    for module_name in sorted(set(i.module_name for i in imports)):
-        normal_imports = [i for i in imports if i.module_name == module_name and not i.version_modules]
-        versioned_imports = [i for i in imports if i.module_name == module_name and i.version_modules]
-        if normal_imports:
-            import_list.append(_serialize_package(normal_imports, delimiter))
-        for i in versioned_imports:
-            import_list.append(_serialize_versioned_package(i, delimiter))
-    return delimiter.join(import_list)
-
-
-def _get_import_clauses(imports: List[ImportModel], delimiter: str) -> List[str]:
-    import_clause = []
-    for import_type in ImportType:
-        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, async_mode: bool = False) -> None:
-        self.file_import = file_import
-        self.async_mode = async_mode
-
-    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 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
-            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 any(self.file_import.get_imports_from_section(TypingSection.TYPING)):
-            self.file_import.add_submodule_import("typing", "TYPE_CHECKING", ImportType.STDLIB)
-
-    def get_typing_definitions(self) -> str:
-        def declare_definition(type_name: str, type_definition: TypeDefinition) -> List[str]:
-            ret: List[str] = []
-            definition_value = type_definition.async_definition if self.async_mode else type_definition.sync_definition
-            ret.append("{} = {}".format(type_name, definition_value))
-            return ret
-
-        if not self.file_import.type_definitions:
-            return ""
-        declarations: List[str] = [""]
-        for type_name, value in self.file_import.type_definitions.items():
-            declarations.extend(declare_definition(type_name, value))
-        return "\n".join(declarations)
-
-    def __str__(self) -> str:
-        self._add_type_checking_import()
-        regular_imports = ""
-        regular_imports_list = self._get_imports_list(
-            baseline_typing_section=TypingSection.REGULAR,
-            add_conditional_typing=True,
-        )
-
-        if regular_imports_list:
-            regular_imports = "\n\n".join(_get_import_clauses(regular_imports_list, "\n"))
-
-        typing_imports = ""
-        typing_imports_list = self._get_imports_list(
-            baseline_typing_section=TypingSection.TYPING,
-            add_conditional_typing=False,
-        )
-        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_list, "\n    "))
-        return regular_imports + typing_imports + self.get_typing_definitions()