slidge 0.2.11__py3-none-any.whl → 0.3.0a0__py3-none-any.whl

slidge/core/dispatcher/registration.py

@@ -15,9 +15,10 @@ if TYPE_CHECKING:
 
 
 class RegistrationMixin(DispatcherMixin):
-    def __init__(self, xmpp: "BaseGateway"):
+    __slots__: list[str] = []
+
+    def __init__(self, xmpp: "BaseGateway") -> None:
         super().__init__(xmpp)
-        self.xmpp = xmpp
         xmpp["xep_0077"].api.register(
             self.xmpp.make_registration_form, "make_registration_form"
         )
@@ -32,7 +33,10 @@ class RegistrationMixin(DispatcherMixin):
         xmpp.add_event_handler("user_unregister", self._on_user_unregister)
 
     def get_user(self, jid: JID) -> GatewayUser | None:
-        return self.xmpp.store.users.get(jid)
+        session = self.xmpp.get_session_from_jid(jid)
+        if session is None:
+            return None
+        return session.user
 
     async def _user_get(
         self, _gateway_jid, _node, ifrom: JID, iq: Iq
@@ -41,7 +45,7 @@ class RegistrationMixin(DispatcherMixin):
             ifrom = iq.get_from()
         return self.get_user(ifrom)
 
-    async def _user_validate(self, _gateway_jid, _node, ifrom: JID, iq: Iq):
+    async def _user_validate(self, _gateway_jid, _node, ifrom: JID, iq: Iq) -> None:
         xmpp = self.xmpp
         log.debug("User validate: %s", ifrom.bare)
         form_dict = {f.var: iq.get(f.var) for f in xmpp.REGISTRATION_FIELDS}
@@ -49,10 +53,13 @@ class RegistrationMixin(DispatcherMixin):
         legacy_module_data = await xmpp.user_prevalidate(ifrom, form_dict)
         if legacy_module_data is None:
             legacy_module_data = form_dict
-        user = self.xmpp.store.users.new(
-            jid=ifrom,
-            legacy_module_data=legacy_module_data,  # type:ignore
-        )
+        with self.xmpp.store.session() as orm:
+            user = GatewayUser(
+                jid=ifrom.bare,
+                legacy_module_data=legacy_module_data,
+            )
+            orm.add(user)
+            orm.commit()
         log.info("New user: %s", user)
 
     async def _user_modify(
@@ -60,13 +67,14 @@ class RegistrationMixin(DispatcherMixin):
     ):
         await self.xmpp.user_prevalidate(ifrom, form_dict)
         log.debug("Modify user: %s", ifrom)
-        user = self.xmpp.store.users.get(ifrom)
+        with self.xmpp.store.session() as orm:
+            user = orm.query(GatewayUser).one_or_none()
         if user is None:
             raise XMPPError("internal-server-error", "User not found")
         user.legacy_module_data.update(form_dict)
         self.xmpp.store.users.update(user)
 
-    async def _on_user_register(self, iq: Iq):
+    async def _on_user_register(self, iq: Iq) -> None:
         session = await self._get_session(iq, wait_for_ready=False)
         for jid in config.ADMINS:
             self.xmpp.send_message(
@@ -78,8 +86,8 @@ class RegistrationMixin(DispatcherMixin):
         session.send_gateway_message(self.xmpp.WELCOME_MESSAGE)
         await self.xmpp.login_wrap(session)
 
-    async def _on_user_unregister(self, iq: Iq):
-        await self.xmpp.session_cls.kill_by_jid(iq.get_from())
+    async def _on_user_unregister(self, iq: Iq) -> None:
+        await self.xmpp.kill_session(iq.get_from())
 
 
 log = logging.getLogger(__name__)

slidge/core/dispatcher/search.py

@@ -3,6 +3,7 @@ from typing import TYPE_CHECKING
 from slixmpp import JID, CoroutineCallback, Iq, StanzaPath
 from slixmpp.exceptions import XMPPError
 
+from ...db.models import GatewayUser
 from .util import DispatcherMixin, exceptions_to_xmpp_errors
 
 if TYPE_CHECKING:
@@ -10,7 +11,9 @@ if TYPE_CHECKING:
 
 
 class SearchMixin(DispatcherMixin):
-    def __init__(self, xmpp: "BaseGateway"):
+    __slots__: list[str] = []
+
+    def __init__(self, xmpp: "BaseGateway") -> None:
         super().__init__(xmpp)
 
         xmpp["xep_0055"].api.register(self.search_get_form, "search_get_form")
@@ -21,7 +24,7 @@ class SearchMixin(DispatcherMixin):
             CoroutineCallback(
                 "iq:gateway",
                 StanzaPath("iq/gateway"),
-                self._handle_gateway_iq,  # type: ignore
+                self._handle_gateway_iq,
             )
         )
 
@@ -29,7 +32,8 @@ class SearchMixin(DispatcherMixin):
         """
         Prepare the search form using :attr:`.BaseSession.SEARCH_FIELDS`
         """
-        user = self.xmpp.store.users.get(ifrom)
+        with self.xmpp.store.session() as orm:
+            user = orm.query(GatewayUser).one_or_none()
         if user is None:
             raise XMPPError(text="Search is only allowed for registered users")
 

slidge/core/dispatcher/session_dispatcher.py

@@ -30,14 +30,16 @@ class SessionDispatcher(
     SearchMixin,
     VCardMixin,
 ):
-    def __init__(self, xmpp: "BaseGateway"):
+    __slots__: list[str] = ["xmpp", "_MamMixin__mam_cleanup_task"]
+
+    def __init__(self, xmpp: "BaseGateway") -> None:
         super().__init__(xmpp)
         xmpp.add_event_handler(
             "avatar_metadata_publish", self.on_avatar_metadata_publish
         )
 
     @exceptions_to_xmpp_errors
-    async def on_avatar_metadata_publish(self, m: Message):
+    async def on_avatar_metadata_publish(self, m: Message) -> None:
         session = await self._get_session(m, timeout=None)
         if not session.user.preferences.get("sync_avatar", False):
             session.log.debug("User does not want to sync their avatar")
@@ -46,7 +48,7 @@ class SessionDispatcher(
 
         await self.on_avatar_metadata_info(session, info)
 
-    async def on_avatar_metadata_info(self, session: BaseSession, info: Info):
+    async def on_avatar_metadata_info(self, session: BaseSession, info: Info) -> None:
         hash_ = info["id"]
 
         if session.user.avatar_hash == hash_:
@@ -66,7 +68,10 @@ class SessionDispatcher(
             height = info["height"]
             width = info["width"]
         else:
-            self.xmpp.store.users.set_avatar_hash(session.user_pk, None)
+            with self.xmpp.store.session(expire_on_commit=False) as orm:
+                session.user.avatar_hash = None
+                orm.add(session.user)
+                orm.commit()
             bytes_ = type_ = height = width = hash_ = None
         try:
             await session.on_avatar(bytes_, hash_, type_, width, height)
@@ -80,7 +85,10 @@ class SessionDispatcher(
                 f"Something went wrong trying to set your avatar: {e!r}"
             )
         else:
-            self.xmpp.store.users.set_avatar_hash(session.user_pk, hash_)
+            session.user.avatar_hash = hash_
+            with self.xmpp.store.session(expire_on_commit=False) as orm:
+                orm.add(session.user)
+                orm.commit()
             for room in session.bookmarks:
                 participant = await room.get_user_participant()
                 participant.send_last_presence(force=True, no_cache_online=True)

slidge/core/dispatcher/util.py

@@ -19,15 +19,17 @@ class Ignore(BaseException):
 
 
 class DispatcherMixin:
-    def __init__(self, xmpp: "BaseGateway"):
-        self.xmpp = xmpp
+    __slots__: list[str] = []
+
+    def __init__(self, xmpp: "BaseGateway") -> None:
+        self.xmpp = xmpp  # type:ignore[misc]
 
     async def _get_session(
         self,
         stanza: Message | Presence | Iq,
         timeout: int | None = 10,
-        wait_for_ready=True,
-        logged=False,
+        wait_for_ready: bool = True,
+        logged: bool = False,
     ) -> BaseSession:
         xmpp = self.xmpp
         if stanza.get_from().server == xmpp.boundjid.bare:
@@ -51,8 +53,8 @@ class DispatcherMixin:
         self,
         jid: JID,
         timeout: int | None = 10,
-        wait_for_ready=True,
-        logged=False,
+        wait_for_ready: bool = True,
+        logged: bool = False,
     ) -> BaseSession:
         session = self.xmpp.get_session_from_jid(jid)
         if session is None:
@@ -72,14 +74,15 @@ class DispatcherMixin:
         muc = await session.bookmarks.by_jid(ito)
         return muc
 
-    def _xmpp_msg_id_to_legacy(self, session: "BaseSession", xmpp_id: str):
-        sent = self.xmpp.store.sent.get_legacy_id(session.user_pk, xmpp_id)
-        if sent is not None:
-            return self.xmpp.LEGACY_MSG_ID_TYPE(sent)
-
-        multi = self.xmpp.store.multi.get_legacy_id(session.user_pk, xmpp_id)
-        if multi:
-            return self.xmpp.LEGACY_MSG_ID_TYPE(multi)
+    def _xmpp_msg_id_to_legacy(
+        self, session: "BaseSession", xmpp_id: str, recipient: Recipient
+    ):
+        with self.xmpp.store.session() as orm:
+            sent = self.xmpp.store.id_map.get_legacy(
+                orm, recipient.stored.id, xmpp_id, False
+            )
+            if sent is not None:
+                return self.xmpp.LEGACY_MSG_ID_TYPE(sent)
 
         try:
             return session.xmpp_to_legacy_msg_id(xmpp_id)
@@ -91,11 +94,11 @@ class DispatcherMixin:
                 "internal-server-error", "Couldn't convert xmpp msg ID to legacy ID."
             )
 
-    async def _get_session_entity_thread(
+    async def _get_session_recipient_thread(
         self, msg: Message
     ) -> tuple["BaseSession", Recipient, int | str]:
         session = await self._get_session(msg)
-        e: Recipient = await _get_entity(session, msg)
+        e: Recipient = await get_recipient(session, msg)
         legacy_thread = await self._xmpp_to_legacy_thread(session, msg, e)
         return session, e, legacy_thread
 
@@ -107,22 +110,29 @@ class DispatcherMixin:
             return None
 
         if session.MESSAGE_IDS_ARE_THREAD_IDS:
-            return self._xmpp_msg_id_to_legacy(session, xmpp_thread)
+            return self._xmpp_msg_id_to_legacy(session, xmpp_thread, recipient)
 
-        legacy_thread_str = session.xmpp.store.sent.get_legacy_thread(
-            session.user_pk, xmpp_thread
-        )
-        if legacy_thread_str is not None:
-            return session.xmpp.LEGACY_MSG_ID_TYPE(legacy_thread_str)
+        with session.xmpp.store.session() as orm:
+            legacy_thread_str = session.xmpp.store.id_map.get_thread(
+                orm, recipient.stored.id, xmpp_thread, recipient.is_group
+            )
+            if legacy_thread_str is not None:
+                return session.xmpp.LEGACY_MSG_ID_TYPE(legacy_thread_str)
         async with session.thread_creation_lock:
             legacy_thread = await recipient.create_thread(xmpp_thread)
-            session.xmpp.store.sent.set_thread(
-                session.user_pk, str(legacy_thread), xmpp_thread
-            )
+            with session.xmpp.store.session() as orm:
+                session.xmpp.store.id_map.set_thread(
+                    orm,
+                    recipient.stored.id,
+                    str(legacy_thread),
+                    xmpp_thread,
+                    recipient.is_group,
+                )
+                orm.commit()
             return legacy_thread
 
 
-def _ignore(session: "BaseSession", msg: Message):
+def _ignore(session: "BaseSession", msg: Message) -> bool:
     i = msg.get_id()
     if i.startswith("slidge-carbon-"):
         return True
@@ -133,7 +143,7 @@ def _ignore(session: "BaseSession", msg: Message):
     return True
 
 
-async def _get_entity(session: "BaseSession", m: Message) -> RecipientType:
+async def get_recipient(session: "BaseSession", m: Message) -> RecipientType:
     session.raise_if_not_logged()
     if m.get_type() == "groupchat":
         muc = await session.bookmarks.by_jid(m.get_to())

slidge/core/dispatcher/vcard.py

@@ -8,11 +8,14 @@ from slixmpp.plugins.xep_0292.stanza import NS as VCard4NS
 from ...contact import LegacyContact
 from ...core.session import BaseSession
 from ...group import LegacyParticipant
+from ...util.types import Avatar
 from .util import DispatcherMixin, exceptions_to_xmpp_errors
 
 
 class VCardMixin(DispatcherMixin):
-    def __init__(self, xmpp):
+    __slots__: list[str] = []
+
+    def __init__(self, xmpp) -> None:
         super().__init__(xmpp)
         xmpp.register_handler(
             CoroutineCallback(
@@ -34,7 +37,7 @@ class VCardMixin(DispatcherMixin):
         )
 
     @exceptions_to_xmpp_errors
-    async def on_get_vcard(self, iq: Iq):
+    async def on_get_vcard(self, iq: Iq) -> None:
         session = await self._get_session(iq, logged=True)
         contact = await session.contacts.by_jid(iq.get_to())
         vcard = await contact.get_vcard()
@@ -139,8 +142,8 @@ class VCardMixin(DispatcherMixin):
         reply.send()
 
         if not data:
-            await muc.set_avatar(None, blocking=True)
+            await muc.set_avatar(None)
             return
 
         if legacy_id:
-            await muc.set_avatar(data, legacy_id, blocking=True)
+            await muc.set_avatar(Avatar(data=data, unique_id=legacy_id))