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

slidge/util/db.py

@@ -1,229 +1,5 @@
-"""
-This module covers a backend for storing user data persistently and managing a
-pseudo-roster for the gateway component.
-"""
+# 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
 
-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
-
-from .sql import db
-
-
-# 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)
-
-    def commit(self):
-        db.user_store(self)
-        user_store.commit(self)
-
-
-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))
-        for user in self._users.values():
-            db.user_store(user)
-        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 add(self, jid: JID, registration_form: dict[str, Optional[str]]):
-        """
-        Add a user to the store.
-
-        NB: there is no reason to call this manually, as this should be covered
-        by slixmpp XEP-0077 and XEP-0100 plugins
-
-        :param jid: JID of the gateway user
-        :param registration_form: Content of the registration form (:xep:`0077`)
-        """
-        log.debug("Adding user %s", jid)
-        self._users[jid.bare] = user = GatewayUser(
-            bare_jid=jid.bare,
-            registration_form=registration_form,
-            registration_date=datetime.datetime.now(),
-        )
-        self._users.sync()
-        user.commit()
-        log.debug("Store: %s", self._users)
-
-    def commit(self, user: GatewayUser):
-        self._users[user.bare_jid] = 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 remove(self, _gateway_jid, _node, ifrom: JID, _iq):
-        """
-        Remove a user from the store
-
-        NB: there is no reason to call this, it is used by SliXMPP internal API
-        """
-        self.remove_by_jid(ifrom)
-
-    def remove_by_jid(self, jid: JID):
-        """
-        Remove a user from the store, by JID
-        """
-        j = jid.bare
-        log.debug("Removing user %s", j)
-        db.user_del(self._users[j])
-        del self._users[j]
-        self._users.sync()
-
-    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__)
+from ..db.alembic.old_user_store import *  # noqa:F403

slidge/util/test.py

@@ -7,6 +7,7 @@ from xml.dom.minidom import parseString
 
 import xmldiff.main
 from slixmpp import (
+    JID,
     ElementBase,
     Iq,
     MatcherId,
@@ -20,6 +21,7 @@ from slixmpp.stanza.error import Error
 from slixmpp.test import SlixTest, TestTransport
 from slixmpp.xmlstream import highlight, tostring
 from slixmpp.xmlstream.matcher import MatchIDSender
+from sqlalchemy import create_engine, delete
 
 from slidge import (
     BaseGateway,
@@ -29,12 +31,16 @@ from slidge import (
     LegacyMUC,
     LegacyParticipant,
     LegacyRoster,
-    user_store,
 )
 
 from ..command import Command
 from ..core import config
 from ..core.config import _TimedeltaSeconds
+from ..core.pubsub import PepAvatar, PepNick
+from ..db import SlidgeStore
+from ..db.avatar import avatar_cache
+from ..db.meta import Base
+from ..db.models import Contact
 
 
 class SlixTestPlus(SlixTest):
@@ -187,10 +193,10 @@ class SlidgeTest(SlixTestPlus):
         no_roster_push = False
         upload_requester = None
         ignore_delay_threshold = _TimedeltaSeconds("300")
+        last_seen_fallback = True
 
     @classmethod
     def setUpClass(cls):
-        user_store.set_file(Path(tempfile.mkdtemp()) / "test.db")
         for k, v in vars(cls.Config).items():
             setattr(config, k.upper(), v)
 
@@ -209,9 +215,27 @@ class SlidgeTest(SlixTestPlus):
                 self.plugin, LegacyBookmarks, base_ok=True
             )
 
-        self.xmpp = BaseGateway.get_self_or_unique_subclass()()
+        # workaround for duplicate output of sql alchemy's log, cf
+        # https://stackoverflow.com/a/76498428/5902284
+        from sqlalchemy import log as sqlalchemy_log
 
+        sqlalchemy_log._add_default_handler = lambda x: None
+
+        engine = self.db_engine = create_engine("sqlite+pysqlite:///:memory:")
+        Base.metadata.create_all(engine)
+        BaseGateway.store = SlidgeStore(engine)
+        BaseGateway._test_mode = True
+        try:
+            self.xmpp = BaseGateway.get_self_or_unique_subclass()()
+        except Exception:
+            raise
+        self.xmpp.TEST_MODE = True
+        PepNick.contact_store = self.xmpp.store.contacts
+        PepAvatar.store = self.xmpp.store
+        avatar_cache.store = self.xmpp.store.avatars
+        avatar_cache.set_dir(Path(tempfile.mkdtemp()))
         self.xmpp._always_send_everything = True
+        engine.echo = True
 
         self.xmpp.connection_made(TestTransport(self.xmpp))
         self.xmpp.session_bind_event.set()
@@ -242,10 +266,73 @@ class SlidgeTest(SlixTestPlus):
         self.xmpp.use_presence_ids = False
         Error.namespace = "jabber:component:accept"
 
+    def tearDown(self):
+        self.db_engine.echo = False
+        super().tearDown()
+        import slidge.db.store
+
+        if slidge.db.store._session is not None:
+            slidge.db.store._session.commit()
+            slidge.db.store._session = None
+        Base.metadata.drop_all(self.xmpp.store._engine)
+
+    def setup_logged_session(self, n_contacts=0):
+        user = self.xmpp.store.users.new(
+            JID("romeo@montague.lit/gajim"), {"username": "romeo", "city": ""}
+        )
+        user.preferences = {"sync_avatar": True, "sync_presence": True}
+        self.xmpp.store.users.update(user)
+
+        with self.xmpp.store.session() as session:
+            session.execute(delete(Contact))
+            session.commit()
+
+        self.run_coro(
+            self.xmpp._BaseGateway__dispatcher._on_user_register(
+                Iq(sfrom="romeo@montague.lit/gajim")
+            )
+        )
+        welcome = self.next_sent()
+        assert welcome["body"], welcome
+        stanza = self.next_sent()
+        assert "logging in" in stanza["status"].lower(), stanza
+        stanza = self.next_sent()
+        assert "syncing contacts" in stanza["status"].lower(), stanza
+        if BaseGateway.get_self_or_unique_subclass().GROUPS:
+            stanza = self.next_sent()
+            assert "syncing groups" in stanza["status"].lower(), stanza
+        for _ in range(n_contacts):
+            probe = self.next_sent()
+            assert probe.get_type() == "probe"
+        stanza = self.next_sent()
+        assert "yup" in stanza["status"].lower(), stanza
+        self.romeo: BaseSession = BaseSession.get_self_or_unique_subclass().from_jid(
+            JID("romeo@montague.lit")
+        )
+
+        self.juliet: LegacyContact = self.run_coro(
+            self.romeo.contacts.by_legacy_id("juliet")
+        )
+        self.room: LegacyMUC = self.run_coro(self.romeo.bookmarks.by_legacy_id("room"))
+        self.first_witch: LegacyParticipant = self.run_coro(
+            self.room.get_participant("firstwitch")
+        )
+        self.send(  # language=XML
+            """
+            <iq type="get"
+                to="romeo@montague.lit"
+                id="1"
+                from="aim.shakespeare.lit">
+              <pubsub xmlns="http://jabber.org/protocol/pubsub">
+                <items node="urn:xmpp:avatar:metadata" />
+              </pubsub>
+            </iq>
+            """
+        )
+
     @classmethod
     def tearDownClass(cls):
         reset_subclasses()
-        user_store._users = None
 
 
 def format_stanza(stanza):

slidge/util/types.py

@@ -3,6 +3,7 @@ Typing stuff
 """
 
 from dataclasses import dataclass
+from datetime import datetime
 from enum import IntEnum
 from pathlib import Path
 from typing import (
@@ -20,14 +21,13 @@ from typing import (
 )
 
 from slixmpp import Message, Presence
-from slixmpp.types import PresenceShows
+from slixmpp.types import PresenceShows, PresenceTypes
 
 if TYPE_CHECKING:
     from ..contact import LegacyContact
     from ..core.pubsub import PepItem
     from ..core.session import BaseSession
     from ..group.participant import LegacyMUC, LegacyParticipant
-    from .db import GatewayUser
 
     AnyBaseSession = BaseSession[Any, Any]
 else:
@@ -75,6 +75,10 @@ FieldType = Literal[
 ]
 MucAffiliation = Literal["owner", "admin", "member", "outcast", "none"]
 MucRole = Literal["visitor", "participant", "moderator", "none"]
+# https://xmpp.org/registrar/disco-categories.html#client
+ClientType = Literal[
+    "bot", "console", "game", "handheld", "pc", "phone", "sms", "tablet", "web"
+]
 
 
 @dataclass
@@ -84,13 +88,16 @@ class MessageReference(Generic[LegacyMessageType]):
 
     At the very minimum, the legacy message ID attribute must be set, but to
     ensure that the quote is displayed in all XMPP clients, the author must also
-    be set.
+    be set (use the string "user" if the slidge user is the author of the referenced
+    message).
     The body is used as a fallback for XMPP clients that do not support :xep:`0461`
     of that failed to find the referenced message.
     """
 
     legacy_id: LegacyMessageType
-    author: Optional[Union["GatewayUser", "LegacyParticipant", "LegacyContact"]] = None
+    author: Optional[Union[Literal["user"], "LegacyParticipant", "LegacyContact"]] = (
+        None
+    )
     body: Optional[str] = None
 
 
@@ -178,3 +185,31 @@ class Mention(NamedTuple):
 class Hat(NamedTuple):
     uri: str
     title: str
+
+
+class UserPreferences(TypedDict):
+    sync_avatar: bool
+    sync_presence: bool
+
+
+class MamMetadata(NamedTuple):
+    id: str
+    sent_on: datetime
+
+
+class HoleBound(NamedTuple):
+    id: int | str
+    timestamp: datetime
+
+
+class CachedPresence(NamedTuple):
+    last_seen: Optional[datetime] = None
+    ptype: Optional[PresenceTypes] = None
+    pstatus: Optional[str] = None
+    pshow: Optional[PresenceShows] = None
+
+
+class Sticker(NamedTuple):
+    path: Path
+    content_type: Optional[str]
+    hashes: dict[str, str]

slidge/util/util.py

@@ -4,8 +4,17 @@ import re
 import subprocess
 import warnings
 from abc import ABCMeta
+from functools import wraps
 from pathlib import Path
-from typing import TYPE_CHECKING, Callable, NamedTuple, Optional, Type
+from time import time
+from typing import TYPE_CHECKING, Callable, NamedTuple, Optional, Type, TypeVar
+
+try:
+    import emoji
+except ImportError:
+    EMOJI_LIB_AVAILABLE = False
+else:
+    EMOJI_LIB_AVAILABLE = True
 
 from .types import Mention, ResourceDict
 
@@ -274,7 +283,10 @@ def deprecated(name: str, new: Callable):
     return wrapped
 
 
-def dict_to_named_tuple(data: dict, cls: Type[NamedTuple]):
+T = TypeVar("T", bound=NamedTuple)
+
+
+def dict_to_named_tuple(data: dict, cls: Type[T]) -> T:
     return cls(*(data.get(f) for f in cls._fields))  # type:ignore
 
 
@@ -293,3 +305,34 @@ def replace_mentions(
         cursor = mention.end
     pieces.append(text[cursor:])
     return "".join(pieces)
+
+
+def with_session(func):
+    @wraps(func)
+    async def wrapped(self, *args, **kwargs):
+        with self.xmpp.store.session():
+            return await func(self, *args, **kwargs)
+
+    return wrapped
+
+
+def timeit(func):
+    @wraps(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))
+        return r
+
+    return wrapped
+
+
+def strip_leading_emoji(text: str) -> str:
+    if not EMOJI_LIB_AVAILABLE:
+        return text
+    words = text.split(" ")
+    # is_emoji returns False for 🛷️ for obscure reasons,
+    # purely_emoji seems better
+    if len(words) > 1 and emoji.purely_emoji(words[0]):
+        return " ".join(words[1:])
+    return text

{slidge-0.1.2.dist-info → slidge-0.2.0.dist-info}/METADATA

@@ -1,25 +1,30 @@
 Metadata-Version: 2.1
 Name: slidge
-Version: 0.1.2
+Version: 0.2.0
 Summary: XMPP bridging framework
 Home-page: https://sr.ht/~nicoco/slidge/
 License: AGPL-3.0-or-later
 Author: Nicolas Cedilnik
 Author-email: nicoco@nicoco.fr
-Requires-Python: >=3.9,<4.0
+Requires-Python: >=3.11,<4.0
 Classifier: License :: OSI Approved :: GNU Affero General Public License v3 or later (AGPLv3+)
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Internet :: XMPP
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
 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: blurhash-python (>=1.2.1,<2.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)
 Requires-Dist: slixmpp (>=1.8.5,<2.0.0)
+Requires-Dist: sqlalchemy (>=2.0.29,<3.0.0)
+Requires-Dist: thumbhash (>=0.1.2,<0.2.0)
+Project-URL: Bug tracker, https://todo.sr.ht/~nicoco/slidge
+Project-URL: Chat room, https://conference.nicoco.fr:5281/muc_log/slidge/
 Project-URL: Documentation, https://slidge.im/
 Project-URL: Repository, https://git.sr.ht/~nicoco/slidge/
 Description-Content-Type: text/markdown