slidge 0.2.5__py3-none-any.whl → 0.2.7__py3-none-any.whl

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__ = "v0.2.5"
+__version__ = "v0.2.7"

slidge/command/adhoc.py

@@ -235,18 +235,29 @@ class AdhocProvider:
         """
         Get items for a disco query
 
-        :param jid: who is requesting the disco
+        :param jid: the entity that should return its items
         :param node: which command node is requested
         :param iq:  the disco query IQ
         :return: commands accessible to the given JID will be listed
         """
+        ifrom = iq.get_from()
+        ifrom_str = str(ifrom)
+        if (
+            not self.xmpp.jid_validator.match(ifrom_str)
+            and ifrom_str not in config.ADMINS
+        ):
+            raise XMPPError(
+                "forbidden",
+                "You are not authorized to execute adhoc commands on this gateway. "
+                "If this is unexpected, ask your administrator to verify that "
+                "'user-jid-validator' is correctly set in slidge's configuration.",
+            )
+
         all_items = self.xmpp.plugin["xep_0030"].static.get_items(jid, node, None, None)
         log.debug("Static items: %r", all_items)
         if not all_items:
             return DiscoItems()
 
-        ifrom = iq.get_from()
-
         filtered_items = DiscoItems()
         filtered_items["node"] = self.xmpp.plugin["xep_0050"].stanza.Command.namespace
         for item in all_items:

slidge/command/user.py

@@ -172,6 +172,9 @@ class Login(Command):
 
     async def run(self, session: Optional[AnyBaseSession], _ifrom, *_):
         assert session is not None
+        if session.is_logging_in:
+            raise XMPPError("bad-request", "You are already logging in.")
+        session.is_logging_in = True
         try:
             msg = await session.login()
         except Exception as e:
@@ -179,6 +182,8 @@ class Login(Command):
             raise XMPPError(
                 "internal-server-error", etype="wait", text=f"Could not login: {e}"
             )
+        finally:
+            session.is_logging_in = False
         session.logged = True
         session.send_gateway_status(msg or "Re-connected", show="chat")
         session.send_gateway_message(msg or "Re-connected")

slidge/contact/contact.py

@@ -448,7 +448,7 @@ class LegacyContact(
             log.debug("Roster push request by plugin ignored (--no-roster-push)")
             return
         try:
-            await self._set_roster(
+            await self.xmpp["xep_0356"].set_roster(
                 jid=self.user_jid, roster_items=self.get_roster_item()
             )
         except PermissionError:
@@ -490,12 +490,6 @@ class LegacyContact(
                 nick,
             )
 
-    async def _set_roster(self, **kw):
-        try:
-            await self.xmpp["xep_0356"].set_roster(**kw)
-        except PermissionError:
-            await self.xmpp["xep_0356_old"].set_roster(**kw)
-
     def send_friend_request(self, text: Optional[str] = None):
         presence = self._make_presence(ptype="subscribe", pstatus=text, bare=True)
         self._send(presence, nick=True)

slidge/core/config.py

@@ -68,7 +68,6 @@ USER_JID_VALIDATOR__DYNAMIC_DEFAULT = True
 ADMINS: tuple[JIDType, ...] = ()
 ADMINS__DOC = "JIDs of the gateway admins"
 
-
 UPLOAD_SERVICE: Optional[str] = None
 UPLOAD_SERVICE__DOC = (
     "JID of an HTTP upload service the gateway can use. "
@@ -76,9 +75,6 @@ UPLOAD_SERVICE__DOC = (
     "discovery."
 )
 
-SECRET_KEY: Optional[str] = None
-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"
 

slidge/core/gateway.py

@@ -515,6 +515,7 @@ class BaseGateway(
     @timeit
     async def login_wrap(self, session: "BaseSession"):
         session.send_gateway_status("Logging in…", show="dnd")
+        session.is_logging_in = True
         try:
             status = await session.login()
         except Exception as e:
@@ -808,7 +809,9 @@ class BaseGateway(
 
     async def unregister_user(self, user: GatewayUser):
         self.send_presence(
-            pshow="busy", pstatus="You are not registered to this gateway anymore."
+            pshow="dnd",
+            pstatus="You unregistered from this gateway.",
+            pto=user.jid,
         )
         await self.xmpp.plugin["xep_0077"].api["user_remove"](None, None, user.jid)
         await self.xmpp.session_cls.kill_by_jid(user.jid)
@@ -913,7 +916,6 @@ SLIXMPP_PLUGINS = [
     "xep_0333",  # Chat markers
     "xep_0334",  # Message Processing Hints
     "xep_0356",  # Privileged Entity
-    "xep_0356_old",  # Privileged Entity (old namespace)
     "xep_0363",  # HTTP file upload
     "xep_0385",  # Stateless in-line media sharing
     "xep_0402",  # PEP Native Bookmarks

slidge/core/mixins/message.py

@@ -177,15 +177,12 @@ class CarbonMessageMixin(ContentMessageMixin, MarkerMixin):
         try:
             self.xmpp["xep_0356"].send_privileged_message(msg)
         except PermissionError:
-            try:
-                self.xmpp["xep_0356_old"].send_privileged_message(msg)
-            except PermissionError:
-                warnings.warn(
-                    "Slidge does not have privileges to send message on behalf of"
-                    " user.Refer to"
-                    " https://slidge.im/docs/slidge/main/admin/privilege.html"
-                    " for more info."
-                )
+            warnings.warn(
+                "Slidge does not have privileges to send message on behalf of"
+                " user.Refer to"
+                " https://slidge.im/docs/slidge/main/admin/privilege.html"
+                " for more info."
+            )
 
 
 class InviteMixin(MessageMaker):

slidge/core/session.py

@@ -33,7 +33,7 @@ from ..util.types import (
     ResourceDict,
     Sticker,
 )
-from ..util.util import deprecated
+from ..util.util import deprecated, noop_coro
 
 if TYPE_CHECKING:
     from ..group.participant import LegacyParticipant
@@ -98,6 +98,7 @@ class BaseSession(
         self.ignore_messages = set[str]()
 
         self.contacts: LegacyRoster = LegacyRoster.get_self_or_unique_subclass()(self)
+        self.is_logging_in = False
         self._logged = False
         self.__reset_ready()
 
@@ -527,11 +528,13 @@ class BaseSession(
 
     @logged.setter
     def logged(self, v: bool):
+        self.is_logging_in = False
         self._logged = v
         if self.ready.done():
             if v:
                 return
             self.__reset_ready()
+            self.shutdown(logout=False)
         else:
             if v:
                 self.ready.set_result(True)
@@ -539,12 +542,15 @@ class BaseSession(
     def __repr__(self):
         return f"<Session of {self.user_jid}>"
 
-    def shutdown(self) -> asyncio.Task:
+    def shutdown(self, logout=True) -> asyncio.Task:
         for c in self.contacts:
             c.offline()
         for m in self.bookmarks:
             m.shutdown()
-        return self.xmpp.loop.create_task(self.logout())
+        if logout:
+            return self.xmpp.loop.create_task(self.logout())
+        else:
+            return self.xmpp.loop.create_task(noop_coro())
 
     @staticmethod
     def legacy_to_xmpp_msg_id(legacy_msg_id: LegacyMessageType) -> str:
@@ -657,6 +663,8 @@ class BaseSession(
             return
         for c in session.contacts:
             c.unsubscribe()
+        for m in session.bookmarks:
+            m.shutdown()
         user = cls.xmpp.store.users.get(jid)
         if user is None:
             log.warning("User not found during unregistration")

slidge/db/alembic/versions/04cf35e3cf85_add_participant_nickname_no_illegal.py

@@ -0,0 +1,33 @@
+"""Add Participant.nickname_no_illegal
+
+Revision ID: 04cf35e3cf85
+Revises: 15b0bd83407a
+Create Date: 2025-02-22 06:57:45.491326
+
+"""
+
+from typing import Sequence, Union
+
+import sqlalchemy as sa
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision: str = "04cf35e3cf85"
+down_revision: Union[str, None] = "15b0bd83407a"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    with op.batch_alter_table("participant", schema=None) as batch_op:
+        batch_op.add_column(
+            sa.Column("nickname_no_illegal", sa.String(), nullable=True)
+        )
+
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    with op.batch_alter_table("participant", schema=None) as batch_op:
+        batch_op.drop_column("nickname_no_illegal")

slidge/db/alembic/versions/aa9d82a7f6ef_db_creation.py

@@ -8,8 +8,6 @@ Create Date: 2024-04-17 20:57:01.357041
 
 """
 
-import logging
-from datetime import datetime
 from typing import Sequence, Union
 
 import sqlalchemy as sa
@@ -44,58 +42,9 @@ def upgrade() -> None:
         sa.UniqueConstraint("jid"),
     )
     # ### end Alembic commands ###
-    try:
-        migrate_from_shelf(accounts)
-    except Exception:
-        downgrade()
-        raise
 
 
 def downgrade() -> None:
     # ### commands auto generated by Alembic - please adjust! ###
     op.drop_table("user_account")
     # ### end Alembic commands ###
-
-
-def migrate_from_shelf(accounts: sa.Table) -> None:
-    from slidge import global_config
-
-    home = getattr(global_config, "HOME_DIR", None)
-    if home is None:
-        return
-
-    db_file = home / "slidge.db"
-    if not db_file.exists():
-        return
-
-    try:
-        from slidge.db.alembic.old_user_store import user_store
-    except ImportError:
-        return
-
-    user_store.set_file(db_file, global_config.SECRET_KEY)
-
-    try:
-        users = list(user_store.get_all())
-    except AttributeError:
-        return
-    logging.info("Migrating %s users from the deprecated user_store shelf", len(users))
-    op.bulk_insert(
-        accounts,
-        [
-            {
-                "jid": user.jid,
-                "registration_date": (
-                    user.registration_date
-                    if user.registration_date is not None
-                    else datetime.now()
-                ),
-                "legacy_module_data": user.registration_form,
-                "preferences": {},
-            }
-            for user in users
-        ],
-    )
-
-    user_store.close()
-    db_file.unlink()

slidge/db/models.py

@@ -388,6 +388,7 @@ class Participant(Base):
 
     resource: Mapped[Optional[str]] = mapped_column(default=None)
     nickname: Mapped[str] = mapped_column(nullable=True, default=None)
+    nickname_no_illegal: Mapped[str] = mapped_column(nullable=True, default=None)
 
     hats: Mapped[list["Hat"]] = relationship(
         secondary=participant_hats, back_populates="participants"

slidge/db/store.py

@@ -698,6 +698,8 @@ class MultiStore(EngineMixin):
             ).scalar()
             if multi is None:
                 return []
+            if multi.legacy_ids_multi is None:
+                return []
             return [m.xmpp_id for m in multi.legacy_ids_multi.xmpp_ids]
 
     def set_xmpp_ids(
@@ -1072,6 +1074,7 @@ class ParticipantStore(EngineMixin):
                 .where(Participant.id == participant.pk)
                 .values(
                     resource=participant.jid.resource,
+                    nickname_no_illegal=participant._nickname_no_illegal,
                     affiliation=participant.affiliation,
                     role=participant.role,
                     presence_sent=participant._presence_sent,  # type:ignore

slidge/group/participant.py

@@ -71,6 +71,7 @@ class LegacyParticipant(
         role: MucRole = "participant",
         affiliation: MucAffiliation = "member",
         resource: str | None = None,
+        nickname_no_illegal: str | None = None,
     ):
         self.session = session = muc.session
         self.xmpp = session.xmpp
@@ -87,7 +88,8 @@ class LegacyParticipant(
         if resource is None:
             self.__update_jid(nickname)
         else:
-            self._nickname_no_illegal = resource
+            assert nickname_no_illegal is not None
+            self._nickname_no_illegal = nickname_no_illegal
             self.jid = JID(self.muc.jid)
             self.jid.resource = resource
 
@@ -518,6 +520,7 @@ class LegacyParticipant(
             role=stored.role,
             affiliation=stored.affiliation,
             resource=stored.resource,
+            nickname_no_illegal=stored.nickname_no_illegal,
         )
         part.pk = stored.id
         if contact is not None:

slidge/group/room.py

@@ -14,6 +14,7 @@ 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.xmlstream import ET
 
 from ..contact.contact import LegacyContact
@@ -26,6 +27,7 @@ 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.types import (
@@ -231,7 +233,7 @@ class LegacyMUC(
             self._participants_filled = True
             async for p in self.fill_participants():
                 self.__participants_store.update(p)
-                self.__store.set_participants_filled(self.pk)
+            self.__store.set_participants_filled(self.pk)
 
     async def get_participants(self) -> AsyncIterator[LegacyParticipant]:
         assert self.pk is not None
@@ -248,19 +250,21 @@ class LegacyMUC(
         async with self.lock("fill participants"):
             self._participants_filled = True
             # We only fill the participants list if/when the MUC is first
-            # joined by an XMPP client. But we may have instantiated
+            # joined by an XMPP client. But we may have instantiated some before.
             resources = set[str]()
+            async for participant in self.fill_participants():
+                # TODO: batch SQL update at the end of this function for perf?
+                self.__store_participant(participant)
+                yield participant
+                resources.add(participant.jid.resource)
             for db_participant in self.xmpp.store.participants.get_all(
                 self.pk, user_included=True
             ):
                 participant = self.Participant.from_store(
                     self.session, db_participant, muc=self
                 )
-                resources.add(participant.jid.resource)
-                yield participant
-            async for p in self.fill_participants():
-                if p.jid.resource not in resources:
-                    yield p
+                if participant.jid.resource not in resources:
+                    yield participant
             self.__store.set_participants_filled(self.pk)
             return
 
@@ -423,7 +427,7 @@ class LegacyMUC(
 
         if subject_setter == self._subject_setter:
             return
-        assert isinstance(subject_setter, str)
+        assert isinstance(subject_setter, str | None)
         self._subject_setter = subject_setter
         if self._updating_info:
             return
@@ -687,6 +691,8 @@ class LegacyMUC(
         assert self.pk is not None
         p.pk = self.__participants_store.add(self.pk, p.nickname)
         self.__participants_store.update(p)
+        if p._hats:
+            self.__participants_store.set_hats(p.pk, p._hats)
 
     async def get_participant(
         self,
@@ -995,6 +1001,32 @@ class LegacyMUC(
         p["muc"]["status_codes"] = {110, 333}
         p.send()
 
+    async def __get_bookmark(self) -> Item | None:
+        item = Item()
+        item["id"] = self.jid
+
+        iq = Iq(stype="get", sfrom=self.user_jid, sto=self.user_jid)
+        iq["pubsub"]["items"]["node"] = self.xmpp["xep_0402"].stanza.NS
+        iq["pubsub"]["items"].append(item)
+
+        try:
+            ans = await self.xmpp["xep_0356"].send_privileged_iq(iq)
+            if len(ans["pubsub"]["items"]) != 1:
+                return None
+            # this below creates the item if it wasn't here already
+            # (slixmpp annoying magic)
+            item = ans["pubsub"]["items"]["item"]
+            item["id"] = self.jid
+            return item
+        except (IqError, IqTimeout) as exc:
+            warnings.warn(f"Cannot fetch bookmark: {exc}")
+            return None
+        except PermissionError:
+            warnings.warn(
+                "IQ privileges (XEP0356) are not set, we cannot fetch the user bookmarks"
+            )
+            return None
+
     async def add_to_bookmarks(
         self,
         auto_join=True,
@@ -1026,68 +1058,90 @@ class LegacyMUC(
             If set to ``None`` (default), the setting will be untouched. Only the "global"
             notification setting is supported (ie, per client type is not possible).
         """
-        item = Item()
-        item["id"] = self.jid
+        existing = await self.__get_bookmark() if preserve else None
 
-        iq = Iq(stype="get", sfrom=self.user_jid, sto=self.user_jid)
-        iq["pubsub"]["items"]["node"] = self.xmpp["xep_0402"].stanza.NS
-        iq["pubsub"]["items"].append(item)
+        new = Item()
+        new["id"] = self.jid
+        new["conference"]["nick"] = self.user_nick
 
-        is_update = False
-        if preserve:
-            try:
-                ans = await self.xmpp["xep_0356"].send_privileged_iq(iq)
-                is_update = len(ans["pubsub"]["items"]) == 1
-                # this below creates the item if it wasn't here already
-                # (slixmpp annoying magic)
-                item = ans["pubsub"]["items"]["item"]
-                item["id"] = self.jid
-            except (IqError, IqTimeout):
-                item["conference"]["autojoin"] = auto_join
-            except PermissionError:
-                warnings.warn(
-                    "IQ privileges (XEP0356) are not set, we cannot fetch the user bookmarks"
-                )
-            else:
-                # if the bookmark is already present, we preserve it as much as
-                # possible, especially custom <extensions>
-                self.log.debug("Existing: %s", item)
-                # if it's an update, we do not touch the auto join flag
-                if not is_update:
-                    item["conference"]["autojoin"] = auto_join
+        if existing is None:
+            change = True
+            new["conference"]["autojoin"] = auto_join
         else:
-            item["conference"]["autojoin"] = auto_join
-
-        item["conference"]["nick"] = self.user_nick
+            change = False
+            new["conference"]["autojoin"] = existing["conference"]["autojoin"]
+
+        existing_extensions = existing is not None and existing[
+            "conference"
+        ].get_plugin("extensions", check=True)
+
+        # preserving extensions we don't know about is a MUST
+        if existing_extensions:
+            assert existing is not None
+            for el in existing["conference"]["extensions"].xml:
+                if el.tag.startswith(f"{{{NOTIFY_NS}}}"):
+                    if notify is not None:
+                        continue
+                if el.tag.startswith(f"{{{PINNING_NS}}}"):
+                    if pin is not None:
+                        continue
+                new["conference"]["extensions"].append(el)
 
         if pin is not None:
-            item["conference"]["extensions"]["pinned"] = pin
+            if existing_extensions:
+                assert existing is not None
+                existing_pin = (
+                    existing["conference"]["extensions"].get_plugin(
+                        "pinned", check=True
+                    )
+                    is not None
+                )
+                if existing_pin != pin:
+                    change = True
+            new["conference"]["extensions"]["pinned"] = pin
 
         if notify is not None:
-            item["conference"]["extensions"]["notify"].configure(notify)
-
-        iq = Iq(stype="set", sfrom=self.user_jid, sto=self.user_jid)
-        iq["pubsub"]["publish"]["node"] = self.xmpp["xep_0402"].stanza.NS
-        iq["pubsub"]["publish"].append(item)
-
-        iq["pubsub"]["publish_options"] = _BOOKMARKS_OPTIONS
+            new["conference"]["extensions"].enable("notify")
+            if existing_extensions:
+                assert existing is not None
+                existing_notify = existing["conference"]["extensions"].get_plugin(
+                    "notify", check=True
+                )
+                if existing_notify is None:
+                    change = True
+                else:
+                    if existing_notify.get_config() != notify:
+                        change = True
+                    for el in existing_notify:
+                        new["conference"]["extensions"]["notify"].append(el)
+            new["conference"]["extensions"]["notify"].configure(notify)
+
+        if change:
+            iq = Iq(stype="set", sfrom=self.user_jid, sto=self.user_jid)
+            iq["pubsub"]["publish"]["node"] = self.xmpp["xep_0402"].stanza.NS
+            iq["pubsub"]["publish"].append(new)
+
+            iq["pubsub"]["publish_options"] = _BOOKMARKS_OPTIONS
 
-        try:
-            await self.xmpp["xep_0356"].send_privileged_iq(iq)
-        except PermissionError:
-            warnings.warn(
-                "IQ privileges (XEP0356) are not set, we cannot add bookmarks for the user"
-            )
-            # fallback by forcing invitation
-            invite = True
-        except IqError as e:
-            warnings.warn(
-                f"Something went wrong while trying to set the bookmarks: {e}"
-            )
-            # fallback by forcing invitation
-            invite = True
+            try:
+                await self.xmpp["xep_0356"].send_privileged_iq(iq)
+            except PermissionError:
+                warnings.warn(
+                    "IQ privileges (XEP0356) are not set, we cannot add bookmarks for the user"
+                )
+                # fallback by forcing invitation
+                invite = True
+            except IqError as e:
+                warnings.warn(
+                    f"Something went wrong while trying to set the bookmarks: {e}"
+                )
+                # fallback by forcing invitation
+                invite = True
+        else:
+            self.log.debug("Bookmark does not need updating.")
+            return
 
-        if invite or (config.ALWAYS_INVITE_WHEN_ADDING_BOOKMARKS and not is_update):
+        if invite or (config.ALWAYS_INVITE_WHEN_ADDING_BOOKMARKS and existing is None):
             self.session.send_gateway_invite(
                 self, reason="This group could not be added automatically for you"
             )

slidge/slixfix/__init__.py

@@ -20,7 +20,6 @@ from . import (
     xep_0100,
     xep_0153,
     xep_0292,
-    xep_0356_old,
     xep_0492,
 )
 
@@ -148,7 +147,6 @@ slixmpp.plugins.PLUGINS.extend(
     [
         "link_preview",
         "xep_0292_provider",
-        "xep_0356_old",
         "xep_0492",
     ]
 )

slidge/slixfix/xep_0100/gateway.py

@@ -93,10 +93,7 @@ class XEP_0100(BasePlugin):
                 self.xmpp.send_presence(ptype="subscribe", pto=jid.bare)
 
     async def _set_roster(self, jid, items):
-        try:
-            await self.xmpp["xep_0356"].set_roster(jid=jid.bare, roster_items=items)
-        except PermissionError:
-            await self.xmpp["xep_0356_old"].set_roster(jid=jid.bare, roster_items=items)
+        await self.xmpp["xep_0356"].set_roster(jid=jid.bare, roster_items=items)
 
     def on_presence_unsubscribe(self, p: Presence):
         if p.get_to() == self.xmpp.boundjid.bare:

slidge/slixfix/xep_0492/stanza.py

@@ -51,7 +51,7 @@ class Notify(ElementBase):
         self.append(element)
 
     def get_config(
-            self, client_type: Optional[ClientType] = None
+        self, client_type: Optional[ClientType] = None
     ) -> Optional[WhenLiteral]:
         """
         Get the chat notification settings for this bookmark.
@@ -67,7 +67,6 @@ class Notify(ElementBase):
                 return cast(WhenLiteral, child.name)
         return None
 
-
 class _Base(ElementBase):
     namespace = NS
     interfaces = {"client-type"}
@@ -75,14 +74,17 @@ class _Base(ElementBase):
 
 class Never(_Base):
     name = "never"
+    plugin_attrib = name
 
 
 class Always(_Base):
     name = "always"
+    plugin_attrib = name
 
 
 class OnMention(_Base):
     name = "on-mention"
+    plugin_attrib = name
 
 
 class Advanced(ElementBase):
@@ -100,3 +102,6 @@ _CLASS_MAP = {
 def register_plugin():
     register_stanza_plugin(Extensions, Notify)
     register_stanza_plugin(Notify, Advanced)
+    register_stanza_plugin(Notify, Never, iterable=True)
+    register_stanza_plugin(Notify, Always, iterable=True)
+    register_stanza_plugin(Notify, OnMention, iterable=True)

slidge/util/util.py

@@ -218,18 +218,18 @@ class SlidgeLogger(logging.Logger):
 log = logging.getLogger(__name__)
 
 
-def get_version():
+def get_version() -> str:
     try:
         git = subprocess.check_output(
-            ["git", "rev-parse", "HEAD"], stderr=subprocess.DEVNULL
+            ["git", "rev-parse", "HEAD"],
+            stderr=subprocess.DEVNULL,
+            cwd=Path(__file__).parent,
         ).decode()
     except (FileNotFoundError, subprocess.CalledProcessError):
-        pass
+        return "NO_VERSION"
     else:
         return "git-" + git[:10]
 
-    return "NO_VERSION"
-
 
 def merge_resources(resources: dict[str, ResourceDict]) -> Optional[ResourceDict]:
     if len(resources) == 0:
@@ -321,7 +321,7 @@ def timeit(func):
     async def wrapped(self, *args, **kwargs):
         start = time()
         r = await func(self, *args, **kwargs)
-        self.log.info("%s took %s ms", func.__name__, round((time() - start) * 1000))
+        self.log.debug("%s took %s ms", func.__name__, round((time() - start) * 1000))
         return r
 
     return wrapped
@@ -336,3 +336,7 @@ def strip_leading_emoji(text: str) -> str:
     if len(words) > 1 and emoji.purely_emoji(words[0]):
         return " ".join(words[1:])
     return text
+
+
+async def noop_coro():
+    pass

{slidge-0.2.5.dist-info → slidge-0.2.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: slidge
-Version: 0.2.5
+Version: 0.2.7
 Summary: XMPP bridging framework
 Author-email: Nicolas Cedilnik <nicoco@nicoco.fr>
 License:                     GNU AFFERO GENERAL PUBLIC LICENSE
@@ -676,16 +676,15 @@ Classifier: Topic :: Internet :: XMPP
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
-Requires-Dist: aiohttp[speedups]>=3.11.11
-Requires-Dist: alembic>=1.14.0
-Requires-Dist: configargparse>=1.7
+Requires-Dist: aiohttp[speedups]<4,>=3.11.11
+Requires-Dist: alembic<2,>=1.14.0
+Requires-Dist: configargparse<2,>=1.7
 Requires-Dist: defusedxml>=0.7.1
-Requires-Dist: pickle-secure>=0.99.9
-Requires-Dist: pillow>=11.0.0
-Requires-Dist: python-magic>=0.4.27
-Requires-Dist: qrcode>=8.0
-Requires-Dist: slixmpp>=1.8.6
-Requires-Dist: sqlalchemy>=2.0.36
+Requires-Dist: pillow<12,>=11.0.0
+Requires-Dist: python-magic<0.5,>=0.4.27
+Requires-Dist: qrcode<9,>=8.0
+Requires-Dist: slixmpp<2,>=1.8.6
+Requires-Dist: sqlalchemy<3,>=2
 Requires-Dist: thumbhash>=0.1.2
 
 ![Slidge logo](https://codeberg.org/slidge/slidge/raw/branch/main/dev/assets/slidge-color-small.png)

{slidge-0.2.5.dist-info → slidge-0.2.7.dist-info}/RECORD

@@ -1,25 +1,25 @@
 slidge/__init__.py,sha256=S0tUjqpZlzsr8G4Y_1Xt-KCYB07qaknTB0OwHU8k29U,1587
 slidge/__main__.py,sha256=ydjUklOoavS4YlGfjRX_8BQN2DaSbaXPMi47RkOgcFI,37
-slidge/__version__.py,sha256=4bAi8qOyNOCy78XyBLZqa2BfhBAl80d4H4U1rf4i8-k,165
+slidge/__version__.py,sha256=4G6eK4xrrezi8g1TxDqa6IID1uzOe-SonV8sT5-MrUs,165
 slidge/main.py,sha256=vMJzhvUxbeuIXuHxXXs6lm_ShBjXiS9B5Li5Ge4vWPo,6238
 slidge/migration.py,sha256=4BJmPIRB56_WIhRTqBFIIBXuvnhhBjjOMl4CE7jY6oc,1541
 slidge/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 slidge/command/__init__.py,sha256=UYf1mjCYbZ5G7PIgaFTWSQRAzEJkQ6dTH8Fu_e_XnO0,613
-slidge/command/adhoc.py,sha256=-AO4h1N6owSuuqZon5tDL29O6qmEeAd1pcPjGCkzKRs,10065
+slidge/command/adhoc.py,sha256=bYLXcYJjbqPE9nBhrEQevqYFh9AS7Ei3m1vTZBIggrc,10557
 slidge/command/admin.py,sha256=TYrzgCIhjcTIwl1IUaFlUd3D98SPyao10gB20zo8b3Q,6187
 slidge/command/base.py,sha256=EDcEl5dJcooSmLarXI2fmBq6QtU7h-7MOM3DDsxXmTU,13447
 slidge/command/categories.py,sha256=vF0KGDV9sEn8TNkcMoDRw-u3gEyNHSXghOU2JRHQtKs,351
 slidge/command/chat_command.py,sha256=z-4qp03rK7kCh3_kEozDViwkDg_hVjHvRCiYYJxedBQ,11153
 slidge/command/register.py,sha256=BduDI31Kx8CbWWEdjybimTA5Wcfhn-Jkt8sSPsySCpo,6724
-slidge/command/user.py,sha256=aksfkRUK7xj9n0XM-IfUSS5LrTp0qIHt5K2UkBBT1UE,12099
+slidge/command/user.py,sha256=fLh5d7XTSXicj6g0I80F5n6BFaA20PaYoXFkfDOR4zA,12303
 slidge/contact/__init__.py,sha256=WMMaHk7UW7YT9EH2LtPdkU0bHQaOp4ikBhbBQskmoc8,191
-slidge/contact/contact.py,sha256=SiFeDoI1zuGKhVoK8O_Jm1ch9jwOsRINKgt1gijrmcc,23121
+slidge/contact/contact.py,sha256=ITcjW_3VMdVEHQfqxscpIULnofZBJ841wvnYwOvk1Tc,22934
 slidge/contact/roster.py,sha256=x3speGdHbZ-VTLoQLQW4s53rBeBvW87W8ZibCCZSLDA,10300
 slidge/core/__init__.py,sha256=RG7Jj5JCJERjhqJ31lOLYV-7bH_oblClQD1KF9LsTXo,68
-slidge/core/config.py,sha256=9oIrXYB4Fx9uVQkMYDswrd0xr0ieEH8r1EkGym-AxBE,8060
-slidge/core/gateway.py,sha256=S2fLp_KLPyoixlTQzvlrlus55dHFTYp-WkLZNSWw9mE,37022
+slidge/core/config.py,sha256=OjJfpXJaDhMxRB-vYA0cqkSf0fwMt-HMThM8GS1htCg,7964
+slidge/core/gateway.py,sha256=qdvLGh5GF823mACVw5j1WLYMzsSmeGpmQFuWvz5Z9AU,37028
 slidge/core/pubsub.py,sha256=BoeYE__ptmRAn4x55Hn_6JWRA4nM-XJgDemG5Cy5kN4,11959
-slidge/core/session.py,sha256=nQexpCd1jlHOhQPnFI4ri-5odp3N2pU5HO4l7WFetZY,28148
+slidge/core/session.py,sha256=Y6psOKm_lv4q7yXARiLuijvSebuS64NjqSNF1WARtHM,28439
 slidge/core/dispatcher/__init__.py,sha256=1EXcjXietUKlxEqdrCWCV3xZ3q_DSsjHoqWrPMbtYao,84
 slidge/core/dispatcher/caps.py,sha256=vzCAXo_bhALuLEpJWtyJTzVfWx96g1AsWD8_wkoDl0Y,2028
 slidge/core/dispatcher/disco.py,sha256=j56VY9NIFzwPEWFKQQZ7YIqS9GdD-ZaF_K8a2L-JvRk,2006
@@ -46,7 +46,7 @@ slidge/core/mixins/base.py,sha256=MOd-pas38_52VawQVlxWtBtmTKC6My9G0ZaCeQxOJbs,74
 slidge/core/mixins/db.py,sha256=5Qpegd7D8e5TLXLLINYcf_DuVdN-7wNmsfztUuFYPcU,442
 slidge/core/mixins/disco.py,sha256=jk3Z1B6zTuisHv8VKNRJodIo0ee5btYHh2ZrlflPj_Q,3670
 slidge/core/mixins/lock.py,sha256=Vf1rrkbyNbSprr38WGfZiMgTB7AdbqH8ppFHY8N2yXE,975
-slidge/core/mixins/message.py,sha256=0dPpDQwkdAdirUodKpb9Ad7mkr5meWc7S3lf0sXPYnc,7994
+slidge/core/mixins/message.py,sha256=X8Ka8j0nOnBcecYE_YuK8_J7MeO5-R0TIZw4X8c7R3Y,7846
 slidge/core/mixins/message_maker.py,sha256=TcCutHi0sIwL6beJNkN7XyR0aDIbA0xZyxd2Gc9ulG4,6022
 slidge/core/mixins/message_text.py,sha256=pCY4tezEuwB2ZuUyUi72i4v9AJkxp_SWF1jrFsn94Ns,8096
 slidge/core/mixins/presence.py,sha256=yywo6KAw8C7GaZSMrSMuioNfhW08MrnobHt8XbHd0q8,7891
@@ -54,12 +54,12 @@ slidge/core/mixins/recipient.py,sha256=b0uFnpym-hOFgYxGjXT1xQcZ4YRbDSBftPcNWLzSw
 slidge/db/__init__.py,sha256=EBDH1JSEhgqYcli2Bw11CRC749wJk8AOucgBzmhDSvU,105
 slidge/db/avatar.py,sha256=z5e72STv8PdN6zkNyKlLqF7NFxHwCa6IjwgFpzu5ghE,8033
 slidge/db/meta.py,sha256=v1Jf-npZ28QwdGpsLQWLBHEbEP3-jnPrygRg05tJ_Iw,1831
-slidge/db/models.py,sha256=0NUJfa3lPKHhwV2zE4p7QVYCVs3yn9egFg2u9mssk5c,13964
-slidge/db/store.py,sha256=A2F8QJ88INMSdw0S8G5wDAQJFjwpeExpLuwHu8T3ZHU,46904
+slidge/db/models.py,sha256=MSVNW04x05qfxahvjCYRDFjfFP-XXp-lOHnK5IqFCXw,14046
+slidge/db/store.py,sha256=ETk6oUUEz8-YUFGCh7nspSJH7dFOj8qeIWLQhX4nOH8,47051
 slidge/db/alembic/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 slidge/db/alembic/env.py,sha256=hsBlRNs0zF5diSHGRSa8Fi3qRVQDA2rJdR41AEIdvxc,1642
-slidge/db/alembic/old_user_store.py,sha256=zFOv0JEWQQK0_TMRlU4Z0G5Mc9pxvEErLyOzXmRAe5Q,5209
 slidge/db/alembic/script.py.mako,sha256=MEqL-2qATlST9TAOeYgscMn1uy6HUS9NFvDgl93dMj8,635
+slidge/db/alembic/versions/04cf35e3cf85_add_participant_nickname_no_illegal.py,sha256=Dwz_azOXr7Tsw7Wnj0L8mknITIPXO9ewEsRn169EUNA,904
 slidge/db/alembic/versions/09f27f098baa_add_missing_attributes_in_room.py,sha256=mUL-0Io6ZPd_QbnKfwGYyjdMcM2uxQ0Wg72H23-2t_E,1033
 slidge/db/alembic/versions/15b0bd83407a_remove_bogus_unique_constraints_on_room_.py,sha256=kzHuHGhzey5CY0p_OsKf5a-3zSk2649wqg2ToLiSD1I,2927
 slidge/db/alembic/versions/2461390c0af2_store_contacts_caps_verstring_in_db.py,sha256=CLB-kOP9Rc0FJIKDLef912L5sYkjpTIPC8fhrIdrC7k,1084
@@ -71,7 +71,7 @@ slidge/db/alembic/versions/5bd48bfdffa2_lift_room_legacy_id_constraint.py,sha256
 slidge/db/alembic/versions/82a4af84b679_add_muc_history_filled.py,sha256=g37po0ydp8ZmzJrE5oFV7GscnploxjCtPDpw28SqVGk,1429
 slidge/db/alembic/versions/8b993243a536_add_vcard_content_to_contact_table.py,sha256=18tG8B03Kq8Qz_-mMd28Beed6jow8XNTtrz7gT5QY3g,1210
 slidge/db/alembic/versions/8d2ced764698_rely_on_db_to_store_contacts_rooms_and_.py,sha256=ikoAlRV3_BJcDcFRANF-9HTB--0xpY0C5XdGuMuW9c0,4866
-slidge/db/alembic/versions/aa9d82a7f6ef_db_creation.py,sha256=XFHaHjPMoxKxKRjNBnYHBzMtS6K38ENcsGzgzlyp60g,2649
+slidge/db/alembic/versions/aa9d82a7f6ef_db_creation.py,sha256=eFlfn-LiDph05yyCc8gmtJwVKzgrSHwyWJ6nuVfEpQA,1391
 slidge/db/alembic/versions/abba1ae0edb3_store_avatar_legacy_id_in_the_contact_.py,sha256=VprqEVHipYuM-ea-CIM4_ubOD5zJ9inLTbhXc869n3A,2779
 slidge/db/alembic/versions/b33993e87db3_move_everything_to_persistent_db.py,sha256=2tiRxoC9PYOQn6XQrwK0JTEsb45Pzp2PsKoZSS4rcIA,7564
 slidge/db/alembic/versions/b64b1a793483_add_source_and_legacy_id_for_archived_.py,sha256=r2sOgR5HcfueJyc3cWNDRmlZzdHOSX6nl2gef54wDbk,1559
@@ -80,9 +80,9 @@ slidge/db/alembic/versions/e91195719c2c_store_users_avatars_persistently.py,sha2
 slidge/group/__init__.py,sha256=yFt7cHqeaKIMN6f9ZyhhspOcJJvBtLedGv-iICG7lto,258
 slidge/group/archive.py,sha256=IPqklzo0UN3lPHckfsKW9c4nl3m_9XGY4u0eehrhe8k,5281
 slidge/group/bookmarks.py,sha256=AvFL34bEX6n3OP1Np309T5hrLK9GnjkjdyLJ3uiLZyc,6616
-slidge/group/participant.py,sha256=tGGcAkdcK6aob1YP8e9ODbdK2_dGmFNH0F2x-gHyc4M,17611
-slidge/group/room.py,sha256=aJ-VIYACuEuoyKDsBFxsUZFoVpd265i0mzTOOHCNTPg,46849
-slidge/slixfix/__init__.py,sha256=aEXtmxMgxQWsUoDV5NSxZKwb-Hml5XeR2FMJlnaDUng,4324
+slidge/group/participant.py,sha256=cUuyJRGq8AIHrwtubje5cyb5hHY2hGLtGboBju4SI0c,17781
+slidge/group/room.py,sha256=IilOT_Z5P-gh0lo5KLFc054z6sOrxJQ6MvjPmLKXiRs,49011
+slidge/slixfix/__init__.py,sha256=Og6_EAuWst6paWmDiGqeqQH6Iof6V8Vkr5pyYisgjsw,4282
 slidge/slixfix/delivery_receipt.py,sha256=3bWdZH3-X3CZJXmnI_TpjkTUUK-EY4Ktm78lW0-40fc,1366
 slidge/slixfix/roster.py,sha256=KvDjh9q7pqaZf69H93okfib13cc95uVZUJ6rzpqmDaU,1704
 slidge/slixfix/link_preview/__init__.py,sha256=TDPTSEH5FQxgGpQpQIde-D72AHg-6YVWG-tOj4KpKmU,290
@@ -92,27 +92,23 @@ slidge/slixfix/xep_0077/__init__.py,sha256=0lY1YXdgAsfrfxI_Woxaf1etHCJXe35Xtntq_
 slidge/slixfix/xep_0077/register.py,sha256=6nwTfHNL7Z9-1wUhpAF743TNbjQLCMP7Rflkdad8d60,10431
 slidge/slixfix/xep_0077/stanza.py,sha256=Lngly7F1ChCkNKn7yl1QmN838fO-KqkAhkazxzDsz80,2410
 slidge/slixfix/xep_0100/__init__.py,sha256=AtEXDQOrEWodkN3fgKR0W3Ezsz_Zza6cgO5ZaZS-JOo,107
-slidge/slixfix/xep_0100/gateway.py,sha256=Fhxs2sUPnVRPa1o7RXCncnbBO2gjeZx3pbItug-8OiA,4501
+slidge/slixfix/xep_0100/gateway.py,sha256=aSR18605MWVqgucNd_zd1SdYlXry7k5uoqDzsvVqQyM,4363
 slidge/slixfix/xep_0100/stanza.py,sha256=7vCzej9VFQupsTpGGl0cJWuGNH4I6oVcckBu_-fE55c,232
 slidge/slixfix/xep_0153/__init__.py,sha256=hsEldnLuzvcp0NqSscxPV7FJl-6GFP372vlDg1G3S3I,283
 slidge/slixfix/xep_0153/vcard_avatar.py,sha256=py-qzj1jmmzsM4GCTKLRW7cAdAmSVjodp6q0r5B0RqQ,458
 slidge/slixfix/xep_0292/__init__.py,sha256=_MvS9wGra6ig3P_dPAVlCPDJkiOFvUWGjaRsHj1woUg,98
 slidge/slixfix/xep_0292/vcard4.py,sha256=jL-TOW3eG2QXLduSLNq03L8HoUNmvy8kTZI5ojvo6GE,358
-slidge/slixfix/xep_0356_old/__init__.py,sha256=3jGWJX2m5gWgDCxcVqCsCCVPRTcfmU96yenwvAJtOKE,180
-slidge/slixfix/xep_0356_old/privilege.py,sha256=kcJzFbzhOHtQMtzOJpvvwm1pghSpealWnqhC0zc8dGo,5338
-slidge/slixfix/xep_0356_old/stanza.py,sha256=i7aqcaTg6PBhVwbHToLtlrwxBj7uO-M7VrYSyElyEKI,1229
 slidge/slixfix/xep_0492/__init__.py,sha256=kjWVeX3SG_2ohHx0fuMh1gmM2G57Bl6SRo7Mfv6sglA,161
 slidge/slixfix/xep_0492/notify.py,sha256=8EPSdU3rTzWkHNm8oFr0tK2PmMJ6hBAIr88GoOmHTuQ,340
-slidge/slixfix/xep_0492/stanza.py,sha256=gL0ixpV07Q9eqTXIOjdLVPtim45izuwaLk0iCoZ8e7c,2649
+slidge/slixfix/xep_0492/stanza.py,sha256=TlwyAHozA6zu32QoBb6M12xqWR-ytT0F9XVFqZkd4d4,2895
 slidge/util/__init__.py,sha256=BELovoTMPcPPGz3D48esBr8A4BRRHXTvavfgnArBgEc,301
 slidge/util/archive_msg.py,sha256=xXAR0BI5r3d6KKWjae9594izCOv6iI03z2WLuTecNw8,1724
 slidge/util/conf.py,sha256=1j2OnOsCBar1tOObErhXR5RC3Vl3faliOZ1U8J3My58,6613
-slidge/util/db.py,sha256=4LxZj8oBYgiSnyBUnF_ALjr0TblkfNQq_p28sCfkHMY,242
 slidge/util/test.py,sha256=l1VHBsw5Uzk2t7wtkfb9kWvtehcYhw1t_d567JAJFKA,14135
 slidge/util/types.py,sha256=R_xfS5mRL0XUJIoDpnaAkZlTOoLPerduXBFftaVwIAI,5489
-slidge/util/util.py,sha256=An4BRIHktZGXnu4kCwaKYaSye_PlyuxEm_4SC9YvPhc,9594
-slidge-0.2.5.dist-info/METADATA,sha256=qPrPddCJQeL3747-F2abvx04v1bGPzyFJiLHX8Xjx0E,44856
-slidge-0.2.5.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-slidge-0.2.5.dist-info/entry_points.txt,sha256=py3_x834fFJ2TEzPd18Wt2DnysdAfuVqJ5zzBrXbAZs,44
-slidge-0.2.5.dist-info/top_level.txt,sha256=2LRjDYHaGZ5ieCMF8xy58JIiabRMzX-MGMbCZwfE17c,7
-slidge-0.2.5.dist-info/RECORD,,
+slidge/util/util.py,sha256=IfyYLkujW6Pk0kvHpfkpQwejFDHSe5oR4_bczEUnhjs,9678
+slidge-0.2.7.dist-info/METADATA,sha256=u5B3zAw9h1inyIcHrGvr23-GNtI7Ba4gHNXLRmTtktc,44841
+slidge-0.2.7.dist-info/WHEEL,sha256=nn6H5-ilmfVryoAQl3ZQ2l8SH5imPWFpm1A5FgEuFV4,91
+slidge-0.2.7.dist-info/entry_points.txt,sha256=py3_x834fFJ2TEzPd18Wt2DnysdAfuVqJ5zzBrXbAZs,44
+slidge-0.2.7.dist-info/top_level.txt,sha256=2LRjDYHaGZ5ieCMF8xy58JIiabRMzX-MGMbCZwfE17c,7
+slidge-0.2.7.dist-info/RECORD,,

{slidge-0.2.5.dist-info → slidge-0.2.7.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.8.0)
+Generator: setuptools (75.8.1)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

slidge/db/alembic/old_user_store.py

@@ -1,183 +0,0 @@
-"""
-This module covers a backend for storing user data persistently and managing a
-pseudo-roster for the gateway component.
-"""
-
-import dataclasses
-import datetime
-import logging
-import os.path
-import shelve
-from io import BytesIO
-from os import PathLike
-from typing import Iterable, Optional, Union
-
-from pickle_secure import Pickler, Unpickler
-from slixmpp import JID, Iq, Message, Presence
-
-
-# noinspection PyUnresolvedReferences
-class EncryptedShelf(shelve.DbfilenameShelf):
-    cache: dict
-    dict: dict
-    writeback: bool
-    keyencoding: str
-    _protocol: int
-
-    def __init__(
-        self, filename: PathLike, key: str, flag="c", protocol=None, writeback=False
-    ):
-        super().__init__(str(filename), flag, protocol, writeback)
-        self.secret_key = key
-
-    def __getitem__(self, key):
-        try:
-            value = self.cache[key]
-        except KeyError:
-            f = BytesIO(self.dict[key.encode(self.keyencoding)])
-            value = Unpickler(f, key=self.secret_key).load()  # type:ignore
-            if self.writeback:
-                self.cache[key] = value
-        return value
-
-    def __setitem__(self, key, value):
-        if self.writeback:
-            self.cache[key] = value
-        f = BytesIO()
-        p = Pickler(f, self._protocol, key=self.secret_key)  # type:ignore
-        p.dump(value)
-        self.dict[key.encode(self.keyencoding)] = f.getvalue()
-
-
-@dataclasses.dataclass
-class GatewayUser:
-    """
-    A gateway user
-    """
-
-    bare_jid: str
-    """Bare JID of the user"""
-    registration_form: dict[str, Optional[str]]
-    """Content of the registration form, as a dict"""
-    plugin_data: Optional[dict] = None
-    registration_date: Optional[datetime.datetime] = None
-
-    def __hash__(self):
-        return hash(self.bare_jid)
-
-    def __repr__(self):
-        return f"<User {self.bare_jid}>"
-
-    def __post_init__(self):
-        if self.registration_date is None:
-            self.registration_date = datetime.datetime.now()
-
-    @property
-    def jid(self) -> JID:
-        """
-        The user's (bare) JID
-
-        :return:
-        """
-        return JID(self.bare_jid)
-
-    def get(self, field: str, default: str = "") -> Optional[str]:
-        # """
-        # Get fields from the registration form (required to comply with slixmpp backend protocol)
-        #
-        # :param field: Name of the field
-        # :param default: Default value to return if the field is not present
-        #
-        # :return: Value of the field
-        # """
-        return self.registration_form.get(field, default)
-
-
-class UserStore:
-    """
-    Basic user store implementation using shelve from the python standard library
-
-    Set_file must be called before it is usable
-    """
-
-    def __init__(self):
-        self._users: shelve.Shelf[GatewayUser] = None  # type: ignore
-
-    def set_file(self, filename: PathLike, secret_key: Optional[str] = None):
-        """
-        Set the file to use to store user data
-
-        :param filename: Path to the shelf file
-        :param secret_key: Secret key to store files encrypted on disk
-        """
-        if self._users is not None:
-            raise RuntimeError("Shelf file already set!")
-        if os.path.exists(filename):
-            log.info("Using existing slidge DB: %s", filename)
-        else:
-            log.info("Creating a new slidge DB: %s", filename)
-        if secret_key:
-            self._users = EncryptedShelf(filename, key=secret_key)
-        else:
-            self._users = shelve.open(str(filename))
-        log.info("Registered users in the DB: %s", list(self._users.keys()))
-
-    def get_all(self) -> Iterable[GatewayUser]:
-        """
-        Get all users in the store
-
-        :return: An iterable of GatewayUsers
-        """
-        return self._users.values()
-
-    def commit(self, user: GatewayUser):
-        self._users[user.jid.bare] = user
-        self._users.sync()
-
-    def get(self, _gateway_jid, _node, ifrom: JID, iq) -> Optional[GatewayUser]:
-        """
-        Get a user from the store
-
-        NB: there is no reason to call this, it is used by SliXMPP internal API
-
-        :param _gateway_jid:
-        :param _node:
-        :param ifrom:
-        :param iq:
-        :return:
-        """
-        if ifrom is None:  # bug in SliXMPP's XEP_0100 plugin
-            ifrom = iq["from"]
-        log.debug("Getting user %s", ifrom.bare)
-        return self._users.get(ifrom.bare)
-
-    def get_by_jid(self, jid: JID) -> Optional[GatewayUser]:
-        """
-        Convenience function to get a user from their JID.
-
-        :param jid: JID of the gateway user
-        :return:
-        """
-        return self._users.get(jid.bare)
-
-    def get_by_stanza(self, s: Union[Presence, Message, Iq]) -> Optional[GatewayUser]:
-        """
-        Convenience function to get a user from a stanza they sent.
-
-        :param s: A stanza sent by the gateway user
-        :return:
-        """
-        return self.get_by_jid(s.get_from())
-
-    def close(self):
-        self._users.sync()
-        self._users.close()
-
-
-user_store = UserStore()
-"""
-A persistent store for slidge users. Not public, but I didn't find how to hide
-it from the docs!
-"""
-
-log = logging.getLogger(__name__)

slidge/slixfix/xep_0356_old/__init__.py

@@ -1,7 +0,0 @@
-from slixmpp.plugins.base import register_plugin
-
-from . import stanza
-from .privilege import XEP_0356_OLD
-from .stanza import PermOld, PrivilegeOld
-
-register_plugin(XEP_0356_OLD)

slidge/slixfix/xep_0356_old/privilege.py

@@ -1,167 +0,0 @@
-import logging
-import typing
-from collections import defaultdict
-
-from slixmpp import JID, Iq, Message
-from slixmpp.plugins.base import BasePlugin
-from slixmpp.plugins.xep_0356.permissions import (
-    MessagePermission,
-    Permissions,
-    RosterAccess,
-)
-from slixmpp.types import JidStr
-from slixmpp.xmlstream import StanzaBase
-from slixmpp.xmlstream.handler import Callback
-from slixmpp.xmlstream.matcher import StanzaPath
-
-from . import stanza
-
-log = logging.getLogger(__name__)
-
-
-# noinspection PyPep8Naming
-class XEP_0356_OLD(BasePlugin):
-    """
-    XEP-0356: Privileged Entity
-
-    Events:
-
-    ::
-
-        privileges_advertised_old -- Received message/privilege from the server
-    """
-
-    name = "xep_0356_old"
-    description = "XEP-0356: Privileged Entity (slidge - old namespace)"
-    dependencies = {"xep_0297"}
-    stanza = stanza
-
-    granted_privileges: defaultdict[JidStr, Permissions] = defaultdict(Permissions)
-
-    def plugin_init(self):
-        if not self.xmpp.is_component:
-            log.error("XEP 0356 is only available for components")
-            return
-
-        stanza.register()
-
-        self.xmpp.register_handler(
-            Callback(
-                "Privileges_old",
-                StanzaPath("message/privilege_old"),
-                self._handle_privilege,
-            )
-        )
-
-    def plugin_end(self):
-        self.xmpp.remove_handler("Privileges_old")
-
-    def _handle_privilege(self, msg: StanzaBase):
-        """
-        Called when the XMPP server advertise the component's privileges.
-
-        Stores the privileges in this instance's granted_privileges attribute (a dict)
-        and raises the privileges_advertised event
-        """
-        for perm in msg["privilege_old"]["perms"]:
-            setattr(
-                self.granted_privileges[msg.get_from()], perm["access"], perm["type"]
-            )
-        log.debug(f"Privileges (old): {self.granted_privileges}")
-        self.xmpp.event("privileges_advertised_old")
-
-    def send_privileged_message(self, msg: Message):
-        if (
-            self.granted_privileges[msg.get_from().domain].message
-            != MessagePermission.OUTGOING
-        ):
-            raise PermissionError(
-                "The server hasn't authorized us to send messages on behalf of other users"
-            )
-        else:
-            self._make_privileged_message(msg).send()
-
-    def _make_privileged_message(self, msg: Message):
-        server = msg.get_from().domain
-        wrapped = self.xmpp.make_message(mto=server, mfrom=self.xmpp.boundjid.bare)
-        wrapped["privilege_old"]["forwarded"].append(msg)
-        return wrapped
-
-    def _make_get_roster(self, jid: typing.Union[JID, str], **iq_kwargs):
-        return self.xmpp.make_iq_get(
-            queryxmlns="jabber:iq:roster",
-            ifrom=self.xmpp.boundjid.bare,
-            ito=jid,
-            **iq_kwargs,
-        )
-
-    def _make_set_roster(
-        self,
-        jid: typing.Union[JID, str],
-        roster_items: dict,
-        **iq_kwargs,
-    ):
-        iq = self.xmpp.make_iq_set(
-            ifrom=self.xmpp.boundjid.bare,
-            ito=jid,
-            **iq_kwargs,
-        )
-        iq["roster"]["items"] = roster_items
-        return iq
-
-    async def get_roster(self, jid: typing.Union[JID, str], **send_kwargs) -> Iq:
-        """
-        Return the roster of user on the server the component has privileged access to.
-
-        Raises ValueError if the server did not advertise the corresponding privileges
-
-        :param jid: user we want to fetch the roster from
-        """
-        if isinstance(jid, str):
-            jid = JID(jid)
-        if self.granted_privileges[jid.domain].roster not in (
-            RosterAccess.GET,
-            RosterAccess.BOTH,
-        ):
-            raise PermissionError(
-                "The server did not grant us privileges to get rosters"
-            )
-        else:
-            return await self._make_get_roster(jid).send(**send_kwargs)
-
-    async def set_roster(
-        self, jid: typing.Union[JID, str], roster_items: dict, **send_kwargs
-    ) -> Iq:
-        """
-        Return the roster of user on the server the component has privileged access to.
-
-        Raises ValueError if the server did not advertise the corresponding privileges
-
-        :param jid: user we want to add or modify roster items
-        :param roster_items: a dict containing the roster items' JIDs as keys and
-            nested dicts containing names, subscriptions and groups.
-            Example:
-            {
-                "friend1@example.com": {
-                    "name": "Friend 1",
-                    "subscription": "both",
-                    "groups": ["group1", "group2"],
-                },
-                "friend2@example.com": {
-                    "name": "Friend 2",
-                    "subscription": "from",
-                    "groups": ["group3"],
-            },
-        }
-        """
-        if isinstance(jid, str):
-            jid = JID(jid)
-        if self.granted_privileges[jid.domain].roster not in (
-            RosterAccess.GET,
-            RosterAccess.BOTH,
-        ):
-            raise PermissionError(
-                "The server did not grant us privileges to set rosters"
-            )
-        else:
-            return await self._make_set_roster(jid, roster_items).send(**send_kwargs)

slidge/slixfix/xep_0356_old/stanza.py

@@ -1,44 +0,0 @@
-from slixmpp.plugins.xep_0297 import Forwarded
-from slixmpp.stanza import Message
-from slixmpp.xmlstream import ElementBase, register_stanza_plugin
-
-
-class PrivilegeOld(ElementBase):
-    namespace = "urn:xmpp:privilege:1"
-    name = "privilege"
-    plugin_attrib = "privilege_old"
-
-    def permission(self, access):
-        for perm in self["perms"]:
-            if perm["access"] == access:
-                return perm["type"]
-
-    def roster(self):
-        return self.permission("roster")
-
-    def message(self):
-        return self.permission("message")
-
-    def presence(self):
-        return self.permission("presence")
-
-    def add_perm(self, access, type):
-        # This should only be needed for servers, so maybe out of scope for slixmpp
-        perm = PermOld()
-        perm["type"] = type
-        perm["access"] = access
-        self.append(perm)
-
-
-class PermOld(ElementBase):
-    namespace = "urn:xmpp:privilege:1"
-    name = "perm"
-    plugin_attrib = "perm"
-    plugin_multi_attrib = "perms"
-    interfaces = {"type", "access"}
-
-
-def register():
-    register_stanza_plugin(Message, PrivilegeOld)
-    register_stanza_plugin(PrivilegeOld, Forwarded)
-    register_stanza_plugin(PrivilegeOld, PermOld, iterable=True)

slidge/util/db.py

@@ -1,5 +0,0 @@
-# here to allow migration of the user store from v0.1
-# since it relies on shelf, which relies on pickle, we need to keep objects
-# importable where they were when the shelf was written
-
-from ..db.alembic.old_user_store import *  # noqa:F403