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

slidge/core/session.py

@@ -7,21 +7,24 @@ from typing import (
     Iterable,
     NamedTuple,
     Optional,
+    Type,
     Union,
     cast,
 )
 
 import aiohttp
+import sqlalchemy as sa
 from slixmpp import JID, Message
 from slixmpp.exceptions import XMPPError
 from slixmpp.types import PresenceShows
 
 from ..command import SearchResult
 from ..contact import LegacyContact, LegacyRoster
-from ..db.models import GatewayUser
+from ..db.models import Contact, GatewayUser
 from ..group.bookmarks import LegacyBookmarks
 from ..group.room import LegacyMUC
 from ..util import ABCSubclassableOnceAtMost
+from ..util.lock import NamedLockMixin
 from ..util.types import (
     LegacyGroupIdType,
     LegacyMessageType,
@@ -48,7 +51,9 @@ class CachedPresence(NamedTuple):
 
 
 class BaseSession(
-    Generic[LegacyMessageType, RecipientType], metaclass=ABCSubclassableOnceAtMost
+    Generic[LegacyMessageType, RecipientType],
+    NamedLockMixin,
+    metaclass=ABCSubclassableOnceAtMost,
 ):
     """
     The session of a registered :term:`User`.
@@ -89,22 +94,22 @@ class BaseSession(
     This can be used to implement voting in polls in a hacky way.
     """
 
-    def __init__(self, user: GatewayUser):
-        self.log = logging.getLogger(user.jid.bare)
+    _roster_cls: Type[LegacyRoster]
+    _bookmarks_cls: Type[LegacyBookmarks]
 
-        self.user_jid = user.jid
-        self.user_pk = user.id
+    def __init__(self, user: GatewayUser) -> None:
+        super().__init__()
+        self.user = user
+        self.log = logging.getLogger(user.jid.bare)
 
         self.ignore_messages = set[str]()
 
-        self.contacts: LegacyRoster = LegacyRoster.get_self_or_unique_subclass()(self)
+        self.contacts = self._roster_cls(self)
         self.is_logging_in = False
         self._logged = False
         self.__reset_ready()
 
-        self.bookmarks: LegacyBookmarks = LegacyBookmarks.get_self_or_unique_subclass()(
-            self
-        )
+        self.bookmarks = self._bookmarks_cls(self)
 
         self.thread_creation_lock = asyncio.Lock()
 
@@ -113,25 +118,29 @@ class BaseSession(
         self.__tasks = set[asyncio.Task]()
 
     @property
-    def user(self) -> GatewayUser:
-        return self.xmpp.store.users.get(self.user_jid)  # type:ignore
+    def user_jid(self) -> JID:
+        return self.user.jid
+
+    @property
+    def user_pk(self) -> int:
+        return self.user.id
 
     @property
     def http(self) -> aiohttp.ClientSession:
         return self.xmpp.http
 
-    def __remove_task(self, fut):
+    def __remove_task(self, fut) -> None:
         self.log.debug("Removing fut %s", fut)
         self.__tasks.remove(fut)
 
-    def create_task(self, coro) -> asyncio.Task:
-        task = self.xmpp.loop.create_task(coro)
+    def create_task(self, coro, name: str | None = None) -> asyncio.Task:
+        task = self.xmpp.loop.create_task(coro, name=name)
         self.__tasks.add(task)
         self.log.debug("Creating task %s", task)
         task.add_done_callback(lambda _: self.__remove_task(task))
         return task
 
-    def cancel_all_tasks(self):
+    def cancel_all_tasks(self) -> None:
         for task in self.__tasks:
             task.cancel()
 
@@ -148,7 +157,7 @@ class BaseSession(
         """
         raise NotImplementedError
 
-    async def logout(self):
+    async def logout(self) -> None:
         """
         Logs out the gateway user from the legacy network.
 
@@ -304,6 +313,17 @@ class BaseSession(
 
     paused = deprecated("BaseSession.paused", on_paused)
 
+    async def on_gone(
+        self, chat: RecipientType, thread: Optional[LegacyThreadType] = None
+    ):
+        """
+        Triggered when the user is "gone" in a legacy chat (:xep:`0085`)
+
+        :param chat: See :meth:`.BaseSession.on_text`
+        :param thread:
+        """
+        raise NotImplementedError
+
     async def on_displayed(
         self,
         chat: RecipientType,
@@ -493,7 +513,7 @@ class BaseSession(
 
     async def on_invitation(
         self, contact: LegacyContact, muc: LegacyMUC, reason: Optional[str]
-    ):
+    ) -> None:
         """
         Triggered when the user invites a :term:`Contact` to a legacy MUC via
         :xep:`0249`.
@@ -519,7 +539,7 @@ class BaseSession(
         """
         raise NotImplementedError
 
-    def __reset_ready(self):
+    def __reset_ready(self) -> None:
         self.ready = self.xmpp.loop.create_future()
 
     @property
@@ -527,7 +547,7 @@ class BaseSession(
         return self._logged
 
     @logged.setter
-    def logged(self, v: bool):
+    def logged(self, v: bool) -> None:
         self.is_logging_in = False
         self._logged = v
         if self.ready.done():
@@ -539,19 +559,34 @@ class BaseSession(
             if v:
                 self.ready.set_result(True)
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return f"<Session of {self.user_jid}>"
 
-    def shutdown(self, logout=True) -> asyncio.Task:
+    def shutdown(self, logout: bool = True) -> asyncio.Task:
         for m in self.bookmarks:
             m.shutdown()
-        for c in self.contacts:
-            c.offline()
+        with self.xmpp.store.session() as orm:
+            for jid in orm.execute(
+                sa.select(Contact.jid).filter_by(user=self.user, is_friend=True)
+            ).scalars():
+                pres = self.xmpp.make_presence(
+                    pfrom=jid,
+                    pto=self.user_jid,
+                    ptype="unavailable",
+                    pstatus="Gateway has shut down.",
+                )
+                pres.send()
         if logout:
-            return self.xmpp.loop.create_task(self.logout())
+            return self.xmpp.loop.create_task(self.__logout())
         else:
             return self.xmpp.loop.create_task(noop_coro())
 
+    async def __logout(self) -> None:
+        try:
+            await self.logout()
+        except NotImplementedError:
+            pass
+
     @staticmethod
     def legacy_to_xmpp_msg_id(legacy_msg_id: LegacyMessageType) -> str:
         """
@@ -604,7 +639,7 @@ class BaseSession(
     @classmethod
     def _from_user_or_none(cls, user):
         if user is None:
-            log.debug("user not found", stack_info=True)
+            log.debug("user not found")
             raise XMPPError(text="User not found", condition="subscription-required")
 
         session = _sessions.get(user.jid.bare)
@@ -641,11 +676,12 @@ class BaseSession(
         session = _sessions.get(jid.bare)
         if session is not None:
             return session
-        user = cls.xmpp.store.users.get(jid)
+        with cls.xmpp.store.session() as orm:
+            user = orm.query(GatewayUser).filter_by(jid=jid.bare).one_or_none()
         return cls._from_user_or_none(user)
 
     @classmethod
-    async def kill_by_jid(cls, jid: JID):
+    async def kill_by_jid(cls, jid: JID) -> None:
         # """
         # Terminate a user session.
         #
@@ -665,17 +701,19 @@ class BaseSession(
             c.unsubscribe()
         for m in session.bookmarks:
             m.shutdown()
-        user = cls.xmpp.store.users.get(jid)
-        if user is None:
+
+        try:
+            session = _sessions.pop(jid.bare)
+        except KeyError:
             log.warning("User not found during unregistration")
             return
-        await cls.xmpp.unregister(user)
-        cls.xmpp.store.users.delete(user.jid)
-        del _sessions[user.jid.bare]
-        del user
-        del session
 
-    def __ack(self, msg: Message):
+        await cls.xmpp.unregister(session)
+        with cls.xmpp.store.session() as orm:
+            orm.delete(session.user)
+            orm.commit()
+
+    def __ack(self, msg: Message) -> None:
         if not self.xmpp.PROPER_RECEIPTS:
             self.xmpp.delivery_receipt.ack(msg)
 
@@ -684,7 +722,7 @@ class BaseSession(
         status: Optional[str] = None,
         show=Optional[PresenceShows],
         **kwargs,
-    ):
+    ) -> None:
         """
         Send a presence from the gateway to the user.
 
@@ -699,7 +737,7 @@ class BaseSession(
             pto=self.user_jid.bare, pstatus=status, pshow=show, **kwargs
         )
 
-    def send_cached_presence(self, to: JID):
+    def send_cached_presence(self, to: JID) -> None:
         if not self.__cached_presence:
             self.xmpp.send_presence(pto=to, ptype="unavailable")
             return
@@ -710,7 +748,7 @@ class BaseSession(
             **self.__cached_presence.kwargs,
         )
 
-    def send_gateway_message(self, text: str, **msg_kwargs):
+    def send_gateway_message(self, text: str, **msg_kwargs) -> None:
         """
         Send a message from the gateway component to the user.
 
@@ -725,7 +763,7 @@ class BaseSession(
         muc: LegacyMUC,
         reason: Optional[str] = None,
         password: Optional[str] = None,
-    ):
+    ) -> None:
         """
         Send an invitation to join a MUC, emanating from the gateway component.
 
@@ -747,7 +785,7 @@ class BaseSession(
         """
         return await self.xmpp.input(self.user_jid, text, **msg_kwargs)
 
-    async def send_qr(self, text: str):
+    async def send_qr(self, text: str) -> None:
         """
         Sends a QR code generated from 'text' via HTTP Upload and send the URL to
         ``self.user``
@@ -756,13 +794,13 @@ class BaseSession(
         """
         await self.xmpp.send_qr(text, mto=self.user_jid)
 
-    def re_login(self):
+    def re_login(self) -> None:
         # Logout then re-login
         #
         # No reason to override this
         self.xmpp.re_login(self)
 
-    async def get_contact_or_group_or_participant(self, jid: JID, create=True):
+    async def get_contact_or_group_or_participant(self, jid: JID, create: bool = True):
         if (contact := self.contacts.by_jid_only_if_exists(jid)) is not None:
             return contact
         if (muc := self.bookmarks.by_jid_only_if_exists(JID(jid.bare))) is not None:
@@ -813,23 +851,20 @@ class BaseSession(
                 "Legacy session is not fully initialized, retry later",
             )
 
-    def legacy_module_data_update(self, data: dict):
-        with self.xmpp.store.session():
-            user = self.user
-            user.legacy_module_data.update(data)
-            self.xmpp.store.users.update(user)
-
-    def legacy_module_data_set(self, data: dict):
-        with self.xmpp.store.session():
-            user = self.user
-            user.legacy_module_data = data
-            self.xmpp.store.users.update(user)
-
-    def legacy_module_data_clear(self):
-        with self.xmpp.store.session():
-            user = self.user
-            user.legacy_module_data.clear()
-            self.xmpp.store.users.update(user)
+    def legacy_module_data_update(self, data: dict) -> None:
+        user = self.user
+        user.legacy_module_data.update(data)
+        self.xmpp.store.users.update(user)
+
+    def legacy_module_data_set(self, data: dict) -> None:
+        user = self.user
+        user.legacy_module_data = data
+        self.xmpp.store.users.update(user)
+
+    def legacy_module_data_clear(self) -> None:
+        user = self.user
+        user.legacy_module_data.clear()
+        self.xmpp.store.users.update(user)
 
 
 # keys = user.jid.bare