slidge 0.2.0a1__tar.gz → 0.2.0a3__tar.gz

{slidge-0.2.0a1 → slidge-0.2.0a3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: slidge
-Version: 0.2.0a1
+Version: 0.2.0a3
 Summary: XMPP bridging framework
 Home-page: https://sr.ht/~nicoco/slidge/
 License: AGPL-3.0-or-later

{slidge-0.2.0a1 → slidge-0.2.0a3}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "slidge"
-version = "0.2.0alpha1"
+version = "0.2.0alpha3"
 description = "XMPP bridging framework"
 authors = ["Nicolas Cedilnik <nicoco@nicoco.fr>"]
 readme = "README.md"

{slidge-0.2.0a1 → slidge-0.2.0a3}/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.0alpha1"
+__version__ = "0.2.0alpha3"

{slidge-0.2.0a1 → slidge-0.2.0a3}/slidge/contact/contact.py

@@ -3,6 +3,7 @@ import logging
 import warnings
 from datetime import date
 from typing import TYPE_CHECKING, Generic, Iterable, Optional, Self, Union
+from xml.etree import ElementTree as ET
 
 from slixmpp import JID, Message, Presence
 from slixmpp.exceptions import IqError
@@ -120,10 +121,21 @@ class LegacyContact(
         self.xmpp = session.xmpp
         self.jid = JID(self.jid_username + "@" + self.xmpp.boundjid.bare)
         self.jid.resource = self.RESOURCE
-        self.log = logging.getLogger(f"{self.user_jid.bare}:{self.jid.bare}")
+        self.log = logging.getLogger(self.jid.bare)
+        self._set_logger_name()
         self._is_friend: bool = False
         self._added_to_roster = False
         self._caps_ver: str | None = None
+        self._vcard_fetched = False
+        self._vcard: str | None = None
+
+    async def get_vcard(self) -> VCard4 | None:
+        if not self._vcard_fetched:
+            await self.fetch_vcard()
+        if self._vcard is None:
+            return None
+
+        return VCard4(xml=ET.fromstring(self._vcard))
 
     @property
     def is_friend(self):
@@ -136,6 +148,7 @@ class LegacyContact(
         self._is_friend = value
         if self._updating_info:
             return
+        self.__ensure_pk()
         assert self.contact_pk is not None
         self.xmpp.store.contacts.set_friend(self.contact_pk, value)
 
@@ -157,7 +170,10 @@ class LegacyContact(
 
     @property
     def participants(self) -> list["LegacyParticipant"]:
-        assert self.contact_pk is not None
+        if self.contact_pk is None:
+            return []
+
+        self.__ensure_pk()
         from ..group.participant import LegacyParticipant
 
         return [
@@ -171,8 +187,25 @@ class LegacyContact(
     def user_jid(self):
         return self.session.user_jid
 
+    def _set_logger_name(self):
+        self.log.name = f"{self.user_jid.bare}:contact:{self}"
+
     def __repr__(self):
-        return f"<Contact {self.jid.bare} - {self.name or self.legacy_id}'>"
+        return f"<Contact #{self.contact_pk} '{self.name}' ({self.legacy_id} - {self.jid.local})'>"
+
+    def __ensure_pk(self):
+        if self.contact_pk is not None:
+            return
+        with self.xmpp.store.session() as orm:
+            orm.commit()
+            stored = self.xmpp.store.contacts.get_by_legacy_id(
+                self.user_pk, str(self.legacy_id)
+            )
+            if stored is None:
+                self.log.error("Cannot find our primary key!", stack_info=True)
+                raise RuntimeError("Cannot find our primary key!")
+            self.contact_pk = stored.id
+        assert self.contact_pk is not None
 
     def __get_subscription_string(self):
         if self.is_friend:
@@ -234,6 +267,7 @@ class LegacyContact(
             and self.xmpp.MARK_ALL_MESSAGES
             and is_markable(stanza)
         ):
+            self.__ensure_pk()
             assert self.contact_pk is not None
             self.xmpp.store.contacts.add_to_sent(self.contact_pk, stanza["id"])
         stanza["to"] = self.user_jid
@@ -254,6 +288,7 @@ class LegacyContact(
         :param horizon_xmpp_id: The latest message
         :return: A list of XMPP ids or None if horizon_xmpp_id was not found
         """
+        self.__ensure_pk()
         assert self.contact_pk is not None
         return self.xmpp.store.contacts.pop_sent_up_to(self.contact_pk, horizon_xmpp_id)
 
@@ -269,6 +304,7 @@ class LegacyContact(
         if self._name == n:
             return
         self._name = n
+        self._set_logger_name()
         if self.is_friend and self.added_to_roster:
             self.xmpp.pubsub.broadcast_nick(
                 user_jid=self.user_jid, jid=self.jid.bare, nick=n
@@ -279,6 +315,7 @@ class LegacyContact(
             return
         for p in self.participants:
             p.nickname = n
+        self.__ensure_pk()
         assert self.contact_pk is not None
         self.xmpp.store.contacts.update_nick(self.contact_pk, n)
 
@@ -293,6 +330,7 @@ class LegacyContact(
         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)
         for p in self.participants:
@@ -346,7 +384,17 @@ class LegacyContact(
         elif country:
             vcard.add_address(country, locality)
 
-        self.xmpp.vcard.set_vcard(self.jid.bare, vcard, {self.user_jid.bare})
+        self._vcard = str(vcard)
+        self._vcard_fetched = True
+        self.session.create_task(
+            self.xmpp.pubsub.broadcast_vcard_event(self.jid, self.user_jid, vcard)
+        )
+
+        if self._updating_info:
+            return
+
+        assert self.contact_pk is not None
+        self.xmpp.store.contacts.set_vcard(self.contact_pk, self._vcard)
 
     def get_roster_item(self):
         item = {
@@ -430,7 +478,7 @@ class LegacyContact(
         """
         self.is_friend = True
         self.added_to_roster = True
-        assert self.contact_pk is not None
+        self.__ensure_pk()
         self.log.debug("Accepting friend request")
         presence = self._make_presence(ptype="subscribed", pstatus=text, bare=True)
         self._send(presence, nick=True)
@@ -554,8 +602,11 @@ class LegacyContact(
         contact.added_to_roster = stored.added_to_roster
         if (data := stored.extra_attributes) is not None:
             contact.deserialize_extra_attributes(data)
-        contact._set_avatar_from_store(stored)
         contact._caps_ver = stored.caps_ver
+        contact._set_logger_name()
+        contact._set_avatar_from_store(stored)
+        contact._vcard = stored.vcard
+        contact._vcard_fetched = stored.vcard_fetched
         return contact
 
 

{slidge-0.2.0a1 → slidge-0.2.0a3}/slidge/core/gateway/base.py

@@ -36,7 +36,6 @@ from ...command.register import RegistrationType
 from ...db import GatewayUser, SlidgeStore
 from ...db.avatar import avatar_cache
 from ...slixfix.roster import RosterBackend
-from ...slixfix.xep_0292.vcard4 import VCard4Provider
 from ...util import ABCSubclassableOnceAtMost
 from ...util.types import AvatarType, MessageOrPresenceTypeVar
 from ...util.util import timeit
@@ -331,7 +330,6 @@ class BaseGateway(
 
         self.register_plugin("pubsub", {"component_name": self.COMPONENT_NAME})
         self.pubsub: PubSubComponent = self["pubsub"]
-        self.vcard: VCard4Provider = self["xep_0292_provider"]
         self.delivery_receipt: DeliveryReceipt = DeliveryReceipt(self)
 
         # with this we receive user avatar updates

{slidge-0.2.0a1 → slidge-0.2.0a3}/slidge/core/gateway/session_dispatcher.py

@@ -68,6 +68,13 @@ class SessionDispatcher:
                 _exceptions_to_xmpp_errors(self.on_ibr_remove),  # type: ignore
             )
         )
+        self.xmpp.register_handler(
+            CoroutineCallback(
+                "get_vcard",
+                StanzaPath("iq@type=get/vcard"),
+                _exceptions_to_xmpp_errors(self.on_get_vcard),  # type:ignore
+            )
+        )
 
         for event in (
             "legacy_message",
@@ -778,6 +785,18 @@ class SessionDispatcher:
 
         raise XMPPError("feature-not-implemented")
 
+    async def on_get_vcard(self, iq: Iq):
+        session = await self.__get_session(iq)
+        session.raise_if_not_logged()
+        contact = await session.contacts.by_jid(iq.get_to())
+        vcard = await contact.get_vcard()
+        reply = iq.reply()
+        if vcard:
+            reply.append(vcard)
+        else:
+            reply.enable("vcard")
+        reply.send()
+
     def _xmpp_msg_id_to_legacy(self, session: "BaseSession", xmpp_id: str):
         sent = self.xmpp.store.sent.get_legacy_id(session.user_pk, xmpp_id)
         if sent is not None:

{slidge-0.2.0a1 → slidge-0.2.0a3}/slidge/core/gateway/vcard_temp.py

@@ -79,14 +79,14 @@ class VCardTemp:
             elif not (contact := entity.contact):
                 raise XMPPError("item-not-found", "This participant has no contact")
             else:
-                vcard = await self.xmpp.vcard.get_vcard(contact.jid, iq.get_from())
+                vcard = await contact.get_vcard()
                 avatar = contact.get_avatar()
                 type_ = "image/png"
         else:
             avatar = entity.get_avatar()
             type_ = "image/png"
             if isinstance(entity, LegacyContact):
-                vcard = await self.xmpp.vcard.get_vcard(entity.jid, iq.get_from())
+                vcard = await entity.get_vcard()
             else:
                 vcard = None
         v = self.xmpp.plugin["xep_0054"].make_vcard()

{slidge-0.2.0a1 → slidge-0.2.0a3}/slidge/core/pubsub.py

@@ -135,6 +135,7 @@ class PubSubComponent(NamedLockMixin, BasePlugin):
 
         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)
@@ -186,17 +187,19 @@ class PubSubComponent(NamedLockMixin, BasePlugin):
             else:
                 await self.__broadcast(data=pep_nick.nick, from_=p.get_to(), to=from_)
 
-        if VCARD4_NAMESPACE + "+notify" in features:
-            await self.broadcast_vcard_event(p.get_to(), to=from_)
+        if contact is not None and VCARD4_NAMESPACE + "+notify" in features:
+            await self.broadcast_vcard_event(
+                p.get_to(), from_, await contact.get_vcard()
+            )
 
-    async def broadcast_vcard_event(self, from_, to):
+    async def broadcast_vcard_event(self, from_: JID, to: JID, vcard: VCard4 | None):
         item = Item()
         item.namespace = VCARD4_NAMESPACE
         item["id"] = "current"
-        vcard: VCard4 = await self.xmpp["xep_0292_provider"].get_vcard(from_, to)
+        # vcard: VCard4 = await self.xmpp["xep_0292_provider"].get_vcard(from_, to)
         # The vcard content should NOT be in this event according to the spec:
         # https://xmpp.org/extensions/xep-0292.html#sect-idm45669698174224
-        # but movim expects it to be here, and I guess
+        # but movim expects it to be here, and I guess it does not hurt
 
         log.debug("Broadcast vcard4 event: %s", vcard)
         await self.__broadcast(
@@ -268,10 +271,9 @@ class PubSubComponent(NamedLockMixin, BasePlugin):
         # this is not the proper way that clients should retrieve VCards, but
         # gajim does it this way.
         # https://xmpp.org/extensions/xep-0292.html#sect-idm45669698174224
-        vcard: VCard4 = await self.xmpp["xep_0292_provider"].get_vcard(
-            iq.get_to().bare, iq.get_from().bare
-        )
-        log.debug("VCARD: %s -- %s -- %s", iq.get_to().bare, iq.get_from().bare, vcard)
+        session = self.xmpp.get_session_from_stanza(iq)
+        contact = await session.contacts.by_jid(iq.get_to())
+        vcard = await contact.get_vcard()
         if vcard is None:
             raise XMPPError("item-not-found")
         self._reply_with_payload(iq, vcard, "current", VCARD4_NAMESPACE)

slidge-0.2.0a3/slidge/db/alembic/versions/5bd48bfdffa2_lift_room_legacy_id_constraint.py

@@ -0,0 +1,44 @@
+"""Lift room legacy ID constraint
+
+Revision ID: 5bd48bfdffa2
+Revises: b64b1a793483
+Create Date: 2024-07-24 10:29:23.467851
+
+"""
+
+from typing import Sequence, Union
+
+from alembic import op
+
+from slidge.db.models import Room
+
+# revision identifiers, used by Alembic.
+revision: str = "5bd48bfdffa2"
+down_revision: Union[str, None] = "b64b1a793483"
+branch_labels: Union[str, Sequence[str], None] = None
+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"]
+        )
+
+
+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")
+
+    # ### end Alembic commands ###

slidge-0.2.0a3/slidge/db/alembic/versions/8b993243a536_add_vcard_content_to_contact_table.py

@@ -0,0 +1,43 @@
+"""Add vcard content to contact table
+
+Revision ID: 8b993243a536
+Revises: 5bd48bfdffa2
+Create Date: 2024-07-24 07:02:47.770894
+
+"""
+
+from typing import Sequence, Union
+
+import sqlalchemy as sa
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision: str = "8b993243a536"
+down_revision: Union[str, None] = "5bd48bfdffa2"
+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("vcard", sa.String(), nullable=True))
+        batch_op.add_column(
+            sa.Column(
+                "vcard_fetched",
+                sa.Boolean(),
+                nullable=False,
+                server_default=sa.sql.true(),
+            )
+        )
+
+    # ### 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("vcard_fetched")
+        batch_op.drop_column("vcard")
+
+    # ### end Alembic commands ###

{slidge-0.2.0a1 → slidge-0.2.0a3}/slidge/db/alembic/versions/aa9d82a7f6ef_db_creation.py

@@ -58,10 +58,19 @@ def downgrade() -> None:
 
 
 def migrate_from_shelf(accounts: sa.Table) -> None:
+    from slidge import global_config
+
+    db_file = global_config.HOME_DIR / "slidge.db"
+    if not db_file.exists():
+        return
+
     try:
-        from slidge.util.db import user_store
+        from slidge.db.alembic.old_user_store import user_store
     except ImportError:
         return
+
+    user_store.set_file(db_file, global_config.SECRET_KEY)
+
     try:
         users = list(user_store.get_all())
     except AttributeError:
@@ -83,3 +92,6 @@ def migrate_from_shelf(accounts: sa.Table) -> None:
             for user in users
         ],
     )
+
+    user_store.close()
+    db_file.unlink()

{slidge-0.2.0a1 → slidge-0.2.0a3}/slidge/db/meta.py

@@ -58,6 +58,13 @@ JSONSerializable = dict[str, JSONSerializableTypes]
 
 class Base(sa.orm.DeclarativeBase):
     type_annotation_map = {JSONSerializable: JSONEncodedDict, JID: JIDType}
+    naming_convention = {
+        "ix": "ix_%(column_0_label)s",
+        "uq": "uq_%(table_name)s_%(column_0_name)s",
+        "ck": "ck_%(table_name)s_`%(constraint_name)s`",
+        "fk": "fk_%(table_name)s_%(column_0_name)s_%(referred_table_name)s",
+        "pk": "pk_%(table_name)s",
+    }
 
 
 def get_engine(path: str) -> sa.Engine:

{slidge-0.2.0a1 → slidge-0.2.0a3}/slidge/db/models.py

@@ -166,6 +166,9 @@ class Contact(Base):
     )
     updated: Mapped[bool] = mapped_column(default=False)
 
+    vcard: Mapped[Optional[str]] = mapped_column()
+    vcard_fetched: Mapped[bool] = mapped_column(default=False)
+
     participants: Mapped[list["Participant"]] = relationship(back_populates="contact")
 
 
@@ -191,13 +194,20 @@ class Room(Base):
     Legacy room
     """
 
+    __table_args__ = (
+        UniqueConstraint(
+            "user_account_id", "legacy_id", name="uq_room_user_account_id_legacy_id"
+        ),
+        UniqueConstraint("user_account_id", "jid", name="uq_room_user_account_id_jid"),
+    )
+
     __tablename__ = "room"
     id: Mapped[int] = mapped_column(primary_key=True)
     user_account_id: Mapped[int] = mapped_column(ForeignKey("user_account.id"))
     user: Mapped[GatewayUser] = relationship(back_populates="rooms")
-    legacy_id: Mapped[str] = mapped_column(unique=True, nullable=False)
+    legacy_id: Mapped[str] = mapped_column(nullable=False)
 
-    jid: Mapped[JID] = mapped_column(unique=True)
+    jid: Mapped[JID] = mapped_column(nullable=False)
 
     avatar_id: Mapped[int] = mapped_column(ForeignKey("avatar.id"), nullable=True)
     avatar: Mapped[Avatar] = relationship(back_populates="rooms")

{slidge-0.2.0a1 → slidge-0.2.0a3}/slidge/db/store.py

@@ -32,6 +32,7 @@ from .models import (
     XmppIdsMulti,
     XmppToLegacyEnum,
     XmppToLegacyIds,
+    participant_hats,
 )
 
 if TYPE_CHECKING:
@@ -379,11 +380,22 @@ class ContactStore(UpdatedMixin):
             row.updated = True
             row.extra_attributes = contact.serialize_extra_attributes()
             row.caps_ver = contact._caps_ver
+            row.vcard = contact._vcard
+            row.vcard_fetched = contact._vcard_fetched
             session.add(row)
             if commit:
                 session.commit()
             return row.id
 
+    def set_vcard(self, contact_pk: int, vcard: str | None) -> None:
+        with self.session() as session:
+            session.execute(
+                update(Contact)
+                .where(Contact.id == contact_pk)
+                .values(vcard=vcard, vcard_fetched=True)
+            )
+            session.commit()
+
     def add_to_sent(self, contact_pk: int, msg_id: str) -> None:
         with self.session() as session:
             new = ContactSent(contact_id=contact_pk, msg_id=msg_id)
@@ -659,7 +671,7 @@ class MultiStore(EngineMixin):
             if existing is not None:
                 if fail:
                     raise
-                log.warning("Resetting multi for %s", legacy_msg_id)
+                log.debug("Resetting multi for %s", legacy_msg_id)
                 session.execute(
                     delete(LegacyIdsMulti)
                     .where(LegacyIdsMulti.user_account_id == user_pk)
@@ -935,6 +947,7 @@ class ParticipantStore(EngineMixin):
         with self.session() as session:
             session.execute(delete(Participant))
             session.execute(delete(Hat))
+            session.execute(delete(participant_hats))
             session.commit()
 
     def add(self, room_pk: int, nickname: str) -> int:

{slidge-0.2.0a1 → slidge-0.2.0a3}/slidge/group/room.py

@@ -131,7 +131,6 @@ class LegacyMUC(
     def __init__(self, session: "BaseSession", legacy_id: LegacyGroupIdType, jid: JID):
         self.session = session
         self.xmpp: "BaseGateway" = session.xmpp
-        self.log = logging.getLogger(f"{self.user_jid.bare}:muc:{jid}")
 
         self.legacy_id = legacy_id
         self.jid = jid
@@ -156,6 +155,8 @@ class LegacyMUC(
 
         self._n_participants: Optional[int] = None
 
+        self.log = logging.getLogger(self.jid.bare)
+        self._set_logger_name()
         super().__init__()
 
     @property
@@ -176,8 +177,11 @@ class LegacyMUC(
     def user_jid(self):
         return self.session.user_jid
 
+    def _set_logger_name(self):
+        self.log = logging.getLogger(f"{self.user_jid}:muc:{self}")
+
     def __repr__(self):
-        return f"<MUC {self.legacy_id}/{self.jid}/{self.name}>"
+        return f"<MUC #{self.pk} '{self.name}' ({self.legacy_id} - {self.jid.local})'>"
 
     @property
     def subject_date(self) -> Optional[datetime]:
@@ -287,6 +291,7 @@ class LegacyMUC(
         if self.DISCO_NAME == n:
             return
         self.DISCO_NAME = n
+        self._set_logger_name()
         self.__send_configuration_change((104,))
         if self._updating_info:
             return
@@ -1207,6 +1212,7 @@ class LegacyMUC(
             muc._user_resources = set(json.loads(stored.user_resources))
         muc._subject_setter = stored.subject_setter
         muc.archive = MessageArchive(muc.pk, session.xmpp.store.mam)
+        muc._set_logger_name()
         muc._set_avatar_from_store(stored)
         return muc
 

{slidge-0.2.0a1 → slidge-0.2.0a3}/slidge/main.py

@@ -32,7 +32,6 @@ from slidge.db.avatar import avatar_cache
 from slidge.db.meta import get_engine
 from slidge.migration import migrate
 from slidge.util.conf import ConfigModule
-from slidge.util.db import user_store
 
 
 class MainConfig(ConfigModule):
@@ -114,9 +113,6 @@ def configure():
         logging.info("Creating directory '%s'", h)
         h.mkdir()
 
-    db_file = config.HOME_DIR / "slidge.db"
-    user_store.set_file(db_file, args.secret_key)
-
     config.UPLOAD_REQUESTER = config.UPLOAD_REQUESTER or config.JID.bare
 
     return unknown_argv

{slidge-0.2.0a1 → slidge-0.2.0a3}/slidge/slixfix/roster.py

@@ -1,9 +1,8 @@
+import logging
 from typing import TYPE_CHECKING
 
 from slixmpp import JID
 
-from ..util.db import log
-
 if TYPE_CHECKING:
     from .. import BaseGateway
 
@@ -65,3 +64,6 @@ class RosterBackend:
                 "whitelisted": False,
                 "subscription": "none",
             }
+
+
+log = logging.getLogger(__name__)

slidge-0.2.0a3/slidge/slixfix/xep_0292/vcard4.py

@@ -0,0 +1,14 @@
+from slixmpp.plugins.base import BasePlugin, register_plugin
+from slixmpp.plugins.xep_0292.stanza import NS
+
+
+class VCard4Provider(BasePlugin):
+    name = "xep_0292_provider"
+    description = "VCard4 Provider"
+    dependencies = {"xep_0030"}
+
+    def plugin_init(self):
+        self.xmpp.plugin["xep_0030"].add_feature(NS)
+
+
+register_plugin(VCard4Provider)

{slidge-0.2.0a1 → slidge-0.2.0a3}/slidge/util/test.py

@@ -287,7 +287,7 @@ class SlidgeTest(SlixTestPlus):
         stanza = self.next_sent()
         assert "yup" in stanza["status"].lower(), stanza
 
-        self.romeo = BaseSession.get_self_or_unique_subclass().from_jid(
+        self.romeo: BaseSession = BaseSession.get_self_or_unique_subclass().from_jid(
             JID("romeo@montague.lit")
         )
         self.juliet: LegacyContact = self.run_coro(

slidge-0.2.0a1/slidge/slixfix/xep_0292/vcard4.py

@@ -1,103 +0,0 @@
-import logging
-from typing import TYPE_CHECKING, NamedTuple, Optional
-
-from slixmpp import JID, CoroutineCallback, Iq, StanzaPath
-from slixmpp.plugins.base import BasePlugin, register_plugin
-from slixmpp.plugins.xep_0292.stanza import NS, VCard4
-from slixmpp.types import JidStr
-
-from slidge.contact import LegacyContact
-
-if TYPE_CHECKING:
-    from slidge.core.gateway import BaseGateway
-
-
-class StoredVCard(NamedTuple):
-    content: VCard4
-    authorized_jids: set[JidStr]
-
-
-class VCard4Provider(BasePlugin):
-    xmpp: "BaseGateway"
-
-    name = "xep_0292_provider"
-    description = "VCard4 Provider"
-    dependencies = {"xep_0030"}
-
-    def __init__(self, *a, **k):
-        super(VCard4Provider, self).__init__(*a, **k)
-        # TODO: store that in DB and not in RAM
-        self._vcards = dict[JidStr, StoredVCard]()
-
-    def plugin_init(self):
-        self.xmpp.register_handler(
-            CoroutineCallback(
-                "get_vcard",
-                StanzaPath(f"iq@type=get/vcard"),
-                self.handle_vcard_get,  # type:ignore
-            )
-        )
-
-        self.xmpp.plugin["xep_0030"].add_feature(NS)
-
-    def _get_cached_vcard(self, jid: JidStr, requested_by: JidStr) -> Optional[VCard4]:
-        vcard = self._vcards.get(JID(jid).bare)
-        if vcard:
-            if auth := vcard.authorized_jids:
-                if JID(requested_by).bare in auth:
-                    return vcard.content
-            else:
-                return vcard.content
-        return None
-
-    async def get_vcard(self, jid: JidStr, requested_by: JidStr) -> Optional[VCard4]:
-        if vcard := self._get_cached_vcard(jid, requested_by):
-            log.debug("Found a cached vcard")
-            return vcard
-        if not hasattr(self.xmpp, "get_session_from_jid"):
-            return None
-        jid = JID(jid)
-        if not jid.local:
-            return None
-        requested_by = JID(requested_by)
-        session = self.xmpp.get_session_from_jid(requested_by)
-        if session is None:
-            return
-        entity = await session.get_contact_or_group_or_participant(jid)
-        if isinstance(entity, LegacyContact):
-            log.debug("Fetching vcard")
-            await entity.fetch_vcard()
-            return self._get_cached_vcard(jid, requested_by)
-        return None
-
-    async def handle_vcard_get(self, iq: Iq):
-        r = iq.reply()
-        if vcard := await self.get_vcard(iq.get_to().bare, iq.get_from().bare):
-            r.append(vcard)
-        else:
-            r.enable("vcard")
-        r.send()
-
-    def set_vcard(
-        self,
-        jid: JidStr,
-        vcard: VCard4,
-        /,
-        authorized_jids: Optional[set[JidStr]] = None,
-    ):
-        cache = self._vcards.get(jid)
-        new = StoredVCard(
-            vcard, authorized_jids if authorized_jids is not None else set()
-        )
-        self._vcards[jid] = new
-        if cache == new:
-            return
-        if self.xmpp["pubsub"] and authorized_jids:
-            for to in authorized_jids:
-                self.xmpp.loop.create_task(
-                    self.xmpp["pubsub"].broadcast_vcard_event(jid, to)
-                )
-
-
-register_plugin(VCard4Provider)
-log = logging.getLogger(__name__)