slidge 0.1.2__py3-none-any.whl → 0.2.0a0__py3-none-any.whl

slidge/util/sql.py

@@ -1,508 +0,0 @@
-import logging
-import os
-import sqlite3
-import tempfile
-from asyncio import AbstractEventLoop, Task, sleep
-from datetime import datetime, timezone
-from functools import lru_cache
-from pathlib import Path
-from time import time
-from typing import (
-    TYPE_CHECKING,
-    Collection,
-    Generic,
-    Iterator,
-    NamedTuple,
-    Optional,
-    TypeVar,
-    Union,
-)
-
-from slixmpp import JID
-from slixmpp.exceptions import XMPPError
-from slixmpp.types import PresenceShows, PresenceTypes
-
-from ..core import config
-from .archive_msg import HistoryMessage
-
-if TYPE_CHECKING:
-    from .db import GatewayUser
-
-KeyType = TypeVar("KeyType")
-ValueType = TypeVar("ValueType")
-
-
-class CachedPresence(NamedTuple):
-    last_seen: Optional[datetime] = None
-    ptype: Optional[PresenceTypes] = None
-    pstatus: Optional[str] = None
-    pshow: Optional[PresenceShows] = None
-
-
-class MamMetadata(NamedTuple):
-    id: str
-    sent_on: datetime
-
-
-class Base:
-    def __init__(self):
-        handler, filename = tempfile.mkstemp()
-
-        os.close(handler)
-        self.__filename = filename
-
-        self.con = sqlite3.connect(filename)
-        self.cur = self.con.cursor()
-        self.cur.executescript((Path(__file__).parent / "schema.sql").read_text())
-
-        self.__mam_cleanup_task: Optional[Task] = None
-
-    def __del__(self):
-        self.con.close()
-        os.unlink(self.__filename)
-
-
-class MAMMixin(Base):
-    def __init__(self):
-        super().__init__()
-        self.__mam_cleanup_task: Optional[Task] = None
-        self.__msg_cur = msg_cur = self.con.cursor()
-        msg_cur.row_factory = self.__msg_factory  # type:ignore
-        self.__metadata_cur = metadata_cur = self.con.cursor()
-        metadata_cur.row_factory = self.__metadata_factory  # type:ignore
-
-    @staticmethod
-    def __msg_factory(_cur, row: tuple[str, float]) -> HistoryMessage:
-        return HistoryMessage(
-            row[0], when=datetime.fromtimestamp(row[1], tz=timezone.utc)
-        )
-
-    @staticmethod
-    def __metadata_factory(_cur, row: tuple[str, float]) -> MamMetadata:
-        return MamMetadata(row[0], datetime.fromtimestamp(row[1], tz=timezone.utc))
-
-    def mam_nuke(self):
-        self.cur.execute("DELETE FROM mam_message")
-        self.con.commit()
-
-    def mam_add_muc(self, jid: str, user: "GatewayUser"):
-        try:
-            self.cur.execute(
-                "INSERT INTO "
-                "muc(jid, user_id) "
-                "VALUES("
-                "  ?, "
-                "  (SELECT id FROM user WHERE jid = ?)"
-                ")",
-                (jid, user.bare_jid),
-            )
-        except sqlite3.IntegrityError:
-            log.debug("Tried to add a MUC that was already here: (%s, %s)", user, jid)
-        else:
-            self.con.commit()
-
-    def mam_add_msg(self, muc_jid: str, msg: "HistoryMessage", user: "GatewayUser"):
-        self.cur.execute(
-            "REPLACE INTO "
-            "mam_message(message_id, sender_jid, sent_on, xml, muc_id, user_id)"
-            "VALUES(?, ?, ?, ?,"
-            "(SELECT id FROM muc WHERE jid = ?),"
-            "(SELECT id FROM user WHERE jid = ?)"
-            ")",
-            (
-                msg.id,
-                str(msg.stanza.get_from()),
-                msg.when.timestamp(),
-                str(msg.stanza),
-                muc_jid,
-                user.bare_jid,
-            ),
-        )
-        self.con.commit()
-
-    def mam_launch_cleanup_task(self, loop: AbstractEventLoop):
-        self.__mam_cleanup_task = loop.create_task(self.__mam_cleanup())
-
-    async def __mam_cleanup(self):
-        await sleep(6 * 3600)
-        self.mam_cleanup()
-
-    def mam_cleanup(self):
-        self.cur.execute(
-            "DELETE FROM mam_message WHERE sent_on < ?",
-            (time() - config.MAM_MAX_DAYS * 24 * 3600,),
-        )
-        self.con.commit()
-
-    def __mam_get_sent_on(self, muc_jid: str, mid: str, user: "GatewayUser"):
-        res = self.cur.execute(
-            "SELECT sent_on "
-            "FROM mam_message "
-            "WHERE message_id = ? "
-            "AND muc_id = (SELECT id FROM muc WHERE jid = ?) "
-            "AND user_id = (SELECT id FROM user WHERE jid = ?)",
-            (mid, muc_jid, user.bare_jid),
-        )
-        row = res.fetchone()
-        if row is None:
-            raise XMPPError("item-not-found", f"Message {mid} not found")
-        return row[0]
-
-    def __mam_bound(
-        self,
-        muc_jid: str,
-        user: "GatewayUser",
-        date: Optional[datetime] = None,
-        id_: Optional[str] = None,
-        comparator=min,
-    ):
-        if id_ is not None:
-            after_id_sent_on = self.__mam_get_sent_on(muc_jid, id_, user)
-            if date:
-                timestamp = comparator(after_id_sent_on, date.timestamp())
-            else:
-                timestamp = after_id_sent_on
-            return " AND sent_on > ?", timestamp
-        elif date is None:
-            raise TypeError
-        else:
-            return " AND sent_on >= ?", date.timestamp()
-
-    def mam_get_messages(
-        self,
-        user: "GatewayUser",
-        muc_jid: str,
-        start_date: Optional[datetime] = None,
-        end_date: Optional[datetime] = None,
-        before_id: Optional[str] = None,
-        after_id: Optional[str] = None,
-        ids: Collection[str] = (),
-        last_page_n: Optional[int] = None,
-        sender: Optional[str] = None,
-        flip=False,
-    ) -> Iterator[HistoryMessage]:
-        query = (
-            "SELECT xml, sent_on FROM mam_message "
-            "WHERE muc_id = (SELECT id FROM muc WHERE jid = ?) "
-            "AND user_id = (SELECT id FROM user WHERE jid = ?) "
-        )
-        params: list[Union[str, float, int]] = [muc_jid, user.bare_jid]
-
-        if start_date or after_id:
-            subquery, timestamp = self.__mam_bound(
-                muc_jid, user, start_date, after_id, max
-            )
-            query += subquery
-            params.append(timestamp)
-        if end_date or before_id:
-            subquery, timestamp = self.__mam_bound(
-                muc_jid, user, end_date, before_id, min
-            )
-            query += subquery
-            params.append(timestamp)
-        if sender:
-            query += " AND sender_jid = ?"
-            params.append(sender)
-        if ids:
-            query += f" AND message_id IN ({','.join('?' * len(ids))})"
-            params.extend(ids)
-        if last_page_n:
-            # TODO: optimize query further when <flip> and last page are
-            #       combined.
-            query = f"SELECT * FROM ({query} ORDER BY sent_on DESC LIMIT ?)"
-            params.append(last_page_n)
-        query += " ORDER BY sent_on"
-        if flip:
-            query += " DESC"
-
-        res = self.__msg_cur.execute(query, params)
-
-        if ids:
-            rows = res.fetchall()
-            if len(rows) != len(ids):
-                raise XMPPError(
-                    "item-not-found",
-                    "One of the requested messages IDs could not be found "
-                    "with the given constraints.",
-                )
-            for row in rows:
-                yield row
-
-        while row := res.fetchone():
-            yield row
-
-    def mam_get_first_and_last(self, muc_jid: str) -> list[MamMetadata]:
-        res = self.__metadata_cur.execute(
-            "SELECT message_id, sent_on "
-            "FROM mam_message "
-            "JOIN muc ON muc.jid = ? "
-            "WHERE sent_on = (SELECT MIN(sent_on) FROM mam_message WHERE muc_id = muc.id) "
-            "   OR sent_on = (SELECT MAX(sent_on) FROM mam_message WHERE muc_id = muc.id) "
-            " ORDER BY sent_on",
-            (muc_jid,),
-        )
-        return res.fetchall()
-
-
-class AttachmentMixin(Base):
-    def attachment_remove(self, legacy_id):
-        self.cur.execute("DELETE FROM attachment WHERE legacy_id = ?", (legacy_id,))
-        self.con.commit()
-
-    def attachment_store_url(self, legacy_id, url: str):
-        self.cur.execute(
-            "REPLACE INTO attachment(legacy_id, url) VALUES (?,?)", (legacy_id, url)
-        )
-        self.con.commit()
-
-    def attachment_store_sims(self, url: str, sims: str):
-        self.cur.execute("UPDATE attachment SET sims = ? WHERE url = ?", (sims, url))
-        self.con.commit()
-
-    def attachment_store_sfs(self, url: str, sfs: str):
-        self.cur.execute("UPDATE attachment SET sfs = ? WHERE url = ?", (sfs, url))
-        self.con.commit()
-
-    def attachment_get_url(self, legacy_id):
-        res = self.cur.execute(
-            "SELECT url FROM attachment WHERE legacy_id = ?", (legacy_id,)
-        )
-        return first_of_tuple_or_none(res.fetchone())
-
-    def attachment_get_sims(self, url: str):
-        res = self.cur.execute("SELECT sims FROM attachment WHERE url = ?", (url,))
-        return first_of_tuple_or_none(res.fetchone())
-
-    def attachment_get_sfs(self, url: str):
-        res = self.cur.execute("SELECT sfs FROM attachment WHERE url = ?", (url,))
-        return first_of_tuple_or_none(res.fetchone())
-
-    def attachment_store_legacy_to_multi_xmpp_msg_ids(
-        self, legacy_id, xmpp_ids: list[str]
-    ):
-        with self.con:
-            res = self.cur.execute(
-                "INSERT OR IGNORE INTO attachment_legacy_msg_id(legacy_id) VALUES (?)",
-                (legacy_id,),
-            )
-            row_id = res.lastrowid
-            # for xmpp_id in xmpp_ids:
-            self.cur.executemany(
-                "INSERT INTO attachment_xmpp_ids(legacy_msg_id, xmpp_id) VALUES (?, ?)",
-                ((row_id, i) for i in xmpp_ids),
-            )
-
-    def attachment_get_xmpp_ids_for_legacy_msg_id(self, legacy_id) -> list:
-        res = self.cur.execute(
-            "SELECT xmpp_id FROM attachment_xmpp_ids "
-            "WHERE legacy_msg_id = (SELECT id FROM attachment_legacy_msg_id WHERE legacy_id = ?)",
-            (legacy_id,),
-        )
-        return [r[0] for r in res.fetchall()]
-
-    def attachment_get_associated_xmpp_ids(self, xmpp_id: str):
-        res = self.cur.execute(
-            "SELECT xmpp_id FROM attachment_xmpp_ids "
-            "WHERE legacy_msg_id = "
-            "(SELECT legacy_msg_id FROM attachment_xmpp_ids WHERE xmpp_id = ?)",
-            (xmpp_id,),
-        )
-        return [r[0] for r in res.fetchall() if r[0] != xmpp_id]
-
-    def attachment_get_legacy_id_for_xmpp_id(self, xmpp_id: str):
-        res = self.cur.execute(
-            "SELECT legacy_id FROM attachment_legacy_msg_id "
-            "WHERE id = (SELECT legacy_msg_id FROM attachment_xmpp_ids WHERE xmpp_id = ?)",
-            (xmpp_id,),
-        )
-        return first_of_tuple_or_none(res.fetchone())
-
-
-class NickMixin(Base):
-    def nick_get(self, jid: JID, user: "GatewayUser"):
-        res = self.cur.execute(
-            "SELECT nick FROM nick "
-            "WHERE jid = ? "
-            "AND user_id = (SELECT id FROM user WHERE jid = ?)",
-            (str(jid), user.bare_jid),
-        )
-        return first_of_tuple_or_none(res.fetchone())
-
-    def nick_store(self, jid: JID, nick: str, user: "GatewayUser"):
-        self.cur.execute(
-            "REPLACE INTO nick(jid, nick, user_id) "
-            "VALUES (?,?,(SELECT id FROM user WHERE jid = ?))",
-            (str(jid), nick, user.bare_jid),
-        )
-        self.con.commit()
-
-
-class AvatarMixin(Base):
-    def avatar_get(self, jid: JID):
-        res = self.cur.execute(
-            "SELECT cached_id FROM avatar WHERE jid = ?", (str(jid),)
-        )
-        return first_of_tuple_or_none(res.fetchone())
-
-    def avatar_store(self, jid: JID, cached_id: Union[int, str]):
-        self.cur.execute(
-            "REPLACE INTO avatar(jid, cached_id) VALUES (?,?)", (str(jid), cached_id)
-        )
-        self.con.commit()
-
-    def avatar_delete(self, jid: JID):
-        self.cur.execute("DELETE FROM avatar WHERE jid = ?", (str(jid),))
-        self.con.commit()
-
-
-class PresenceMixin(Base):
-    def __init__(self):
-        super().__init__()
-        self.__cur = cur = self.con.cursor()
-        cur.row_factory = self.__row_factory  # type:ignore
-
-    @staticmethod
-    def __row_factory(
-        _cur: sqlite3.Cursor,
-        row: tuple[
-            Optional[int],
-            Optional[PresenceTypes],
-            Optional[str],
-            Optional[PresenceShows],
-        ],
-    ):
-        if row[0] is not None:
-            last_seen = datetime.fromtimestamp(row[0], tz=timezone.utc)
-        else:
-            last_seen = None
-        return CachedPresence(last_seen, *row[1:])
-
-    def presence_nuke(self):
-        # useful for tests
-        self.cur.execute("DELETE FROM presence")
-        self.con.commit()
-
-    def presence_store(self, jid: JID, presence: CachedPresence, user: "GatewayUser"):
-        self.cur.execute(
-            "REPLACE INTO presence(jid, last_seen, ptype, pstatus, pshow, user_id) "
-            "VALUES (?,?,?,?,?,(SELECT id FROM user WHERE jid = ?))",
-            (
-                str(jid),
-                presence[0].timestamp() if presence[0] else None,
-                *presence[1:],
-                user.bare_jid,
-            ),
-        )
-        self.con.commit()
-
-    def presence_delete(self, jid: JID, user: "GatewayUser"):
-        self.cur.execute(
-            "DELETE FROM presence WHERE (jid = ? and user_id = (SELECT id FROM user WHERE jid = ?))",
-            (str(jid), user.bare_jid),
-        )
-        self.con.commit()
-
-    def presence_get(self, jid: JID, user: "GatewayUser") -> Optional[CachedPresence]:
-        return self.__cur.execute(
-            "SELECT last_seen, ptype, pstatus, pshow FROM presence "
-            "WHERE jid = ? AND user_id = (SELECT id FROM user WHERE jid = ?)",
-            (str(jid), user.bare_jid),
-        ).fetchone()
-
-
-class UserMixin(Base):
-    def user_store(self, user: "GatewayUser"):
-        try:
-            self.cur.execute("INSERT INTO user(jid) VALUES (?)", (user.bare_jid,))
-        except sqlite3.IntegrityError:
-            log.debug("User has already been added.")
-        else:
-            self.con.commit()
-
-    def user_del(self, user: "GatewayUser"):
-        self.cur.execute("DELETE FROM user WHERE jid = ?", (user.bare_jid,))
-        self.con.commit()
-
-
-def first_of_tuple_or_none(x: Optional[tuple]):
-    if x is None:
-        return None
-    return x[0]
-
-
-class SQLBiDict(Generic[KeyType, ValueType]):
-    def __init__(
-        self,
-        table: str,
-        key1: str,
-        key2: str,
-        user: "GatewayUser",
-        sql: Optional[Base] = None,
-        create_table=False,
-        is_inverse=False,
-    ):
-        if sql is None:
-            sql = db
-        self.db = sql
-        self.table = table
-        self.key1 = key1
-        self.key2 = key2
-        self.user = user
-        if create_table:
-            sql.cur.execute(
-                f"CREATE TABLE {table} (id "
-                "INTEGER PRIMARY KEY,"
-                "user_id INTEGER,"
-                f"{key1} UNIQUE,"
-                f"{key2} UNIQUE,"
-                f"FOREIGN KEY(user_id) REFERENCES user(id))",
-            )
-        if is_inverse:
-            return
-        self.inverse = SQLBiDict[ValueType, KeyType](
-            table, key2, key1, user, sql=sql, is_inverse=True
-        )
-
-    def __setitem__(self, key: KeyType, value: ValueType):
-        self.db.cur.execute(
-            f"REPLACE INTO {self.table}"
-            f"(user_id, {self.key1}, {self.key2}) "
-            "VALUES ((SELECT id FROM user WHERE jid = ?), ?, ?)",
-            (self.user.bare_jid, key, value),
-        )
-        self.db.con.commit()
-
-    def __getitem__(self, item: KeyType) -> ValueType:
-        v = self.get(item)
-        if v is None:
-            raise KeyError(item)
-        return v
-
-    def __contains__(self, item: KeyType) -> bool:
-        res = self.db.cur.execute(
-            f"SELECT {self.key1} FROM {self.table} "
-            f"WHERE {self.key1} = ? AND user_id = (SELECT id FROM user WHERE jid = ?)",
-            (item, self.user.bare_jid),
-        ).fetchone()
-        return res is not None
-
-    @lru_cache(100)
-    def get(self, item: KeyType) -> Optional[ValueType]:
-        res = self.db.cur.execute(
-            f"SELECT {self.key2} FROM {self.table} "
-            f"WHERE {self.key1} = ? AND user_id = (SELECT id FROM user WHERE jid = ?)",
-            (item, self.user.bare_jid),
-        ).fetchone()
-        if res is None:
-            return res
-        return res[0]
-
-
-class TemporaryDB(
-    AvatarMixin, AttachmentMixin, NickMixin, MAMMixin, UserMixin, PresenceMixin
-):
-    pass
-
-
-db = TemporaryDB()
-log = logging.getLogger(__name__)

slidge-0.1.2.dist-info/RECORD

@@ -1,96 +0,0 @@
-slidge/__init__.py,sha256=ykOurwgxvgYkuEim5t3M5zdbgyFyVs21SE20d4XkCKY,1624
-slidge/__main__.py,sha256=QCG_5nFBtMTsX_au_FYKebU3TIog0aZipNmxLYRmloI,5804
-slidge/command/__init__.py,sha256=UYf1mjCYbZ5G7PIgaFTWSQRAzEJkQ6dTH8Fu_e_XnO0,613
-slidge/command/adhoc.py,sha256=ga1i36m2Heg10h9Elb9U5dBDRT-Q5lNk4HM64nzvKoU,9188
-slidge/command/admin.py,sha256=aZCuQFfAWqOO8RgQu_EzKBg1yjOtohYz6r9Vtg9KQ0Y,5759
-slidge/command/base.py,sha256=ht0Rgq4RCx5hHthATPbbWIbX2VqfFKSUolzcHpncxk0,13073
-slidge/command/categories.py,sha256=BJCfaga2qoAxnHfgHD7I_RKZuBA5nnNOukkWHJwsUFE,99
-slidge/command/chat_command.py,sha256=kMnxrzmD7LhWgyO1w9Rgz1eA7PhfAJ2Rf34YWjoKrwQ,9975
-slidge/command/register.py,sha256=uU8_21do7_uSl6JpvjTu7RHypjIxOPkKFX9tHgZVGGc,6014
-slidge/command/user.py,sha256=2mpIfjVJt7x9AZHQq4zcOlJGk8WVahUQhh4TYiW9T2Q,8781
-slidge/contact/__init__.py,sha256=WMMaHk7UW7YT9EH2LtPdkU0bHQaOp4ikBhbBQskmoc8,191
-slidge/contact/contact.py,sha256=9umQ-fCXDHU4IgkC3kuuejqU1Bnr8GV_xfCIwXUR6PE,16101
-slidge/contact/roster.py,sha256=XhcAJEs_j7VIn88DVmPReXK2VopzIQVoH2bwoeCqk_U,7489
-slidge/core/__init__.py,sha256=RG7Jj5JCJERjhqJ31lOLYV-7bH_oblClQD1KF9LsTXo,68
-slidge/core/cache.py,sha256=Tkw8Bsor8zTN5wPIsBzxfnEk8GaOXMIauO4iBXxgv3M,5443
-slidge/core/config.py,sha256=upZsWObT14foXc5HaXlOcZPLhGL2KSeK0K-QwPDHL3I,7392
-slidge/core/gateway/__init__.py,sha256=rZckY2gAE-mon77_DSsAW1XtWqhBAETE2d4FqZ8pJXk,58
-slidge/core/gateway/base.py,sha256=SOjoEV6MME2gGDS7oZgA3RdWBlqdrZeQs5Usf80ijcY,34645
-slidge/core/gateway/caps.py,sha256=Qosd3cZ356mGzzQkdP6Y8OZ5c0l7H3Lr2wptoFrD1qU,1919
-slidge/core/gateway/delivery_receipt.py,sha256=AT_9gvZrtWpSRsDJcYjE8CmF7TW-YBbUPdqNW5zWAdo,1352
-slidge/core/gateway/disco.py,sha256=_ylFGQAzBvKSe1iB85uhBnRUXExExDrEaFa5MEM3E7Y,2230
-slidge/core/gateway/mam.py,sha256=4appZbiaFICw1kySE-y1lgNzlUzY4jbgxC0IdGv87zw,2471
-slidge/core/gateway/muc_admin.py,sha256=z2l4Zt0h-Z9WzEcA6MEiPNPrbYwggEqBVXpia5HtpLI,1033
-slidge/core/gateway/ping.py,sha256=YUmreEyEw89l0M65D_AylL5oW4xj4lvJvhwucyiKofw,1753
-slidge/core/gateway/presence.py,sha256=Ow2tWRx-tBL9mGeYRrHLboxD2CdJ32w9yor1kHZEL4U,2732
-slidge/core/gateway/registration.py,sha256=KmxDFV3N01gCs_58Re9QIxJukYP7S3_i6IbukZxzEIs,1619
-slidge/core/gateway/search.py,sha256=ZZPnZlTYFedsQAY-80ZX2el_oej6X7HfIwydYdTxl-o,3518
-slidge/core/gateway/session_dispatcher.py,sha256=YNcyVhoe-iyGfCpjoMz9py9HCkZ_Wag48rx-jnyoVOw,29193
-slidge/core/gateway/vcard_temp.py,sha256=uCSefV1D0Xx7Ex40t4uS0KHF7cbnq-xixAQQBxTtme8,4639
-slidge/core/mixins/__init__.py,sha256=iAVi4gzekXIR2xDS8ic1gSguvBbfVSScWArM4t87L-U,368
-slidge/core/mixins/attachment.py,sha256=yu7AzrRUCvKM_4AXYO1a83I4o_Sc8h3zteNRYOP2LgU,17808
-slidge/core/mixins/avatar.py,sha256=f3zSWFbj5sEo8HzV5btKsqt-clr_s1IkO5XrOjl2sWE,5493
-slidge/core/mixins/base.py,sha256=eWKV_9Io59roAt7BGRt6DKJgTxSaJEX4ptS9KneF32A,702
-slidge/core/mixins/disco.py,sha256=SKPVRVq8NUcc-zerHit7_K3Xmo1yJF1ipYN9lhHUDBU,3935
-slidge/core/mixins/lock.py,sha256=mVzwVVEoq1hrAMgGLh4K84BTLt7JTJ33B8HSGSorTdY,913
-slidge/core/mixins/message.py,sha256=yK1f6SsngJR9mQQzPwFvnscvaH3ln7pqGSv7-omWeIE,14790
-slidge/core/mixins/message_maker.py,sha256=cZy2eq87Cl019zVN_aay3Cxww9PUi1Z68QPorRcPJ2E,5606
-slidge/core/mixins/presence.py,sha256=I4jAtJd2WIHQxqPBBKLIPB4aP09vjt8yYbY-u6ojfHk,7216
-slidge/core/mixins/recipient.py,sha256=U-YppozUO8pA94jmD3-qmhkykTebPNaOVWc3JDPC9w8,1302
-slidge/core/pubsub.py,sha256=u0KvRqsOcwyc2yapzDH4eNjeqrwo8jtUYLtjYjC9W3E,18268
-slidge/core/session.py,sha256=xKyFxmi_tbp0WJNB7uJX_AENA2u1Pc0EzGr54ajmzfA,26134
-slidge/group/__init__.py,sha256=yFt7cHqeaKIMN6f9ZyhhspOcJJvBtLedGv-iICG7lto,258
-slidge/group/archive.py,sha256=5lnhUZ27RoVsYgcs-KiYiOLHZtB7VfRozLiTf0ZGNjM,3426
-slidge/group/bookmarks.py,sha256=2uX7EiMlJJhYOnTXS1oJOchF5u_hFQAlp8VT2mcPqi0,5944
-slidge/group/participant.py,sha256=CQnH3ayAO0MYVnVmeIehYU16gUByyjzwD0UlhIacq60,14908
-slidge/group/room.py,sha256=I6cysvz8rfL6mZZ2AloYufJeG4FlDkEmESLH5oG8b-0,38972
-slidge/migration.py,sha256=PPSjYMFsc9WGWWiSHWqUskpV_L9OJcrlecRf-Z0Vw_E,334
-slidge/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-slidge/slixfix/__init__.py,sha256=eYYLj3e4zJMRasjDlWxV4fe3zN0VJfwxbsc_rkOHefw,1777
-slidge/slixfix/link_preview/__init__.py,sha256=TDPTSEH5FQxgGpQpQIde-D72AHg-6YVWG-tOj4KpKmU,290
-slidge/slixfix/link_preview/link_preview.py,sha256=9PgdfnoyVMHnXS0w5OFp0wz3ku96Ck-HtRXbVUlDi1U,448
-slidge/slixfix/link_preview/stanza.py,sha256=YAXoNw2MD0a3nzvldGKlvSemjUMbUEG23regzmj4Ntc,2664
-slidge/slixfix/roster.py,sha256=PkoLroNkvmrOFuVSvxj_kiQ_gWVc45DilhmZZDMNgkQ,1545
-slidge/slixfix/xep_0077/__init__.py,sha256=0lY1YXdgAsfrfxI_Woxaf1etHCJXe35Xtntq_icF6nA,325
-slidge/slixfix/xep_0077/register.py,sha256=6nwTfHNL7Z9-1wUhpAF743TNbjQLCMP7Rflkdad8d60,10431
-slidge/slixfix/xep_0077/stanza.py,sha256=Lngly7F1ChCkNKn7yl1QmN838fO-KqkAhkazxzDsz80,2410
-slidge/slixfix/xep_0100/__init__.py,sha256=AtEXDQOrEWodkN3fgKR0W3Ezsz_Zza6cgO5ZaZS-JOo,107
-slidge/slixfix/xep_0100/gateway.py,sha256=Fhxs2sUPnVRPa1o7RXCncnbBO2gjeZx3pbItug-8OiA,4501
-slidge/slixfix/xep_0100/stanza.py,sha256=7vCzej9VFQupsTpGGl0cJWuGNH4I6oVcckBu_-fE55c,232
-slidge/slixfix/xep_0153/__init__.py,sha256=wZCTLaVsXQn_wYEHA8YXdGCsspvj2rvq92iyi16W0xA,319
-slidge/slixfix/xep_0153/stanza.py,sha256=qhVfxlJEKuYDuWnd_I_VT4TtJbpX2opN6kG8oxYrc3o,735
-slidge/slixfix/xep_0153/vcard_avatar.py,sha256=mzaReW5c1OaeL39CeGvuzIkh3j-Z5mc2joLqn5cNc5Q,658
-slidge/slixfix/xep_0264/__init__.py,sha256=c6g_y-PAwQJZ4ZLWcwXc6Q5xRPeXTvvvJH4ZKQpkj3o,109
-slidge/slixfix/xep_0264/stanza.py,sha256=YvkI9rsGztkc9yOZBjf5PNKReW8aeGdF6MnrsfDckYs,864
-slidge/slixfix/xep_0264/thumbnail.py,sha256=6ukgPCWJTFUnew4USB6hNtEk_ZcpWcFAvHr2r0T5znw,456
-slidge/slixfix/xep_0292/__init__.py,sha256=_MvS9wGra6ig3P_dPAVlCPDJkiOFvUWGjaRsHj1woUg,98
-slidge/slixfix/xep_0292/vcard4.py,sha256=V-RJy15elHraKP5oj8Rx5n-y17yJNbzI5sGwzErQvNw,3113
-slidge/slixfix/xep_0313/__init__.py,sha256=rpvXxN4Fi-ey4Ww39OEAXoiaeWs3XMqvzR64hA6j_x4,368
-slidge/slixfix/xep_0313/mam.py,sha256=2USgMGgklnGXPcw_1F3482HxIyd41TLx0uit43_RthA,9211
-slidge/slixfix/xep_0313/stanza.py,sha256=WriAx6XKiiyZTkoTw5RHcgu3ZYdkDd6hjQ0wHqDkXE0,10249
-slidge/slixfix/xep_0317/__init__.py,sha256=KRMpj3n2TYTyXzlGHdGXzNbMEvbHxn7Qd1WxqRIkrhU,104
-slidge/slixfix/xep_0317/hats.py,sha256=HAZ7y5DNehpdPVpNpgo1JxnG2GVhVSElLYdARiL9KJQ,290
-slidge/slixfix/xep_0317/stanza.py,sha256=HYSJSUHqPNHmrpJsschb__qazfb2Jm3WUxLsrmPqC4I,659
-slidge/slixfix/xep_0356_old/__init__.py,sha256=3jGWJX2m5gWgDCxcVqCsCCVPRTcfmU96yenwvAJtOKE,180
-slidge/slixfix/xep_0356_old/privilege.py,sha256=kcJzFbzhOHtQMtzOJpvvwm1pghSpealWnqhC0zc8dGo,5338
-slidge/slixfix/xep_0356_old/stanza.py,sha256=i7aqcaTg6PBhVwbHToLtlrwxBj7uO-M7VrYSyElyEKI,1229
-slidge/slixfix/xep_0424/__init__.py,sha256=ngz0GBepiJs_cocaohkDRTiaB8mvaEwXoqQBv9Av9o8,284
-slidge/slixfix/xep_0424/retraction.py,sha256=VmJQCj4umtjslnU1ydVOL6KquZnVvqgPTAyoE1KQKwE,2448
-slidge/slixfix/xep_0424/stanza.py,sha256=mT8QzRX3YcyTqTSfaaWKxyhag1s1-iQy5QW9nH6cyU8,753
-slidge/slixfix/xep_0490/__init__.py,sha256=Rhu_1h1P34LfIP_yr4JQ_PBHcuNBLDzLdJMnNmNJRrE,158
-slidge/slixfix/xep_0490/mds.py,sha256=KaITeEzSWgpGyU7RP-iwipjSyCEdVMPiVIT5vHVK-RM,1527
-slidge/slixfix/xep_0490/stanza.py,sha256=ztec_ipyhUFz_uWQYkS0Q6LlsNiSBBC5aZK-qSmhHXk,443
-slidge/util/__init__.py,sha256=BELovoTMPcPPGz3D48esBr8A4BRRHXTvavfgnArBgEc,301
-slidge/util/archive_msg.py,sha256=2gq0N8GMVN8PKB0HxkWJza5FdgCDob_WPo0yVcx7DJk,1686
-slidge/util/conf.py,sha256=1j2OnOsCBar1tOObErhXR5RC3Vl3faliOZ1U8J3My58,6613
-slidge/util/db.py,sha256=q4IZJa2JIz_QiQHf3jU2JqZxuFjyJAXFmnUYRHR-IgU,6604
-slidge/util/schema.sql,sha256=zBq4K7DbaX5cjX25JnXiEXLA9loft3mMFLJN3TGRCJE,2682
-slidge/util/sql.py,sha256=xjSldsDwgpZc20cmk6UfS4nhdc7Hbuml7kjH6IZgT0I,16517
-slidge/util/test.py,sha256=8cTrL-traDv2jfvfTDNgqewsBJH19ePQ1bf7qzp1RHQ,10688
-slidge/util/types.py,sha256=djIOI4kBBKl_2w8gm7QLtE3NDOCA832rD_GU7A3N6U4,4689
-slidge/util/util.py,sha256=t8t1nPybcitpmuSlYsOwZ8gDjfiEwTjaa4D7vtzrvQ8,8587
-slidge-0.1.2.dist-info/LICENSE,sha256=DZak_2itbUtvHzD3E7GNUYSRK6jdOJ-GqncQ2weavLA,34523
-slidge-0.1.2.dist-info/METADATA,sha256=yEVZPfmmBIGsoFz9G6XVDjn_8l4aZjC0gNxN9f0zb1U,4736
-slidge-0.1.2.dist-info/WHEEL,sha256=7Z8_27uaHI_UZAc4Uox4PpBhQ9Y5_modZXWMxtUi4NU,88
-slidge-0.1.2.dist-info/entry_points.txt,sha256=SNl72KSocF5plsu_67xyH6wVWfGTXQbzkQgXbLtzDrQ,47
-slidge-0.1.2.dist-info/RECORD,,