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

slidge/core/mixins/avatar.py

@@ -1,25 +1,21 @@
-from asyncio import Task, create_task
-from hashlib import sha1
+from asyncio import Task
 from pathlib import Path
 from typing import TYPE_CHECKING, Optional
 
 from PIL import UnidentifiedImageError
 from slixmpp import JID
+from sqlalchemy.orm.exc import DetachedInstanceError
 
 from ...db.avatar import CachedAvatar, avatar_cache
-from ...util.types import (
-    URL,
-    AnyBaseSession,
-    AvatarIdType,
-    AvatarType,
-    LegacyFileIdType,
-)
+from ...db.models import Contact, Room
+from ...util.types import AnyBaseSession, Avatar
+from .db import UpdateInfoMixin
 
 if TYPE_CHECKING:
     from ..pubsub import PepAvatar
 
 
-class AvatarMixin:
+class AvatarMixin(UpdateInfoMixin):
     """
     Mixin for XMPP entities that have avatars that represent them.
 
@@ -29,154 +25,119 @@ class AvatarMixin:
 
     jid: JID = NotImplemented
     session: AnyBaseSession = NotImplemented
-    _avatar_bare_jid: bool = NotImplemented
+    stored: Contact | Room
 
     def __init__(self) -> None:
         super().__init__()
-        self._set_avatar_task: Optional[Task] = None
-        self.__broadcast_task: Optional[Task] = None
-        self.__avatar_unique_id: Optional[AvatarIdType] = None
-        self._avatar_pk: Optional[int] = None
+        self._set_avatar_task: Task | None = None
 
     @property
-    def __avatar_jid(self):
-        return JID(self.jid.bare) if self._avatar_bare_jid else self.jid
-
-    @property
-    def avatar_id(self) -> Optional[AvatarIdType]:
+    def avatar(self) -> Avatar | None:
         """
-        The unique ID of this entity's avatar.
-        """
-        return self.__avatar_unique_id
+        This property can be used to set or unset the avatar.
 
-    @property
-    def avatar(self) -> Optional[AvatarIdType]:
+        Unlike the awaitable :method:`.set_avatar`, it schedules the update for
+        later execution and is not blocking
         """
-        This property can be used to set the avatar, but
-        :py:meth:`~.AvatarMixin.set_avatar()` should be preferred because you can
-        provide a unique ID for the avatar for efficient caching.
-        Setting this is OKish in case the avatar type is a URL or a local path
-        that can act as a legacy ID.
-
-        Python's ``property`` is abused here to maintain backwards
-        compatibility, but when getting it you actually get the avatar legacy
-        ID.
-        """
-        return self.__avatar_unique_id
+        try:
+            if self.stored.avatar is None:
+                return None
+        except DetachedInstanceError:
+            self.merge()
+            if self.stored.avatar is None:
+                return None
+        if self.stored.avatar.legacy_id is None:
+            unique_id = None
+        else:
+            unique_id = self.session.xmpp.AVATAR_ID_TYPE(self.stored.avatar.legacy_id)
+        return Avatar(
+            unique_id=unique_id,
+            url=self.stored.avatar.url,
+        )
 
     @avatar.setter
-    def avatar(self, a: Optional[AvatarType]):
+    def avatar(self, avatar: Avatar | Path | str | None) -> None:
+        avatar = convert_avatar(avatar)
         if self._set_avatar_task:
             self._set_avatar_task.cancel()
         self.session.log.debug("Setting avatar with property")
-        self._set_avatar_task = self.session.xmpp.loop.create_task(
-            self.set_avatar(a, None, blocking=True, cancel=False),
-            name=f"Set avatar of {self} from property",
-        )
+        self._set_avatar_task = self.session.create_task(self.set_avatar(avatar))
 
-    @property
-    def avatar_pk(self) -> int | None:
-        return self._avatar_pk
-
-    @staticmethod
-    def __get_uid(a: Optional[AvatarType]) -> Optional[AvatarIdType]:
-        if isinstance(a, str):
-            return URL(a)
-        elif isinstance(a, Path):
-            return str(a)
-        elif isinstance(a, bytes):
-            return sha1(a).hexdigest()
-        elif a is None:
-            return None
-        raise TypeError("Bad avatar", a)
+    async def __has_changed(self, avatar: Avatar | None) -> bool:
+        if self.avatar is None:
+            return avatar is not None
+        if avatar is None:
+            return self.avatar is not None
 
-    async def __set_avatar(
-        self, a: Optional[AvatarType], uid: Optional[AvatarIdType], delete: bool
-    ):
-        self.__avatar_unique_id = uid
+        if self.avatar.unique_id is not None and avatar.unique_id is not None:
+            return self.avatar.unique_id != avatar.unique_id
 
-        if a is None:
-            cached_avatar = None
-            self._avatar_pk = None
-        else:
-            try:
-                cached_avatar = await avatar_cache.convert_or_get(a)
-            except UnidentifiedImageError:
-                self.session.log.warning("%s is not a valid avatar", a)
-                self._avatar_pk = None
-                self.__avatar_unique_id = uid
-                return
-            except Exception as e:
-                self.session.log.error("Failed to set avatar %s", a, exc_info=e)
-                self._avatar_pk = None
-                self.__avatar_unique_id = uid
-                return
-            self._avatar_pk = cached_avatar.pk
+        if (
+            self.avatar.url is not None
+            and avatar.url is not None
+            and self.avatar.url == avatar.url
+        ):
+            return await avatar_cache.url_modified(avatar.url)
 
-        if self.__should_pubsub_broadcast():
-            await self.session.xmpp.pubsub.broadcast_avatar(
-                self.__avatar_jid, self.session.user_jid, cached_avatar
-            )
+        if avatar.path is not None:
+            cached = self.get_cached_avatar()
+            if cached is not None:
+                return cached.path.read_bytes() != avatar.path.read_bytes()
 
-        if delete and isinstance(a, Path):
-            a.unlink()
-
-        self._post_avatar_update()
-
-    def __should_pubsub_broadcast(self):
-        return getattr(self, "is_friend", False) and getattr(
-            self, "added_to_roster", False
-        )
-
-    async def _no_change(self, a: Optional[AvatarType], uid: Optional[AvatarIdType]):
-        if a is None:
-            return self.__avatar_unique_id is None
-        if not self.__avatar_unique_id:
-            return False
-        if isinstance(uid, URL):
-            if self.__avatar_unique_id != uid:
-                return False
-            return not await avatar_cache.url_modified(uid)
-        return self.__avatar_unique_id == uid
+        return True
 
     async def set_avatar(
-        self,
-        a: Optional[AvatarType],
-        avatar_unique_id: Optional[LegacyFileIdType] = None,
-        delete: bool = False,
-        blocking=False,
-        cancel=True,
+        self, avatar: Avatar | Path | str | None = None, delete: bool = False
     ) -> None:
         """
         Set an avatar for this entity
 
-        :param a: The avatar, in one of the types slidge supports
-        :param avatar_unique_id: A globally unique ID for the avatar on the
-            legacy network
+        :param avatar: The avatar. Should ideally come with a legacy network-wide unique
+            ID
         :param delete: If the avatar is provided as a Path, whether to delete
             it once used or not.
-        :param blocking: Internal use by slidge for tests, do not use!
-        :param cancel: Internal use by slidge, do not use!
         """
-        if avatar_unique_id is None and a is not None:
-            avatar_unique_id = self.__get_uid(a)
-        if await self._no_change(a, avatar_unique_id):
+        avatar = convert_avatar(avatar)
+
+        if not await self.__has_changed(avatar):
             return
-        if cancel and self._set_avatar_task:
-            self._set_avatar_task.cancel()
-        awaitable = create_task(
-            self.__set_avatar(a, avatar_unique_id, delete),
-            name=f"Set pubsub avatar of {self}",
-        )
-        if not self._set_avatar_task or self._set_avatar_task.done():
-            self._set_avatar_task = awaitable
-        if blocking:
-            await awaitable
+
+        if avatar is None:
+            cached_avatar = None
+        else:
+            try:
+                cached_avatar = await avatar_cache.convert_or_get(avatar)
+            except UnidentifiedImageError:
+                self.session.log.warning("%s is not a valid image", avatar)
+                cached_avatar = None
+            except Exception as e:
+                self.session.log.error("Failed to set avatar %s: %s", avatar, e)
+                cached_avatar = None
+
+        if delete:
+            if avatar is None or avatar.path is None:
+                self.session.log.warning(
+                    "Requested avatar path delete, but no path provided"
+                )
+            else:
+                avatar.path.unlink()
+
+        if cached_avatar is None:
+            self.stored.avatar = None
+        else:
+            self.stored.avatar = cached_avatar.stored
+        self.commit(merge=True)
+        self._post_avatar_update(cached_avatar)
 
     def get_cached_avatar(self) -> Optional["CachedAvatar"]:
-        if self._avatar_pk is None:
-            return None
-        return avatar_cache.get_by_pk(self._avatar_pk)
+        try:
+            if self.stored.avatar is None:
+                return None
+        except DetachedInstanceError:
+            self.merge()
+            if self.stored.avatar is None:
+                return None
+        return avatar_cache.get(self.stored.avatar)
 
     def get_avatar(self) -> Optional["PepAvatar"]:
         cached_avatar = self.get_cached_avatar()
@@ -188,55 +149,17 @@ class AvatarMixin:
         item.set_avatar_from_cache(cached_avatar)
         return item
 
-    def _post_avatar_update(self) -> None:
-        return
-
-    def __get_cached_avatar_id(self):
-        i = self._get_cached_avatar_id()
-        if i is None:
-            return None
-        return self.session.xmpp.AVATAR_ID_TYPE(i)
-
-    def _get_cached_avatar_id(self) -> Optional[str]:
+    def _post_avatar_update(self, cached_avatar: Optional["CachedAvatar"]) -> None:
         raise NotImplementedError
 
-    async def avatar_wrap_update_info(self):
-        cached_id = self.__get_cached_avatar_id()
-        self.__avatar_unique_id = cached_id
-        try:
-            await self.update_info()  # type:ignore
-        except NotImplementedError:
-            return
-        new_id = self.avatar
-        if isinstance(new_id, URL) and not await avatar_cache.url_modified(new_id):
-            return
-        elif new_id != cached_id:
-            # at this point it means that update_info set the avatar, and we don't
-            # need to do anything else
-            return
 
-        if self.__should_pubsub_broadcast():
-            if new_id is None and cached_id is None:
-                return
-            if self._avatar_pk is not None:
-                cached_avatar = avatar_cache.get_by_pk(self._avatar_pk)
-            else:
-                cached_avatar = None
-            self.__broadcast_task = self.session.xmpp.loop.create_task(
-                self.session.xmpp.pubsub.broadcast_avatar(
-                    self.__avatar_jid, self.session.user_jid, cached_avatar
-                )
-            )
-
-    def _set_avatar_from_store(self, stored):
-        if stored.avatar_id is None:
-            return
-        if stored.avatar is None:
-            # seems to happen after avatar cleanup for some reason?
-            self.__avatar_unique_id = None
-            return
-        self.__avatar_unique_id = (
-            stored.avatar.legacy_id
-            if stored.avatar.legacy_id is not None
-            else URL(stored.avatar.url)
-        )
+def convert_avatar(
+    avatar: Avatar | Path | str | None, unique_id: str | None = None
+) -> Avatar | None:
+    if isinstance(avatar, Path):
+        return Avatar(path=avatar, unique_id=unique_id)
+    if isinstance(avatar, str):
+        return Avatar(url=avatar)
+    if avatar is None or all(x is None for x in avatar):
+        return None
+    return avatar

slidge/core/mixins/db.py

@@ -1,18 +1,66 @@
+import logging
+import typing
 from contextlib import contextmanager
 
+from ...db.models import Base, Contact, Participant, Room
 
-class UpdateInfoMixin:
+if typing.TYPE_CHECKING:
+    from slidge import BaseGateway
+
+
+class DBMixin:
+    stored: Base
+    xmpp: "BaseGateway"
+    log: logging.Logger
+
+    def merge(self) -> None:
+        with self.xmpp.store.session() as orm:
+            self.stored = orm.merge(self.stored)
+
+    def commit(self, merge: bool = False) -> None:
+        with self.xmpp.store.session(expire_on_commit=False) as orm:
+            if merge:
+                self.log.debug("Merging %s", self.stored)
+                self.stored = orm.merge(self.stored)
+                self.log.debug("Merged %s", self.stored)
+            orm.add(self.stored)
+            self.log.debug("Committing to DB")
+            orm.commit()
+
+
+class UpdateInfoMixin(DBMixin):
     """
     This mixin just adds a context manager that prevents commiting to the DB
     on every attribute change.
     """
 
-    def __init__(self, *args, **kwargs):
+    stored: Contact | Room
+    xmpp: "BaseGateway"
+    log: logging.Logger
+
+    def __init__(self, *args, **kwargs) -> None:
         super().__init__(*args, **kwargs)
         self._updating_info = False
+        if self.stored.extra_attributes is not None:
+            self.deserialize_extra_attributes(self.stored.extra_attributes)
+
+    def serialize_extra_attributes(self) -> dict | None:
+        return None
+
+    def deserialize_extra_attributes(self, data: dict) -> None:
+        pass
 
     @contextmanager
     def updating_info(self):
         self._updating_info = True
         yield
         self._updating_info = False
+        self.stored.updated = True
+        self.commit()
+
+    def commit(self, merge: bool = False) -> None:
+        if self._updating_info:
+            self.log.debug("Not updating %s right now", self.stored)
+        else:
+            self.stored.extra_attributes = self.serialize_extra_attributes()
+            super().commit(merge=merge)

slidge/core/mixins/message.py

@@ -27,11 +27,11 @@ PUBLISH_OPTIONS.add_field("pubsub#access_model", value="whitelist")
 
 
 class ChatStateMixin(MessageMaker):
-    def __init__(self):
+    def __init__(self) -> None:
         super().__init__()
         self.__last_chat_state: Optional[ChatState] = None
 
-    def _chat_state(self, state: ChatState, forced=False, **kwargs):
+    def _chat_state(self, state: ChatState, forced: bool = False, **kwargs) -> None:
         carbon = kwargs.get("carbon", False)
         if carbon or (state == self.__last_chat_state and not forced):
             return
@@ -39,28 +39,28 @@ class ChatStateMixin(MessageMaker):
         msg = self._make_message(state=state, hints={"no-store"})
         self._send(msg, **kwargs)
 
-    def active(self, **kwargs):
+    def active(self, **kwargs) -> None:
         """
         Send an "active" chat state (:xep:`0085`) from this
         :term:`XMPP Entity`.
         """
         self._chat_state("active", **kwargs)
 
-    def composing(self, **kwargs):
+    def composing(self, **kwargs) -> None:
         """
         Send a "composing" (ie "typing notification") chat state (:xep:`0085`)
         from this :term:`XMPP Entity`.
         """
         self._chat_state("composing", forced=True, **kwargs)
 
-    def paused(self, **kwargs):
+    def paused(self, **kwargs) -> None:
         """
         Send a "paused" (ie "typing paused notification") chat state
         (:xep:`0085`) from this :term:`XMPP Entity`.
         """
         self._chat_state("paused", **kwargs)
 
-    def inactive(self, **kwargs):
+    def inactive(self, **kwargs) -> None:
         """
         Send an "inactive" (ie "contact has not interacted with the chat session
         interface for an intermediate period of time") chat state (:xep:`0085`)
@@ -68,7 +68,7 @@ class ChatStateMixin(MessageMaker):
         """
         self._chat_state("inactive", **kwargs)
 
-    def gone(self, **kwargs):
+    def gone(self, **kwargs) -> None:
         """
         Send a "gone" (ie "contact has not interacted with the chat session interface,
         system, or device for a relatively long period of time") chat state
@@ -81,13 +81,13 @@ class MarkerMixin(MessageMaker):
     is_group: bool = NotImplemented
 
     def _make_marker(
-        self, legacy_msg_id: LegacyMessageType, marker: Marker, carbon=False
+        self, legacy_msg_id: LegacyMessageType, marker: Marker, carbon: bool = False
     ):
         msg = self._make_message(carbon=carbon)
         msg[marker]["id"] = self._legacy_to_xmpp(legacy_msg_id)
         return msg
 
-    def ack(self, legacy_msg_id: LegacyMessageType, **kwargs):
+    def ack(self, legacy_msg_id: LegacyMessageType, **kwargs) -> None:
         """
         Send an "acknowledged" message marker (:xep:`0333`) from this :term:`XMPP Entity`.
 
@@ -95,12 +95,12 @@ class MarkerMixin(MessageMaker):
         """
         self._send(
             self._make_marker(
-                legacy_msg_id, "acknowledged", carbon=kwargs.get("carbon")
+                legacy_msg_id, "acknowledged", carbon=bool(kwargs.get("carbon"))
             ),
             **kwargs,
         )
 
-    def received(self, legacy_msg_id: LegacyMessageType, **kwargs):
+    def received(self, legacy_msg_id: LegacyMessageType, **kwargs) -> None:
         """
         Send a "received" message marker (:xep:`0333`) from this :term:`XMPP Entity`.
         If called on a :class:`LegacyContact`, also send a delivery receipt
@@ -108,7 +108,7 @@ class MarkerMixin(MessageMaker):
 
         :param legacy_msg_id: The message this marker refers to
         """
-        carbon = kwargs.get("carbon")
+        carbon = bool(kwargs.get("carbon"))
         if self.mtype == "chat":
             self._send(
                 self.xmpp.delivery_receipt.make_ack(
@@ -121,20 +121,22 @@ class MarkerMixin(MessageMaker):
             self._make_marker(legacy_msg_id, "received", carbon=carbon), **kwargs
         )
 
-    def displayed(self, legacy_msg_id: LegacyMessageType, **kwargs):
+    def displayed(self, legacy_msg_id: LegacyMessageType, **kwargs) -> None:
         """
         Send a "displayed" message marker (:xep:`0333`) from this :term:`XMPP Entity`.
 
         :param legacy_msg_id: The message this marker refers to
         """
         self._send(
-            self._make_marker(legacy_msg_id, "displayed", carbon=kwargs.get("carbon")),
+            self._make_marker(
+                legacy_msg_id, "displayed", carbon=bool(kwargs.get("carbon"))
+            ),
             **kwargs,
         )
         if getattr(self, "is_user", False):
             self.session.create_task(self.__send_mds(legacy_msg_id))
 
-    async def __send_mds(self, legacy_msg_id: LegacyMessageType):
+    async def __send_mds(self, legacy_msg_id: LegacyMessageType) -> None:
         # Send a MDS displayed marker on behalf of the user for a group chat
         if muc := getattr(self, "muc", None):
             muc_jid = muc.jid.bare
@@ -166,7 +168,7 @@ class ContentMessageMixin(AttachmentMixin, TextMessageMixin):
 
 
 class CarbonMessageMixin(ContentMessageMixin, MarkerMixin):
-    def _privileged_send(self, msg: Message):
+    def _privileged_send(self, msg: Message) -> None:
         i = msg.get_id()
         if i:
             self.session.ignore_messages.add(i)
@@ -192,7 +194,7 @@ class InviteMixin(MessageMaker):
         reason: Optional[str] = None,
         password: Optional[str] = None,
         **send_kwargs,
-    ):
+    ) -> None:
         """
         Send an invitation to join a group (:xep:`0249`) from this :term:`XMPP Entity`.
 

slidge/core/mixins/message_maker.py

@@ -1,5 +1,4 @@
 import warnings
-from copy import copy
 from datetime import datetime, timezone
 from typing import TYPE_CHECKING, Iterable, Optional, cast
 from uuid import uuid4
@@ -20,7 +19,7 @@ from .. import config
 from .base import BaseSender
 
 if TYPE_CHECKING:
-    from ...group.participant import LegacyParticipant
+    from ...group import LegacyMUC, LegacyParticipant
 
 
 class MessageMaker(BaseSender):
@@ -29,6 +28,12 @@ class MessageMaker(BaseSender):
     STRIP_SHORT_DELAY = False
     USE_STANZA_ID = False
 
+    muc: "LegacyMUC"
+    is_group: bool
+
+    def _recipient_pk(self) -> int:
+        return self.muc.stored.id if self.is_group else self.stored.id  # type:ignore
+
     def _make_message(
         self,
         state: Optional[ChatState] = None,
@@ -36,7 +41,7 @@ class MessageMaker(BaseSender):
         legacy_msg_id: Optional[LegacyMessageType] = None,
         when: Optional[datetime] = None,
         reply_to: Optional[MessageReference] = None,
-        carbon=False,
+        carbon: bool = False,
         link_previews: Optional[Iterable[LinkPreview]] = None,
         **kwargs,
     ):
@@ -60,9 +65,14 @@ class MessageMaker(BaseSender):
             msg["body"] = body
             state = "active"
         if thread:
-            msg["thread"] = self.xmpp.store.sent.get_legacy_thread(
-                self.user_pk, str(thread)
-            ) or str(thread)
+            with self.xmpp.store.session() as orm:
+                thread_str = str(thread)
+                msg["thread"] = (
+                    self.xmpp.store.id_map.get_thread(
+                        orm, self._recipient_pk(), thread_str, self.is_group
+                    )
+                    or thread_str
+                )
         if state:
             msg["chat_state"] = state
         for hint in hints:
@@ -77,9 +87,9 @@ class MessageMaker(BaseSender):
 
     def _set_msg_id(
         self, msg: Message, legacy_msg_id: Optional[LegacyMessageType] = None
-    ):
+    ) -> None:
         if legacy_msg_id is not None:
-            i = self._legacy_to_xmpp(legacy_msg_id)
+            i = self.session.legacy_to_xmpp_msg_id(legacy_msg_id)
             msg.set_id(i)
             if self.USE_STANZA_ID:
                 msg["stanza_id"]["id"] = i
@@ -88,12 +98,16 @@ class MessageMaker(BaseSender):
             msg["stanza_id"]["id"] = str(uuid4())
             msg["stanza_id"]["by"] = self.muc.jid  # type: ignore
 
-    def _legacy_to_xmpp(self, legacy_id: LegacyMessageType):
-        return self.xmpp.store.sent.get_xmpp_id(
-            self.session.user_pk, str(legacy_id)
-        ) or self.session.legacy_to_xmpp_msg_id(legacy_id)
+    def _legacy_to_xmpp(self, legacy_id: LegacyMessageType) -> str:
+        with self.xmpp.store.session() as orm:
+            ids = self.xmpp.store.id_map.get_xmpp(
+                orm, self._recipient_pk(), str(legacy_id), False
+            )
+            if ids:
+                return ids[-1]
+        return self.session.legacy_to_xmpp_msg_id(legacy_id)
 
-    def _add_delay(self, msg: Message, when: Optional[datetime]):
+    def _add_delay(self, msg: Message, when: Optional[datetime]) -> None:
         if when:
             if when.tzinfo is None:
                 when = when.astimezone(timezone.utc)
@@ -104,7 +118,7 @@ class MessageMaker(BaseSender):
             msg["delay"].set_stamp(when)
             msg["delay"].set_from(self.xmpp.boundjid.bare)
 
-    def _add_reply_to(self, msg: Message, reply_to: MessageReference):
+    def _add_reply_to(self, msg: Message, reply_to: MessageReference) -> None:
         xmpp_id = self._legacy_to_xmpp(reply_to.legacy_id)
         msg["reply"]["id"] = xmpp_id
 
@@ -151,7 +165,7 @@ class MessageMaker(BaseSender):
             msg["reply"].add_quoted_fallback(fallback, fallback_nick)
 
     @staticmethod
-    def _add_link_previews(msg: Message, link_previews: Iterable[LinkPreview]):
+    def _add_link_previews(msg: Message, link_previews: Iterable[LinkPreview]) -> None:
         for preview in link_previews:
             element = LinkPreviewStanza()
             for i, name in enumerate(preview._fields):