slidge 0.2.0a8__py3-none-any.whl → 0.2.0a10__py3-none-any.whl

slidge/core/{gateway/base.py → gateway.py}

@@ -8,16 +8,7 @@ import re
 import tempfile
 from copy import copy
 from datetime import datetime
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    Callable,
-    Collection,
-    Mapping,
-    Optional,
-    Sequence,
-    Union,
-)
+from typing import TYPE_CHECKING, Any, Callable, Mapping, Optional, Sequence, Union
 
 import aiohttp
 import qrcode
@@ -27,40 +18,30 @@ from slixmpp.plugins.xep_0060.stanza import OwnerAffiliation
 from slixmpp.types import MessageTypes
 from slixmpp.xmlstream.xmlstream import NotConnectedError
 
-from ... import command  # noqa: F401
-from ...command.adhoc import AdhocProvider
-from ...command.admin import Exec
-from ...command.base import Command, FormField
-from ...command.chat_command import ChatCommandProvider
-from ...command.register import RegistrationType
-from ...db import GatewayUser, SlidgeStore
-from ...db.avatar import avatar_cache
-from ...slixfix.roster import RosterBackend
-from ...util import ABCSubclassableOnceAtMost
-from ...util.types import AvatarType, MessageOrPresenceTypeVar
-from ...util.util import timeit
-from .. import config
-from ..mixins import MessageMixin
-from ..pubsub import PubSubComponent
-from ..session import BaseSession
-from .caps import Caps
-from .delivery_receipt import DeliveryReceipt
-from .disco import Disco
-from .mam import Mam
-from .muc_admin import MucAdmin
-from .ping import Ping
-from .presence import PresenceHandlerMixin
-from .registration import Registration
-from .search import Search
-from .session_dispatcher import SessionDispatcher
-from .vcard_temp import VCardTemp
+from slidge import command  # noqa: F401
+from slidge.command.adhoc import AdhocProvider
+from slidge.command.admin import Exec
+from slidge.command.base import Command, FormField
+from slidge.command.chat_command import ChatCommandProvider
+from slidge.command.register import RegistrationType
+from slidge.core import config
+from slidge.core.dispatcher.session_dispatcher import SessionDispatcher
+from slidge.core.mixins import MessageMixin
+from slidge.core.pubsub import PubSubComponent
+from slidge.core.session import BaseSession
+from slidge.db import GatewayUser, SlidgeStore
+from slidge.db.avatar import avatar_cache
+from slidge.slixfix.delivery_receipt import DeliveryReceipt
+from slidge.slixfix.roster import RosterBackend
+from slidge.util import ABCSubclassableOnceAtMost
+from slidge.util.types import AvatarType, MessageOrPresenceTypeVar
+from slidge.util.util import timeit
 
 if TYPE_CHECKING:
-    from ...group.room import LegacyMUC
+    pass
 
 
 class BaseGateway(
-    PresenceHandlerMixin,
     ComponentXMPP,
     MessageMixin,
     metaclass=ABCSubclassableOnceAtMost,
@@ -118,7 +99,7 @@ class BaseGateway(
     Path, bytes or URL used by the component as an avatar.
     """
 
-    REGISTRATION_FIELDS: Collection[FormField] = [
+    REGISTRATION_FIELDS: Sequence[FormField] = [
         FormField(var="username", label="User name", required=True),
         FormField(var="password", label="Password", required=True, private=True),
     ]
@@ -315,7 +296,7 @@ class BaseGateway(
         self.session_cls: BaseSession = BaseSession.get_unique_subclass()
         self.session_cls.xmpp = self
 
-        from ...group.room import LegacyMUC
+        from ..group.room import LegacyMUC
 
         LegacyMUC.get_self_or_unique_subclass().xmpp = self
 
@@ -328,6 +309,7 @@ class BaseGateway(
 
         self.register_plugins()
         self.__register_slixmpp_events()
+        self.__register_slixmpp_api()
         self.roster.set_backend(RosterBackend(self))
 
         self.register_plugin("pubsub", {"component_name": self.COMPONENT_NAME})
@@ -355,21 +337,11 @@ class BaseGateway(
         # why does mypy need these type annotations? no idea
         self.__adhoc_handler: AdhocProvider = AdhocProvider(self)
         self.__chat_commands_handler: ChatCommandProvider = ChatCommandProvider(self)
-        self.__disco_handler = Disco(self)
-
-        self.__ping_handler = Ping(self)
-        self.__mam_handler = Mam(self)
-        self.__search_handler = Search(self)
-        self.__caps_handler = Caps(self)
-        self.__vcard_temp_handler = VCardTemp(self)
-        self.__muc_admin_handler = MucAdmin(self)
-        self.__registration = Registration(self)
+
         self.__dispatcher = SessionDispatcher(self)
 
         self.__register_commands()
 
-        self.__mam_cleanup_task = self.loop.create_task(self.__mam_cleanup())
-
         MessageMixin.__init__(self)  # ComponentXMPP does not call super().__init__()
 
     async def __set_http(self):
@@ -378,13 +350,6 @@ class BaseGateway(
             return
         avatar_cache.http = self.http
 
-    async def __mam_cleanup(self):
-        if not config.MAM_MAX_DAYS:
-            return
-        while True:
-            await asyncio.sleep(3600 * 6)
-            self.store.mam.nuke_older_than(config.MAM_MAX_DAYS)
-
     def __register_commands(self):
         for cls in Command.subclasses:
             if any(x is NotImplemented for x in [cls.CHAT_COMMAND, cls.NODE, cls.NAME]):
@@ -421,40 +386,27 @@ class BaseGateway(
             loop.stop()
 
     def __register_slixmpp_events(self):
+        self.del_event_handler("presence_subscribe", self._handle_subscribe)
+        self.del_event_handler("presence_unsubscribe", self._handle_unsubscribe)
+        self.del_event_handler("presence_subscribed", self._handle_subscribed)
+        self.del_event_handler("presence_unsubscribed", self._handle_unsubscribed)
+        self.del_event_handler(
+            "roster_subscription_request", self._handle_new_subscription
+        )
+        self.del_event_handler("presence_probe", self._handle_probe)
         self.add_event_handler("session_start", self.__on_session_start)
         self.add_event_handler("disconnected", self.connect)
-        self.add_event_handler("user_register", self._on_user_register)
-        self.add_event_handler("user_unregister", self._on_user_unregister)
-        self.add_event_handler("groupchat_message_error", self.__on_group_chat_error)
+
+    def __register_slixmpp_api(self) -> None:
+        self.plugin["xep_0231"].api.register(self.store.bob.get_bob, "get_bob")
+        self.plugin["xep_0231"].api.register(self.store.bob.set_bob, "set_bob")
+        self.plugin["xep_0231"].api.register(self.store.bob.del_bob, "del_bob")
 
     @property  # type: ignore
     def jid(self):
         # Override to avoid slixmpp deprecation warnings.
         return self.boundjid
 
-    async def __on_group_chat_error(self, msg: Message):
-        condition = msg["error"].get_condition()
-        if condition not in KICKABLE_ERRORS:
-            return
-
-        try:
-            muc = await self.get_muc_from_stanza(msg)
-        except XMPPError as e:
-            log.debug("Not removing resource", exc_info=e)
-            return
-        mfrom = msg.get_from()
-        resource = mfrom.resource
-        try:
-            muc.remove_user_resource(resource)
-        except KeyError:
-            # this actually happens quite frequently on for both beagle and monal
-            # (not sure why?), but is of no consequence
-            log.debug("%s was not in the resources of %s", resource, muc)
-        else:
-            log.info(
-                "Removed %s from the resources of %s because of error", resource, muc
-            )
-
     async def __on_session_start(self, event):
         log.debug("Gateway session start: %s", event)
 
@@ -490,7 +442,7 @@ class BaseGateway(
                 pto=user.jid.bare, ptype="probe"
             )  # ensure we get all resources for user
             session = self.session_cls.from_user(user)
-            session.create_task(self.__login_wrap(session))
+            session.create_task(self.login_wrap(session))
             if cached_avatar is not None:
                 await self.pubsub.broadcast_avatar(
                     self.boundjid.bare, session.user_jid, cached_avatar
@@ -551,7 +503,7 @@ class BaseGateway(
             )
 
     @timeit
-    async def __login_wrap(self, session: "BaseSession"):
+    async def login_wrap(self, session: "BaseSession"):
         session.send_gateway_status("Logging in…", show="dnd")
         try:
             status = await session.login()
@@ -612,21 +564,6 @@ class BaseGateway(
         stanza.send()
         return stanza
 
-    async def _on_user_register(self, iq: Iq):
-        session = self.get_session_from_stanza(iq)
-        for jid in config.ADMINS:
-            self.send_message(
-                mto=jid,
-                mbody=f"{iq.get_from()} has registered",
-                mtype="chat",
-                mfrom=self.boundjid.bare,
-            )
-        session.send_gateway_message(self.WELCOME_MESSAGE)
-        await self.__login_wrap(session)
-
-    async def _on_user_unregister(self, iq: Iq):
-        await self.session_cls.kill_by_jid(iq.get_from())
-
     def raise_if_not_allowed_jid(self, jid: JID):
         if not self.jid_validator.match(jid.bare):
             raise XMPPError(
@@ -665,26 +602,6 @@ class BaseGateway(
         except XMPPError:
             pass
 
-    async def get_muc_from_stanza(self, iq: Union[Iq, Message]) -> "LegacyMUC":
-        ito = iq.get_to()
-
-        if ito == self.boundjid.bare:
-            raise XMPPError(
-                text="No MAM on the component itself, use a JID with a resource"
-            )
-
-        ifrom = iq.get_from()
-        user = self.store.users.get(ifrom)
-        if user is None:
-            raise XMPPError("registration-required")
-
-        session = self.get_session_from_user(user)
-        session.raise_if_not_logged()
-
-        muc = await session.bookmarks.by_jid(ito)
-
-        return muc
-
     def exception(self, exception: Exception):
         # """
         # Called when a task created by slixmpp's internal (eg, on slix events) raises an Exception.
@@ -719,7 +636,7 @@ class BaseGateway(
         async def w():
             session.cancel_all_tasks()
             await session.logout()
-            await self.__login_wrap(session)
+            await self.login_wrap(session)
 
         session.create_task(w())
 
@@ -949,20 +866,6 @@ class BaseGateway(
         return tasks
 
 
-KICKABLE_ERRORS = {
-    "gone",
-    "internal-server-error",
-    "item-not-found",
-    "jid-malformed",
-    "recipient-unavailable",
-    "redirect",
-    "remote-server-not-found",
-    "remote-server-timeout",
-    "service-unavailable",
-    "malformed error",
-}
-
-
 SLIXMPP_PLUGINS = [
     "link_preview",  # https://wiki.soprani.ca/CheogramApp/LinkPreviews
     "xep_0030",  # Service discovery
@@ -972,6 +875,7 @@ SLIXMPP_PLUGINS = [
     "xep_0055",  # Jabber search
     "xep_0059",  # Result Set Management
     "xep_0066",  # Out of Band Data
+    "xep_0071",  # XHTML-IM (for stickers and custom emojis maybe later)
     "xep_0077",  # In-band registration
     "xep_0084",  # User Avatar
     "xep_0085",  # Chat state notifications
@@ -984,6 +888,7 @@ SLIXMPP_PLUGINS = [
     "xep_0184",  # Message Delivery Receipts
     "xep_0199",  # XMPP Ping
     "xep_0221",  # Data Forms Media Element
+    "xep_0231",  # Bits of Binary (for stickers and custom emojis maybe later)
     "xep_0249",  # Direct MUC Invitations
     "xep_0264",  # Jingle Content Thumbnails
     "xep_0280",  # Carbons

slidge/core/mixins/attachment.py

@@ -9,7 +9,7 @@ import tempfile
 import warnings
 from datetime import datetime
 from itertools import chain
-from mimetypes import guess_type
+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
@@ -171,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:

slidge/core/mixins/base.py

@@ -6,8 +6,8 @@ from slixmpp import JID
 from ...util.types import MessageOrPresenceTypeVar
 
 if TYPE_CHECKING:
-    from slidge.core.gateway import BaseGateway
-    from slidge.core.session import BaseSession
+    from ..gateway import BaseGateway
+    from ..session import BaseSession
 
 
 class MetaBase(ABCMeta):

slidge/core/mixins/message.py

@@ -214,7 +214,7 @@ class ContentMessageMixin(AttachmentMixin):
         :param archive_only: (only in groups) Do not send this message to user,
             but store it in the archive. Meant to be used during ``MUC.backfill()``
         """
-        if carbon:
+        if carbon and not hasattr(self, "muc"):
             if not correction and self.xmpp.store.sent.was_sent_by_user(
                 self.session.user_pk, str(legacy_msg_id)
             ):
@@ -223,6 +223,11 @@ class ContentMessageMixin(AttachmentMixin):
                     legacy_msg_id,
                 )
                 return
+            if hasattr(self, "muc") and not self.is_user:  # type:ignore
+                log.warning(
+                    "send_text() called with carbon=True on a participant who is not the user",
+                    legacy_msg_id,
+                )
             self.xmpp.store.sent.set_message(
                 self.session.user_pk,
                 str(legacy_msg_id),
@@ -352,11 +357,12 @@ class ContentMessageMixin(AttachmentMixin):
 class CarbonMessageMixin(ContentMessageMixin, MarkerMixin):
     def _privileged_send(self, msg: Message):
         i = msg.get_id()
-        if not i:
-            i = str(uuid.uuid4())
+        if i:
+            self.session.ignore_messages.add(i)
+        else:
+            i = "slidge-carbon-" + str(uuid.uuid4())
             msg.set_id(i)
         msg.del_origin_id()
-        self.session.ignore_messages.add(i)
         try:
             self.xmpp["xep_0356"].send_privileged_message(msg)
         except PermissionError:

slidge/core/pubsub.py

@@ -25,8 +25,9 @@ from ..db.store import ContactStore, SlidgeStore
 from .mixins.lock import NamedLockMixin
 
 if TYPE_CHECKING:
+    from slidge.core.gateway import BaseGateway
+
     from ..contact.contact import LegacyContact
-    from ..core.gateway.base import BaseGateway
 
 VCARD4_NAMESPACE = "urn:xmpp:vcard4"
 

slidge/core/session.py

@@ -31,6 +31,7 @@ from ..util.types import (
     PseudoPresenceShow,
     RecipientType,
     ResourceDict,
+    Sticker,
 )
 from ..util.util import deprecated
 
@@ -225,6 +226,31 @@ class BaseSession(
 
     send_file = deprecated("BaseSession.send_file", on_file)
 
+    async def on_sticker(
+        self,
+        chat: RecipientType,
+        sticker: Sticker,
+        *,
+        reply_to_msg_id: Optional[LegacyMessageType] = None,
+        reply_to_fallback_text: Optional[str] = None,
+        reply_to: Optional[Union["LegacyContact", "LegacyParticipant"]] = None,
+        thread: Optional[LegacyThreadType] = None,
+    ) -> Optional[LegacyMessageType]:
+        """
+        Triggered when the user sends a file using HTTP Upload (:xep:`0363`)
+
+        :param chat: See :meth:`.BaseSession.on_text`
+        :param sticker: The sticker sent by the user.
+        :param reply_to_msg_id: See :meth:`.BaseSession.on_text`
+        :param reply_to_fallback_text: See :meth:`.BaseSession.on_text`
+        :param reply_to: See :meth:`.BaseSession.on_text`
+        :param thread:
+
+        :return: An ID of some sort that can be used later to ack and mark the message
+            as read by the user
+        """
+        raise NotImplementedError
+
     async def on_active(
         self, chat: RecipientType, thread: Optional[LegacyThreadType] = None
     ):
@@ -729,8 +755,8 @@ class BaseSession(
         self.xmpp.re_login(self)
 
     async def get_contact_or_group_or_participant(self, jid: JID, create=True):
-        if jid.bare in (contacts := self.contacts.known_contacts(only_friends=False)):
-            return contacts[jid.bare]
+        if (contact := self.contacts.by_jid_only_if_exists(jid)) is not None:
+            return contact
         if (muc := self.bookmarks.by_jid_only_if_exists(JID(jid.bare))) is not None:
             return await self.__get_muc_or_participant(muc, jid)
         else:

slidge/db/alembic/versions/45c24cc73c91_add_bob.py

@@ -0,0 +1,42 @@
+"""Add BoB
+
+Revision ID: 45c24cc73c91
+Revises: 3071e0fa69d4
+Create Date: 2024-08-01 22:30:07.073935
+
+"""
+
+from typing import Sequence, Union
+
+import sqlalchemy as sa
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision: str = "45c24cc73c91"
+down_revision: Union[str, None] = "3071e0fa69d4"
+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! ###
+    op.create_table(
+        "bob",
+        sa.Column("id", sa.Integer(), nullable=False),
+        sa.Column("file_name", sa.String(), nullable=False),
+        sa.Column("sha_1", sa.String(), nullable=False),
+        sa.Column("sha_256", sa.String(), nullable=False),
+        sa.Column("sha_512", sa.String(), nullable=False),
+        sa.Column("content_type", sa.String(), nullable=False),
+        sa.PrimaryKeyConstraint("id"),
+        sa.UniqueConstraint("sha_1"),
+        sa.UniqueConstraint("sha_256"),
+        sa.UniqueConstraint("sha_512"),
+    )
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_table("bob")
+    # ### end Alembic commands ###

slidge/db/models.py

@@ -386,3 +386,16 @@ class Participant(Base):
     )
 
     extra_attributes: Mapped[Optional[JSONSerializable]] = mapped_column(default=None)
+
+
+class Bob(Base):
+    __tablename__ = "bob"
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+    file_name: Mapped[str] = mapped_column(nullable=False)
+
+    sha_1: Mapped[str] = mapped_column(nullable=False, unique=True)
+    sha_256: Mapped[str] = mapped_column(nullable=False, unique=True)
+    sha_512: Mapped[str] = mapped_column(nullable=False, unique=True)
+
+    content_type: Mapped[Optional[str]] = mapped_column(nullable=False)

slidge/db/store.py

@@ -1,27 +1,33 @@
 from __future__ import annotations
 
+import hashlib
 import json
 import logging
+import uuid
 from contextlib import contextmanager
 from datetime import datetime, timedelta, timezone
+from mimetypes import guess_extension
 from typing import TYPE_CHECKING, Collection, Iterator, Optional, Type
 
 from slixmpp import JID, Iq, Message, Presence
 from slixmpp.exceptions import XMPPError
+from slixmpp.plugins.xep_0231.stanza import BitsOfBinary
 from sqlalchemy import Engine, delete, select, update
-from sqlalchemy.orm import Session, attributes
+from sqlalchemy.orm import Session, attributes, load_only
 from sqlalchemy.sql.functions import count
 
+from ..core import config
 from ..util.archive_msg import HistoryMessage
 from ..util.types import URL, CachedPresence, ClientType
 from ..util.types import Hat as HatTuple
-from ..util.types import MamMetadata, MucAffiliation, MucRole
+from ..util.types import MamMetadata, MucAffiliation, MucRole, Sticker
 from .meta import Base
 from .models import (
     ArchivedMessage,
     ArchivedMessageSource,
     Attachment,
     Avatar,
+    Bob,
     Contact,
     ContactSent,
     GatewayUser,
@@ -87,6 +93,7 @@ class SlidgeStore(EngineMixin):
         self.rooms = RoomStore(engine)
         self.sent = SentStore(engine)
         self.participants = ParticipantStore(engine)
+        self.bob = BobStore(engine)
 
 
 class UserStore(EngineMixin):
@@ -973,6 +980,15 @@ class RoomStore(UpdatedMixin):
                 select(Room).where(Room.user_account_id == user_pk)
             ).scalars()
 
+    def get_all_jid_and_names(self, user_pk: int) -> Iterator[Room]:
+        with self.session() as session:
+            yield from session.scalars(
+                select(Room)
+                .filter(Room.user_account_id == user_pk)
+                .options(load_only(Room.jid, Room.name))
+                .order_by(Room.name)
+            ).all()
+
 
 class ParticipantStore(EngineMixin):
     def __init__(self, *a, **kw):
@@ -1120,5 +1136,115 @@ class ParticipantStore(EngineMixin):
             ).scalar()
 
 
+class BobStore(EngineMixin):
+    _ATTR_MAP = {
+        "sha-1": "sha_1",
+        "sha1": "sha_1",
+        "sha-256": "sha_256",
+        "sha256": "sha_256",
+        "sha-512": "sha_512",
+        "sha512": "sha_512",
+    }
+
+    _ALG_MAP = {
+        "sha_1": hashlib.sha1,
+        "sha_256": hashlib.sha256,
+        "sha_512": hashlib.sha512,
+    }
+
+    def __init__(self, *a, **k):
+        super().__init__(*a, **k)
+        self.root_dir = config.HOME_DIR / "slidge_stickers"
+        self.root_dir.mkdir(exist_ok=True)
+
+    @staticmethod
+    def __split_cid(cid: str) -> list[str]:
+        return cid.removesuffix("@bob.xmpp.org").split("+")
+
+    def __get_condition(self, cid: str):
+        alg_name, digest = self.__split_cid(cid)
+        attr = self._ATTR_MAP.get(alg_name)
+        if attr is None:
+            log.warning("Unknown hash algo: %s", alg_name)
+            return None
+        return getattr(Bob, attr) == digest
+
+    def get(self, cid: str) -> Bob | None:
+        with self.session() as session:
+            try:
+                return session.query(Bob).filter(self.__get_condition(cid)).scalar()
+            except ValueError:
+                log.warning("Cannot get Bob with CID: %s", cid)
+                return None
+
+    def get_sticker(self, cid: str) -> Sticker | None:
+        bob = self.get(cid)
+        if bob is None:
+            return None
+        return Sticker(
+            self.root_dir / bob.file_name,
+            bob.content_type,
+            {h: getattr(bob, h) for h in self._ALG_MAP},
+        )
+
+    def get_bob(self, _jid, _node, _ifrom, cid: str) -> BitsOfBinary | None:
+        stored = self.get(cid)
+        if stored is None:
+            return None
+        bob = BitsOfBinary()
+        bob["data"] = (self.root_dir / stored.file_name).read_bytes()
+        if stored.content_type is not None:
+            bob["type"] = stored.content_type
+        bob["cid"] = cid
+        return bob
+
+    def del_bob(self, _jid, _node, _ifrom, cid: str) -> None:
+        with self.session() as orm:
+            try:
+                file_name = orm.scalar(
+                    delete(Bob)
+                    .where(self.__get_condition(cid))
+                    .returning(Bob.file_name)
+                )
+            except ValueError:
+                log.warning("Cannot delete Bob with CID: %s", cid)
+                return None
+            if file_name is None:
+                log.warning("No BoB with CID: %s", cid)
+                return None
+            (self.root_dir / file_name).unlink()
+            orm.commit()
+
+    def set_bob(self, _jid, _node, _ifrom, bob: BitsOfBinary) -> None:
+        cid = bob["cid"]
+        try:
+            alg_name, digest = self.__split_cid(cid)
+        except ValueError:
+            log.warning("Cannot set Bob with CID: %s", cid)
+            return
+        attr = self._ATTR_MAP.get(alg_name)
+        if attr is None:
+            log.warning("Cannot set BoB with unknown hash algo: %s", alg_name)
+            return None
+        with self.session() as orm:
+            existing = self.get(bob["cid"])
+            if existing is not None:
+                log.debug("Bob already known")
+                return
+            bytes_ = bob["data"]
+            path = self.root_dir / uuid.uuid4().hex
+            if bob["type"]:
+                path = path.with_suffix(guess_extension(bob["type"]) or "")
+            path.write_bytes(bytes_)
+            hashes = {k: v(bytes_).hexdigest() for k, v in self._ALG_MAP.items()}
+            if hashes[attr] != digest:
+                raise ValueError(
+                    "The given CID does not correspond to the result of our hash"
+                )
+            row = Bob(file_name=path.name, content_type=bob["type"] or None, **hashes)
+            orm.add(row)
+            orm.commit()
+
+
 log = logging.getLogger(__name__)
 _session: Optional[Session] = None

slidge/{core/gateway → slixfix}/delivery_receipt.py

@@ -11,7 +11,7 @@ from slixmpp import JID, Message
 from slixmpp.types import MessageTypes
 
 if TYPE_CHECKING:
-    from .base import BaseGateway
+    from slidge.core.gateway import BaseGateway
 
 
 class DeliveryReceipt: