拆分SQLAlchemy模型文件时，如何用类型注解避免循环导入？

当把Parent和Child模型拆分到不同文件时，互相引用会导致循环导入问题，以下几种方法可以在保留类型注解和原有功能的前提下解决这个问题：

方法一：利用字符串类型注解（配合from __future__ import annotations） #

借助Python的from __future__ import annotations导入，类型注解会以字符串形式保留，运行时才会解析，无需在导入阶段直接引用对方类。

parent.py：

from __future__ import annotations
from sqlalchemy import String
from sqlalchemy.orm import Mapped, mapped_column, relationship
from base import Base

class Parent(Base):
    __tablename__ = "parent"
    id: Mapped[str] = mapped_column(String, primary_key=True)
    children: Mapped[list["Child"]] = relationship("Child", back_populates="parent")

child.py：

from __future__ import annotations
from typing import Optional
from sqlalchemy import String, ForeignKey
from sqlalchemy.orm import Mapped, mapped_column, relationship
from base import Base

class Child(Base):
    __tablename__ = "child"
    id: Mapped[str] = mapped_column(String, primary_key=True)
    parent_id: Mapped[Optional[str]] = mapped_column(
        String, 
        ForeignKey("parent.id", name="parent_id_fk", ondelete="CASCADE"),  
        nullable=True, 
        default=None
    )
    parent: Mapped["Parent"] = relationship("Parent", back_populates="children")

说明：relationship参数本身就支持传入类名字符串，而字符串形式的类型注解配合future导入，会跳过导入时的类型解析，彻底避免循环导入。

方法二：使用TYPE_CHECKING条件导入 #

如果需要编辑器和类型检查工具（如mypy）提供准确的类型提示，可以利用typing.TYPE_CHECKING常量，仅在类型检查阶段导入对方类，运行时不执行导入操作。

parent.py：

from __future__ import annotations
from typing import TYPE_CHECKING
from sqlalchemy import String
from sqlalchemy.orm import Mapped, mapped_column, relationship
from base import Base

if TYPE_CHECKING:
    from child import Child

class Parent(Base):
    __tablename__ = "parent"
    id: Mapped[str] = mapped_column(String, primary_key=True)
    children: Mapped[list[Child]] = relationship("Child", back_populates="parent")

child.py：

from __future__ import annotations
from typing import TYPE_CHECKING, Optional
from sqlalchemy import String, ForeignKey
from sqlalchemy.orm import Mapped, mapped_column, relationship
from base import Base

if TYPE_CHECKING:
    from parent import Parent

class Child(Base):
    __tablename__ = "child"
    id: Mapped[str] = mapped_column(String, primary_key=True)
    parent_id: Mapped[Optional[str]] = mapped_column(
        String, 
        ForeignKey("parent.id", name="parent_id_fk", ondelete="CASCADE"),  
        nullable=True, 
        default=None
    )
    parent: Mapped[Parent] = relationship("Parent", back_populates="children")

说明：TYPE_CHECKING在Python运行时的值为False，所以条件分支里的导入不会执行；而类型检查工具会将其视为True，从而提供正确的类型提示，兼顾运行时无循环和开发时的类型友好。

方法三：统一在__init__.py导入所有模型 #

创建一个包含所有模型的包，在包的__init__.py中导入全部模型，然后在各个模型文件中从包自身引用所需类，利用Python模块的加载机制解决循环引用。

models/init.py：

from .parent import Parent
from .child import Child

models/parent.py：

from __future__ import annotations
from sqlalchemy import String
from sqlalchemy.orm import Mapped, mapped_column, relationship
from base import Base
from . import Child

class Parent(Base):
    __tablename__ = "parent"
    id: Mapped[str] = mapped_column(String, primary_key=True)
    children: Mapped[list[Child]] = relationship("Child", back_populates="parent")

models/child.py：

from __future__ import annotations
from typing import Optional
from sqlalchemy import String, ForeignKey
from sqlalchemy.orm import Mapped, mapped_column, relationship
from base import Base
from . import Parent

class Child(Base):
    __tablename__ = "child"
    id: Mapped[str] = mapped_column(String, primary_key=True)
    parent_id: Mapped[Optional[str]] = mapped_column(
        String, 
        ForeignKey("parent.id", name="parent_id_fk", ondelete="CASCADE"),  
        nullable=True, 
        default=None
    )
    parent: Mapped[Parent] = relationship("Parent", back_populates="children")

说明：当Python加载models包时，会先执行__init__.py导入所有模型，后续模型文件从包内引用时，目标类已经被加载，不会触发循环导入。

内容的提问来源于stack exchange，提问作者lorg