slidge 0.2.0a6__py3-none-any.whl → 0.2.0a9__py3-none-any.whl

slidge/core/pubsub.py

@@ -22,11 +22,11 @@ from slixmpp.types import JidStr, OptJidStr
 
 from ..db.avatar import CachedAvatar, avatar_cache
 from ..db.store import ContactStore, SlidgeStore
-from ..util.types import URL
 from .mixins.lock import NamedLockMixin
 
 if TYPE_CHECKING:
-    from slidge import BaseGateway
+    from ..contact.contact import LegacyContact
+    from ..core.gateway.base import BaseGateway
 
 VCARD4_NAMESPACE = "urn:xmpp:vcard4"
 
@@ -116,7 +116,6 @@ class PubSubComponent(NamedLockMixin, BasePlugin):
                 self._get_vcard,  # type:ignore
             )
         )
-        self.xmpp.add_event_handler("presence_available", self._on_presence_available)
 
         disco = self.xmpp.plugin["xep_0030"]
         disco.add_identity("pubsub", "pep", self.component_name)
@@ -125,63 +124,51 @@ class PubSubComponent(NamedLockMixin, BasePlugin):
         disco.add_feature("http://jabber.org/protocol/pubsub#retrieve-items")
         disco.add_feature("http://jabber.org/protocol/pubsub#persistent-items")
 
-    async def _on_presence_available(self, p: Presence):
+    async def __get_features(self, presence: Presence) -> list[str]:
+        from_ = presence.get_from()
+        ver_string = presence["caps"]["ver"]
+        if ver_string:
+            info = await self.xmpp.plugin["xep_0115"].get_caps(from_)
+        else:
+            info = None
+        if info is None:
+            async with self.lock(from_):
+                iq = await self.xmpp.plugin["xep_0030"].get_info(from_)
+            info = iq["disco_info"]
+        return info["features"]
+
+    async def on_presence_available(
+        self, p: Presence, contact: Optional["LegacyContact"]
+    ):
         if p.get_plugin("muc_join", check=True) is not None:
             log.debug("Ignoring MUC presence here")
             return
 
-        from_ = p.get_from()
-        ver_string = p["caps"]["ver"]
-        info = None
-
         to = p.get_to()
-
-        contact = None
-        # we don't want to push anything for contacts that are not in the user's roster
         if to != self.xmpp.boundjid.bare:
-            session = self.xmpp.get_session_from_stanza(p)
-
-            if session is None:
+            # we don't want to push anything for contacts that are not in the user's roster
+            if contact is None or not contact.is_friend:
                 return
 
-            await session.contacts.ready
-            try:
-                contact = await session.contacts.by_jid(to)
-            except XMPPError as e:
-                log.debug(
-                    "Could not determine if %s was added to the roster: %s", to, e
-                )
-                return
-            except Exception as e:
-                log.warning("Could not determine if %s was added to the roster.", to)
-                log.exception(e)
-                return
-            if not contact.is_friend:
-                return
+        from_ = p.get_from()
+        features = await self.__get_features(p)
 
-        if ver_string:
-            info = await self.xmpp.plugin["xep_0115"].get_caps(from_)
-        if info is None:
-            async with self.lock(from_):
-                iq = await self.xmpp.plugin["xep_0030"].get_info(from_)
-            info = iq["disco_info"]
-        features = info["features"]
         if AvatarMetadata.namespace + "+notify" in features:
             try:
-                pep_avatar = await self._get_authorized_avatar(p)
+                pep_avatar = await self._get_authorized_avatar(p, contact)
             except XMPPError:
                 pass
             else:
                 if pep_avatar.metadata is not None:
                     await self.__broadcast(
                         data=pep_avatar.metadata,
-                        from_=p.get_to(),
+                        from_=p.get_to().bare,
                         to=from_,
                         id=pep_avatar.metadata["info"]["id"],
                     )
         if UserNick.namespace + "+notify" in features:
             try:
-                pep_nick = await self._get_authorized_nick(p)
+                pep_nick = await self._get_authorized_nick(p, contact)
             except XMPPError:
                 pass
             else:
@@ -210,64 +197,64 @@ class PubSubComponent(NamedLockMixin, BasePlugin):
             node=VCARD4_NAMESPACE,
         )
 
-    async def _get_authorized_avatar(self, stanza: Union[Iq, Presence]) -> PepAvatar:
+    async def __get_contact(self, stanza: Union[Iq, Presence]):
+        session = self.xmpp.get_session_from_stanza(stanza)
+        return await session.contacts.by_jid(stanza.get_to())
+
+    async def _get_authorized_avatar(
+        self, stanza: Union[Iq, Presence], contact: Optional["LegacyContact"] = None
+    ) -> PepAvatar:
         if stanza.get_to() == self.xmpp.boundjid.bare:
             item = PepAvatar()
             item.set_avatar_from_cache(avatar_cache.get_by_pk(self.xmpp.avatar_pk))
             return item
 
-        session = self.xmpp.get_session_from_stanza(stanza)
-        entity = await session.get_contact_or_group_or_participant(stanza.get_to())
+        if contact is None:
+            contact = await self.__get_contact(stanza)
 
         item = PepAvatar()
-        avatar_id = entity.avatar_id
-        if avatar_id is not None:
-            stored = avatar_cache.get(
-                avatar_id if isinstance(avatar_id, URL) else str(avatar_id)
-            )
+        if contact.avatar_pk is not None:
+            stored = avatar_cache.get_by_pk(contact.avatar_pk)
             assert stored is not None
             item.set_avatar_from_cache(stored)
         return item
 
-    async def _get_authorized_nick(self, stanza: Union[Iq, Presence]) -> PepNick:
+    async def _get_authorized_nick(
+        self, stanza: Union[Iq, Presence], contact: Optional["LegacyContact"] = None
+    ) -> PepNick:
         if stanza.get_to() == self.xmpp.boundjid.bare:
             return PepNick(self.xmpp.COMPONENT_NAME)
 
-        session = self.xmpp.get_session_from_stanza(stanza)
-        entity = await session.contacts.by_jid(stanza.get_to())
+        if contact is None:
+            contact = await self.__get_contact(stanza)
 
-        if entity.name is not None:
-            return PepNick(entity.name)
+        if contact.name is not None:
+            return PepNick(contact.name)
         else:
             return PepNick()
 
-    async def _get_avatar_data(self, iq: Iq):
-        pep_avatar = await self._get_authorized_avatar(iq)
-
+    def __reply_with(
+        self, iq: Iq, content: AvatarData | AvatarMetadata | None, item_id: str | None
+    ) -> None:
         requested_items = iq["pubsub"]["items"]
+
         if len(requested_items) == 0:
-            self._reply_with_payload(iq, pep_avatar.data, pep_avatar.id)
+            self._reply_with_payload(iq, content, item_id)
         else:
             for item in requested_items:
-                if item["id"] == pep_avatar.id:
-                    self._reply_with_payload(iq, pep_avatar.data, pep_avatar.id)
+                if item["id"] == item_id:
+                    self._reply_with_payload(iq, content, item_id)
                     return
             else:
                 raise XMPPError("item-not-found")
 
-    async def _get_avatar_metadata(self, iq: Iq):
+    async def _get_avatar_data(self, iq: Iq):
         pep_avatar = await self._get_authorized_avatar(iq)
+        self.__reply_with(iq, pep_avatar.data, pep_avatar.id)
 
-        requested_items = iq["pubsub"]["items"]
-        if len(requested_items) == 0:
-            self._reply_with_payload(iq, pep_avatar.metadata, pep_avatar.id)
-        else:
-            for item in requested_items:
-                if item["id"] == pep_avatar.id:
-                    self._reply_with_payload(iq, pep_avatar.metadata, pep_avatar.id)
-                    return
-            else:
-                raise XMPPError("item-not-found")
+    async def _get_avatar_metadata(self, iq: Iq):
+        pep_avatar = await self._get_authorized_avatar(iq)
+        self.__reply_with(iq, pep_avatar.metadata, pep_avatar.id)
 
     async def _get_vcard(self, iq: Iq):
         # this is not the proper way that clients should retrieve VCards, but

slidge/core/session.py

@@ -73,8 +73,6 @@ class BaseSession(
     session-specific.
     """
 
-    http: aiohttp.ClientSession
-
     MESSAGE_IDS_ARE_THREAD_IDS = False
     """
     Set this to True if the legacy service uses message IDs as thread IDs,
@@ -106,8 +104,6 @@ class BaseSession(
             self
         )
 
-        self.http = self.xmpp.http
-
         self.thread_creation_lock = asyncio.Lock()
 
         self.__cached_presence: Optional[CachedPresence] = None
@@ -118,6 +114,10 @@ class BaseSession(
     def user(self) -> GatewayUser:
         return self.xmpp.store.users.get(self.user_jid)  # type:ignore
 
+    @property
+    def http(self) -> aiohttp.ClientSession:
+        return self.xmpp.http
+
     def __remove_task(self, fut):
         self.log.debug("Removing fut %s", fut)
         self.__tasks.remove(fut)

slidge/db/alembic/versions/3071e0fa69d4_add_contact_client_type.py

@@ -0,0 +1,52 @@
+"""Add Contact.client_type
+
+Revision ID: 3071e0fa69d4
+Revises: abba1ae0edb3
+Create Date: 2024-07-30 23:12:49.345593
+
+"""
+
+from typing import Sequence, Union
+
+import sqlalchemy as sa
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision: str = "3071e0fa69d4"
+down_revision: Union[str, None] = "abba1ae0edb3"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    with op.batch_alter_table("contact", schema=None) as batch_op:
+        batch_op.add_column(
+            sa.Column(
+                "client_type",
+                sa.Enum(
+                    "bot",
+                    "console",
+                    "game",
+                    "handheld",
+                    "pc",
+                    "phone",
+                    "sms",
+                    "tablet",
+                    "web",
+                    native_enum=False,
+                ),
+                nullable=False,
+                server_default=sa.text("pc"),
+            )
+        )
+
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    with op.batch_alter_table("contact", schema=None) as batch_op:
+        batch_op.drop_column("client_type")
+
+    # ### end Alembic commands ###

slidge/db/alembic/versions/5bd48bfdffa2_lift_room_legacy_id_constraint.py

@@ -20,19 +20,25 @@ depends_on: Union[str, Sequence[str], None] = None
 
 
 def upgrade() -> None:
-    with op.batch_alter_table(
-        "room",
-        schema=None,
-        # without copy_from, the newly created table keeps the constraints
-        # we actually want to ditch.
-        copy_from=Room.__table__,  # type:ignore
-    ) as batch_op:
-        batch_op.create_unique_constraint(
-            "uq_room_user_account_id_jid", ["user_account_id", "jid"]
-        )
-        batch_op.create_unique_constraint(
-            "uq_room_user_account_id_legacy_id", ["user_account_id", "legacy_id"]
-        )
+    try:
+        with op.batch_alter_table(
+            "room",
+            schema=None,
+            # without copy_from, the newly created table keeps the constraints
+            # we actually want to ditch.
+            copy_from=Room.__table__,  # type:ignore
+        ) as batch_op:
+            batch_op.create_unique_constraint(
+                "uq_room_user_account_id_jid", ["user_account_id", "jid"]
+            )
+            batch_op.create_unique_constraint(
+                "uq_room_user_account_id_legacy_id", ["user_account_id", "legacy_id"]
+            )
+    except Exception:
+        # happens when migration is not needed
+        # wouldn't be necessary if the constraint was named in the first place,
+        # cf https://alembic.sqlalchemy.org/en/latest/naming.html
+        pass
 
 
 def downgrade() -> None:

slidge/db/alembic/versions/aa9d82a7f6ef_db_creation.py

@@ -60,7 +60,11 @@ def downgrade() -> None:
 def migrate_from_shelf(accounts: sa.Table) -> None:
     from slidge import global_config
 
-    db_file = global_config.HOME_DIR / "slidge.db"
+    home = getattr(global_config, "HOME_DIR", None)
+    if home is None:
+        return
+
+    db_file = home / "slidge.db"
     if not db_file.exists():
         return
 

slidge/db/alembic/versions/abba1ae0edb3_store_avatar_legacy_id_in_the_contact_.py

@@ -0,0 +1,78 @@
+"""Store avatar legacy ID in the Contact and Room table
+
+Revision ID: abba1ae0edb3
+Revises: 8b993243a536
+Create Date: 2024-07-29 15:44:41.557388
+
+"""
+
+from typing import Sequence, Union
+
+import sqlalchemy as sa
+from alembic import op
+
+from slidge.db.models import Contact, Room
+
+# revision identifiers, used by Alembic.
+revision: str = "abba1ae0edb3"
+down_revision: Union[str, None] = "8b993243a536"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    conn = op.get_bind()
+    room_avatars = conn.execute(
+        sa.text(
+            "select room.id, avatar.legacy_id from room join avatar on room.avatar_id = avatar.id"
+        )
+    ).all()
+    contact_avatars = conn.execute(
+        sa.text(
+            "select contact.id, avatar.legacy_id from contact join avatar on contact.avatar_id = avatar.id"
+        )
+    ).all()
+    with op.batch_alter_table("contact", schema=None) as batch_op:
+        batch_op.add_column(sa.Column("avatar_legacy_id", sa.String(), nullable=True))
+
+    with op.batch_alter_table("room", schema=None) as batch_op:
+        batch_op.add_column(sa.Column("avatar_legacy_id", sa.String(), nullable=True))
+        batch_op.create_unique_constraint(
+            "uq_room_user_account_id_jid", ["user_account_id", "jid"]
+        )
+        batch_op.create_unique_constraint(
+            "uq_room_user_account_id_legacy_id", ["user_account_id", "legacy_id"]
+        )
+
+    for room_pk, avatar_legacy_id in room_avatars:
+        conn.execute(
+            sa.update(Room)
+            .where(Room.id == room_pk)
+            .values(avatar_legacy_id=avatar_legacy_id)
+        )
+    for contact_pk, avatar_legacy_id in contact_avatars:
+        conn.execute(
+            sa.update(Contact)
+            .where(Contact.id == contact_pk)
+            .values(avatar_legacy_id=avatar_legacy_id)
+        )
+    # conn.commit()
+
+    with op.batch_alter_table("avatar", schema=None) as batch_op:
+        batch_op.drop_column("legacy_id")
+
+
+def downgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    with op.batch_alter_table("room", schema=None) as batch_op:
+        batch_op.drop_constraint("uq_room_user_account_id_legacy_id", type_="unique")
+        batch_op.drop_constraint("uq_room_user_account_id_jid", type_="unique")
+        batch_op.drop_column("avatar_legacy_id")
+
+    with op.batch_alter_table("contact", schema=None) as batch_op:
+        batch_op.drop_column("avatar_legacy_id")
+
+    with op.batch_alter_table("avatar", schema=None) as batch_op:
+        batch_op.add_column(sa.Column("legacy_id", sa.VARCHAR(), nullable=True))
+
+    # ### end Alembic commands ###

slidge/db/avatar.py

@@ -7,7 +7,7 @@ from concurrent.futures import ThreadPoolExecutor
 from dataclasses import dataclass
 from http import HTTPStatus
 from pathlib import Path
-from typing import Any, Callable, Optional
+from typing import Optional
 
 import aiohttp
 from multidict import CIMultiDictProxy
@@ -18,7 +18,7 @@ from sqlalchemy import select
 from slidge.core import config
 from slidge.db.models import Avatar
 from slidge.db.store import AvatarStore
-from slidge.util.types import URL, AvatarType, LegacyFileIdType
+from slidge.util.types import URL, AvatarType
 
 
 @dataclass
@@ -62,7 +62,6 @@ class AvatarCache:
     dir: Path
     http: aiohttp.ClientSession
     store: AvatarStore
-    legacy_avatar_type: Callable[[str], Any] = str
 
     def __init__(self):
         self._thread_pool = ThreadPoolExecutor(config.AVATAR_RESAMPLING_THREADS)
@@ -119,15 +118,6 @@ class AvatarCache:
         headers = self.__get_http_headers(cached)
         return await self.__is_modified(url, headers)
 
-    def get(self, unique_id: LegacyFileIdType | URL) -> Optional[CachedAvatar]:
-        if isinstance(unique_id, URL):
-            stored = self.store.get_by_url(unique_id)
-        else:
-            stored = self.store.get_by_legacy_id(str(unique_id))
-        if stored is None:
-            return None
-        return CachedAvatar.from_store(stored, self.dir)
-
     def get_by_pk(self, pk: int) -> CachedAvatar:
         stored = self.store.get_by_pk(pk)
         assert stored is not None
@@ -141,40 +131,21 @@ class AvatarCache:
             return open_image(avatar)
         raise TypeError("Avatar must be bytes or a Path", avatar)
 
-    async def convert_or_get(
-        self,
-        avatar: AvatarType,
-        unique_id: Optional[LegacyFileIdType],
-    ) -> CachedAvatar:
-        if unique_id is not None:
-            cached = self.get(str(unique_id))
-            if cached is not None:
-                return cached
-
+    async def convert_or_get(self, avatar: AvatarType) -> CachedAvatar:
         if isinstance(avatar, (URL, str)):
-            if unique_id is None:
-                with self.store.session():
-                    stored = self.store.get_by_url(avatar)
-                    try:
-                        img, response_headers = await self.__download(
-                            avatar, self.__get_http_headers(stored)
-                        )
-                    except NotModified:
-                        assert stored is not None
-                        return CachedAvatar.from_store(stored, self.dir)
-            else:
-                img, _ = await self.__download(avatar, {})
-                response_headers = None
+            with self.store.session():
+                stored = self.store.get_by_url(avatar)
+                try:
+                    img, response_headers = await self.__download(
+                        avatar, self.__get_http_headers(stored)
+                    )
+                except NotModified:
+                    assert stored is not None
+                    return CachedAvatar.from_store(stored, self.dir)
         else:
             img = await self._get_image(avatar)
             response_headers = None
         with self.store.session() as orm:
-            stored = orm.execute(
-                select(Avatar).where(Avatar.legacy_id == str(unique_id))
-            ).scalar()
-            if stored is not None and stored.url is None:
-                return CachedAvatar.from_store(stored, self.dir)
-
             resize = (size := config.AVATAR_SIZE) and any(x > size for x in img.size)
             if resize:
                 await asyncio.get_event_loop().run_in_executor(
@@ -188,8 +159,8 @@ class AvatarCache:
             if (
                 not resize
                 and img.format == "PNG"
-                and isinstance(unique_id, str)
-                and (path := Path(unique_id))
+                and isinstance(avatar, (str, Path))
+                and (path := Path(avatar))
                 and path.exists()
             ):
                 img_bytes = path.read_bytes()
@@ -206,11 +177,6 @@ class AvatarCache:
             stored = orm.execute(select(Avatar).where(Avatar.hash == hash_)).scalar()
 
             if stored is not None:
-                if unique_id is not None:
-                    log.warning("Updating 'unique' IDs of a known avatar.")
-                    stored.legacy_id = str(unique_id)
-                    orm.add(stored)
-                    orm.commit()
                 return CachedAvatar.from_store(stored, self.dir)
 
             stored = Avatar(
@@ -218,7 +184,6 @@ class AvatarCache:
                 hash=hash_,
                 height=img.height,
                 width=img.width,
-                legacy_id=None if unique_id is None else str(unique_id),
                 url=avatar if isinstance(avatar, (URL, str)) else None,
             )
             if response_headers:

slidge/db/models.py

@@ -9,7 +9,7 @@ from slixmpp.types import MucAffiliation, MucRole
 from sqlalchemy import ForeignKey, Index, UniqueConstraint
 from sqlalchemy.orm import Mapped, mapped_column, relationship
 
-from ..util.types import MucType
+from ..util.types import ClientType, MucType
 from .meta import Base, JSONSerializable, JSONSerializableTypes
 
 
@@ -114,9 +114,6 @@ class Avatar(Base):
     height: Mapped[int] = mapped_column()
     width: Mapped[int] = mapped_column()
 
-    # legacy network-wide unique identifier for the avatar
-    legacy_id: Mapped[Optional[str]] = mapped_column(unique=True, nullable=True)
-
     # this is only used when avatars are available as HTTP URLs and do not
     # have a legacy_id
     url: Mapped[Optional[str]] = mapped_column(default=None)
@@ -171,6 +168,10 @@ class Contact(Base):
 
     participants: Mapped[list["Participant"]] = relationship(back_populates="contact")
 
+    avatar_legacy_id: Mapped[Optional[str]] = mapped_column(nullable=True)
+
+    client_type: Mapped[ClientType] = mapped_column(nullable=False, default="pc")
+
 
 class ContactSent(Base):
     """
@@ -235,6 +236,8 @@ class Room(Base):
         back_populates="room", primaryjoin="Participant.room_id == Room.id"
     )
 
+    avatar_legacy_id: Mapped[Optional[str]] = mapped_column(nullable=True)
+
 
 class ArchivedMessage(Base):
     """
@@ -366,7 +369,7 @@ class Participant(Base):
     )
 
     contact_id: Mapped[int] = mapped_column(ForeignKey("contact.id"), nullable=True)
-    contact: Mapped[Contact] = relationship(back_populates="participants")
+    contact: Mapped[Contact] = relationship(lazy=False, back_populates="participants")
 
     is_user: Mapped[bool] = mapped_column(default=False)