slidge 0.1.3__py3-none-any.whl → 0.2.0__py3-none-any.whl

slidge/core/config.py

@@ -43,11 +43,18 @@ PORT__SHORT = "p"
 
 HOME_DIR: Path
 HOME_DIR__DOC = (
-    "Shelve file used to store persistent user data. "
+    "Directory where slidge will writes it persistent data and cache. "
     "Defaults to /var/lib/slidge/${SLIDGE_JID}. "
 )
 HOME_DIR__DYNAMIC_DEFAULT = True
 
+DB_URL: str
+DB_URL__DOC = (
+    "Database URL, see <https://docs.sqlalchemy.org/en/20/core/engines.html#database-urls>. "
+    "Defaults to sqlite:///${HOME_DIR}/slidge.sqlite"
+)
+DB_URL__DYNAMIC_DEFAULT = True
+
 USER_JID_VALIDATOR: str
 USER_JID_VALIDATOR__DOC = (
     "Regular expression to restrict users that can register to the gateway, by JID. "
@@ -70,7 +77,7 @@ UPLOAD_SERVICE__DOC = (
 )
 
 SECRET_KEY: Optional[str] = None
-SECRET_KEY__DOC = "Encryption for disk storage"
+SECRET_KEY__DOC = "Encryption for disk storage. Deprecated."
 
 NO_ROSTER_PUSH = False
 NO_ROSTER_PUSH__DOC = "Do not fill users' rosters with legacy contacts automatically"
@@ -135,19 +142,18 @@ PARTIAL_REGISTRATION_TIMEOUT__DOC = (
     "a single step registration process is not enough."
 )
 
-LAST_SEEN_FALLBACK = True
+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."
+    " 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."
 
-DOWNLOAD_CHUNK_SIZE = 1024
-DOWNLOAD_CHUNK_SIZE__DOC = "Chunk size when slidge needs to download files using HTTP."
-
 LAST_MESSAGE_CORRECTION_RETRACTION_WORKAROUND = False
 LAST_MESSAGE_CORRECTION_RETRACTION_WORKAROUND__DOC = (
     "If the legacy service does not support last message correction but supports"
@@ -176,10 +182,7 @@ LOG_FORMAT__DOC = (
 )
 
 MAM_MAX_DAYS = 7
-MAM_MAX_DAYS__DOC = (
-    "Maximum number of days for group archive retention. "
-    "Since all text content stored in RAM right now, "
-)
+MAM_MAX_DAYS__DOC = "Maximum number of days for group archive retention."
 
 CORRECTION_EMPTY_BODY_AS_RETRACTION = True
 CORRECTION_EMPTY_BODY_AS_RETRACTION__DOC = (
@@ -212,5 +215,8 @@ DEV_MODE__DOC = (
     "Not safe to use in prod, but great during dev."
 )
 
-SYNC_AVATAR = True
-SYNC_AVATAR__DOC = "Sync the user XMPP avatar to legacy network (if supported)."
+STRIP_LEADING_EMOJI_ADHOC = False
+STRIP_LEADING_EMOJI_ADHOC__DOC = (
+    "Strip the leading emoji in ad-hoc command names, if present, in case you "
+    "are a emoji-hater."
+)

slidge/core/dispatcher/__init__.py

@@ -0,0 +1,3 @@
+from .session_dispatcher import SessionDispatcher
+
+__all__ = ("SessionDispatcher",)

slidge/core/{gateway → dispatcher}/caps.py

@@ -5,19 +5,19 @@ from slixmpp import Presence
 from slixmpp.exceptions import XMPPError
 from slixmpp.xmlstream import StanzaBase
 
-from ...contact import LegacyContact
+from .util import DispatcherMixin
 
 if TYPE_CHECKING:
-    from .base import BaseGateway
+    from slidge.core.gateway import BaseGateway
 
 
-class Caps:
+class CapsMixin(DispatcherMixin):
     def __init__(self, xmpp: "BaseGateway"):
-        self.xmpp = xmpp
+        super().__init__(xmpp)
         xmpp.del_filter("out", xmpp.plugin["xep_0115"]._filter_add_caps)
         xmpp.add_filter("out", self._filter_add_caps)  # type:ignore
 
-    async def _filter_add_caps(self, stanza: StanzaBase):
+    async def _filter_add_caps(self, stanza: StanzaBase) -> StanzaBase:
         # we rolled our own "add caps on presences" filter because
         # there is too much magic happening in slixmpp
         # anyway, we probably want to roll our own "dynamic disco"/caps
@@ -25,6 +25,9 @@ class Caps:
         if not isinstance(stanza, Presence):
             return stanza
 
+        if stanza.get_plugin("caps", check=True):
+            return stanza
+
         if stanza["type"] not in ("available", "chat", "away", "dnd", "xa"):
             return stanza
 
@@ -44,10 +47,11 @@ class Caps:
 
             await session.ready
 
-            entity = await session.get_contact_or_group_or_participant(pfrom)
-            if not isinstance(entity, LegacyContact):
+            try:
+                contact = await session.contacts.by_jid(pfrom)
+            except XMPPError:
                 return stanza
-            ver = await entity.get_caps_ver(pfrom)
+            ver = await contact.get_caps_ver(pfrom)
         else:
             ver = await caps.get_verstring(pfrom)
 

slidge/core/{gateway → dispatcher}/disco.py

@@ -5,15 +5,15 @@ from slixmpp.exceptions import XMPPError
 from slixmpp.plugins.xep_0030.stanza.items import DiscoItems
 from slixmpp.types import OptJid
 
-from ...util.db import user_store
+from .util import DispatcherMixin
 
 if TYPE_CHECKING:
-    from .base import BaseGateway
+    from slidge.core.gateway import BaseGateway
 
 
-class Disco:
+class DiscoMixin(DispatcherMixin):
     def __init__(self, xmpp: "BaseGateway"):
-        self.xmpp = xmpp
+        super().__init__(xmpp)
 
         xmpp.plugin["xep_0030"].set_node_handler(
             "get_info",
@@ -38,15 +38,11 @@ class Disco:
         if ifrom is None:
             raise XMPPError("subscription-required")
 
-        user = user_store.get_by_jid(ifrom)
-        if user is None:
-            raise XMPPError("registration-required")
-        session = self.xmpp.get_session_from_user(user)
-        await session.wait_for_ready()
+        assert jid is not None
+        session = await self._get_session_from_jid(jid=ifrom)
 
         log.debug("Looking for entity: %s", jid)
 
-        assert jid is not None
         entity = await session.get_contact_or_group_or_participant(jid)
 
         if entity is None:
@@ -63,16 +59,12 @@ class Disco:
         if jid != self.xmpp.boundjid.bare:
             return DiscoItems()
 
-        user = user_store.get_by_jid(ifrom)
-        if user is None:
-            raise XMPPError("registration-required")
-
-        session = self.xmpp.get_session_from_user(user)
-        await session.wait_for_ready()
+        assert ifrom is not None
+        session = await self._get_session_from_jid(ifrom)
 
         d = DiscoItems()
-        for muc in sorted(session.bookmarks, key=lambda m: m.name):
-            d.add_item(muc.jid, name=muc.name)
+        for room in self.xmpp.store.rooms.get_all_jid_and_names(session.user_pk):
+            d.add_item(room.jid, name=room.name)
 
         return d
 

slidge/core/dispatcher/message/__init__.py

@@ -0,0 +1,10 @@
+from .chat_state import ChatStateMixin
+from .marker import MarkerMixin
+from .message import MessageContentMixin
+
+
+class MessageMixin(ChatStateMixin, MarkerMixin, MessageContentMixin):
+    pass
+
+
+__all__ = ("MessageMixin",)

slidge/core/dispatcher/message/chat_state.py

@@ -0,0 +1,40 @@
+from slixmpp import Message
+from slixmpp.xmlstream import StanzaBase
+
+from ..util import DispatcherMixin, exceptions_to_xmpp_errors
+
+
+class ChatStateMixin(DispatcherMixin):
+    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)
+
+    @exceptions_to_xmpp_errors
+    async def on_chatstate_active(self, msg: StanzaBase) -> None:
+        assert isinstance(msg, Message)
+        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)
+
+    @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)
+
+    @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)
+
+    @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)

slidge/core/dispatcher/message/marker.py

@@ -0,0 +1,62 @@
+from slixmpp import JID, Message
+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
+
+
+class MarkerMixin(DispatcherMixin):
+    def __init__(self, xmpp) -> None:
+        super().__init__(xmpp)
+        xmpp.add_event_handler("marker_displayed", self.on_marker_displayed)
+        xmpp.add_event_handler(
+            "message_displayed_synchronization_publish",
+            self.on_message_displayed_synchronization_publish,
+        )
+
+    @exceptions_to_xmpp_errors
+    async def on_marker_displayed(self, msg: StanzaBase) -> None:
+        assert isinstance(msg, Message)
+        session = await self._get_session(msg)
+
+        e: Recipient = await _get_entity(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
+            if to_mark is None:
+                session.log.debug("Can't mark all messages up to %s", displayed_msg_id)
+                to_mark = [displayed_msg_id]
+        else:
+            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
+            )
+            if isinstance(e, LegacyMUC):
+                await e.echo(msg, None)
+
+    @exceptions_to_xmpp_errors
+    async def on_message_displayed_synchronization_publish(
+        self, msg: StanzaBase
+    ) -> None:
+        assert isinstance(msg, Message)
+        chat_jid = JID(msg["pubsub_event"]["items"]["item"]["id"])
+        if chat_jid.server != self.xmpp.boundjid.bare:
+            return
+
+        session = await self._get_session(msg, timeout=None)
+
+        if chat_jid == self.xmpp.boundjid.bare:
+            return
+
+        chat = await session.get_contact_or_group_or_participant(chat_jid)
+        if not isinstance(chat, LegacyMUC):
+            session.log.debug("Ignoring non-groupchat MDS event")
+            return
+
+        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)
+        )