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

slidge/group/archive.py

@@ -1,12 +1,13 @@
 import logging
 import uuid
+import warnings
 from copy import copy
 from datetime import datetime, timezone
 from typing import TYPE_CHECKING, Collection, Optional
 
 from slixmpp import Iq, Message
 
-from ..db.models import ArchivedMessage, ArchivedMessageSource
+from ..db.models import ArchivedMessage, ArchivedMessageSource, Room
 from ..db.store import MAMStore
 from ..util.archive_msg import HistoryMessage
 from ..util.types import HoleBound
@@ -16,17 +17,17 @@ if TYPE_CHECKING:
 
 
 class MessageArchive:
-    def __init__(self, room_pk: int, store: MAMStore):
-        self.room_pk = room_pk
+    def __init__(self, room: Room, store: MAMStore) -> None:
+        self.room = room
         self.__store = store
 
     def add(
         self,
         msg: Message,
         participant: Optional["LegacyParticipant"] = None,
-        archive_only=False,
+        archive_only: bool = False,
         legacy_msg_id=None,
-    ):
+    ) -> None:
         """
         Add a message to the archive if it is deemed archivable
 
@@ -39,8 +40,8 @@ class MessageArchive:
             return
         new_msg = copy(msg)
         if participant and not participant.muc.is_anonymous:
-            new_msg["muc"]["role"] = participant.role
-            new_msg["muc"]["affiliation"] = participant.affiliation
+            new_msg["muc"]["role"] = participant.role or "participant"
+            new_msg["muc"]["affiliation"] = participant.affiliation or "member"
             if participant.contact:
                 new_msg["muc"]["jid"] = participant.contact.jid.bare
             elif participant.is_user:
@@ -48,17 +49,22 @@ class MessageArchive:
             elif participant.is_system:
                 new_msg["muc"]["jid"] = participant.muc.jid
             else:
-                log.warning("No real JID for participant in this group")
+                warnings.warn(
+                    f"No real JID for participant '{participant.nickname}' in '{self.room.name}'"
+                )
                 new_msg["muc"]["jid"] = (
                     f"{uuid.uuid4()}@{participant.xmpp.boundjid.bare}"
                 )
 
-        self.__store.add_message(
-            self.room_pk,
-            HistoryMessage(new_msg),
-            archive_only,
-            None if legacy_msg_id is None else str(legacy_msg_id),
-        )
+        with self.__store.session() as orm:
+            self.__store.add_message(
+                orm,
+                self.room.id,
+                HistoryMessage(new_msg),
+                archive_only,
+                None if legacy_msg_id is None else str(legacy_msg_id),
+            )
+            orm.commit()
 
     def __iter__(self):
         return iter(self.get_all())
@@ -71,31 +77,32 @@ class MessageArchive:
         )
 
     def get_hole_bounds(self) -> tuple[HoleBound | None, HoleBound | None]:
-        most_recent = self.__store.get_most_recent_with_legacy_id(self.room_pk)
-        if most_recent is None:
-            return None, None
-        if most_recent.source == ArchivedMessageSource.BACKFILL:
-            # most recent = only backfill, fetch everything since last backfill
-            return self.__to_bound(most_recent), None
-
-        most_recent_back_filled = self.__store.get_most_recent_with_legacy_id(
-            self.room_pk, ArchivedMessageSource.BACKFILL
-        )
-        if most_recent_back_filled is None:
-            # group was never back-filled, fetch everything before first live
-            least_recent_live = self.__store.get_first(self.room_pk, True)
+        with self.__store.session() as orm:
+            most_recent = self.__store.get_most_recent_with_legacy_id(orm, self.room.id)
+            if most_recent is None:
+                return None, None
+            if most_recent.source == ArchivedMessageSource.BACKFILL:
+                # most recent = only backfill, fetch everything since last backfill
+                return self.__to_bound(most_recent), None
+
+            most_recent_back_filled = self.__store.get_most_recent_with_legacy_id(
+                orm, self.room.id, ArchivedMessageSource.BACKFILL
+            )
+            if most_recent_back_filled is None:
+                # group was never back-filled, fetch everything before first live
+                least_recent_live = self.__store.get_first(orm, self.room.id, True)
+                assert least_recent_live is not None
+                return None, self.__to_bound(least_recent_live)
+
+            assert most_recent_back_filled.legacy_id is not None
+            least_recent_live = self.__store.get_least_recent_with_legacy_id_after(
+                orm, self.room.id, most_recent_back_filled.legacy_id
+            )
             assert least_recent_live is not None
-            return None, self.__to_bound(least_recent_live)
-
-        assert most_recent_back_filled.legacy_id is not None
-        least_recent_live = self.__store.get_least_recent_with_legacy_id_after(
-            self.room_pk, most_recent_back_filled.legacy_id
-        )
-        assert least_recent_live is not None
-        # this is a hole caused by slidge downtime
-        return self.__to_bound(most_recent_back_filled), self.__to_bound(
-            least_recent_live
-        )
+            # this is a hole caused by slidge downtime
+            return self.__to_bound(most_recent_back_filled), self.__to_bound(
+                least_recent_live
+            )
 
     def get_all(
         self,
@@ -106,22 +113,24 @@ class MessageArchive:
         ids: Collection[str] = (),
         last_page_n: Optional[int] = None,
         sender: Optional[str] = None,
-        flip=False,
+        flip: bool = False,
     ):
-        for msg in self.__store.get_messages(
-            self.room_pk,
-            before_id=before_id,
-            after_id=after_id,
-            ids=ids,
-            last_page_n=last_page_n,
-            sender=sender,
-            start_date=start_date,
-            end_date=end_date,
-            flip=flip,
-        ):
-            yield msg
-
-    async def send_metadata(self, iq: Iq):
+        with self.__store.session() as orm:
+            for msg in self.__store.get_messages(
+                orm,
+                self.room.id,
+                before_id=before_id,
+                after_id=after_id,
+                ids=ids,
+                last_page_n=last_page_n,
+                sender=sender,
+                start_date=start_date,
+                end_date=end_date,
+                flip=flip,
+            ):
+                yield msg
+
+    async def send_metadata(self, iq: Iq) -> None:
         """
         Send archive extent, as per the spec
 
@@ -129,7 +138,8 @@ class MessageArchive:
         :return:
         """
         reply = iq.reply()
-        messages = self.__store.get_first_and_last(self.room_pk)
+        with self.__store.session() as orm:
+            messages = self.__store.get_first_and_last(orm, self.room.id)
         if messages:
             for x, m in [("start", messages[0]), ("end", messages[-1])]:
                 reply["mam_metadata"][x]["id"] = m.id
@@ -141,7 +151,7 @@ class MessageArchive:
         reply.send()
 
 
-def archivable(msg: Message):
+def archivable(msg: Message) -> bool:
     """
     Determine if a message stanza is worth archiving, ie, convey meaningful
     info

slidge/group/bookmarks.py

@@ -1,16 +1,15 @@
 import abc
 import logging
-from typing import TYPE_CHECKING, Generic, Iterator, Optional, Type
+from typing import TYPE_CHECKING, Generic, Iterator, Literal, Optional, Type, overload
 
 from slixmpp import JID
 from slixmpp.exceptions import XMPPError
 
-from ..core.mixins.lock import NamedLockMixin
 from ..db.models import Room
 from ..util import SubclassableOnce
 from ..util.jid_escaping import ESCAPE_TABLE, unescape_node
+from ..util.lock import NamedLockMixin
 from ..util.types import LegacyGroupIdType, LegacyMUCType
-from .archive import MessageArchive
 from .room import LegacyMUC
 
 if TYPE_CHECKING:
@@ -26,13 +25,12 @@ class LegacyBookmarks(
     This is instantiated once per :class:`~slidge.BaseSession`
     """
 
-    def __init__(self, session: "BaseSession"):
+    _muc_cls: Type[LegacyMUCType]
+
+    def __init__(self, session: "BaseSession") -> None:
         self.session = session
         self.xmpp = session.xmpp
         self.user_jid = session.user_jid
-        self.__store = self.xmpp.store.rooms
-
-        self._muc_class: Type[LegacyMUCType] = LegacyMUC.get_self_or_unique_subclass()
 
         self._user_nick: str = self.session.user_jid.node
 
@@ -47,23 +45,28 @@ class LegacyBookmarks(
         return self._user_nick
 
     @user_nick.setter
-    def user_nick(self, nick: str):
+    def user_nick(self, nick: str) -> None:
         self._user_nick = nick
 
-    def __iter__(self) -> Iterator[LegacyMUCType]:
-        for stored in self.__store.get_all(user_pk=self.session.user_pk):
-            yield self._muc_class.from_store(self.session, stored)
+    def from_store(self, stored: Room) -> LegacyMUCType:
+        return self._muc_cls(self.session, stored)
+
+    def __iter__(self) -> Iterator[LegacyMUC]:
+        with self.xmpp.store.session() as orm:
+            for stored in orm.query(Room).filter_by(user=self.session.user).all():
+                if stored.updated:
+                    yield self.from_store(stored)
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return f"<Bookmarks of {self.user_jid}>"
 
-    async def legacy_id_to_jid_local_part(self, legacy_id: LegacyGroupIdType):
+    async def legacy_id_to_jid_local_part(self, legacy_id: LegacyGroupIdType) -> str:
         return await self.legacy_id_to_jid_username(legacy_id)
 
-    async def jid_local_part_to_legacy_id(self, local_part: str):
+    async def jid_local_part_to_legacy_id(self, local_part: str) -> LegacyGroupIdType:
         return await self.jid_username_to_legacy_id(local_part)
 
-    async def legacy_id_to_jid_username(self, legacy_id: LegacyGroupIdType):
+    async def legacy_id_to_jid_username(self, legacy_id: LegacyGroupIdType) -> str:
         """
         The default implementation calls ``str()`` on the legacy_id and
         escape characters according to :xep:`0106`.
@@ -88,59 +91,92 @@ class LegacyBookmarks(
         if jid.resource:
             jid = JID(jid.bare)
         async with self.lock(("bare", jid.bare)):
-            assert isinstance(jid.user, str)
-            legacy_id = await self.jid_local_part_to_legacy_id(jid.user)
+            legacy_id = await self.jid_local_part_to_legacy_id(jid.node)
             if self.get_lock(("legacy_id", legacy_id)):
-                self.log.debug("Not instantiating %s after all", jid)
+                self.session.log.debug("Already updating %s via by_legacy_id()", jid)
                 return await self.by_legacy_id(legacy_id)
 
-            with self.__store.session():
-                stored = self.__store.get_by_jid(self.session.user_pk, jid)
-                return await self.__update_muc(stored, legacy_id, jid)
+            with self.session.xmpp.store.session() as orm:
+                stored = (
+                    orm.query(Room)
+                    .filter_by(user_account_id=self.session.user_pk, jid=jid)
+                    .one_or_none()
+                )
+            if stored is None:
+                stored = Room(
+                    user_account_id=self.session.user_pk,
+                    jid=jid,
+                    legacy_id=legacy_id,
+                )
+            return await self.__update_if_needed(stored)
 
     def by_jid_only_if_exists(self, jid: JID) -> Optional[LegacyMUCType]:
-        with self.__store.session():
-            stored = self.__store.get_by_jid(self.session.user_pk, jid)
+        with self.xmpp.store.session() as orm:
+            stored = (
+                orm.query(Room).filter_by(user=self.session.user, jid=jid).one_or_none()
+            )
             if stored is not None and stored.updated:
-                return self._muc_class.from_store(self.session, stored)
+                return self.from_store(stored)
         return None
 
-    async def by_legacy_id(self, legacy_id: LegacyGroupIdType) -> LegacyMUCType:
+    @overload
+    async def by_legacy_id(self, legacy_id: LegacyGroupIdType) -> "LegacyMUCType": ...
+
+    @overload
+    async def by_legacy_id(
+        self, legacy_id: LegacyGroupIdType, create: Literal[False]
+    ) -> "LegacyMUCType | None": ...
+
+    @overload
+    async def by_legacy_id(
+        self, legacy_id: LegacyGroupIdType, create: Literal[True]
+    ) -> "LegacyMUCType": ...
+
+    async def by_legacy_id(
+        self, legacy_id: LegacyGroupIdType, create: bool = False
+    ) -> LegacyMUCType | None:
         async with self.lock(("legacy_id", legacy_id)):
             local = await self.legacy_id_to_jid_local_part(legacy_id)
             jid = JID(f"{local}@{self.xmpp.boundjid}")
             if self.get_lock(("bare", jid.bare)):
-                self.log.debug("Not instantiating %s after all", legacy_id)
-                return await self.by_jid(jid)
-
-            with self.__store.session():
-                stored = self.__store.get_by_legacy_id(
-                    self.session.user_pk, str(legacy_id)
+                self.session.log.debug("Already updating %s via by_jid()", jid)
+                if create:
+                    return await self.by_jid(jid)
+                else:
+                    return self.by_jid_only_if_exists(jid)
+
+            with self.xmpp.store.session() as orm:
+                stored = (
+                    orm.query(Room)
+                    .filter_by(
+                        user_account_id=self.session.user_pk,
+                        legacy_id=str(legacy_id),
+                    )
+                    .one_or_none()
+                )
+            if stored is None:
+                stored = Room(
+                    user_account_id=self.session.user_pk,
+                    jid=jid,
+                    legacy_id=str(legacy_id),
                 )
-                return await self.__update_muc(stored, legacy_id, jid)
-
-    async def __update_muc(
-        self, stored: Room | None, legacy_id: LegacyGroupIdType, jid: JID
-    ):
-        if stored is None:
-            muc = self._muc_class(self.session, legacy_id=legacy_id, jid=jid)
-        else:
-            muc = self._muc_class.from_store(self.session, stored)
-            if stored.updated:
-                return muc
-
-        try:
-            with muc.updating_info():
-                await muc.avatar_wrap_update_info()
-        except XMPPError:
-            raise
-        except Exception as e:
-            raise XMPPError("internal-server-error", str(e))
-        if not muc.user_nick:
-            muc.user_nick = self._user_nick
-        self.log.debug("MUC created: %r", muc)
-        muc.pk = self.__store.update(muc)
-        muc.archive = MessageArchive(muc.pk, self.xmpp.store.mam)
+            return await self.__update_if_needed(stored)
+
+    async def __update_if_needed(self, stored: Room) -> LegacyMUCType:
+        muc = self.from_store(stored)
+        if muc.stored.updated:
+            return muc
+
+        with muc.updating_info():
+            try:
+                await muc.update_info()
+            except NotImplementedError:
+                pass
+            except XMPPError:
+                raise
+            except Exception as e:
+                raise XMPPError("internal-server-error", str(e))
+
         return muc
 
     @abc.abstractmethod
@@ -164,8 +200,8 @@ class LegacyBookmarks(
     async def remove(
         self,
         muc: LegacyMUC,
-        reason="You left this group from the official client.",
-        kick=True,
+        reason: str = "You left this group from the official client.",
+        kick: bool = True,
     ) -> None:
         """
         Delete everything about a specific group.
@@ -179,8 +215,9 @@ class LegacyBookmarks(
             to False in case you do this somewhere else in your code, eg, on
             receiving the confirmation that the group was deleted.
         """
-        assert muc.pk is not None
         if kick:
             user_participant = await muc.get_user_participant()
             user_participant.kick(reason)
-        self.__store.delete(muc.pk)
+        with self.xmpp.store.session() as orm:
+            orm.delete(muc.stored)
+            orm.commit()