slidge 0.3.0b4__py3-none-any.whl → 0.3.2__py3-none-any.whl

slidge/core/mixins/attachment.py

@@ -162,15 +162,12 @@ class AttachmentMixin(TextMessageMixin):
             legacy_file_id=None
             if attachment.legacy_file_id is None
             else str(attachment.legacy_file_id),
-            url=attachment.url,
+            url=attachment.url if config.USE_ATTACHMENT_ORIGINAL_URLS else None,
         )
 
     async def __get_url(
         self, attachment: LegacyAttachment, stored: Attachment
     ) -> tuple[bool, Optional[Path], str]:
-        if attachment.url and config.USE_ATTACHMENT_ORIGINAL_URLS:
-            return False, None, attachment.url
-
         file_name = attachment.name
         content_type = attachment.content_type
         file_path = attachment.path
@@ -221,7 +218,9 @@ class AttachmentMixin(TextMessageMixin):
 
         assert isinstance(file_path, Path)
         if config.FIX_FILENAME_SUFFIX_MIME_TYPE:
-            file_name = str(fix_suffix(file_path, content_type, file_name))
+            file_name, content_type = fix_suffix(file_path, content_type, file_name)
+            attachment.content_type = content_type
+            attachment.name = file_name
 
         if config.NO_UPLOAD_PATH:
             local_path, new_url = await self.__no_upload(
@@ -312,6 +311,50 @@ class AttachmentMixin(TextMessageMixin):
         stored.sfs = str(sfs)
         msg.append(sfs)
 
+    async def __set_sfs_and_sims_without_download(
+        self, msg: Message, attachment: LegacyAttachment
+    ) -> None:
+        assert attachment.url is not None
+
+        if not any(
+            (
+                attachment.content_type,
+                attachment.name,
+                attachment.disposition,
+            )
+        ):
+            return
+
+        sims = self.xmpp.plugin["xep_0385"].stanza.Sims()
+        ref = self.xmpp["xep_0372"].stanza.Reference()
+
+        ref["uri"] = attachment.url
+        ref["type"] = "data"
+        sims["sources"].append(ref)
+        sims.enable("file")
+
+        xep_0447_stanza = self.xmpp.plugin["xep_0447"].stanza
+        sfs = xep_0447_stanza.StatelessFileSharing()
+        url_data = xep_0447_stanza.UrlData()
+        url_data["target"] = attachment.url
+        sfs["sources"].append(url_data)
+        sfs.enable("file")
+
+        if attachment.content_type:
+            sims["file"]["media-type"] = attachment.content_type
+            sfs["file"]["media-type"] = attachment.content_type
+        if attachment.caption:
+            sims["file"]["desc"] = attachment.caption
+            sfs["file"]["desc"] = attachment.caption
+        if attachment.name:
+            sims["file"]["name"] = attachment.name
+            sfs["file"]["name"] = attachment.name
+        if attachment.disposition:
+            sfs["disposition"] = attachment.disposition
+
+        msg.append(sims)
+        msg.append(sfs)
+
     def __send_url(
         self,
         msg: Message,
@@ -325,6 +368,9 @@ class AttachmentMixin(TextMessageMixin):
     ) -> list[Message]:
         msg["oob"]["url"] = uploaded_url
         msg["body"] = uploaded_url
+        if msg.get_plugin("sfs", check=True):
+            msg["fallback"].enable("body")
+            msg["fallback"]["for"] = self.xmpp.plugin["xep_0447"].stanza.NAMESPACE
         if caption:
             m1 = self._send(msg, carbon=carbon, **kwargs)
             m2 = self.send_text(
@@ -465,7 +511,10 @@ class AttachmentMixin(TextMessageMixin):
             new_url = stored.url
         else:
             is_temp, local_path, new_url = await self.__get_url(attachment, stored)
-            if new_url is None:
+            if new_url is None or (
+                local_path is not None and local_path.stat().st_size == 0
+            ):
+                log.warning("Something went wrong with this attachment: %s", attachment)
                 msg["body"] = (
                     "I tried to send a file, but something went wrong. "
                     "Tell your slidge admin to check the logs."
@@ -474,8 +523,13 @@ class AttachmentMixin(TextMessageMixin):
                 return None, [self._send(msg, **kwargs)]
 
         stored.url = new_url
-        thumbnail = await self.__set_sims(msg, new_url, local_path, attachment, stored)
-        self.__set_sfs(msg, new_url, local_path, attachment, stored, thumbnail)
+        if config.USE_ATTACHMENT_ORIGINAL_URLS and attachment.url:
+            await self.__set_sfs_and_sims_without_download(msg, attachment)
+        else:
+            thumbnail = await self.__set_sims(
+                msg, new_url, local_path, attachment, stored
+            )
+            self.__set_sfs(msg, new_url, local_path, attachment, stored, thumbnail)
 
         if self.session is not NotImplemented:
             with self.xmpp.store.session(expire_on_commit=False) as orm:

slidge/core/mixins/db.py

@@ -2,7 +2,7 @@ import logging
 import typing
 from contextlib import contextmanager
 
-from ...db.models import Base, Contact, Participant, Room
+from ...db.models import Base, Contact, Room
 
 if typing.TYPE_CHECKING:
     from slidge import BaseGateway
@@ -41,13 +41,35 @@ class UpdateInfoMixin(DBMixin):
     def __init__(self, *args, **kwargs) -> None:
         super().__init__(*args, **kwargs)
         self._updating_info = False
+        self.__deserialize()
+
+    def __deserialize(self):
         if self.stored.extra_attributes is not None:
             self.deserialize_extra_attributes(self.stored.extra_attributes)
 
+    def refresh(self) -> None:
+        with self.xmpp.store.session(expire_on_commit=False) as orm:
+            orm.add(self.stored)
+            orm.refresh(self.stored)
+            self.__deserialize()
+
     def serialize_extra_attributes(self) -> dict | None:
+        """
+        If you want custom attributes of your instance to be stored persistently
+        to the DB, here is where you have to return them as a dict to be used in
+        `deserialize_extra_attributes()`.
+
+        """
         return None
 
     def deserialize_extra_attributes(self, data: dict) -> None:
+        """
+        This is where you get the dict that you passed in
+        `serialize_extra_attributes()`.
+
+        ⚠ Since it is serialized as json, dictionary keys are converted to strings!
+        Be sure to convert to other types if necessary.
+        """
         pass
 
     @contextmanager

slidge/core/mixins/message_maker.py

@@ -1,7 +1,7 @@
+import uuid
 import warnings
 from datetime import datetime, timezone
 from typing import TYPE_CHECKING, Iterable, Optional, cast
-from uuid import uuid4
 
 from slixmpp import JID, Message
 from slixmpp.types import MessageTypes
@@ -95,7 +95,7 @@ class MessageMaker(BaseSender):
                 msg["stanza_id"]["id"] = i
                 msg["stanza_id"]["by"] = self.muc.jid  # type: ignore
         elif self.USE_STANZA_ID:
-            msg["stanza_id"]["id"] = str(uuid4())
+            msg["stanza_id"]["id"] = str(uuid.uuid4())
             msg["stanza_id"]["by"] = self.muc.jid  # type: ignore
 
     def _legacy_to_xmpp(self, legacy_id: LegacyMessageType) -> str:
@@ -112,7 +112,7 @@ class MessageMaker(BaseSender):
             if when.tzinfo is None:
                 when = when.astimezone(timezone.utc)
             if self.STRIP_SHORT_DELAY:
-                delay = datetime.now().astimezone(timezone.utc) - when
+                delay = (datetime.now().astimezone(timezone.utc) - when).seconds
                 if delay < config.IGNORE_DELAY_THRESHOLD:
                     return
             msg["delay"].set_stamp(when)

slidge/core/mixins/message_text.py

@@ -191,7 +191,7 @@ class TextMessageMixin(MessageMaker):
         xmpp_id = kwargs.pop("xmpp_id", None)
         if not xmpp_id:
             xmpp_id = self._legacy_to_xmpp(legacy_msg_id)
-        self.xmpp["xep_0444"].set_reactions(msg, to_id=xmpp_id, reactions=emojis)
+        self.xmpp["xep_0444"].set_reactions(msg, to_id=xmpp_id, reactions=set(emojis))
         self.__add_reaction_fallback(msg, legacy_msg_id, emojis)
         self._send(msg, **kwargs)
 

slidge/core/mixins/presence.py

@@ -46,6 +46,8 @@ def _clear_last_seen_task(contact_pk: int, _task) -> None:
 class PresenceMixin(BaseSender, DBMixin):
     _ONLY_SEND_PRESENCE_CHANGES = False
 
+    # this attribute actually only exists for contacts and not participants
+    _updating_info: bool
     stored: Contact | Participant
 
     def __init__(self, *a, **k) -> None:
@@ -55,15 +57,24 @@ class PresenceMixin(BaseSender, DBMixin):
         # to DB at the end of update_info()
         self.cached_presence: Optional[CachedPresence] = None
 
+    def __is_contact(self) -> bool:
+        return isinstance(self.stored, Contact)
+
     def __stored(self) -> Contact | None:
-        if isinstance(self.stored, Contact):
+        if self.__is_contact():
+            assert isinstance(self.stored, Contact)
             return self.stored
         else:
+            assert isinstance(self.stored, Participant)
             try:
                 return self.stored.contact
             except DetachedInstanceError:
                 with self.xmpp.store.session() as orm:
                     orm.add(self.stored)
+                    if self.stored.contact is None:
+                        return None
+                    orm.refresh(self.stored.contact)
+                    orm.merge(self.stored)
                     return self.stored.contact
 
     @property
@@ -85,15 +96,22 @@ class PresenceMixin(BaseSender, DBMixin):
         )
 
     def _store_last_presence(self, new: CachedPresence) -> None:
-        stored = self.__stored()
-        if stored is not None:
-            stored.cached_presence = True
-            for k, v in new._asdict().items():
-                setattr(stored, k, v)
+        stored_contact = self.__stored()
+        if stored_contact is None:
+            return
+        stored_contact.cached_presence = True
+        for k, v in new._asdict().items():
+            setattr(stored_contact, k, v)
+        if self.__is_contact() and self._updating_info:
+            return
+        with self.xmpp.store.session(expire_on_commit=False) as orm:
             try:
-                self.commit()
+                orm.add(stored_contact)
             except InvalidRequestError:
-                self.commit(merge=True)
+                stored_contact = orm.merge(stored_contact)
+                orm.add(stored_contact)
+
+            orm.commit()
 
     def _make_presence(
         self,
@@ -279,9 +297,9 @@ class PresenceMixin(BaseSender, DBMixin):
             pass
 
 
-def get_last_seen_fallback(last_seen: datetime):
+def get_last_seen_fallback(last_seen: datetime) -> tuple[str, bool]:
     now = datetime.now(tz=timezone.utc)
     if now - last_seen < timedelta(days=7):
-        return f"Last seen {last_seen:%A %H:%M GMT}", True
+        return f"Last seen {last_seen:%A %H:%M %p GMT}", True
     else:
         return f"Last seen {last_seen:%b %-d %Y}", False

slidge/core/pubsub.py

@@ -120,7 +120,7 @@ class PubSubComponent(NamedLockMixin, BasePlugin):
                 try:
                     iq = await self.xmpp.plugin["xep_0030"].get_info(from_)
                 except (IqError, IqTimeout):
-                    log.debug("Could get disco#info of %s, ignoring", from_)
+                    log.debug("Could not get disco#info of %s, ignoring", from_)
                     return []
             info = iq["disco_info"]
         return info["features"]

slidge/core/session.py

@@ -539,6 +539,17 @@ class BaseSession(
         """
         raise NotImplementedError
 
+    async def on_preferences(
+        self, previous: dict[str, Any], new: dict[str, Any]
+    ) -> None:
+        """
+        This is called when the user updates their preferences.
+
+        Override this if you need set custom preferences field and need to trigger
+        something when a preference has changed.
+        """
+        raise NotImplementedError
+
     def __reset_ready(self) -> None:
         self.ready = self.xmpp.loop.create_future()
 
@@ -708,6 +719,8 @@ class BaseSession(
             log.warning("User not found during unregistration")
             return
 
+        session.cancel_all_tasks()
+
         await cls.xmpp.unregister(session)
         with cls.xmpp.store.session() as orm:
             orm.delete(session.user)

slidge/db/models.py

@@ -7,7 +7,7 @@ import sqlalchemy as sa
 from slixmpp import JID
 from slixmpp.types import MucAffiliation, MucRole
 from sqlalchemy import JSON, ForeignKey, Index, UniqueConstraint
-from sqlalchemy.orm import Mapped, declared_attr, mapped_column, relationship
+from sqlalchemy.orm import Mapped, mapped_column, relationship
 
 from ..util.types import ClientType, MucType
 from .meta import Base, JSONSerializable, JSONSerializableTypes

slidge/db/store.py

@@ -7,9 +7,10 @@ from datetime import datetime, timedelta, timezone
 from mimetypes import guess_extension
 from typing import Collection, Iterator, Optional, Type
 
+import sqlalchemy as sa
 from slixmpp.exceptions import XMPPError
 from slixmpp.plugins.xep_0231.stanza import BitsOfBinary
-from sqlalchemy import Engine, delete, select, update
+from sqlalchemy import Engine, delete, event, select, update
 from sqlalchemy.exc import InvalidRequestError
 from sqlalchemy.orm import Session, attributes, sessionmaker
 
@@ -20,6 +21,7 @@ from .meta import Base
 from .models import (
     ArchivedMessage,
     ArchivedMessageSource,
+    Avatar,
     Bob,
     Contact,
     ContactSent,
@@ -213,6 +215,7 @@ class ContactStore(UpdatedMixin):
     def __init__(self, session: Session) -> None:
         super().__init__(session)
         session.execute(update(Contact).values(cached_presence=False))
+        session.execute(update(Contact).values(caps_ver=None))
 
     @staticmethod
     def add_to_sent(session: Session, contact_pk: int, msg_id: str) -> None:
@@ -589,4 +592,29 @@ class BobStore:
         session.add(row)
 
 
+@event.listens_for(sa.orm.Session, "after_flush")
+def _check_avatar_orphans(session, flush_context):
+    if not session.deleted:
+        return
+
+    potentially_orphaned = set()
+    for obj in session.deleted:
+        if isinstance(obj, (Contact, Room)) and obj.avatar_id:
+            potentially_orphaned.add(obj.avatar_id)
+    if not potentially_orphaned:
+        return
+
+    result = session.execute(
+        sa.delete(Avatar).where(
+            sa.and_(
+                Avatar.id.in_(potentially_orphaned),
+                sa.not_(sa.exists().where(Contact.avatar_id == Avatar.id)),
+                sa.not_(sa.exists().where(Room.avatar_id == Avatar.id)),
+            )
+        )
+    )
+    deleted_count = result.rowcount
+    log.debug(f"Auto-deleted %s orphaned avatars", deleted_count)
+
+
 log = logging.getLogger(__name__)

slidge/group/archive.py

@@ -181,6 +181,9 @@ def archivable(msg: Message) -> bool:
     if msg.get_plugin("displayed", check=True):
         return True
 
+    if msg["thread"] and msg["subject"]:
+        return True
+
     return False
 
 

slidge/group/participant.py

@@ -22,6 +22,7 @@ from ..util.types import (
     CachedPresence,
     Hat,
     LegacyMessageType,
+    LegacyThreadType,
     MessageOrPresenceTypeVar,
     MucAffiliation,
     MucRole,
@@ -526,6 +527,24 @@ class LegacyParticipant(
             msg.xml.append(ET.Element(f"{{{msg.namespace}}}subject"))
         self._send(msg, full_jid)
 
+    def set_thread_subject(
+        self,
+        thread: LegacyThreadType,
+        subject: str | None,
+        when: Optional[datetime] = None,
+    ) -> None:
+        msg = self._make_message()
+        msg["thread"] = str(thread)
+        if when is not None:
+            msg["delay"].set_stamp(when)
+            msg["delay"]["from"] = self.muc.jid
+        if subject:
+            msg["subject"] = subject
+        else:
+            # may be simplified if slixmpp lets it do it more easily some day
+            msg.xml.append(ET.Element(f"{{{msg.namespace}}}subject"))
+        self._send(msg)
+
 
 def escape_nickname(muc_jid: JID, nickname: str) -> tuple[str, JID]:
     nickname = nickname_no_illegal = strip_illegal_chars(nickname)

slidge/group/room.py

@@ -43,6 +43,7 @@ from ..util.types import (
     LegacyGroupIdType,
     LegacyMessageType,
     LegacyParticipantType,
+    LegacyThreadType,
     LegacyUserIdType,
     Mention,
     MucAffiliation,
@@ -295,7 +296,7 @@ class LegacyMUC(
         self, affiliation: Optional[MucAffiliation] = None
     ) -> AsyncIterator[LegacyParticipantType]:
         await self.__fill_participants()
-        with self.xmpp.store.session(expire_on_commit=False) as orm:
+        with self.xmpp.store.session(expire_on_commit=False, autoflush=False) as orm:
             orm.add(self.stored)
             for db_participant in self.stored.participants:
                 if (
@@ -523,6 +524,9 @@ class LegacyMUC(
         if s := self.subject:
             form.add_field("muc#roominfo_subject", value=s)
 
+        if name := self.name:
+            form.add_field("muc#roomconfig_roomname", value=name)
+
         if self._set_avatar_task is not None:
             await self._set_avatar_task
         avatar = self.get_avatar()
@@ -651,7 +655,7 @@ class LegacyMUC(
                 with orm.no_autoflush:
                     orm.refresh(self.stored, ["participants"])
         if not user_participant.is_user:
-            self.log.warning("is_user flag not set participant on user_participant")
+            self.log.warning("is_user flag not set on user_participant")
             user_participant.is_user = True
         user_participant.send_initial_presence(
             user_full_jid,
@@ -1335,6 +1339,17 @@ class LegacyMUC(
         """
         raise NotImplementedError
 
+    async def on_set_thread_subject(
+        self, thread: LegacyThreadType, subject: str
+    ) -> None:
+        """
+        Triggered when the user requests changing the subject of a specific thread.
+
+        :param thread: Legacy identifier of the thread
+        :param subject: The new subject for this thread.
+        """
+        raise NotImplementedError
+
     @property
     def participants_filled(self) -> bool:
         return self.stored.participants_filled

slidge/slixfix/xep_0292/vcard4.py

@@ -1,5 +1,6 @@
+from slixmpp import register_stanza_plugin, __version_info__
 from slixmpp.plugins.base import BasePlugin, register_plugin
-from slixmpp.plugins.xep_0292.stanza import NS
+from slixmpp.plugins.xep_0292.stanza import NS, _VCardTextElementBase, VCard4
 
 
 class VCard4Provider(BasePlugin):
@@ -11,4 +12,13 @@ class VCard4Provider(BasePlugin):
         self.xmpp.plugin["xep_0030"].add_feature(NS)
 
 
+
+
 register_plugin(VCard4Provider)
+
+
+if __version_info__[0] <= 1 and __version_info__[1] <= 11:
+    class Pronouns(_VCardTextElementBase):
+        name = plugin_attrib = "pronouns"
+
+    register_stanza_plugin(VCard4, Pronouns)

slidge/util/test.py

@@ -42,7 +42,7 @@ from slidge import (
 
 from ..command import Command
 from ..core import config
-from ..core.config import _TimedeltaSeconds
+from ..core.session import _sessions
 from ..db import SlidgeStore
 from ..db.avatar import avatar_cache
 from ..db.meta import Base
@@ -206,7 +206,7 @@ class SlidgeTest(SlixTestPlus):
         user_jid_validator = ".*"
         admins: list[str] = []
         upload_requester = None
-        ignore_delay_threshold = _TimedeltaSeconds("300")
+        ignore_delay_threshold = 300
 
     @classmethod
     def setUpClass(cls) -> None:
@@ -281,6 +281,7 @@ class SlidgeTest(SlixTestPlus):
         self.db_engine.echo = False
         super().tearDown()
         Base.metadata.drop_all(self.xmpp.store._engine)
+        _sessions.clear()
 
     def setup_logged_session(self, n_contacts: int = 0) -> None:
         with self.xmpp.store.session() as orm:

slidge/util/util.py

@@ -34,7 +34,9 @@ except ImportError as e:
     )
 
 
-def fix_suffix(path: Path, mime_type: Optional[str], file_name: Optional[str]) -> Path:
+def fix_suffix(
+    path: Path, mime_type: Optional[str], file_name: Optional[str]
+) -> tuple[str, str]:
     guessed = magic.from_file(path, mime=True)
     if guessed == mime_type:
         log.debug("Magic and given MIME match")
@@ -53,15 +55,15 @@ def fix_suffix(path: Path, mime_type: Optional[str], file_name: Optional[str]) -
 
     if suffix in valid_suffix_list:
         log.debug("Suffix %s is in %s", suffix, valid_suffix_list)
-        return name
+        return str(name), guessed
 
     valid_suffix = mimetypes.guess_extension(mime_type.split(";")[0], strict=False)
     if valid_suffix is None:
         log.debug("No valid suffix found")
-        return name
+        return str(name), guessed
 
     log.debug("Changing suffix of %s to %s", file_name or path.name, valid_suffix)
-    return name.with_suffix(valid_suffix)
+    return str(name.with_suffix(valid_suffix)), guessed
 
 
 class SubclassableOnce(type):

{slidge-0.3.0b4.dist-info → slidge-0.3.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: slidge
-Version: 0.3.0b4
+Version: 0.3.2
 Summary: XMPP bridging framework
 Author-email: Nicolas Cedilnik <nicoco@nicoco.fr>
 License-Expression: AGPL-3.0-or-later