slidge 0.2.0a9__py3-none-any.whl → 0.2.0b0__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,205 +150,19 @@ 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:
-            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
-            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):
     def _privileged_send(self, msg: Message):
         i = msg.get_id()
-        if not i:
-            i = str(uuid.uuid4())
+        if i:
+            self.session.ignore_messages.add(i)
+        else:
+            i = "slidge-carbon-" + str(uuid.uuid4())
             msg.set_id(i)
         msg.del_origin_id()
-        self.session.ignore_messages.add(i)
         try:
             self.xmpp["xep_0356"].send_privileged_message(msg)
         except PermissionError:

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/core/pubsub.py

@@ -25,8 +25,9 @@ from ..db.store import ContactStore, SlidgeStore
 from .mixins.lock import NamedLockMixin
 
 if TYPE_CHECKING:
+    from slidge.core.gateway import BaseGateway
+
     from ..contact.contact import LegacyContact
-    from ..core.gateway.base import BaseGateway
 
 VCARD4_NAMESPACE = "urn:xmpp:vcard4"
 

slidge/core/session.py

@@ -31,6 +31,7 @@ from ..util.types import (
     PseudoPresenceShow,
     RecipientType,
     ResourceDict,
+    Sticker,
 )
 from ..util.util import deprecated
 
@@ -225,6 +226,31 @@ class BaseSession(
 
     send_file = deprecated("BaseSession.send_file", on_file)
 
+    async def on_sticker(
+        self,
+        chat: RecipientType,
+        sticker: Sticker,
+        *,
+        reply_to_msg_id: Optional[LegacyMessageType] = None,
+        reply_to_fallback_text: Optional[str] = None,
+        reply_to: Optional[Union["LegacyContact", "LegacyParticipant"]] = None,
+        thread: Optional[LegacyThreadType] = None,
+    ) -> Optional[LegacyMessageType]:
+        """
+        Triggered when the user sends a file using HTTP Upload (:xep:`0363`)
+
+        :param chat: See :meth:`.BaseSession.on_text`
+        :param sticker: The sticker sent by the user.
+        :param reply_to_msg_id: See :meth:`.BaseSession.on_text`
+        :param reply_to_fallback_text: See :meth:`.BaseSession.on_text`
+        :param reply_to: See :meth:`.BaseSession.on_text`
+        :param thread:
+
+        :return: An ID of some sort that can be used later to ack and mark the message
+            as read by the user
+        """
+        raise NotImplementedError
+
     async def on_active(
         self, chat: RecipientType, thread: Optional[LegacyThreadType] = None
     ):
@@ -729,8 +755,8 @@ class BaseSession(
         self.xmpp.re_login(self)
 
     async def get_contact_or_group_or_participant(self, jid: JID, create=True):
-        if jid.bare in (contacts := self.contacts.known_contacts(only_friends=False)):
-            return contacts[jid.bare]
+        if (contact := self.contacts.by_jid_only_if_exists(jid)) is not None:
+            return contact
         if (muc := self.bookmarks.by_jid_only_if_exists(JID(jid.bare))) is not None:
             return await self.__get_muc_or_participant(muc, jid)
         else:

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

@@ -0,0 +1,83 @@
+"""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:
+    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/45c24cc73c91_add_bob.py

@@ -0,0 +1,42 @@
+"""Add BoB
+
+Revision ID: 45c24cc73c91
+Revises: 3071e0fa69d4
+Create Date: 2024-08-01 22:30:07.073935
+
+"""
+
+from typing import Sequence, Union
+
+import sqlalchemy as sa
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision: str = "45c24cc73c91"
+down_revision: Union[str, None] = "3071e0fa69d4"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.create_table(
+        "bob",
+        sa.Column("id", sa.Integer(), nullable=False),
+        sa.Column("file_name", sa.String(), nullable=False),
+        sa.Column("sha_1", sa.String(), nullable=False),
+        sa.Column("sha_256", sa.String(), nullable=False),
+        sa.Column("sha_512", sa.String(), nullable=False),
+        sa.Column("content_type", sa.String(), nullable=False),
+        sa.PrimaryKeyConstraint("id"),
+        sa.UniqueConstraint("sha_1"),
+        sa.UniqueConstraint("sha_256"),
+        sa.UniqueConstraint("sha_512"),
+    )
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_table("bob")
+    # ### end Alembic commands ###

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