slidge 0.2.0a9__py3-none-any.whl → 0.2.0b0__py3-none-any.whl

slidge/__main__.py

@@ -1,4 +1,3 @@
-if __name__ == "__main__":
-    from slidge.main import main
+from slidge.main import main
 
-    main()
+main()

slidge/__version__.py

@@ -2,4 +2,4 @@ from slidge.util.util import get_version  # noqa: F401
 
 # this is modified before publish, but if someone cloned from the repo,
 # it can help
-__version__ = "0.2.0alpha9"
+__version__ = "0.2.0beta0"

slidge/command/adhoc.py

@@ -13,7 +13,7 @@ from . import Command, CommandResponseType, Confirmation, Form, TableResult
 from .base import FormField
 
 if TYPE_CHECKING:
-    from ..core.gateway.base import BaseGateway
+    from ..core.gateway import BaseGateway
     from ..core.session import BaseSession
 
 

slidge/command/base.py

@@ -6,9 +6,9 @@ from typing import (
     Any,
     Awaitable,
     Callable,
-    Collection,
     Iterable,
     Optional,
+    Sequence,
     Type,
     TypedDict,
     Union,
@@ -54,11 +54,11 @@ class TableResult:
     Structured data as the result of a command
     """
 
-    fields: Collection["FormField"]
+    fields: Sequence["FormField"]
     """
     The 'columns names' of the table.
     """
-    items: Collection[dict[str, Union[str, JID]]]
+    items: Sequence[dict[str, Union[str, JID]]]
     """
     The rows of the table. Each row is a dict where keys are the fields ``var``
     attribute.
@@ -149,7 +149,7 @@ class Form:
 
     title: str
     instructions: str
-    fields: Collection["FormField"]
+    fields: Sequence["FormField"]
     handler: FormHandlerType
     handler_args: Iterable[Any] = field(default_factory=list)
     handler_kwargs: dict[str, Any] = field(default_factory=dict)

slidge/command/user.py

@@ -305,7 +305,10 @@ class LeaveGroup(Command):
                 FormField(
                     "group",
                     "Group name",
-                    options=[{"label": g.name, "value": g.name} for g in groups],
+                    type="list-single",
+                    options=[
+                        {"label": g.name, "value": str(i)} for i, g in enumerate(groups)
+                    ],
                 )
             ],
             handler=self.confirm,  # type:ignore
@@ -329,3 +332,4 @@ class LeaveGroup(Command):
     @staticmethod
     async def finish(session: AnyBaseSession, _ifrom, group: LegacyMUC):
         await session.on_leave_group(group.legacy_id)
+        await session.bookmarks.remove(group, reason="You left this group via slidge.")

slidge/contact/roster.py

@@ -92,6 +92,13 @@ class LegacyRoster(
                 stored = self.__store.get_by_jid(self.session.user_pk, contact_jid)
                 return await self.__update_contact(stored, legacy_id, username)
 
+    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)
+            if stored is not None and stored.updated:
+                return self._contact_cls.from_store(self.session, stored)
+        return None
+
     async def by_legacy_id(
         self, legacy_id: LegacyUserIdType, *args, **kwargs
     ) -> LegacyContactType:
@@ -147,6 +154,8 @@ class LegacyRoster(
         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)

slidge/core/config.py

@@ -154,9 +154,6 @@ LAST_SEEN_FALLBACK__DOC = (
 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"

slidge/core/dispatcher/__init__.py

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

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

@@ -5,17 +5,19 @@ from slixmpp import Presence
 from slixmpp.exceptions import XMPPError
 from slixmpp.xmlstream import StanzaBase
 
+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

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

@@ -5,13 +5,15 @@ from slixmpp.exceptions import XMPPError
 from slixmpp.plugins.xep_0030.stanza.items import DiscoItems
 from slixmpp.types import OptJid
 
+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",
@@ -36,15 +38,11 @@ class Disco:
         if ifrom is None:
             raise XMPPError("subscription-required")
 
-        user = self.xmpp.store.users.get(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:
@@ -61,16 +59,12 @@ class Disco:
         if jid != self.xmpp.boundjid.bare:
             return DiscoItems()
 
-        user = self.xmpp.store.users.get(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)
+        )