@typespec/http-client-python 0.4.4 → 0.5.0

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

@@ -0,0 +1,294 @@
+# -------------------------------------------------------------------------
+# 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,
+        )
+
+    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/build/lib/pygen/codegen/serializers/enum_serializer.py

@@ -0,0 +1,15 @@
+# -------------------------------------------------------------------------
+# 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/build/lib/pygen/codegen/serializers/general_serializer.py

@@ -0,0 +1,213 @@
+# -------------------------------------------------------------------------
+# 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/build/lib/pygen/codegen/serializers/import_serializer.py

@@ -0,0 +1,126 @@
+# -------------------------------------------------------------------------
+# 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"
+    )
+    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    "
+            typing_imports += "\n\n    ".join(_get_import_clauses(typing_imports_list, "\n    "))
+        return regular_imports + typing_imports + self.get_typing_definitions()