slidge 0.2.0a9__tar.gz → 0.2.0a10__tar.gz

{slidge-0.2.0a9 → slidge-0.2.0a10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: slidge
-Version: 0.2.0a9
+Version: 0.2.0a10
 Summary: XMPP bridging framework
 Home-page: https://sr.ht/~nicoco/slidge/
 License: AGPL-3.0-or-later
@@ -16,6 +16,7 @@ Requires-Dist: ConfigArgParse (>=1.5.3,<2.0.0)
 Requires-Dist: Pillow (>=10,<11)
 Requires-Dist: aiohttp[speedups] (>=3.8.3,<4.0.0)
 Requires-Dist: alembic (>=1.13.1,<2.0.0)
+Requires-Dist: defusedxml (>=0.7.1,<0.8.0)
 Requires-Dist: pickle-secure (>=0.99.9,<0.100.0)
 Requires-Dist: python-magic (>=0.4.27,<0.5.0)
 Requires-Dist: qrcode (>=7.4.1,<8.0.0)

{slidge-0.2.0a9 → slidge-0.2.0a10}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "slidge"
-version = "0.2.0alpha9"
+version = "0.2.0alpha10"
 description = "XMPP bridging framework"
 authors = ["Nicolas Cedilnik <nicoco@nicoco.fr>"]
 readme = "README.md"
@@ -29,6 +29,7 @@ slixmpp = "^1.8.5"
 sqlalchemy = "^2.0.29"
 alembic = "^1.13.1"
 thumbhash = "^0.1.2"
+defusedxml = "^0.7.1"
 
 [build-system]
 requires = ["poetry-core>=1.0.0"]

{slidge-0.2.0a9 → slidge-0.2.0a10}/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.0alpha10"

{slidge-0.2.0a9 → slidge-0.2.0a10}/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-0.2.0a9 → slidge-0.2.0a10}/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-0.2.0a9 → slidge-0.2.0a10}/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:

slidge-0.2.0a10/slidge/core/dispatcher/__init__.py

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

{slidge-0.2.0a9/slidge/core/gateway → slidge-0.2.0a10/slidge/core/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-0.2.0a9/slidge/core/gateway → slidge-0.2.0a10/slidge/core/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-0.2.0a10/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-0.2.0a10/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-0.2.0a10/slidge/core/dispatcher/message/marker.py

@@ -0,0 +1,67 @@
+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,
+    _xmpp_to_legacy_thread,
+    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 _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)
+        )