slidge 0.2.7.post1__py3-none-any.whl → 0.2.9__py3-none-any.whl

slidge/__init__.py

@@ -6,6 +6,7 @@ Contains importable classes for a minimal function :term:`Legacy Module`.
 
 import sys
 import warnings
+from importlib.metadata import PackageNotFoundError, version
 
 from . import slixfix  # noqa: F401
 from .command import FormField, SearchResult  # noqa: F401
@@ -37,8 +38,15 @@ def formatwarning(message, category, filename, lineno, line=""):
 
 warnings.formatwarning = formatwarning
 
+try:
+    __version__ = version("slidge")
+except PackageNotFoundError:
+    # package is not installed
+    __version__ = "dev"
+
 
 __all__ = [
+    "__version__",
     "BaseGateway",
     "BaseSession",
     # For backwards compatibility, these names are still importable from the

slidge/command/admin.py

@@ -60,8 +60,6 @@ class SlidgeInfo(AdminCommand):
     ACCESS = CommandAccess.ANY
 
     async def run(self, _session, _ifrom, *_):
-        from slidge.__version__ import __version__
-
         start = self.xmpp.datetime_started  # type:ignore
         uptime = datetime.now() - start
 
@@ -100,8 +98,10 @@ class SlidgeInfo(AdminCommand):
         legacy_module = importlib.import_module(config.LEGACY_MODULE)
         version = getattr(legacy_module, "__version__", "No version")
 
+        import slidge
+
         return (
-            f"{self.xmpp.COMPONENT_NAME} (slidge core {__version__},"
+            f"{self.xmpp.COMPONENT_NAME} (slidge core {slidge.__version__},"
             f" {config.LEGACY_MODULE} {version})\n"
             f"Up since {start:%Y-%m-%d %H:%M} ({ago} ago)"
         )

slidge/contact/contact.py

@@ -218,7 +218,7 @@ class LegacyContact(
         self.log.name = f"{self.user_jid.bare}:contact:{self}"
 
     def __repr__(self):
-        return f"<Contact #{self.contact_pk} '{self.name}' ({self.legacy_id} - {self.jid.local})'>"
+        return f"<Contact #{self.contact_pk} '{self.name}' ({self.legacy_id} - {self.jid.user})'>"
 
     def __ensure_pk(self):
         if self.contact_pk is not None:
@@ -617,7 +617,7 @@ class LegacyContact(
         contact = cls(
             session,
             cls.xmpp.LEGACY_CONTACT_ID_TYPE(stored.legacy_id),
-            stored.jid.username,  # type: ignore
+            stored.jid.user,  # type: ignore
             *args,  # type: ignore
             **kwargs,  # type: ignore
         )

slidge/contact/roster.py

@@ -5,12 +5,12 @@ from typing import TYPE_CHECKING, AsyncIterator, Generic, Iterator, Optional, Ty
 
 from slixmpp import JID
 from slixmpp.exceptions import IqError, IqTimeout, XMPPError
-from slixmpp.jid import JID_UNESCAPE_TRANSFORMATIONS, _unescape_node
 
 from ..core.mixins.lock import NamedLockMixin
 from ..db.models import Contact
 from ..db.store import ContactStore
 from ..util import SubclassableOnce
+from ..util.jid_escaping import ESCAPE_TABLE, unescape_node
 from ..util.types import LegacyContactType, LegacyUserIdType
 from .contact import LegacyContact
 
@@ -198,7 +198,7 @@ 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)
 
     async def _fill(self):
         try:
@@ -259,5 +259,4 @@ class LegacyRoster(
         yield
 
 
-ESCAPE_TABLE = "".maketrans({v: k for k, v in JID_UNESCAPE_TRANSFORMATIONS.items()})
 log = logging.getLogger(__name__)

slidge/core/dispatcher/session_dispatcher.py

@@ -52,7 +52,6 @@ class SessionDispatcher(
         if session.user.avatar_hash == hash_:
             session.log.debug("We already know this avatar hash")
             return
-        self.xmpp.store.users.set_avatar_hash(session.user_pk, None)
 
         if hash_:
             try:
@@ -67,6 +66,7 @@ class SessionDispatcher(
             height = info["height"]
             width = info["width"]
         else:
+            self.xmpp.store.users.set_avatar_hash(session.user_pk, None)
             bytes_ = type_ = height = width = hash_ = None
         try:
             await session.on_avatar(bytes_, hash_, type_, width, height)
@@ -79,6 +79,11 @@ class SessionDispatcher(
             session.send_gateway_message(
                 f"Something went wrong trying to set your avatar: {e!r}"
             )
+        else:
+            self.xmpp.store.users.set_avatar_hash(session.user_pk, hash_)
+            for room in session.bookmarks:
+                participant = await room.get_user_participant()
+                participant.send_last_presence(force=True, no_cache_online=True)
 
 
 log = logging.getLogger(__name__)

slidge/core/gateway.py

@@ -526,6 +526,7 @@ class BaseGateway(
                 "You are not connected to this gateway! "
                 f"Maybe this message will tell you why: {e}"
             )
+            session.logged = False
             return
 
         log.info("Login success for %s", session.user_jid)
@@ -559,8 +560,18 @@ class BaseGateway(
                 self.xmpp.plugin["xep_0084"].stanza.MetaData.namespace,
                 ifrom=self.boundjid.bare,
             )
-        except (IqError, IqTimeout):
-            self.xmpp.store.users.set_avatar_hash(session.user_pk, None)
+        except IqTimeout:
+            self.log.warning("Iq timeout trying to fetch user avatar")
+            return
+        except IqError as e:
+            self.log.debug("Iq error when trying to fetch user avatar: %s", e)
+            if e.condition == "item-not-found":
+                try:
+                    await session.on_avatar(None, None, None, None, None)
+                except NotImplementedError:
+                    pass
+                else:
+                    self.xmpp.store.users.set_avatar_hash(session.user_pk, None)
             return
         await self.__dispatcher.on_avatar_metadata_info(
             session, iq["pubsub"]["items"]["item"]["avatar_metadata"]["info"]

slidge/core/mixins/message_maker.py

@@ -4,7 +4,7 @@ from datetime import datetime, timezone
 from typing import TYPE_CHECKING, Iterable, Optional, cast
 from uuid import uuid4
 
-from slixmpp import Message
+from slixmpp import JID, Message
 from slixmpp.types import MessageTypes
 
 from ...db.models import GatewayUser
@@ -120,14 +120,14 @@ class MessageMaker(BaseSender):
                         DeprecationWarning,
                     )
                 if muc:
-                    jid = copy(muc.jid)
+                    jid = JID(muc.jid)
                     jid.resource = fallback_nick = muc.user_nick
                     msg["reply"]["to"] = jid
                 else:
                     msg["reply"]["to"] = self.session.user_jid
                     # TODO: here we should use preferably use the PEP nick of the user
                     # (but it doesn't matter much)
-                    fallback_nick = self.session.user_jid.local
+                    fallback_nick = self.session.user_jid.user
             else:
                 if muc:
                     if hasattr(entity, "muc"):

slidge/core/session.py

@@ -543,10 +543,10 @@ class BaseSession(
         return f"<Session of {self.user_jid}>"
 
     def shutdown(self, logout=True) -> asyncio.Task:
-        for c in self.contacts:
-            c.offline()
         for m in self.bookmarks:
             m.shutdown()
+        for c in self.contacts:
+            c.offline()
         if logout:
             return self.xmpp.loop.create_task(self.logout())
         else:

slidge/db/store.py

@@ -443,6 +443,7 @@ class ContactStore(UpdatedMixin):
                     break
             for row_id in to_del:
                 session.execute(delete(ContactSent).where(ContactSent.id == row_id))
+            session.commit()
         return result
 
     def set_friend(self, contact_pk: int, is_friend: bool) -> None:
@@ -751,6 +752,8 @@ class MultiStore(EngineMixin):
             ).scalar()
             if multi is None:
                 return None
+            if multi.legacy_ids_multi is None:
+                return None
             return multi.legacy_ids_multi.legacy_id
 
 

slidge/group/archive.py

@@ -150,19 +150,27 @@ def archivable(msg: Message):
     :return:
     """
 
-    if msg.get_plugin("hint", check=True) and msg["hint"] == "no-store":
+    if msg.get_plugin("no-store", check=True):
         return False
 
+    if msg.get_plugin("no-permanent-store", check=True):
+        return False
+
+    if msg.get_plugin("store", check=True):
+        return True
+
     if msg["body"]:
         return True
 
-    if msg.get_plugin("apply_to", check=True):
-        # retractions
+    if msg.get_plugin("retract", check=True):
         return True
 
     if msg.get_plugin("reactions", check=True):
         return True
 
+    if msg.get_plugin("displayed", check=True):
+        return True
+
     return False
 
 

slidge/group/bookmarks.py

@@ -4,12 +4,11 @@ from typing import TYPE_CHECKING, Generic, Iterator, Optional, Type
 
 from slixmpp import JID
 from slixmpp.exceptions import XMPPError
-from slixmpp.jid import _unescape_node
 
-from ..contact.roster import ESCAPE_TABLE
 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.types import LegacyGroupIdType, LegacyMUCType
 from .archive import MessageArchive
 from .room import LegacyMUC
@@ -83,14 +82,14 @@ class LegacyBookmarks(
         :param username:
         :return:
         """
-        return _unescape_node(username)
+        return unescape_node(username)
 
     async def by_jid(self, jid: JID) -> LegacyMUCType:
         if jid.resource:
             jid = JID(jid.bare)
         async with self.lock(("bare", jid.bare)):
-            assert isinstance(jid.local, str)
-            legacy_id = await self.jid_local_part_to_legacy_id(jid.local)
+            assert isinstance(jid.user, str)
+            legacy_id = await self.jid_local_part_to_legacy_id(jid.user)
             if self.get_lock(("legacy_id", legacy_id)):
                 self.log.debug("Not instantiating %s after all", jid)
                 return await self.by_legacy_id(legacy_id)

slidge/group/participant.py

@@ -1,6 +1,5 @@
 import logging
 import string
-import stringprep
 import uuid
 import warnings
 from copy import copy
@@ -10,9 +9,7 @@ from typing import TYPE_CHECKING, Optional, Self, Union
 
 from slixmpp import JID, InvalidJID, Message, Presence
 from slixmpp.plugins.xep_0045.stanza import MUCAdminItem
-from slixmpp.stringprep import StringprepError, resourceprep
 from slixmpp.types import MessageTypes, OptJid
-from slixmpp.util.stringprep_profiles import StringPrepError, prohibit_output
 
 from ..contact import LegacyContact
 from ..core.mixins import (
@@ -175,39 +172,22 @@ class LegacyParticipant(
         self.send_last_presence(force=True, no_cache_online=True)
 
     def __update_jid(self, unescaped_nickname: Optional[str]):
-        j: JID = copy(self.muc.jid)
-
-        if self.is_system:
-            self.jid = j
-            self._nickname_no_illegal = ""
+        if not unescaped_nickname:
+            self.jid = JID(self.muc.jid)
+            if self.is_system:
+                self._nickname_no_illegal = ""
+            else:
+                warnings.warn(
+                    "Only the system participant is allowed to not have a nickname"
+                )
+                nickname = f"unnamed-{uuid.uuid4()}"
+                self.jid.resource = self._nickname_no_illegal = nickname
             return
 
-        nickname = unescaped_nickname
-
-        if nickname:
-            nickname = self._nickname_no_illegal = strip_illegal_chars(nickname)
-        else:
-            warnings.warn(
-                "Only the system participant is allowed to not have a nickname"
-            )
-            nickname = f"unnamed-{uuid.uuid4()}"
-
-        assert isinstance(nickname, str)
-
-        try:
-            # workaround for https://codeberg.org/poezio/slixmpp/issues/3480
-            prohibit_output(nickname, [stringprep.in_table_a1])
-            resourceprep(nickname)
-        except (StringPrepError, StringprepError):
-            nickname = nickname.encode("punycode").decode()
-
-        # at this point there still might be control chars
-        try:
-            j.resource = nickname
-        except InvalidJID:
-            j.resource = strip_non_printable(nickname)
-
-        self.jid = j
+        self._nickname_no_illegal, self.jid = escape_nickname(
+            self.muc.jid,
+            unescaped_nickname,
+        )
 
     def send_configuration_change(self, codes: tuple[int]):
         if not self.is_system:
@@ -270,7 +250,7 @@ class LegacyParticipant(
                 if user_full_jid:
                     p["muc"]["jid"] = user_full_jid
                 else:
-                    jid = copy(self.user_jid)
+                    jid = JID(self.user_jid)
                     try:
                         jid.resource = next(
                             iter(self.muc.get_user_resources())  # type:ignore
@@ -539,4 +519,22 @@ class LegacyParticipant(
         return part
 
 
+def escape_nickname(muc_jid: JID, nickname: str) -> tuple[str, JID]:
+    nickname = nickname_no_illegal = strip_illegal_chars(nickname)
+
+    jid = JID(muc_jid)
+
+    try:
+        jid.resource = nickname
+    except InvalidJID:
+        nickname = nickname.encode("punycode").decode()
+        try:
+            jid.resource = nickname
+        except InvalidJID:
+            # at this point there still might be control chars
+            jid.resource = strip_non_printable(nickname)
+
+    return nickname_no_illegal, jid
+
+
 log = logging.getLogger(__name__)

slidge/group/room.py

@@ -10,11 +10,12 @@ from uuid import uuid4
 
 from slixmpp import JID, Iq, Message, Presence
 from slixmpp.exceptions import IqError, IqTimeout, XMPPError
-from slixmpp.jid import _unescape_node
 from slixmpp.plugins.xep_0004 import Form
 from slixmpp.plugins.xep_0060.stanza import Item
 from slixmpp.plugins.xep_0082 import parse as str_to_datetime
 from slixmpp.plugins.xep_0469.stanza import NS as PINNING_NS
+from slixmpp.plugins.xep_0492.stanza import NS as NOTIFY_NS
+from slixmpp.plugins.xep_0492.stanza import WhenLiteral
 from slixmpp.xmlstream import ET
 
 from ..contact.contact import LegacyContact
@@ -27,9 +28,8 @@ from ..core.mixins.disco import ChatterDiscoMixin
 from ..core.mixins.lock import NamedLockMixin
 from ..core.mixins.recipient import ReactionRecipientMixin, ThreadRecipientMixin
 from ..db.models import Room
-from ..slixfix.xep_0492.stanza import NS as NOTIFY_NS
-from ..slixfix.xep_0492.stanza import WhenLiteral
 from ..util import ABCSubclassableOnceAtMost
+from ..util.jid_escaping import unescape_node
 from ..util.types import (
     HoleBound,
     LegacyGroupIdType,
@@ -42,7 +42,7 @@ from ..util.types import (
 )
 from ..util.util import deprecated, timeit, with_session
 from .archive import MessageArchive
-from .participant import LegacyParticipant
+from .participant import LegacyParticipant, escape_nickname
 
 if TYPE_CHECKING:
     from ..core.gateway import BaseGateway
@@ -184,7 +184,7 @@ class LegacyMUC(
         self.log = logging.getLogger(f"{self.user_jid}:muc:{self}")
 
     def __repr__(self):
-        return f"<MUC #{self.pk} '{self.name}' ({self.legacy_id} - {self.jid.local})'>"
+        return f"<MUC #{self.pk} '{self.name}' ({self.legacy_id} - {self.jid.user})'>"
 
     @property
     def subject_date(self) -> Optional[datetime]:
@@ -515,8 +515,7 @@ class LegacyMUC(
         return r
 
     def shutdown(self):
-        user_jid = copy(self.jid)
-        user_jid.resource = self.user_nick
+        _, user_jid = escape_nickname(self.jid, self.user_nick)
         for user_full_jid in self.user_full_jids():
             presence = self.xmpp.make_presence(
                 pfrom=user_jid, pto=user_full_jid, ptype="unavailable"
@@ -528,14 +527,13 @@ class LegacyMUC(
 
     def user_full_jids(self):
         for r in self._user_resources:
-            j = copy(self.user_jid)
+            j = JID(self.user_jid)
             j.resource = r
             yield j
 
     @property
     def user_muc_jid(self):
-        user_muc_jid = copy(self.jid)
-        user_muc_jid.resource = self.user_nick
+        _, user_muc_jid = escape_nickname(self.jid, self.user_nick)
         return user_muc_jid
 
     def _legacy_to_xmpp(self, legacy_id: LegacyMessageType):
@@ -782,7 +780,7 @@ class LegacyMUC(
                         self.session, stored, muc=self, contact=c
                     )
 
-        nickname = c.name or _unescape_node(c.jid_username)
+        nickname = c.name or unescape_node(c.jid_username)
 
         if self.pk is None:
             nick_available = True
@@ -990,7 +988,7 @@ class LegacyMUC(
 
         :param r: The resource to kick
         """
-        pto = self.user_jid
+        pto = JID(self.user_jid)
         pto.resource = r
         p = self.xmpp.make_presence(
             pfrom=(await self.get_user_participant()).jid, pto=pto
@@ -1018,8 +1016,11 @@ class LegacyMUC(
             item = ans["pubsub"]["items"]["item"]
             item["id"] = self.jid
             return item
-        except (IqError, IqTimeout) as exc:
-            warnings.warn(f"Cannot fetch bookmark: {exc}")
+        except IqTimeout as exc:
+            warnings.warn(f"Cannot fetch bookmark for {self.user_jid}: timeout")
+            return None
+        except IqError as exc:
+            warnings.warn(f"Cannot fetch bookmark for {self.user_jid}: {exc}")
             return None
         except PermissionError:
             warnings.warn(

slidge/main.py

@@ -24,8 +24,8 @@ from pathlib import Path
 
 import configargparse
 
+import slidge
 from slidge import BaseGateway
-from slidge.__version__ import __version__
 from slidge.core import config
 from slidge.core.pubsub import PepAvatar, PepNick
 from slidge.db import SlidgeStore
@@ -96,7 +96,7 @@ def get_configurator():
     p.add_argument(
         "--version",
         action="version",
-        version=f"%(prog)s {__version__}",
+        version=f"%(prog)s {slidge.__version__}",
     )
     configurator = MainConfig(config, p)
     return configurator
@@ -128,7 +128,7 @@ def main():
     signal.signal(signal.SIGTERM, handle_sigterm)
 
     unknown_argv = configure()
-    logging.info("Starting slidge version %s", __version__)
+    logging.info("Starting slidge version %s", slidge.__version__)
 
     legacy_module = importlib.import_module(config.LEGACY_MODULE)
     logging.debug("Legacy module: %s", dir(legacy_module))

slidge/slixfix/__init__.py

@@ -3,13 +3,12 @@
 
 # ruff: noqa: F401
 
+import logging
+
 import slixmpp.plugins
-from slixmpp import Iq, Message
-from slixmpp.exceptions import _DEFAULT_ERROR_TYPES, XMPPError
-from slixmpp.plugins.xep_0004.stanza.field import FormField
+import slixmpp.stanza.roster
+from slixmpp import InvalidJID, Message
 from slixmpp.plugins.xep_0050 import XEP_0050, Command
-from slixmpp.plugins.xep_0231 import XEP_0231
-from slixmpp.plugins.xep_0425.stanza import Moderate
 from slixmpp.plugins.xep_0469.stanza import NS as PINNED_NS
 from slixmpp.plugins.xep_0469.stanza import Pinned
 from slixmpp.xmlstream import StanzaBase
@@ -20,38 +19,25 @@ from . import (
     xep_0100,
     xep_0153,
     xep_0292,
-    xep_0492,
 )
 
-# TODO: remove this when the fix is included in slixmpp
-Moderate.interfaces.add("id")
-
-_DEFAULT_ERROR_TYPES["policy-violation"] = "modify"  # type:ignore
-
 
-async def _handle_bob_iq(self, iq: Iq):
-    cid = iq["bob"]["cid"]
+# TODO: remove this when we pin slixmpp > 1.9.0
+def get_items(self):
+    items = {}
+    for item in self["substanzas"]:
+        if isinstance(item, slixmpp.stanza.roster.RosterItem):
+            try:
+                items[item["jid"]] = item.values
+            except InvalidJID:
+                logging.warning("Invalid JID in roster: %s", item)
+                continue
+            del items[item["jid"]]["jid"]
+            del items[item["jid"]]["lang"]
+    return items
 
-    if iq["type"] == "result":
-        await self.api["set_bob"](iq["from"], None, iq["to"], args=iq["bob"])
-        self.xmpp.event("bob", iq)
-    elif iq["type"] == "get":
-        data = await self.api["get_bob"](iq["to"], None, iq["from"], args=cid)
 
-        if data is None:
-            raise XMPPError(
-                "item-not-found",
-                f"Bits of binary '{cid}' is not available.",
-            )
-
-        if isinstance(data, Iq):
-            data["id"] = iq["id"]
-            data.send()
-            return
-
-        iq = iq.reply()
-        iq.append(data)
-        iq.send()
+slixmpp.stanza.roster.Roster.get_items = get_items  # type:ignore
 
 
 def set_pinned(self, val: bool):
@@ -65,9 +51,6 @@ def set_pinned(self, val: bool):
 Pinned.set_pinned = set_pinned
 
 
-XEP_0231._handle_bob_iq = _handle_bob_iq
-
-
 def session_bind(self, jid):
     self.xmpp["xep_0030"].add_feature(Command.namespace)
     # awful hack to for the disco items: we need to comment this line
@@ -101,52 +84,9 @@ def reply(self, body=None, clear=True):
 Message.reply = reply  # type: ignore
 
 
-FormField.set_value_base = FormField.set_value  # type:ignore
-
-
-def set_value(self: FormField, value):
-    if not self._type:
-        if isinstance(value, bool):
-            self._type = "boolean"
-        elif isinstance(value, str):
-            self._type = "text-single"
-        elif isinstance(value, (list, tuple)):
-            self._type = "text-multi"
-
-    FormField.set_value_base(self, value)
-
-
-def get_value(self, convert=True, convert_list=False):
-    valsXML = self.xml.findall("{%s}value" % self.namespace)
-    if len(valsXML) == 0:
-        return None
-    elif self._type == "boolean":
-        if convert:
-            return valsXML[0].text in self.true_values
-        return valsXML[0].text
-    elif self._type in self.multi_value_types or len(valsXML) > 1:
-        values = []
-        for valXML in valsXML:
-            if valXML.text is None:
-                valXML.text = ""
-            values.append(valXML.text)
-        if self._type == "text-multi" and convert_list:
-            values = "\n".join(values)
-        return values
-    else:
-        if valsXML[0].text is None:
-            return ""
-        return valsXML[0].text
-
-
-FormField.set_value = set_value  # type:ignore
-FormField.get_value = get_value  # type:ignore
-
-
 slixmpp.plugins.PLUGINS.extend(
     [
         "link_preview",
         "xep_0292_provider",
-        "xep_0492",
     ]
 )