slidge 0.2.0a6__py3-none-any.whl → 0.2.0a9__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__ = "0.2.0alpha6"
+__version__ = "0.2.0alpha9"

slidge/command/chat_command.py

@@ -153,6 +153,9 @@ class ChatCommandProvider:
         self.xmpp.delivery_receipt.ack(msg)
         return await self._handle_result(result, msg, session)
 
+    def __make_uri(self, body: str) -> str:
+        return f"xmpp:{self.xmpp.boundjid.bare}?message;body={body}"
+
     async def _handle_result(self, result: CommandResponseType, msg: Message, session):
         if isinstance(result, str) or result is None:
             reply = msg.reply()
@@ -175,9 +178,14 @@ class ChatCommandProvider:
                         ).send()
                     if f.options:
                         for o in f.options:
-                            msg.reply(f"{o['value']} -- {o['label']}").send()
+                            msg.reply(
+                                f"{o['label']}: {self.__make_uri(o['value'])}"
+                            ).send()
                     if f.value:
                         msg.reply(f"Default: {f.value}").send()
+                    if f.type == "boolean":
+                        msg.reply("yes: " + self.__make_uri("yes")).send()
+                        msg.reply("no: " + self.__make_uri("no")).send()
 
                     ans = await self.xmpp.input(
                         msg.get_from(), (f.label or f.var) + "? (or 'abort')"
@@ -186,6 +194,12 @@ class ChatCommandProvider:
                         return await self._handle_result(
                             "Command aborted", msg, session
                         )
+                    if f.type == "boolean":
+                        if ans.lower() == "yes":
+                            ans = "true"
+                        else:
+                            ans = "false"
+
                     if f.type.endswith("multi"):
                         form_values[f.var] = f.validate(ans.split(" "))
                     else:

slidge/command/user.py

@@ -260,6 +260,8 @@ class Preferences(Command):
         self.xmpp.store.users.update(user)
         if form_values["sync_avatar"]:
             await self.xmpp.fetch_user_avatar(session)
+        else:
+            session.xmpp.store.users.set_avatar_hash(session.user_pk, None)
         return "Your preferences have been updated."
 
 

slidge/contact/contact.py

@@ -17,7 +17,7 @@ from ..core.mixins.disco import ContactAccountDiscoMixin
 from ..core.mixins.recipient import ReactionRecipientMixin, ThreadRecipientMixin
 from ..db.models import Contact
 from ..util import SubclassableOnce
-from ..util.types import LegacyUserIdType, MessageOrPresenceTypeVar
+from ..util.types import ClientType, LegacyUserIdType, MessageOrPresenceTypeVar
 
 if TYPE_CHECKING:
     from ..core.session import BaseSession
@@ -128,6 +128,7 @@ class LegacyContact(
         self._caps_ver: str | None = None
         self._vcard_fetched = False
         self._vcard: str | None = None
+        self._client_type: ClientType = "pc"
 
     async def get_vcard(self, fetch=True) -> VCard4 | None:
         if fetch and not self._vcard_fetched:
@@ -187,6 +188,32 @@ class LegacyContact(
     def user_jid(self):
         return self.session.user_jid
 
+    @property  # type:ignore
+    def DISCO_TYPE(self) -> ClientType:
+        return self._client_type
+
+    @DISCO_TYPE.setter
+    def DISCO_TYPE(self, value: ClientType) -> None:
+        self.client_type = value
+
+    @property
+    def client_type(self) -> ClientType:
+        """
+        The client type of this contact, cf https://xmpp.org/registrar/disco-categories.html#client
+
+        Default is "pc".
+        """
+        return self._client_type
+
+    @client_type.setter
+    def client_type(self, value: ClientType) -> None:
+        self._client_type = value
+        if self._updating_info:
+            return
+        self.__ensure_pk()
+        assert self.contact_pk is not None
+        self.xmpp.store.contacts.set_client_type(self.contact_pk, value)
+
     def _set_logger_name(self):
         self.log.name = f"{self.user_jid.bare}:contact:{self}"
 
@@ -255,8 +282,9 @@ class LegacyContact(
             self._privileged_send(stanza)
             return stanza  # type:ignore
 
-        if not self._updating_info and isinstance(stanza, Presence):
-            self.__propagate_to_participants(stanza)
+        if isinstance(stanza, Presence):
+            if not self._updating_info:
+                self.__propagate_to_participants(stanza)
             if (
                 not self.is_friend
                 and stanza["type"] not in self._NON_FRIEND_PRESENCES_FILTER
@@ -329,14 +357,13 @@ class LegacyContact(
         return self.xmpp.store.contacts.get_avatar_legacy_id(self.contact_pk)
 
     def _post_avatar_update(self):
-        if self._updating_info:
-            return
-        if self.contact_pk is None:
-            # happens in LegacyRoster.fill(), the contact primary key is not
-            # set yet, but this will eventually be called in LegacyRoster.__finish_init_contact
-            self.log.debug("Not setting avatar PK")
-            return
-        self.xmpp.store.contacts.set_avatar(self.contact_pk, self._avatar_pk)
+        self.__ensure_pk()
+        assert self.contact_pk is not None
+        self.xmpp.store.contacts.set_avatar(
+            self.contact_pk,
+            self._avatar_pk,
+            None if self.avatar_id is None else str(self.avatar_id),
+        )
         for p in self.participants:
             self.log.debug("Propagating new avatar to %s", p.muc)
             p.send_last_presence(force=True, no_cache_online=True)
@@ -603,14 +630,20 @@ class LegacyContact(
         contact.contact_pk = stored.id
         contact._name = stored.nick
         contact._is_friend = stored.is_friend
-        contact.added_to_roster = stored.added_to_roster
+        contact._added_to_roster = stored.added_to_roster
         if (data := stored.extra_attributes) is not None:
             contact.deserialize_extra_attributes(data)
         contact._caps_ver = stored.caps_ver
         contact._set_logger_name()
-        contact._set_avatar_from_store(stored)
+        contact._AvatarMixin__avatar_unique_id = (  # type:ignore
+            None
+            if stored.avatar_legacy_id is None
+            else session.xmpp.AVATAR_ID_TYPE(stored.avatar_legacy_id)
+        )
+        contact._avatar_pk = stored.avatar_id
         contact._vcard = stored.vcard
         contact._vcard_fetched = stored.vcard_fetched
+        contact._client_type = stored.client_type
         return contact
 
 

slidge/contact/roster.py

@@ -150,10 +150,7 @@ class LegacyRoster(
         except Exception as e:
             raise XMPPError("internal-server-error", str(e))
         contact._caps_ver = await contact.get_caps_ver(contact.jid)
-        need_avatar = contact.contact_pk is None
         contact.contact_pk = self.__store.update(contact, commit=not self.__filling)
-        if need_avatar:
-            contact._post_avatar_update()
         return contact
 
     async def by_stanza(self, s) -> LegacyContact:

slidge/core/gateway/base.py

@@ -270,6 +270,8 @@ class BaseGateway(
     Common example: ``int``.
     """
 
+    http: aiohttp.ClientSession
+
     def __init__(self):
         self.log = log
         self.datetime_started = datetime.now()
@@ -303,7 +305,7 @@ class BaseGateway(
             fix_error_ns=True,
         )
         self.loop.set_exception_handler(self.__exception_handler)
-        self.http: aiohttp.ClientSession = aiohttp.ClientSession()
+        self.loop.create_task(self.__set_http())
         self.has_crashed: bool = False
         self.use_origin_id = False
 
@@ -370,6 +372,12 @@ class BaseGateway(
 
         MessageMixin.__init__(self)  # ComponentXMPP does not call super().__init__()
 
+    async def __set_http(self):
+        self.http = aiohttp.ClientSession()
+        if getattr(self, "_test_mode", False):
+            return
+        avatar_cache.http = self.http
+
     async def __mam_cleanup(self):
         if not config.MAM_MAX_DAYS:
             return
@@ -455,10 +463,8 @@ class BaseGateway(
         await disco.del_feature(feature="urn:xmpp:http:upload:0", jid=self.boundjid)
         await self.plugin["xep_0115"].update_caps(jid=self.boundjid)
 
-        if self.COMPONENT_AVATAR:
-            cached_avatar = await avatar_cache.convert_or_get(
-                self.COMPONENT_AVATAR, None
-            )
+        if self.COMPONENT_AVATAR is not None:
+            cached_avatar = await avatar_cache.convert_or_get(self.COMPONENT_AVATAR)
             self.avatar_pk = cached_avatar.pk
         else:
             cached_avatar = None
@@ -580,6 +586,8 @@ class BaseGateway(
             session.send_gateway_status(status, show="chat")
         if session.user.preferences.get("sync_avatar", False):
             session.create_task(self.fetch_user_avatar(session))
+        else:
+            self.xmpp.store.users.set_avatar_hash(session.user_pk, None)
 
     async def fetch_user_avatar(self, session: BaseSession):
         try:
@@ -588,8 +596,8 @@ class BaseGateway(
                 self.xmpp.plugin["xep_0084"].stanza.MetaData.namespace,
                 ifrom=self.boundjid.bare,
             )
-        except IqError as e:
-            session.log.debug("Failed to retrieve avatar: %r", e)
+        except IqError:
+            self.xmpp.store.users.set_avatar_hash(session.user_pk, None)
             return
         await self.__dispatcher.on_avatar_metadata_info(
             session, iq["pubsub"]["items"]["item"]["avatar_metadata"]["info"]

slidge/core/gateway/session_dispatcher.py

@@ -31,7 +31,6 @@ class Ignore(BaseException):
 class SessionDispatcher:
     def __init__(self, xmpp: "BaseGateway"):
         self.xmpp = xmpp
-        self.http = xmpp.http
 
         xmpp.register_handler(
             CoroutineCallback(
@@ -98,6 +97,10 @@ class SessionDispatcher:
                 event, _exceptions_to_xmpp_errors(getattr(self, "on_" + event))
             )
 
+    @property
+    def http(self):
+        return self.xmpp.http
+
     async def __get_session(
         self, stanza: Union[Message, Presence, Iq], timeout: Optional[int] = 10
     ) -> BaseSession:
@@ -503,8 +506,19 @@ class SessionDispatcher:
                 resources,
                 merge_resources(resources),
             )
+            if p.get_type() == "available":
+                await self.xmpp.pubsub.on_presence_available(p, None)
             return
 
+        if p.get_type() == "available":
+            try:
+                contact = await session.contacts.by_jid(pto)
+            except XMPPError:
+                contact = None
+            if contact is not None:
+                await self.xmpp.pubsub.on_presence_available(p, contact)
+                return
+
         muc = session.bookmarks.by_jid_only_if_exists(JID(pto.bare))
 
         if muc is not None and p.get_type() == "unavailable":
@@ -580,12 +594,7 @@ class SessionDispatcher:
         if session.user.avatar_hash == hash_:
             session.log.debug("We already know this avatar hash")
             return
-        with self.xmpp.store.session() as orm_session:
-            user = self.xmpp.store.users.get(session.user_jid)
-            assert user is not None
-            user.avatar_hash = hash_
-            orm_session.add(user)
-            orm_session.commit()
+        self.xmpp.store.users.set_avatar_hash(session.user_pk, None)
 
         if hash_:
             try:

slidge/core/mixins/attachment.py

@@ -1,3 +1,4 @@
+import base64
 import functools
 import logging
 import os
@@ -7,22 +8,23 @@ import stat
 import tempfile
 import warnings
 from datetime import datetime
-from mimetypes import guess_type
+from itertools import chain
+from mimetypes import guess_extension, guess_type
 from pathlib import Path
 from typing import IO, AsyncIterator, Collection, Optional, Sequence, Union
 from urllib.parse import quote as urlquote
 from uuid import uuid4
 from xml.etree import ElementTree as ET
 
-import blurhash
-from PIL import Image
+import thumbhash
+from PIL import Image, ImageOps
 from slixmpp import JID, Message
 from slixmpp.exceptions import IqError
 from slixmpp.plugins.xep_0363 import FileUploadError
-from slixmpp.plugins.xep_0385.stanza import Sims
 from slixmpp.plugins.xep_0447.stanza import StatelessFileSharing
 
 from ...db.avatar import avatar_cache
+from ...slixfix.xep_0264.stanza import Thumbnail
 from ...util.types import (
     LegacyAttachment,
     LegacyMessageType,
@@ -169,7 +171,12 @@ class AttachmentMixin(MessageMaker):
             )
 
         if file_path is None:
-            file_name = str(uuid4()) if file_name is None else file_name
+            if file_name is None:
+                file_name = str(uuid4())
+                if content_type is not None:
+                    ext = guess_extension(content_type, strict=False)  # type:ignore
+                    if ext is not None:
+                        file_name += ext
             temp_dir = Path(tempfile.mkdtemp())
             file_path = temp_dir / file_name
             if file_url:
@@ -223,37 +230,44 @@ class AttachmentMixin(MessageMaker):
         content_type: Optional[str] = None,
         caption: Optional[str] = None,
         file_name: Optional[str] = None,
-    ):
+    ) -> Thumbnail | None:
         cache = self.__store.get_sims(uploaded_url)
         if cache:
-            msg.append(Sims(xml=ET.fromstring(cache)))
-            return
+            ref = self.xmpp["xep_0372"].stanza.Reference(xml=ET.fromstring(cache))
+            msg.append(ref)
+            if ref["sims"]["file"].get_plugin("thumbnail", check=True):
+                return ref["sims"]["file"]["thumbnail"]
+            else:
+                return None
 
         if not path:
-            return
+            return None
 
-        sims = self.xmpp["xep_0385"].get_sims(
+        ref = self.xmpp["xep_0385"].get_sims(
             path, [uploaded_url], content_type, caption
         )
         if file_name:
-            sims["sims"]["file"]["name"] = file_name
+            ref["sims"]["file"]["name"] = file_name
+        thumbnail = None
         if content_type is not None and content_type.startswith("image"):
             try:
                 h, x, y = await self.xmpp.loop.run_in_executor(
-                    avatar_cache._thread_pool, get_blurhash, path
+                    avatar_cache._thread_pool, get_thumbhash, path
                 )
             except Exception as e:
-                log.debug("Could not generate a blurhash", exc_info=e)
+                log.debug("Could not generate a thumbhash", exc_info=e)
             else:
-                thumbnail = sims["sims"]["file"]["thumbnail"]
+                thumbnail = ref["sims"]["file"]["thumbnail"]
                 thumbnail["width"] = x
                 thumbnail["height"] = y
-                thumbnail["media-type"] = "image/blurhash"
-                thumbnail["uri"] = "data:image/blurhash," + urlquote(h)
+                thumbnail["media-type"] = "image/thumbhash"
+                thumbnail["uri"] = "data:image/thumbhash," + urlquote(h)
+
+        self.__store.set_sims(uploaded_url, str(ref))
 
-        self.__store.set_sims(uploaded_url, str(sims))
+        msg.append(ref)
 
-        msg.append(sims)
+        return thumbnail
 
     def __set_sfs(
         self,
@@ -263,6 +277,7 @@ class AttachmentMixin(MessageMaker):
         content_type: Optional[str] = None,
         caption: Optional[str] = None,
         file_name: Optional[str] = None,
+        thumbnail: Optional[Thumbnail] = None,
     ):
         cache = self.__store.get_sfs(uploaded_url)
         if cache:
@@ -275,6 +290,8 @@ class AttachmentMixin(MessageMaker):
         sfs = self.xmpp["xep_0447"].get_sfs(path, [uploaded_url], content_type, caption)
         if file_name:
             sfs["file"]["name"] = file_name
+        if thumbnail is not None:
+            sfs["file"].append(thumbnail)
         self.__store.set_sfs(uploaded_url, str(sfs))
 
         msg.append(sfs)
@@ -371,10 +388,12 @@ class AttachmentMixin(MessageMaker):
             self._set_msg_id(msg, legacy_msg_id)
             return None, [self._send(msg, **kwargs)]
 
-        await self.__set_sims(
+        thumbnail = await self.__set_sims(
             msg, new_url, local_path, content_type, caption, file_name
         )
-        self.__set_sfs(msg, new_url, local_path, content_type, caption, file_name)
+        self.__set_sfs(
+            msg, new_url, local_path, content_type, caption, file_name, thumbnail
+        )
         if is_temp and isinstance(local_path, Path):
             local_path.unlink()
             local_path.parent.rmdir()
@@ -493,32 +512,18 @@ class AttachmentMixin(MessageMaker):
         )
 
 
-def get_blurhash(path: Path, n=9) -> tuple[str, int, int]:
-    img = Image.open(path)
-    width, height = img.size
-    n = min(width, height, n)
-    if width == height:
-        x = y = n
-    elif width > height:
-        x = n
-        y = round(n * height / width)
-    else:
-        x = round(n * width / height)
-        y = n
-    # There are 2 blurhash-python packages:
-    # https://github.com/woltapp/blurhash-python
-    # https://github.com/halcy/blurhash-python
-    # With this hack we're compatible with both, which is useful for packaging
-    # without using pyproject.toml, as most distro do
-    try:
-        hash_ = blurhash.encode(img, x, y)
-    except TypeError:
-        # We are using halcy's blurhash which expects
-        # the 1st argument to be a 3-dimensional array
-        import numpy  # type:ignore
-
-        hash_ = blurhash.encode(numpy.array(img.convert("RGB")), x, y)
-    return hash_, width, height
+def get_thumbhash(path: Path) -> tuple[str, int, int]:
+    with path.open("rb") as fp:
+        img = Image.open(fp)
+        width, height = img.size
+        img = img.convert("RGBA")
+        if width > 100 or height > 100:
+            img.thumbnail((100, 100))
+    img = ImageOps.exif_transpose(img)
+    rgba_2d = list(img.getdata())
+    rgba = list(chain(*rgba_2d))
+    ints = thumbhash.rgba_to_thumb_hash(img.width, img.height, rgba)
+    return base64.b64encode(bytes(ints)).decode(), width, height
 
 
 log = logging.getLogger(__name__)

slidge/core/mixins/avatar.py

@@ -73,6 +73,10 @@ class AvatarMixin:
             name=f"Set avatar of {self} from property",
         )
 
+    @property
+    def avatar_pk(self) -> int | None:
+        return self._avatar_pk
+
     @staticmethod
     def __get_uid(a: Optional[AvatarType]) -> Optional[AvatarIdType]:
         if isinstance(a, str):
@@ -95,10 +99,7 @@ class AvatarMixin:
             self._avatar_pk = None
         else:
             try:
-                cached_avatar = await avatar_cache.convert_or_get(
-                    URL(a) if isinstance(a, URL) else a,
-                    None if isinstance(uid, URL) else uid,
-                )
+                cached_avatar = await avatar_cache.convert_or_get(a)
             except Exception as e:
                 self.session.log.error("Failed to set avatar %s", a, exc_info=e)
                 self._avatar_pk = None
@@ -167,9 +168,9 @@ class AvatarMixin:
             await awaitable
 
     def get_cached_avatar(self) -> Optional["CachedAvatar"]:
-        if not self.__avatar_unique_id:
+        if self._avatar_pk is None:
             return None
-        return avatar_cache.get(self.__avatar_unique_id)
+        return avatar_cache.get_by_pk(self._avatar_pk)
 
     def get_avatar(self) -> Optional["PepAvatar"]:
         cached_avatar = self.get_cached_avatar()
@@ -211,7 +212,10 @@ class AvatarMixin:
         if self.__should_pubsub_broadcast():
             if new_id is None and cached_id is None:
                 return
-            cached_avatar = avatar_cache.get(cached_id)
+            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