slidge 0.2.12__py3-none-any.whl → 0.3.0a0__py3-none-any.whl

slidge/core/session.py

@@ -7,18 +7,20 @@ from typing import (
     Iterable,
     NamedTuple,
     Optional,
+    Type,
     Union,
     cast,
 )
 
 import aiohttp
+import sqlalchemy as sa
 from slixmpp import JID, Message
 from slixmpp.exceptions import XMPPError
 from slixmpp.types import PresenceShows
 
 from ..command import SearchResult
 from ..contact import LegacyContact, LegacyRoster
-from ..db.models import GatewayUser
+from ..db.models import Contact, GatewayUser
 from ..group.bookmarks import LegacyBookmarks
 from ..group.room import LegacyMUC
 from ..util import ABCSubclassableOnceAtMost
@@ -89,22 +91,21 @@ class BaseSession(
     This can be used to implement voting in polls in a hacky way.
     """
 
-    def __init__(self, user: GatewayUser):
-        self.log = logging.getLogger(user.jid.bare)
+    _roster_cls: Type[LegacyRoster]
+    _bookmarks_cls: Type[LegacyBookmarks]
 
-        self.user_jid = user.jid
-        self.user_pk = user.id
+    def __init__(self, user: GatewayUser) -> None:
+        self.user = user
+        self.log = logging.getLogger(user.jid.bare)
 
         self.ignore_messages = set[str]()
 
-        self.contacts: LegacyRoster = LegacyRoster.get_self_or_unique_subclass()(self)
+        self.contacts = self._roster_cls(self)
         self.is_logging_in = False
         self._logged = False
         self.__reset_ready()
 
-        self.bookmarks: LegacyBookmarks = LegacyBookmarks.get_self_or_unique_subclass()(
-            self
-        )
+        self.bookmarks = self._bookmarks_cls(self)
 
         self.thread_creation_lock = asyncio.Lock()
 
@@ -113,14 +114,18 @@ class BaseSession(
         self.__tasks = set[asyncio.Task]()
 
     @property
-    def user(self) -> GatewayUser:
-        return self.xmpp.store.users.get(self.user_jid)  # type:ignore
+    def user_jid(self) -> JID:
+        return self.user.jid
+
+    @property
+    def user_pk(self) -> int:
+        return self.user.id
 
     @property
     def http(self) -> aiohttp.ClientSession:
         return self.xmpp.http
 
-    def __remove_task(self, fut):
+    def __remove_task(self, fut) -> None:
         self.log.debug("Removing fut %s", fut)
         self.__tasks.remove(fut)
 
@@ -131,7 +136,7 @@ class BaseSession(
         task.add_done_callback(lambda _: self.__remove_task(task))
         return task
 
-    def cancel_all_tasks(self):
+    def cancel_all_tasks(self) -> None:
         for task in self.__tasks:
             task.cancel()
 
@@ -148,7 +153,7 @@ class BaseSession(
         """
         raise NotImplementedError
 
-    async def logout(self):
+    async def logout(self) -> None:
         """
         Logs out the gateway user from the legacy network.
 
@@ -304,6 +309,17 @@ class BaseSession(
 
     paused = deprecated("BaseSession.paused", on_paused)
 
+    async def on_gone(
+        self, chat: RecipientType, thread: Optional[LegacyThreadType] = None
+    ):
+        """
+        Triggered when the user is "gone" in a legacy chat (:xep:`0085`)
+
+        :param chat: See :meth:`.BaseSession.on_text`
+        :param thread:
+        """
+        raise NotImplementedError
+
     async def on_displayed(
         self,
         chat: RecipientType,
@@ -493,7 +509,7 @@ class BaseSession(
 
     async def on_invitation(
         self, contact: LegacyContact, muc: LegacyMUC, reason: Optional[str]
-    ):
+    ) -> None:
         """
         Triggered when the user invites a :term:`Contact` to a legacy MUC via
         :xep:`0249`.
@@ -519,7 +535,7 @@ class BaseSession(
         """
         raise NotImplementedError
 
-    def __reset_ready(self):
+    def __reset_ready(self) -> None:
         self.ready = self.xmpp.loop.create_future()
 
     @property
@@ -527,7 +543,7 @@ class BaseSession(
         return self._logged
 
     @logged.setter
-    def logged(self, v: bool):
+    def logged(self, v: bool) -> None:
         self.is_logging_in = False
         self._logged = v
         if self.ready.done():
@@ -539,19 +555,34 @@ class BaseSession(
             if v:
                 self.ready.set_result(True)
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return f"<Session of {self.user_jid}>"
 
-    def shutdown(self, logout=True) -> asyncio.Task:
+    def shutdown(self, logout: bool = True) -> asyncio.Task:
         for m in self.bookmarks:
             m.shutdown()
-        for c in self.contacts:
-            c.offline()
+        with self.xmpp.store.session() as orm:
+            for jid in orm.execute(
+                sa.select(Contact.jid).filter_by(user=self.user, is_friend=True)
+            ).scalars():
+                pres = self.xmpp.make_presence(
+                    pfrom=jid,
+                    pto=self.user_jid,
+                    ptype="unavailable",
+                    pstatus="Gateway has shut down.",
+                )
+                pres.send()
         if logout:
-            return self.xmpp.loop.create_task(self.logout())
+            return self.xmpp.loop.create_task(self.__logout())
         else:
             return self.xmpp.loop.create_task(noop_coro())
 
+    async def __logout(self) -> None:
+        try:
+            await self.logout()
+        except NotImplementedError:
+            pass
+
     @staticmethod
     def legacy_to_xmpp_msg_id(legacy_msg_id: LegacyMessageType) -> str:
         """
@@ -604,7 +635,7 @@ class BaseSession(
     @classmethod
     def _from_user_or_none(cls, user):
         if user is None:
-            log.debug("user not found", stack_info=True)
+            log.debug("user not found")
             raise XMPPError(text="User not found", condition="subscription-required")
 
         session = _sessions.get(user.jid.bare)
@@ -641,11 +672,12 @@ class BaseSession(
         session = _sessions.get(jid.bare)
         if session is not None:
             return session
-        user = cls.xmpp.store.users.get(jid)
+        with cls.xmpp.store.session() as orm:
+            user = orm.query(GatewayUser).filter_by(jid=jid.bare).one_or_none()
         return cls._from_user_or_none(user)
 
     @classmethod
-    async def kill_by_jid(cls, jid: JID):
+    async def kill_by_jid(cls, jid: JID) -> None:
         # """
         # Terminate a user session.
         #
@@ -665,17 +697,19 @@ class BaseSession(
             c.unsubscribe()
         for m in session.bookmarks:
             m.shutdown()
-        user = cls.xmpp.store.users.get(jid)
-        if user is None:
+
+        try:
+            session = _sessions.pop(jid.bare)
+        except KeyError:
             log.warning("User not found during unregistration")
             return
-        await cls.xmpp.unregister(user)
-        cls.xmpp.store.users.delete(user.jid)
-        del _sessions[user.jid.bare]
-        del user
-        del session
 
-    def __ack(self, msg: Message):
+        with cls.xmpp.store.session() as orm:
+            await cls.xmpp.unregister(session.user)
+            orm.delete(session.user)
+            orm.commit()
+
+    def __ack(self, msg: Message) -> None:
         if not self.xmpp.PROPER_RECEIPTS:
             self.xmpp.delivery_receipt.ack(msg)
 
@@ -684,7 +718,7 @@ class BaseSession(
         status: Optional[str] = None,
         show=Optional[PresenceShows],
         **kwargs,
-    ):
+    ) -> None:
         """
         Send a presence from the gateway to the user.
 
@@ -699,7 +733,7 @@ class BaseSession(
             pto=self.user_jid.bare, pstatus=status, pshow=show, **kwargs
         )
 
-    def send_cached_presence(self, to: JID):
+    def send_cached_presence(self, to: JID) -> None:
         if not self.__cached_presence:
             self.xmpp.send_presence(pto=to, ptype="unavailable")
             return
@@ -710,7 +744,7 @@ class BaseSession(
             **self.__cached_presence.kwargs,
         )
 
-    def send_gateway_message(self, text: str, **msg_kwargs):
+    def send_gateway_message(self, text: str, **msg_kwargs) -> None:
         """
         Send a message from the gateway component to the user.
 
@@ -725,7 +759,7 @@ class BaseSession(
         muc: LegacyMUC,
         reason: Optional[str] = None,
         password: Optional[str] = None,
-    ):
+    ) -> None:
         """
         Send an invitation to join a MUC, emanating from the gateway component.
 
@@ -747,7 +781,7 @@ class BaseSession(
         """
         return await self.xmpp.input(self.user_jid, text, **msg_kwargs)
 
-    async def send_qr(self, text: str):
+    async def send_qr(self, text: str) -> None:
         """
         Sends a QR code generated from 'text' via HTTP Upload and send the URL to
         ``self.user``
@@ -756,13 +790,13 @@ class BaseSession(
         """
         await self.xmpp.send_qr(text, mto=self.user_jid)
 
-    def re_login(self):
+    def re_login(self) -> None:
         # Logout then re-login
         #
         # No reason to override this
         self.xmpp.re_login(self)
 
-    async def get_contact_or_group_or_participant(self, jid: JID, create=True):
+    async def get_contact_or_group_or_participant(self, jid: JID, create: bool = True):
         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:
@@ -813,23 +847,20 @@ class BaseSession(
                 "Legacy session is not fully initialized, retry later",
             )
 
-    def legacy_module_data_update(self, data: dict):
-        with self.xmpp.store.session():
-            user = self.user
-            user.legacy_module_data.update(data)
-            self.xmpp.store.users.update(user)
-
-    def legacy_module_data_set(self, data: dict):
-        with self.xmpp.store.session():
-            user = self.user
-            user.legacy_module_data = data
-            self.xmpp.store.users.update(user)
-
-    def legacy_module_data_clear(self):
-        with self.xmpp.store.session():
-            user = self.user
-            user.legacy_module_data.clear()
-            self.xmpp.store.users.update(user)
+    def legacy_module_data_update(self, data: dict) -> None:
+        user = self.user
+        user.legacy_module_data.update(data)
+        self.xmpp.store.users.update(user)
+
+    def legacy_module_data_set(self, data: dict) -> None:
+        user = self.user
+        user.legacy_module_data = data
+        self.xmpp.store.users.update(user)
+
+    def legacy_module_data_clear(self) -> None:
+        user = self.user
+        user.legacy_module_data.clear()
+        self.xmpp.store.users.update(user)
 
 
 # keys = user.jid.bare

slidge/db/alembic/versions/0337c90c0b96_unify_legacy_xmpp_id_mappings.py

@@ -0,0 +1,183 @@
+"""Unify legacy/XMPP id mappings
+
+Revision ID: 0337c90c0b96
+Revises: 58b98dacf819
+Create Date: 2025-04-25 20:22:47.612652
+
+"""
+
+from typing import Sequence, Union
+
+import sqlalchemy as sa
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision: str = "0337c90c0b96"
+down_revision: Union[str, None] = "58b98dacf819"
+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(
+        "direct_msg",
+        sa.Column("foreign_key", sa.Integer(), nullable=False),
+        sa.Column("id", sa.Integer(), nullable=False),
+        sa.Column("legacy_id", sa.String(), nullable=False),
+        sa.Column("xmpp_id", sa.String(), nullable=False),
+        sa.ForeignKeyConstraint(
+            ["foreign_key"],
+            ["contact.id"],
+            name=op.f("fk_direct_msg_foreign_key_contact"),
+        ),
+        sa.PrimaryKeyConstraint("id", name=op.f("pk_direct_msg")),
+    )
+    with op.batch_alter_table("direct_msg", schema=None) as batch_op:
+        batch_op.create_index(
+            "ix_direct_msg_legacy_id", ["legacy_id", "foreign_key"], unique=False
+        )
+
+    op.create_table(
+        "direct_thread",
+        sa.Column("foreign_key", sa.Integer(), nullable=False),
+        sa.Column("id", sa.Integer(), nullable=False),
+        sa.Column("legacy_id", sa.String(), nullable=False),
+        sa.Column("xmpp_id", sa.String(), nullable=False),
+        sa.ForeignKeyConstraint(
+            ["foreign_key"],
+            ["contact.id"],
+            name=op.f("fk_direct_thread_foreign_key_contact"),
+        ),
+        sa.PrimaryKeyConstraint("id", name=op.f("pk_direct_thread")),
+    )
+    with op.batch_alter_table("direct_thread", schema=None) as batch_op:
+        batch_op.create_index(
+            "ix_direct_direct_thread_id", ["legacy_id", "foreign_key"], unique=False
+        )
+
+    op.create_table(
+        "group_msg",
+        sa.Column("foreign_key", sa.Integer(), nullable=False),
+        sa.Column("id", sa.Integer(), nullable=False),
+        sa.Column("legacy_id", sa.String(), nullable=False),
+        sa.Column("xmpp_id", sa.String(), nullable=False),
+        sa.ForeignKeyConstraint(
+            ["foreign_key"], ["room.id"], name=op.f("fk_group_msg_foreign_key_room")
+        ),
+        sa.PrimaryKeyConstraint("id", name=op.f("pk_group_msg")),
+    )
+    with op.batch_alter_table("group_msg", schema=None) as batch_op:
+        batch_op.create_index(
+            "ix_group_msg_legacy_id", ["legacy_id", "foreign_key"], unique=False
+        )
+
+    op.create_table(
+        "group_thread",
+        sa.Column("foreign_key", sa.Integer(), nullable=False),
+        sa.Column("id", sa.Integer(), nullable=False),
+        sa.Column("legacy_id", sa.String(), nullable=False),
+        sa.Column("xmpp_id", sa.String(), nullable=False),
+        sa.ForeignKeyConstraint(
+            ["foreign_key"], ["room.id"], name=op.f("fk_group_thread_foreign_key_room")
+        ),
+        sa.PrimaryKeyConstraint("id", name=op.f("pk_group_thread")),
+    )
+    with op.batch_alter_table("group_thread", schema=None) as batch_op:
+        batch_op.create_index(
+            "ix_direct_group_thread_id", ["legacy_id", "foreign_key"], unique=False
+        )
+
+    with op.batch_alter_table("xmpp_ids_multi", schema=None) as batch_op:
+        batch_op.drop_index("legacy_ids_multi_user_account_id_xmpp_id")
+
+    op.drop_table("xmpp_ids_multi")
+    with op.batch_alter_table("xmpp_to_legacy_ids", schema=None) as batch_op:
+        batch_op.drop_index("xmpp_legacy")
+
+    op.drop_table("xmpp_to_legacy_ids")
+    with op.batch_alter_table("legacy_ids_multi", schema=None) as batch_op:
+        batch_op.drop_index("legacy_ids_multi_user_account_id_legacy_id")
+
+    op.drop_table("legacy_ids_multi")
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.create_table(
+        "legacy_ids_multi",
+        sa.Column("id", sa.INTEGER(), nullable=False),
+        sa.Column("user_account_id", sa.INTEGER(), nullable=False),
+        sa.Column("legacy_id", sa.VARCHAR(), nullable=False),
+        sa.ForeignKeyConstraint(
+            ["user_account_id"],
+            ["user_account.id"],
+        ),
+        sa.PrimaryKeyConstraint("id"),
+    )
+    with op.batch_alter_table("legacy_ids_multi", schema=None) as batch_op:
+        batch_op.create_index(
+            "legacy_ids_multi_user_account_id_legacy_id",
+            ["user_account_id", "legacy_id"],
+            unique=1,
+        )
+
+    op.create_table(
+        "xmpp_to_legacy_ids",
+        sa.Column("id", sa.INTEGER(), nullable=False),
+        sa.Column("user_account_id", sa.INTEGER(), nullable=False),
+        sa.Column("xmpp_id", sa.VARCHAR(), nullable=False),
+        sa.Column("legacy_id", sa.VARCHAR(), nullable=False),
+        sa.Column("type", sa.VARCHAR(length=10), nullable=False),
+        sa.ForeignKeyConstraint(
+            ["user_account_id"],
+            ["user_account.id"],
+        ),
+        sa.PrimaryKeyConstraint("id"),
+    )
+    with op.batch_alter_table("xmpp_to_legacy_ids", schema=None) as batch_op:
+        batch_op.create_index(
+            "xmpp_legacy", ["user_account_id", "xmpp_id", "legacy_id"], unique=1
+        )
+
+    op.create_table(
+        "xmpp_ids_multi",
+        sa.Column("id", sa.INTEGER(), nullable=False),
+        sa.Column("user_account_id", sa.INTEGER(), nullable=False),
+        sa.Column("xmpp_id", sa.VARCHAR(), nullable=False),
+        sa.Column("legacy_ids_multi_id", sa.INTEGER(), nullable=False),
+        sa.ForeignKeyConstraint(
+            ["legacy_ids_multi_id"],
+            ["legacy_ids_multi.id"],
+        ),
+        sa.ForeignKeyConstraint(
+            ["user_account_id"],
+            ["user_account.id"],
+        ),
+        sa.PrimaryKeyConstraint("id"),
+    )
+    with op.batch_alter_table("xmpp_ids_multi", schema=None) as batch_op:
+        batch_op.create_index(
+            "legacy_ids_multi_user_account_id_xmpp_id",
+            ["user_account_id", "xmpp_id"],
+            unique=1,
+        )
+
+    with op.batch_alter_table("group_thread", schema=None) as batch_op:
+        batch_op.drop_index("ix_direct_group_thread_id")
+
+    op.drop_table("group_thread")
+    with op.batch_alter_table("group_msg", schema=None) as batch_op:
+        batch_op.drop_index("ix_group_msg_legacy_id")
+
+    op.drop_table("group_msg")
+    with op.batch_alter_table("direct_thread", schema=None) as batch_op:
+        batch_op.drop_index("ix_direct_direct_thread_id")
+
+    op.drop_table("direct_thread")
+    with op.batch_alter_table("direct_msg", schema=None) as batch_op:
+        batch_op.drop_index("ix_direct_msg_legacy_id")
+
+    op.drop_table("direct_msg")
+    # ### end Alembic commands ###

slidge/db/alembic/versions/4dbd23a3f868_new_avatar_store.py

@@ -0,0 +1,56 @@
+"""New avatar store
+
+Revision ID: 4dbd23a3f868
+Revises: 04cf35e3cf85
+Create Date: 2025-04-14 21:57:49.030430
+
+"""
+
+from typing import Sequence, Union
+
+import sqlalchemy as sa
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision: str = "4dbd23a3f868"
+down_revision: Union[str, None] = "04cf35e3cf85"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    with op.batch_alter_table("avatar", schema=None) as batch_op:
+        batch_op.add_column(sa.Column("legacy_id", sa.String(), nullable=True))
+        batch_op.create_unique_constraint("avatar_unique_legacy_id", ["legacy_id"])
+
+    batch_op.execute("""
+        UPDATE avatar
+        SET legacy_id = contact.avatar_legacy_id
+        FROM contact
+        WHERE avatar.id = contact.avatar_id
+    """)
+
+    batch_op.execute("""
+        UPDATE avatar
+        SET legacy_id = room.avatar_legacy_id
+        FROM room
+        WHERE avatar.id = room.avatar_id
+    """)
+
+    with op.batch_alter_table("contact", schema=None) as batch_op:
+        batch_op.drop_column("avatar_legacy_id")
+
+    with op.batch_alter_table("room", schema=None) as batch_op:
+        batch_op.drop_column("avatar_legacy_id")
+
+
+def downgrade() -> None:
+    with op.batch_alter_table("room", schema=None) as batch_op:
+        batch_op.add_column(sa.Column("avatar_legacy_id", sa.VARCHAR(), nullable=True))
+
+    with op.batch_alter_table("contact", schema=None) as batch_op:
+        batch_op.add_column(sa.Column("avatar_legacy_id", sa.VARCHAR(), nullable=True))
+
+    with op.batch_alter_table("avatar", schema=None) as batch_op:
+        batch_op.drop_constraint("avatar_unique_legacy_id", type_="unique")
+        batch_op.drop_column("legacy_id")

slidge/db/alembic/versions/54ce3cde350c_use_hash_for_avatar_filenames.py

@@ -0,0 +1,50 @@
+"""Use hash for avatar filenames
+
+Revision ID: 54ce3cde350c
+Revises: 4dbd23a3f868
+Create Date: 2025-04-14 23:52:38.520744
+
+"""
+
+from pathlib import Path
+from typing import Sequence, Union
+
+import sqlalchemy as sa
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision: str = "54ce3cde350c"
+down_revision: Union[str, None] = "4dbd23a3f868"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    from slidge.core import config
+
+    try:
+        avatars_root = config.HOME_DIR / "slidge_avatars_v3"
+    except AttributeError:
+        avatars_root = Path(".")
+
+    connection = op.get_bind()
+    avatars = connection.execute(sa.text("SELECT id, filename, hash FROM avatar"))
+    for avatar in avatars:
+        filename = avatar[1]
+        hash_value = avatar[2]
+        if filename and hash_value:
+            old_file_path = avatars_root / filename
+            new_file_path = (avatars_root / hash_value).with_suffix(".png")
+            if old_file_path.exists():
+                old_file_path.rename(new_file_path)
+
+    with op.batch_alter_table("avatar", schema=None) as batch_op:
+        batch_op.drop_column("filename")
+
+
+def downgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    with op.batch_alter_table("avatar", schema=None) as batch_op:
+        batch_op.add_column(sa.Column("filename", sa.VARCHAR(), nullable=False))
+
+    # ### end Alembic commands ###