slidge 0.2.0a10__py3-none-any.whl → 0.2.0b1__py3-none-any.whl

slidge/core/mixins/message.py

@@ -1,23 +1,15 @@
 import logging
 import uuid
 import warnings
-from datetime import datetime
-from typing import TYPE_CHECKING, Iterable, Optional
+from typing import TYPE_CHECKING, Optional
 
 from slixmpp import Iq, Message
 
 from ...slixfix.xep_0490.mds import PUBLISH_OPTIONS
-from ...util.types import (
-    ChatState,
-    LegacyMessageType,
-    LegacyThreadType,
-    LinkPreview,
-    Marker,
-    MessageReference,
-    ProcessingHint,
-)
+from ...util.types import ChatState, LegacyMessageType, Marker
 from .attachment import AttachmentMixin
 from .message_maker import MessageMaker
+from .message_text import TextMessageMixin
 
 if TYPE_CHECKING:
     from ...group import LegacyMUC
@@ -158,200 +150,8 @@ class MarkerMixin(MessageMaker):
             self.session.log.debug("Could not MDS mark", exc_info=e)
 
 
-class ContentMessageMixin(AttachmentMixin):
-    def __default_hints(self, hints: Optional[Iterable[ProcessingHint]] = None):
-        if hints is not None:
-            return hints
-        elif self.mtype == "chat":
-            return {"markable", "store"}
-        elif self.mtype == "groupchat":
-            return {"markable"}
-
-    def __replace_id(self, legacy_msg_id: LegacyMessageType):
-        if self.mtype == "groupchat":
-            return self.xmpp.store.sent.get_group_xmpp_id(
-                self.session.user_pk, str(legacy_msg_id)
-            ) or self._legacy_to_xmpp(legacy_msg_id)
-        else:
-            return self._legacy_to_xmpp(legacy_msg_id)
-
-    def send_text(
-        self,
-        body: str,
-        legacy_msg_id: Optional[LegacyMessageType] = None,
-        *,
-        when: Optional[datetime] = None,
-        reply_to: Optional[MessageReference] = None,
-        thread: Optional[LegacyThreadType] = None,
-        hints: Optional[Iterable[ProcessingHint]] = None,
-        carbon=False,
-        archive_only=False,
-        correction=False,
-        correction_event_id: Optional[LegacyMessageType] = None,
-        link_previews: Optional[list[LinkPreview]] = None,
-        **send_kwargs,
-    ):
-        """
-        Send a text message from this :term:`XMPP Entity`.
-
-        :param body: Content of the message
-        :param legacy_msg_id: If you want to be able to transport read markers from the gateway
-            user to the legacy network, specify this
-        :param when: when the message was sent, for a "delay" tag (:xep:`0203`)
-        :param reply_to: Quote another message (:xep:`0461`)
-        :param hints:
-        :param thread:
-        :param carbon: (only used if called on a :class:`LegacyContact`)
-            Set this to ``True`` if this is actually a message sent **to** the
-            :class:`LegacyContact` by the :term:`User`.
-            Use this to synchronize outgoing history for legacy official apps.
-        :param correction: whether this message is a correction or not
-        :param correction_event_id: in the case where an ID is associated with the legacy
-            'correction event', specify it here to use it on the XMPP side. If not specified,
-            a random ID will be used.
-        :param link_previews: A little of sender (or server, or gateway)-generated
-            previews of URLs linked in the body.
-        :param archive_only: (only in groups) Do not send this message to user,
-            but store it in the archive. Meant to be used during ``MUC.backfill()``
-        """
-        if carbon and not hasattr(self, "muc"):
-            if not correction and self.xmpp.store.sent.was_sent_by_user(
-                self.session.user_pk, str(legacy_msg_id)
-            ):
-                log.warning(
-                    "Carbon message for a message an XMPP has sent? This is a bug! %s",
-                    legacy_msg_id,
-                )
-                return
-            if hasattr(self, "muc") and not self.is_user:  # type:ignore
-                log.warning(
-                    "send_text() called with carbon=True on a participant who is not the user",
-                    legacy_msg_id,
-                )
-            self.xmpp.store.sent.set_message(
-                self.session.user_pk,
-                str(legacy_msg_id),
-                self.session.legacy_to_xmpp_msg_id(legacy_msg_id),
-            )
-        hints = self.__default_hints(hints)
-        msg = self._make_message(
-            mbody=body,
-            legacy_msg_id=correction_event_id if correction else legacy_msg_id,
-            when=when,
-            reply_to=reply_to,
-            hints=hints or (),
-            carbon=carbon,
-            thread=thread,
-            link_previews=link_previews,
-        )
-        if correction:
-            msg["replace"]["id"] = self.__replace_id(legacy_msg_id)
-        return self._send(
-            msg,
-            archive_only=archive_only,
-            carbon=carbon,
-            legacy_msg_id=legacy_msg_id,
-            **send_kwargs,
-        )
-
-    def correct(
-        self,
-        legacy_msg_id: LegacyMessageType,
-        new_text: str,
-        *,
-        when: Optional[datetime] = None,
-        reply_to: Optional[MessageReference] = None,
-        thread: Optional[LegacyThreadType] = None,
-        hints: Optional[Iterable[ProcessingHint]] = None,
-        carbon=False,
-        archive_only=False,
-        correction_event_id: Optional[LegacyMessageType] = None,
-        link_previews: Optional[list[LinkPreview]] = None,
-        **send_kwargs,
-    ):
-        """
-        Modify a message that was previously sent by this :term:`XMPP Entity`.
-
-        Uses last message correction (:xep:`0308`)
-
-        :param new_text: New content of the message
-        :param legacy_msg_id: The legacy message ID of the message to correct
-        :param when: when the message was sent, for a "delay" tag (:xep:`0203`)
-        :param reply_to: Quote another message (:xep:`0461`)
-        :param hints:
-        :param thread:
-        :param carbon: (only in 1:1) Reflect a message sent to this ``Contact`` by the user.
-            Use this to synchronize outgoing history for legacy official apps.
-        :param archive_only: (only in groups) Do not send this message to user,
-            but store it in the archive. Meant to be used during ``MUC.backfill()``
-        :param correction_event_id: in the case where an ID is associated with the legacy
-            'correction event', specify it here to use it on the XMPP side. If not specified,
-            a random ID will be used.
-        :param link_previews: A little of sender (or server, or gateway)-generated
-            previews of URLs linked in the body.
-        """
-        self.send_text(
-            new_text,
-            legacy_msg_id,
-            when=when,
-            reply_to=reply_to,
-            hints=hints,
-            carbon=carbon,
-            thread=thread,
-            correction=True,
-            archive_only=archive_only,
-            correction_event_id=correction_event_id,
-            link_previews=link_previews,
-            **send_kwargs,
-        )
-
-    def react(
-        self,
-        legacy_msg_id: LegacyMessageType,
-        emojis: Iterable[str] = (),
-        thread: Optional[LegacyThreadType] = None,
-        **kwargs,
-    ):
-        """
-        Send a reaction (:xep:`0444`) from this :term:`XMPP Entity`.
-
-        :param legacy_msg_id: The message which the reaction refers to.
-        :param emojis: An iterable of emojis used as reactions
-        :param thread:
-        """
-        msg = self._make_message(
-            hints={"store"}, carbon=kwargs.get("carbon"), thread=thread
-        )
-        xmpp_id = kwargs.pop("xmpp_id", None)
-        if not xmpp_id:
-            xmpp_id = self._legacy_to_xmpp(legacy_msg_id)
-        self.xmpp["xep_0444"].set_reactions(msg, to_id=xmpp_id, reactions=emojis)
-        self._send(msg, **kwargs)
-
-    def retract(
-        self,
-        legacy_msg_id: LegacyMessageType,
-        thread: Optional[LegacyThreadType] = None,
-        **kwargs,
-    ):
-        """
-        Send a message retraction (:XEP:`0424`) from this :term:`XMPP Entity`.
-
-        :param legacy_msg_id: Legacy ID of the message to delete
-        :param thread:
-        """
-        msg = self._make_message(
-            state=None,
-            hints={"store"},
-            mbody=f"/me retracted the message {legacy_msg_id}",
-            carbon=kwargs.get("carbon"),
-            thread=thread,
-        )
-        msg.enable("fallback")
-        # namespace version mismatch between slidge and slixmpp, update me later
-        msg["fallback"]["for"] = self.xmpp["xep_0424"].namespace[:-1] + "1"
-        msg["retract"]["id"] = msg["replace"]["id"] = self.__replace_id(legacy_msg_id)
-        self._send(msg, **kwargs)
+class ContentMessageMixin(AttachmentMixin, TextMessageMixin):
+    pass
 
 
 class CarbonMessageMixin(ContentMessageMixin, MarkerMixin):

slidge/core/mixins/message_text.py

@@ -0,0 +1,211 @@
+import logging
+from datetime import datetime
+from typing import Iterable, Optional
+
+from ...util.types import (
+    LegacyMessageType,
+    LegacyThreadType,
+    LinkPreview,
+    MessageReference,
+    ProcessingHint,
+)
+from .message_maker import MessageMaker
+
+
+class TextMessageMixin(MessageMaker):
+    def __default_hints(self, hints: Optional[Iterable[ProcessingHint]] = None):
+        if hints is not None:
+            return hints
+        elif self.mtype == "chat":
+            return {"markable", "store"}
+        elif self.mtype == "groupchat":
+            return {"markable"}
+
+    def _replace_id(self, legacy_msg_id: LegacyMessageType):
+        if self.mtype == "groupchat":
+            return self.xmpp.store.sent.get_group_xmpp_id(
+                self.session.user_pk, str(legacy_msg_id)
+            ) or self._legacy_to_xmpp(legacy_msg_id)
+        else:
+            return self._legacy_to_xmpp(legacy_msg_id)
+
+    def send_text(
+        self,
+        body: str,
+        legacy_msg_id: Optional[LegacyMessageType] = None,
+        *,
+        when: Optional[datetime] = None,
+        reply_to: Optional[MessageReference] = None,
+        thread: Optional[LegacyThreadType] = None,
+        hints: Optional[Iterable[ProcessingHint]] = None,
+        carbon=False,
+        archive_only=False,
+        correction=False,
+        correction_event_id: Optional[LegacyMessageType] = None,
+        link_previews: Optional[list[LinkPreview]] = None,
+        **send_kwargs,
+    ):
+        """
+        Send a text message from this :term:`XMPP Entity`.
+
+        :param body: Content of the message
+        :param legacy_msg_id: If you want to be able to transport read markers from the gateway
+            user to the legacy network, specify this
+        :param when: when the message was sent, for a "delay" tag (:xep:`0203`)
+        :param reply_to: Quote another message (:xep:`0461`)
+        :param hints:
+        :param thread:
+        :param carbon: (only used if called on a :class:`LegacyContact`)
+            Set this to ``True`` if this is actually a message sent **to** the
+            :class:`LegacyContact` by the :term:`User`.
+            Use this to synchronize outgoing history for legacy official apps.
+        :param correction: whether this message is a correction or not
+        :param correction_event_id: in the case where an ID is associated with the legacy
+            'correction event', specify it here to use it on the XMPP side. If not specified,
+            a random ID will be used.
+        :param link_previews: A little of sender (or server, or gateway)-generated
+            previews of URLs linked in the body.
+        :param archive_only: (only in groups) Do not send this message to user,
+            but store it in the archive. Meant to be used during ``MUC.backfill()``
+        """
+        if carbon and not hasattr(self, "muc"):
+            if not correction and self.xmpp.store.sent.was_sent_by_user(
+                self.session.user_pk, str(legacy_msg_id)
+            ):
+                log.warning(
+                    "Carbon message for a message an XMPP has sent? This is a bug! %s",
+                    legacy_msg_id,
+                )
+                return
+            if hasattr(self, "muc") and not self.is_user:  # type:ignore
+                log.warning(
+                    "send_text() called with carbon=True on a participant who is not the user",
+                    legacy_msg_id,
+                )
+            self.xmpp.store.sent.set_message(
+                self.session.user_pk,
+                str(legacy_msg_id),
+                self.session.legacy_to_xmpp_msg_id(legacy_msg_id),
+            )
+        hints = self.__default_hints(hints)
+        msg = self._make_message(
+            mbody=body,
+            legacy_msg_id=correction_event_id if correction else legacy_msg_id,
+            when=when,
+            reply_to=reply_to,
+            hints=hints or (),
+            carbon=carbon,
+            thread=thread,
+            link_previews=link_previews,
+        )
+        if correction:
+            msg["replace"]["id"] = self._replace_id(legacy_msg_id)
+        return self._send(
+            msg,
+            archive_only=archive_only,
+            carbon=carbon,
+            legacy_msg_id=legacy_msg_id,
+            **send_kwargs,
+        )
+
+    def correct(
+        self,
+        legacy_msg_id: LegacyMessageType,
+        new_text: str,
+        *,
+        when: Optional[datetime] = None,
+        reply_to: Optional[MessageReference] = None,
+        thread: Optional[LegacyThreadType] = None,
+        hints: Optional[Iterable[ProcessingHint]] = None,
+        carbon=False,
+        archive_only=False,
+        correction_event_id: Optional[LegacyMessageType] = None,
+        link_previews: Optional[list[LinkPreview]] = None,
+        **send_kwargs,
+    ):
+        """
+        Modify a message that was previously sent by this :term:`XMPP Entity`.
+
+        Uses last message correction (:xep:`0308`)
+
+        :param new_text: New content of the message
+        :param legacy_msg_id: The legacy message ID of the message to correct
+        :param when: when the message was sent, for a "delay" tag (:xep:`0203`)
+        :param reply_to: Quote another message (:xep:`0461`)
+        :param hints:
+        :param thread:
+        :param carbon: (only in 1:1) Reflect a message sent to this ``Contact`` by the user.
+            Use this to synchronize outgoing history for legacy official apps.
+        :param archive_only: (only in groups) Do not send this message to user,
+            but store it in the archive. Meant to be used during ``MUC.backfill()``
+        :param correction_event_id: in the case where an ID is associated with the legacy
+            'correction event', specify it here to use it on the XMPP side. If not specified,
+            a random ID will be used.
+        :param link_previews: A little of sender (or server, or gateway)-generated
+            previews of URLs linked in the body.
+        """
+        self.send_text(
+            new_text,
+            legacy_msg_id,
+            when=when,
+            reply_to=reply_to,
+            hints=hints,
+            carbon=carbon,
+            thread=thread,
+            correction=True,
+            archive_only=archive_only,
+            correction_event_id=correction_event_id,
+            link_previews=link_previews,
+            **send_kwargs,
+        )
+
+    def react(
+        self,
+        legacy_msg_id: LegacyMessageType,
+        emojis: Iterable[str] = (),
+        thread: Optional[LegacyThreadType] = None,
+        **kwargs,
+    ):
+        """
+        Send a reaction (:xep:`0444`) from this :term:`XMPP Entity`.
+
+        :param legacy_msg_id: The message which the reaction refers to.
+        :param emojis: An iterable of emojis used as reactions
+        :param thread:
+        """
+        msg = self._make_message(
+            hints={"store"}, carbon=kwargs.get("carbon"), thread=thread
+        )
+        xmpp_id = kwargs.pop("xmpp_id", None)
+        if not xmpp_id:
+            xmpp_id = self._legacy_to_xmpp(legacy_msg_id)
+        self.xmpp["xep_0444"].set_reactions(msg, to_id=xmpp_id, reactions=emojis)
+        self._send(msg, **kwargs)
+
+    def retract(
+        self,
+        legacy_msg_id: LegacyMessageType,
+        thread: Optional[LegacyThreadType] = None,
+        **kwargs,
+    ):
+        """
+        Send a message retraction (:XEP:`0424`) from this :term:`XMPP Entity`.
+
+        :param legacy_msg_id: Legacy ID of the message to delete
+        :param thread:
+        """
+        msg = self._make_message(
+            state=None,
+            hints={"store"},
+            mbody=f"/me retracted the message {legacy_msg_id}",
+            carbon=kwargs.get("carbon"),
+            thread=thread,
+        )
+        msg.enable("fallback")
+        # namespace version mismatch between slidge and slixmpp, update me later
+        msg["fallback"]["for"] = self.xmpp["xep_0424"].namespace[:-1] + "1"
+        msg["retract"]["id"] = msg["replace"]["id"] = self._replace_id(legacy_msg_id)
+        self._send(msg, **kwargs)
+
+
+log = logging.getLogger(__name__)

slidge/db/alembic/versions/15b0bd83407a_remove_bogus_unique_constraints_on_room_.py

@@ -0,0 +1,85 @@
+"""Remove bogus unique constraints on room table
+
+Revision ID: 15b0bd83407a
+Revises: 45c24cc73c91
+Create Date: 2024-08-28 06:57:25.022994
+
+"""
+
+from typing import Sequence, Union
+
+import sqlalchemy as sa
+from alembic import op
+
+import slidge.db.meta
+
+# revision identifiers, used by Alembic.
+revision: str = "15b0bd83407a"
+down_revision: Union[str, None] = "45c24cc73c91"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+meta = sa.MetaData()
+room_table = sa.Table(
+    "room",
+    meta,
+    sa.Column("id", sa.Integer(), nullable=False),
+    sa.Column("user_account_id", sa.Integer(), nullable=False),
+    sa.Column("legacy_id", sa.String(), nullable=False),
+    sa.Column("jid", slidge.db.meta.JIDType(), nullable=False),
+    sa.Column("avatar_id", sa.Integer(), nullable=True),
+    sa.Column("name", sa.String(), nullable=True),
+    sa.Column("description", sa.String(), nullable=True),
+    sa.Column("subject", sa.String(), nullable=True),
+    sa.Column("subject_date", sa.DateTime(), nullable=True),
+    sa.Column("subject_setter", sa.String(), nullable=True),
+    sa.Column("n_participants", sa.Integer(), nullable=True),
+    sa.Column(
+        "muc_type",
+        sa.Enum("GROUP", "CHANNEL", "CHANNEL_NON_ANONYMOUS", name="muctype"),
+        nullable=True,
+    ),
+    sa.Column("user_nick", sa.String(), nullable=True),
+    sa.Column("user_resources", sa.String(), nullable=True),
+    sa.Column("participants_filled", sa.Boolean(), nullable=False),
+    sa.Column("history_filled", sa.Boolean(), nullable=False),
+    sa.Column("extra_attributes", slidge.db.meta.JSONEncodedDict(), nullable=True),
+    sa.Column("updated", sa.Boolean(), nullable=False),
+    sa.Column("avatar_legacy_id", sa.String(), nullable=True),
+    sa.ForeignKeyConstraint(
+        ["avatar_id"],
+        ["avatar.id"],
+    ),
+    sa.ForeignKeyConstraint(
+        ["user_account_id"],
+        ["user_account.id"],
+    ),
+    sa.PrimaryKeyConstraint("id"),
+)
+
+
+def upgrade() -> None:
+    if op.get_bind().engine.name == "postgresql":
+        return
+    with op.batch_alter_table(
+        "room",
+        schema=None,
+        # without copy_from, the newly created table keeps the constraints
+        # we actually want to ditch.
+        copy_from=room_table,
+    ) as batch_op:
+        batch_op.create_unique_constraint(
+            "uq_room_user_account_id_jid", ["user_account_id", "jid"]
+        )
+        batch_op.create_unique_constraint(
+            "uq_room_user_account_id_legacy_id", ["user_account_id", "legacy_id"]
+        )
+
+
+def downgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    with op.batch_alter_table("room", schema=None) as batch_op:
+        batch_op.drop_constraint("uq_room_user_account_id_legacy_id", type_="unique")
+        batch_op.drop_constraint("uq_room_user_account_id_jid", type_="unique")
+
+    # ### end Alembic commands ###

slidge/db/alembic/versions/3071e0fa69d4_add_contact_client_type.py

@@ -37,7 +37,7 @@ def upgrade() -> None:
                     native_enum=False,
                 ),
                 nullable=False,
-                server_default=sa.text("pc"),
+                server_default=sa.literal("pc"),
             )
         )
 

slidge/db/alembic/versions/5bd48bfdffa2_lift_room_legacy_id_constraint.py

@@ -4,8 +4,12 @@ Revision ID: 5bd48bfdffa2
 Revises: b64b1a793483
 Create Date: 2024-07-24 10:29:23.467851
 
+Broken; fixed by "Remove bogus unique constraints on room table",
+rev 15b0bd83407a.
+
 """
 
+import logging
 from typing import Sequence, Union
 
 from alembic import op
@@ -26,6 +30,8 @@ def upgrade() -> None:
             schema=None,
             # without copy_from, the newly created table keeps the constraints
             # we actually want to ditch.
+            # LATER EDIT: this actually does not work, I should have copied the
+            # schema in here.
             copy_from=Room.__table__,  # type:ignore
         ) as batch_op:
             batch_op.create_unique_constraint(
@@ -35,9 +41,11 @@ def upgrade() -> None:
                 "uq_room_user_account_id_legacy_id", ["user_account_id", "legacy_id"]
             )
     except Exception:
-        # happens when migration is not needed
+        # This only works when upgrading rev by rev because I messed up. It
         # wouldn't be necessary if the constraint was named in the first place,
         # cf https://alembic.sqlalchemy.org/en/latest/naming.html
+        # This is fixed by rev 15b0bd83407a
+        log.info("Skipping")
         pass
 
 
@@ -48,3 +56,6 @@ def downgrade() -> None:
         batch_op.drop_constraint("uq_room_user_account_id_jid", type_="unique")
 
     # ### end Alembic commands ###
+
+
+log = logging.getLogger(__name__)

slidge/db/alembic/versions/8d2ced764698_rely_on_db_to_store_contacts_rooms_and_.py

@@ -95,6 +95,12 @@ def upgrade() -> None:
     op.add_column("room", sa.Column("description", sa.String(), nullable=True))
     op.add_column("room", sa.Column("subject", sa.String(), nullable=True))
     op.add_column("room", sa.Column("subject_date", sa.DateTime(), nullable=True))
+
+    if op.get_bind().engine.name == "postgresql":
+        op.execute(
+            "CREATE TYPE muctype AS ENUM ('GROUP', 'CHANNEL', 'CHANNEL_NON_ANONYMOUS')"
+        )
+
     op.add_column(
         "room",
         sa.Column(

slidge/db/alembic/versions/abba1ae0edb3_store_avatar_legacy_id_in_the_contact_.py

@@ -37,12 +37,13 @@ def upgrade() -> None:
 
     with op.batch_alter_table("room", schema=None) as batch_op:
         batch_op.add_column(sa.Column("avatar_legacy_id", sa.String(), nullable=True))
-        batch_op.create_unique_constraint(
-            "uq_room_user_account_id_jid", ["user_account_id", "jid"]
-        )
-        batch_op.create_unique_constraint(
-            "uq_room_user_account_id_legacy_id", ["user_account_id", "legacy_id"]
-        )
+        if op.get_bind().engine.name != "postgresql":
+            batch_op.create_unique_constraint(
+                "uq_room_user_account_id_jid", ["user_account_id", "jid"]
+            )
+            batch_op.create_unique_constraint(
+                "uq_room_user_account_id_legacy_id", ["user_account_id", "legacy_id"]
+            )
 
     for room_pk, avatar_legacy_id in room_avatars:
         conn.execute(

slidge/db/alembic/versions/b64b1a793483_add_source_and_legacy_id_for_archived_.py

@@ -24,6 +24,10 @@ def upgrade() -> None:
     # since we don't want source to be nullable, we drop all rows first.
     # This is what you get by using alpha versions!
     op.execute(sa.delete(ArchivedMessage))
+
+    if op.get_bind().engine.name == "postgresql":
+        op.execute("CREATE TYPE archivedmessagesource AS ENUM ('LIVE', 'BACKFILL')")
+
     # ### commands auto generated by Alembic - please adjust! ###
 
     with op.batch_alter_table("mam", schema=None) as batch_op:

slidge/db/models.py

@@ -156,7 +156,9 @@ class Contact(Base):
 
     is_friend: Mapped[bool] = mapped_column(default=False)
     added_to_roster: Mapped[bool] = mapped_column(default=False)
-    sent_order: Mapped[list["ContactSent"]] = relationship(back_populates="contact")
+    sent_order: Mapped[list["ContactSent"]] = relationship(
+        back_populates="contact", cascade="all, delete-orphan"
+    )
 
     extra_attributes: Mapped[Optional[JSONSerializable]] = mapped_column(
         default=None, nullable=True
@@ -315,7 +317,7 @@ class LegacyIdsMulti(Base):
 
     legacy_id: Mapped[str] = mapped_column(nullable=False)
     xmpp_ids: Mapped[list["XmppIdsMulti"]] = relationship(
-        back_populates="legacy_ids_multi"
+        back_populates="legacy_ids_multi", cascade="all, delete-orphan"
     )