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

slidge/contact/roster.py

@@ -4,14 +4,16 @@ import warnings
 from typing import TYPE_CHECKING, AsyncIterator, Generic, Iterator, Optional, Type
 
 from slixmpp import JID
-from slixmpp.exceptions import IqError, IqTimeout, XMPPError
+from slixmpp.exceptions import IqError, IqTimeout
+from sqlalchemy.orm import Session
+from sqlalchemy.orm import Session as OrmSession
 
-from ..core.mixins.lock import NamedLockMixin
-from ..db.models import Contact
-from ..db.store import ContactStore
+from ..db.models import Contact, GatewayUser
 from ..util import SubclassableOnce
 from ..util.jid_escaping import ESCAPE_TABLE, unescape_node
+from ..util.lock import NamedLockMixin
 from ..util.types import LegacyContactType, LegacyUserIdType
+from ..util.util import timeit
 from .contact import LegacyContact
 
 if TYPE_CHECKING:
@@ -28,7 +30,7 @@ class LegacyRoster(
     metaclass=SubclassableOnce,
 ):
     """
-    Virtual roster of a gateway user, that allows to represent all
+    Virtual roster of a gateway user that allows to represent all
     of their contacts as singleton instances (if used properly and not too bugged).
 
     Every :class:`.BaseSession` instance will have its own :class:`.LegacyRoster` instance
@@ -42,29 +44,38 @@ class LegacyRoster(
     if you need some characters when translation JID user parts and legacy IDs.
     """
 
-    def __init__(self, session: "BaseSession"):
-        self._contact_cls: Type[LegacyContactType] = (
-            LegacyContact.get_self_or_unique_subclass()
-        )
-        self._contact_cls.xmpp = session.xmpp
-        self.__store: ContactStore = session.xmpp.store.contacts
+    _contact_cls: Type[LegacyContactType]
 
-        self.session = session
-        self.log = logging.getLogger(f"{self.session.user_jid.bare}:roster")
+    def __init__(self, session: "BaseSession") -> None:
+        super().__init__()
+
+        self.log = logging.getLogger(f"{session.user_jid.bare}:roster")
         self.user_legacy_id: Optional[LegacyUserIdType] = None
-        self.ready: asyncio.Future[bool] = self.session.xmpp.loop.create_future()
+        self.ready: asyncio.Future[bool] = session.xmpp.loop.create_future()
+
+        self.session = session
         self.__filling = False
-        super().__init__()
 
-    def __repr__(self):
+    @property
+    def user(self) -> GatewayUser:
+        return self.session.user
+
+    def orm(self) -> Session:
+        return self.session.xmpp.store.session()
+
+    def from_store(self, stored: Contact) -> LegacyContactType:
+        return self._contact_cls(self.session, stored=stored)
+
+    def __repr__(self) -> str:
         return f"<Roster of {self.session.user_jid}>"
 
     def __iter__(self) -> Iterator[LegacyContactType]:
-        with self.__store.session():
-            for stored in self.__store.get_all(user_pk=self.session.user_pk):
-                yield self._contact_cls.from_store(self.session, stored)
+        with self.orm() as orm:
+            for stored in orm.query(Contact).filter_by(user=self.user).all():
+                if stored.updated:
+                    yield self.from_store(stored)
 
-    def known_contacts(self, only_friends=True) -> dict[str, LegacyContactType]:
+    def known_contacts(self, only_friends: bool = True) -> dict[str, LegacyContactType]:
         if only_friends:
             return {c.jid.bare: c for c in self if c.is_friend}
         return {c.jid.bare: c for c in self}
@@ -81,27 +92,54 @@ class LegacyRoster(
         # :return:
         # """
         username = contact_jid.node
+        contact_jid = JID(contact_jid.bare)
         async with self.lock(("username", username)):
             legacy_id = await self.jid_username_to_legacy_id(username)
-            log.debug("Contact %s not found", contact_jid)
+            if legacy_id == self.user_legacy_id:
+                raise ContactIsUser
             if self.get_lock(("legacy_id", legacy_id)):
-                log.debug("Already updating %s", contact_jid)
+                self.log.debug("Already updating %s via by_legacy_id()", contact_jid)
                 return await self.by_legacy_id(legacy_id)
 
-            with self.__store.session():
-                stored = self.__store.get_by_jid(self.session.user_pk, contact_jid)
-                return await self.__update_contact(stored, legacy_id, username)
+            with self.orm() as orm:
+                stored = (
+                    orm.query(Contact)
+                    .filter_by(user=self.user, jid=contact_jid)
+                    .one_or_none()
+                )
+            if stored is None:
+                stored = Contact(
+                    user_account_id=self.session.user_pk,
+                    legacy_id=legacy_id,
+                    jid=contact_jid,
+                )
+            return await self.__update_if_needed(stored)
+
+    async def __update_if_needed(self, stored: Contact) -> LegacyContactType:
+        contact = self.from_store(stored)
+        if contact.stored.updated:
+            return contact
+
+        with contact.updating_info():
+            await contact.update_info()
+
+        if contact.cached_presence is not None:
+            contact._store_last_presence(contact.cached_presence)
+        return contact
 
     def by_jid_only_if_exists(self, contact_jid: JID) -> LegacyContactType | None:
-        with self.__store.session():
-            stored = self.__store.get_by_jid(self.session.user_pk, contact_jid)
+        with self.orm() as orm:
+            stored = (
+                orm.query(Contact)
+                .filter_by(user=self.user, jid=contact_jid)
+                .one_or_none()
+            )
             if stored is not None and stored.updated:
-                return self._contact_cls.from_store(self.session, stored)
+                return self.from_store(stored)
         return None
 
-    async def by_legacy_id(
-        self, legacy_id: LegacyUserIdType, *args, **kwargs
-    ) -> LegacyContactType:
+    @timeit
+    async def by_legacy_id(self, legacy_id: LegacyUserIdType) -> LegacyContactType:
         """
         Retrieve a contact by their legacy_id
 
@@ -110,11 +148,6 @@ class LegacyRoster(
         legacy user ID.
 
         :param legacy_id:
-        :param args: arbitrary additional positional arguments passed to the contact constructor.
-            Requires subclassing LegacyContact.__init__ to accept those.
-            This is useful for networks where you fetch the contact list and information
-            about these contacts in a single request
-        :param kwargs: arbitrary keyword arguments passed to the contact constructor
         :return:
         """
         if legacy_id == self.user_legacy_id:
@@ -122,56 +155,26 @@ class LegacyRoster(
         async with self.lock(("legacy_id", legacy_id)):
             username = await self.legacy_id_to_jid_username(legacy_id)
             if self.get_lock(("username", username)):
-                log.debug("Already updating %s", username)
+                self.log.debug("Already updating %s via by_jid()", username)
+
                 jid = JID()
                 jid.node = username
                 jid.domain = self.session.xmpp.boundjid.bare
                 return await self.by_jid(jid)
 
-            with self.__store.session():
-                stored = self.__store.get_by_legacy_id(
-                    self.session.user_pk, str(legacy_id)
+            with self.orm() as orm:
+                stored = (
+                    orm.query(Contact)
+                    .filter_by(user=self.user, legacy_id=str(legacy_id))
+                    .one_or_none()
                 )
-                return await self.__update_contact(
-                    stored, legacy_id, username, *args, **kwargs
+            if stored is None:
+                stored = Contact(
+                    user_account_id=self.session.user_pk,
+                    legacy_id=str(legacy_id),
+                    jid=JID(f"{username}@{self.session.xmpp.boundjid.bare}"),
                 )
-
-    async def __update_contact(
-        self,
-        stored: Contact | None,
-        legacy_id: LegacyUserIdType,
-        username: str,
-        *a,
-        **kw,
-    ) -> LegacyContactType:
-        if stored is None:
-            contact = self._contact_cls(self.session, legacy_id, username, *a, **kw)
-        else:
-            contact = self._contact_cls.from_store(self.session, stored, *a, **kw)
-            if stored.updated:
-                return contact
-
-        try:
-            with contact.updating_info():
-                await contact.avatar_wrap_update_info()
-        except XMPPError:
-            raise
-        except Exception as e:
-            raise XMPPError("internal-server-error", str(e))
-        contact._caps_ver = await contact.get_caps_ver(contact.jid)
-        contact.contact_pk = self.__store.update(contact, commit=not self.__filling)
-        return contact
-
-    async def by_stanza(self, s) -> LegacyContact:
-        # """
-        # Retrieve a contact by the destination of a stanza
-        #
-        # See :meth:`slidge.Roster.by_legacy_id` for more info.
-        #
-        # :param s:
-        # :return:
-        # """
-        return await self.by_jid(s.get_to())
+            return await self.__update_if_needed(stored)
 
     async def legacy_id_to_jid_username(self, legacy_id: LegacyUserIdType) -> str:
         """
@@ -198,9 +201,10 @@ class LegacyRoster(
         :param jid_username: User part of a JID, ie "user" in "user@example.com"
         :return: An identifier for the user on the legacy network.
         """
-        return unescape_node(jid_username)
+        return unescape_node(jid_username)  # type:ignore
 
-    async def _fill(self):
+    @timeit
+    async def _fill(self, orm: OrmSession):
         try:
             if hasattr(self.session.xmpp, "TEST_MODE"):
                 # dirty hack to avoid mocking xmpp server replies to this
@@ -213,30 +217,29 @@ class LegacyRoster(
         except (PermissionError, IqError, IqTimeout):
             user_roster = None
 
-        with self.__store.session() as orm:
-            self.__filling = True
-            async for contact in self.fill():
-                if user_roster is None:
-                    continue
-                item = contact.get_roster_item()
-                old = user_roster.get(contact.jid.bare)
-                if old is not None and all(
-                    old[k] == item[contact.jid.bare].get(k)
-                    for k in ("subscription", "groups", "name")
-                ):
-                    self.log.debug("No need to update roster")
-                    continue
-                self.log.debug("Updating roster")
-                try:
-                    await self.session.xmpp["xep_0356"].set_roster(
-                        self.session.user_jid.bare,
-                        item,
-                    )
-                except (PermissionError, IqError, IqTimeout) as e:
-                    warnings.warn(f"Could not add to roster: {e}")
-                else:
-                    contact._added_to_roster = True
-            orm.commit()
+        self.__filling = True
+        async for contact in self.fill():
+            if user_roster is None:
+                continue
+            item = contact.get_roster_item()
+            old = user_roster.get(contact.jid.bare)
+            if old is not None and all(
+                old[k] == item[contact.jid.bare].get(k)
+                for k in ("subscription", "groups", "name")
+            ):
+                self.log.debug("No need to update roster")
+                continue
+            self.log.debug("Updating roster")
+            try:
+                await self.session.xmpp["xep_0356"].set_roster(
+                    self.session.user_jid.bare,
+                    item,
+                )
+            except (PermissionError, IqError, IqTimeout) as e:
+                warnings.warn(f"Could not add to roster: {e}")
+            else:
+                contact.added_to_roster = True
+        orm.commit()
         self.__filling = False
 
     async def fill(self) -> AsyncIterator[LegacyContact]:

slidge/core/config.py

@@ -1,12 +1,12 @@
 from datetime import timedelta
 from pathlib import Path
-from typing import Optional
+from typing import Optional, Self
 
 from slixmpp import JID as JIDType
 
 
 class _TimedeltaSeconds(timedelta):
-    def __new__(cls, s: str):
+    def __new__(cls, s: str) -> Self:
         return super().__new__(cls, seconds=int(s))
 
 
@@ -75,16 +75,6 @@ UPLOAD_SERVICE__DOC = (
     "discovery."
 )
 
-NO_ROSTER_PUSH = False
-NO_ROSTER_PUSH__DOC = "Do not fill users' rosters with legacy contacts automatically"
-
-ROSTER_PUSH_PRESENCE_SUBSCRIPTION_REQUEST_FALLBACK = True
-ROSTER_PUSH_PRESENCE_SUBSCRIPTION_REQUEST_FALLBACK__DOC = (
-    "If True, legacy contacts will send a presence request subscription "
-    "when privileged roster push does not work, eg, if XEP-0356 (privileged "
-    "entity) is not available for the component."
-)
-
 AVATAR_SIZE = 200
 AVATAR_SIZE__DOC = (
     "Maximum image size (width and height), image ratio will be preserved"
@@ -138,27 +128,9 @@ PARTIAL_REGISTRATION_TIMEOUT__DOC = (
     "a single step registration process is not enough."
 )
 
-LAST_SEEN_FALLBACK = False
-LAST_SEEN_FALLBACK__DOC = (
-    "When using XEP-0319 (Last User Interaction in Presence), use the presence status"
-    " to display the last seen information in the presence status. Useful for clients"
-    " that do not implement XEP-0319. Because of implementation details, this can increase"
-    " RAM usage and might be deprecated in the future. Ask your client dev for XEP-0319"
-    " support ;o)."
-)
-
 QR_TIMEOUT = 60
 QR_TIMEOUT__DOC = "Timeout for QR code flashing confirmation."
 
-LAST_MESSAGE_CORRECTION_RETRACTION_WORKAROUND = False
-LAST_MESSAGE_CORRECTION_RETRACTION_WORKAROUND__DOC = (
-    "If the legacy service does not support last message correction but supports"
-    " message retractions, slidge can 'retract' the edited message when you edit from"
-    " an XMPP client, as a workaround. This may only work for editing messages"
-    " **once**. If the legacy service does not support retractions and this is set to"
-    " true, when XMPP clients attempt to correct, this will send a new message."
-)
-
 FIX_FILENAME_SUFFIX_MIME_TYPE = False
 FIX_FILENAME_SUFFIX_MIME_TYPE__DOC = (
     "Fix the Filename suffix based on the Mime Type of the file. Some clients (eg"
@@ -180,25 +152,12 @@ LOG_FORMAT__DOC = (
 MAM_MAX_DAYS = 7
 MAM_MAX_DAYS__DOC = "Maximum number of days for group archive retention."
 
-CORRECTION_EMPTY_BODY_AS_RETRACTION = True
-CORRECTION_EMPTY_BODY_AS_RETRACTION__DOC = (
-    "Treat last message correction to empty message as a retraction. "
-    "(this is what cheogram does for retraction)"
-)
-
 ATTACHMENT_MAXIMUM_FILE_NAME_LENGTH = 200
 ATTACHMENT_MAXIMUM_FILE_NAME_LENGTH__DOC = (
     "Some legacy network provide ridiculously long filenames, strip above this limit, "
     "preserving suffix."
 )
 
-ALWAYS_INVITE_WHEN_ADDING_BOOKMARKS = True
-ALWAYS_INVITE_WHEN_ADDING_BOOKMARKS__DOC = (
-    "Send an invitation to join MUCs when adding them to the bookmarks. While this "
-    "should not be necessary, it helps with clients that do not support :xep:`0402` "
-    "or that do not respect the auto-join flag."
-)
-
 AVATAR_RESAMPLING_THREADS = 2
 AVATAR_RESAMPLING_THREADS__DOC = (
     "Number of additional threads to use for avatar resampling. Even in a single-core "

slidge/core/dispatcher/caps.py

@@ -12,7 +12,9 @@ if TYPE_CHECKING:
 
 
 class CapsMixin(DispatcherMixin):
-    def __init__(self, xmpp: "BaseGateway"):
+    __slots__: list[str] = []
+
+    def __init__(self, xmpp: "BaseGateway") -> None:
         super().__init__(xmpp)
         xmpp.del_filter("out", xmpp.plugin["xep_0115"]._filter_add_caps)
         xmpp.add_filter("out", self._filter_add_caps)  # type:ignore
@@ -51,7 +53,12 @@ class CapsMixin(DispatcherMixin):
                 contact = await session.contacts.by_jid(pfrom)
             except XMPPError:
                 return stanza
-            ver = await contact.get_caps_ver(pfrom)
+            if contact.stored.caps_ver:
+                ver = contact.stored.caps_ver
+            else:
+                ver = await contact.get_caps_ver(pfrom)
+                contact.stored.caps_ver = ver
+                contact.commit()
         else:
             ver = await caps.get_verstring(pfrom)
 

slidge/core/dispatcher/disco.py

@@ -1,10 +1,12 @@
 import logging
 from typing import TYPE_CHECKING, Any, Optional
 
+import sqlalchemy as sa
 from slixmpp.exceptions import XMPPError
 from slixmpp.plugins.xep_0030.stanza.items import DiscoItems
 from slixmpp.types import OptJid
 
+from ...db.models import Room
 from .util import DispatcherMixin
 
 if TYPE_CHECKING:
@@ -12,7 +14,9 @@ if TYPE_CHECKING:
 
 
 class DiscoMixin(DispatcherMixin):
-    def __init__(self, xmpp: "BaseGateway"):
+    __slots__: list[str] = []
+
+    def __init__(self, xmpp: "BaseGateway") -> None:
         super().__init__(xmpp)
 
         xmpp.plugin["xep_0030"].set_node_handler(
@@ -63,8 +67,14 @@ class DiscoMixin(DispatcherMixin):
         session = await self._get_session_from_jid(ifrom)
 
         d = DiscoItems()
-        for room in self.xmpp.store.rooms.get_all_jid_and_names(session.user_pk):
-            d.add_item(room.jid, name=room.name)
+        with self.xmpp.store.session() as orm:
+            for room in orm.execute(
+                sa.select(Room)
+                .options(sa.orm.load_only(Room.jid, Room.name))
+                .filter_by(user=session.user)
+                .order_by(Room.name)
+            ).scalars():
+                d.add_item(room.jid, name=room.name)
 
         return d
 

slidge/core/dispatcher/message/__init__.py

@@ -4,7 +4,7 @@ from .message import MessageContentMixin
 
 
 class MessageMixin(ChatStateMixin, MarkerMixin, MessageContentMixin):
-    pass
+    __slots__: list[str] = []
 
 
 __all__ = ("MessageMixin",)

slidge/core/dispatcher/message/chat_state.py

@@ -5,12 +5,15 @@ from ..util import DispatcherMixin, exceptions_to_xmpp_errors
 
 
 class ChatStateMixin(DispatcherMixin):
+    __slots__: list[str] = []
+
     def __init__(self, xmpp) -> None:
         super().__init__(xmpp)
         xmpp.add_event_handler("chatstate_active", self.on_chatstate_active)
         xmpp.add_event_handler("chatstate_inactive", self.on_chatstate_inactive)
         xmpp.add_event_handler("chatstate_composing", self.on_chatstate_composing)
         xmpp.add_event_handler("chatstate_paused", self.on_chatstate_paused)
+        xmpp.add_event_handler("chatstate_gone", self.on_chatstate_gone)
 
     @exceptions_to_xmpp_errors
     async def on_chatstate_active(self, msg: StanzaBase) -> None:
@@ -18,23 +21,29 @@ class ChatStateMixin(DispatcherMixin):
         if msg["body"]:
             # if there is a body, it's handled in on_legacy_message()
             return
-        session, entity, thread = await self._get_session_entity_thread(msg)
-        await session.on_active(entity, thread)
+        session, recipient, thread = await self._get_session_recipient_thread(msg)
+        await session.on_active(recipient, thread)
 
     @exceptions_to_xmpp_errors
     async def on_chatstate_inactive(self, msg: StanzaBase) -> None:
         assert isinstance(msg, Message)
-        session, entity, thread = await self._get_session_entity_thread(msg)
-        await session.on_inactive(entity, thread)
+        session, recipient, thread = await self._get_session_recipient_thread(msg)
+        await session.on_inactive(recipient, thread)
 
     @exceptions_to_xmpp_errors
     async def on_chatstate_composing(self, msg: StanzaBase) -> None:
         assert isinstance(msg, Message)
-        session, entity, thread = await self._get_session_entity_thread(msg)
-        await session.on_composing(entity, thread)
+        session, recipient, thread = await self._get_session_recipient_thread(msg)
+        await session.on_composing(recipient, thread)
 
     @exceptions_to_xmpp_errors
     async def on_chatstate_paused(self, msg: StanzaBase) -> None:
         assert isinstance(msg, Message)
-        session, entity, thread = await self._get_session_entity_thread(msg)
-        await session.on_paused(entity, thread)
+        session, recipient, thread = await self._get_session_recipient_thread(msg)
+        await session.on_paused(recipient, thread)
+
+    @exceptions_to_xmpp_errors
+    async def on_chatstate_gone(self, msg: StanzaBase) -> None:
+        assert isinstance(msg, Message)
+        session, recipient, thread = await self._get_session_recipient_thread(msg)
+        await session.on_gone(recipient, thread)

slidge/core/dispatcher/message/marker.py

@@ -3,10 +3,12 @@ from slixmpp.xmlstream import StanzaBase
 
 from ....group.room import LegacyMUC
 from ....util.types import Recipient
-from ..util import DispatcherMixin, _get_entity, exceptions_to_xmpp_errors
+from ..util import DispatcherMixin, exceptions_to_xmpp_errors, get_recipient
 
 
 class MarkerMixin(DispatcherMixin):
+    __slots__: list[str] = []
+
     def __init__(self, xmpp) -> None:
         super().__init__(xmpp)
         xmpp.add_event_handler("marker_displayed", self.on_marker_displayed)
@@ -20,11 +22,11 @@ class MarkerMixin(DispatcherMixin):
         assert isinstance(msg, Message)
         session = await self._get_session(msg)
 
-        e: Recipient = await _get_entity(session, msg)
+        e: Recipient = await get_recipient(session, msg)
         legacy_thread = await self._xmpp_to_legacy_thread(session, msg, e)
         displayed_msg_id = msg["displayed"]["id"]
         if not isinstance(e, LegacyMUC) and self.xmpp.MARK_ALL_MESSAGES:
-            to_mark = e.get_msg_xmpp_id_up_to(displayed_msg_id)  # type: ignore
+            to_mark = e.get_msg_xmpp_id_up_to(displayed_msg_id)
             if to_mark is None:
                 session.log.debug("Can't mark all messages up to %s", displayed_msg_id)
                 to_mark = [displayed_msg_id]
@@ -32,7 +34,7 @@ class MarkerMixin(DispatcherMixin):
             to_mark = [displayed_msg_id]
         for xmpp_id in to_mark:
             await session.on_displayed(
-                e, self._xmpp_msg_id_to_legacy(session, xmpp_id), legacy_thread
+                e, self._xmpp_msg_id_to_legacy(session, xmpp_id, e), legacy_thread
             )
             if isinstance(e, LegacyMUC):
                 await e.echo(msg, None)
@@ -58,5 +60,5 @@ class MarkerMixin(DispatcherMixin):
 
         stanza_id = msg["pubsub_event"]["items"]["item"]["displayed"]["stanza_id"]["id"]
         await session.on_displayed(
-            chat, self._xmpp_msg_id_to_legacy(session, stanza_id)
+            chat, self._xmpp_msg_id_to_legacy(session, stanza_id, chat)
         )