PyPI - slidge - Versions diffs - 0.2.0a9__py3-none-any.whl → 0.2.0b0__py3-none-any.whl - Mend

slidge 0.2.0a9py3-none-any.whl → 0.2.0b0py3-none-any.whl

Files changed (56) hide show

slidge/__main__.py +2 -3
slidge/__version__.py +1 -1
slidge/command/adhoc.py +1 -1
slidge/command/base.py +4 -4
slidge/command/user.py +5 -1
slidge/contact/roster.py +9 -0
slidge/core/config.py +0 -3
slidge/core/dispatcher/__init__.py +3 -0
slidge/core/{gateway → dispatcher}/caps.py +6 -4
slidge/core/{gateway → dispatcher}/disco.py +11 -17
slidge/core/dispatcher/message/__init__.py +10 -0
slidge/core/dispatcher/message/chat_state.py +40 -0
slidge/core/dispatcher/message/marker.py +62 -0
slidge/core/dispatcher/message/message.py +397 -0
slidge/core/dispatcher/muc/__init__.py +12 -0
slidge/core/dispatcher/muc/admin.py +98 -0
slidge/core/{gateway → dispatcher/muc}/mam.py +26 -15
slidge/core/dispatcher/muc/misc.py +121 -0
slidge/core/dispatcher/muc/owner.py +96 -0
slidge/core/{gateway → dispatcher/muc}/ping.py +10 -15
slidge/core/dispatcher/presence.py +177 -0
slidge/core/{gateway → dispatcher}/registration.py +23 -2
slidge/core/{gateway → dispatcher}/search.py +9 -14
slidge/core/dispatcher/session_dispatcher.py +84 -0
slidge/core/dispatcher/util.py +174 -0
slidge/core/{gateway/vcard_temp.py → dispatcher/vcard.py} +26 -12
slidge/core/{gateway/base.py → gateway.py} +42 -137
slidge/core/mixins/attachment.py +24 -8
slidge/core/mixins/base.py +2 -2
slidge/core/mixins/lock.py +10 -8
slidge/core/mixins/message.py +9 -203
slidge/core/mixins/message_text.py +211 -0
slidge/core/pubsub.py +2 -1
slidge/core/session.py +28 -2
slidge/db/alembic/versions/15b0bd83407a_remove_bogus_unique_constraints_on_room_.py +83 -0
slidge/db/alembic/versions/45c24cc73c91_add_bob.py +42 -0
slidge/db/alembic/versions/5bd48bfdffa2_lift_room_legacy_id_constraint.py +12 -1
slidge/db/models.py +16 -1
slidge/db/store.py +144 -11
slidge/group/bookmarks.py +23 -1
slidge/group/participant.py +5 -5
slidge/group/room.py +10 -1
slidge/{core/gateway → slixfix}/delivery_receipt.py +1 -1
slidge/util/test.py +9 -5
slidge/util/types.py +6 -0
slidge/util/util.py +5 -2
{slidge-0.2.0a9.dist-info → slidge-0.2.0b0.dist-info}/METADATA +2 -1
{slidge-0.2.0a9.dist-info → slidge-0.2.0b0.dist-info}/RECORD +51 -40
slidge-0.2.0b0.dist-info/entry_points.txt +3 -0
slidge/core/gateway/__init__.py +0 -3
slidge/core/gateway/muc_admin.py +0 -35
slidge/core/gateway/presence.py +0 -95
slidge/core/gateway/session_dispatcher.py +0 -895
slidge-0.2.0a9.dist-info/entry_points.txt +0 -3
{slidge-0.2.0a9.dist-info → slidge-0.2.0b0.dist-info}/LICENSE +0 -0
{slidge-0.2.0a9.dist-info → slidge-0.2.0b0.dist-info}/WHEEL +0 -0

slidge/core/dispatcher/message/message.py ADDED Viewed

@@ -0,0 +1,397 @@
+import logging
+from copy import copy
+from xml.etree import ElementTree
+from slixmpp import JID, Message
+from slixmpp.exceptions import XMPPError
+from ....contact.contact import LegacyContact
+from ....group.participant import LegacyParticipant
+from ....group.room import LegacyMUC
+from ....util.types import LinkPreview, Recipient
+from ....util.util import dict_to_named_tuple, remove_emoji_variation_selector_16
+from ... import config
+from ...session import BaseSession
+from ..util import DispatcherMixin, exceptions_to_xmpp_errors
+class MessageContentMixin(DispatcherMixin):
+    def __init__(self, xmpp):
+        super().__init__(xmpp)
+        xmpp.add_event_handler("legacy_message", self.on_legacy_message)
+        xmpp.add_event_handler("message_correction", self.on_message_correction)
+        xmpp.add_event_handler("message_retract", self.on_message_retract)
+        xmpp.add_event_handler("groupchat_message", self.on_groupchat_message)
+        xmpp.add_event_handler("reactions", self.on_reactions)
+    async def on_groupchat_message(self, msg: Message) -> None:
+        await self.on_legacy_message(msg)
+    @exceptions_to_xmpp_errors
+    async def on_legacy_message(self, msg: Message):
+        """
+        Meant to be called from :class:`BaseGateway` only.
+        :param msg:
+        :return:
+        """
+        # we MUST not use `if m["replace"]["id"]` because it adds the tag if not
+        # present. this is a problem for MUC echoed messages
+        if msg.get_plugin("replace", check=True) is not None:
+            # ignore last message correction (handled by a specific method)
+            return
+        if msg.get_plugin("apply_to", check=True) is not None:
+            # ignore message retraction (handled by a specific method)
+            return
+        if msg.get_plugin("reactions", check=True) is not None:
+            # ignore message reaction fallback.
+            # the reaction itself is handled by self.react_from_msg().
+            return
+        if msg.get_plugin("retract", check=True) is not None:
+            # ignore message retraction fallback.
+            # the retraction itself is handled by self.on_retract
+            return
+        cid = None
+        if msg.get_plugin("html", check=True) is not None:
+            body = ElementTree.fromstring("<body>" + msg["html"].get_body() + "</body>")
+            p = body.findall("p")
+            if p is not None and len(p) == 1:
+                if p[0].text is None or not p[0].text.strip():
+                    images = p[0].findall("img")
+                    if len(images) == 1:
+                        # no text, single img ⇒ this is a sticker
+                        # other cases should be interpreted as "custom emojis" in text
+                        src = images[0].get("src")
+                        if src is not None and src.startswith("cid:"):
+                            cid = src.removeprefix("cid:")
+        session, entity, thread = await self._get_session_entity_thread(msg)
+        if msg.get_plugin("oob", check=True) is not None:
+            url = msg["oob"]["url"]
+        else:
+            url = None
+        if msg.get_plugin("reply", check=True):
+            text, reply_to_msg_id, reply_to, reply_fallback = await self.__get_reply(
+                msg, session, entity
+            )
+        else:
+            text = msg["body"]
+            reply_to_msg_id = None
+            reply_to = None
+            reply_fallback = None
+        if msg.get_plugin("link_previews", check=True):
+            link_previews = [
+                dict_to_named_tuple(p, LinkPreview) for p in msg["link_previews"]
+            ]
+        else:
+            link_previews = []
+        if url:
+            legacy_msg_id = await self.__send_url(
+                url,
+                session,
+                entity,
+                reply_to_msg_id=reply_to_msg_id,
+                reply_to_fallback_text=reply_fallback,
+                reply_to=reply_to,
+                thread=thread,
+            )
+        elif cid:
+            legacy_msg_id = await self.__send_bob(
+                msg.get_from(),
+                cid,
+                session,
+                entity,
+                reply_to_msg_id=reply_to_msg_id,
+                reply_to_fallback_text=reply_fallback,
+                reply_to=reply_to,
+                thread=thread,
+            )
+        elif text:
+            if isinstance(entity, LegacyMUC):
+                mentions = {"mentions": await entity.parse_mentions(text)}
+            else:
+                mentions = {}
+            legacy_msg_id = await session.on_text(
+                entity,
+                text,
+                reply_to_msg_id=reply_to_msg_id,
+                reply_to_fallback_text=reply_fallback,
+                reply_to=reply_to,
+                thread=thread,
+                link_previews=link_previews,
+                **mentions,
+            )
+        else:
+            log.debug("Ignoring %s", msg.get_id())
+            return
+        if isinstance(entity, LegacyMUC):
+            await entity.echo(msg, legacy_msg_id)
+            if legacy_msg_id is not None:
+                self.xmpp.store.sent.set_group_message(
+                    session.user_pk, str(legacy_msg_id), msg.get_id()
+                )
+        else:
+            self.__ack(msg)
+            if legacy_msg_id is not None:
+                self.xmpp.store.sent.set_message(
+                    session.user_pk, str(legacy_msg_id), msg.get_id()
+                )
+                if session.MESSAGE_IDS_ARE_THREAD_IDS and (t := msg["thread"]):
+                    self.xmpp.store.sent.set_thread(
+                        session.user_pk, t, str(legacy_msg_id)
+                    )
+    @exceptions_to_xmpp_errors
+    async def on_message_correction(self, msg: Message):
+        if msg.get_plugin("retract", check=True) is not None:
+            # ignore message retraction fallback (fallback=last msg correction)
+            return
+        session, entity, thread = await self._get_session_entity_thread(msg)
+        xmpp_id = msg["replace"]["id"]
+        if isinstance(entity, LegacyMUC):
+            legacy_id_str = self.xmpp.store.sent.get_group_legacy_id(
+                session.user_pk, xmpp_id
+            )
+            if legacy_id_str is None:
+                legacy_id = self._xmpp_msg_id_to_legacy(session, xmpp_id)
+            else:
+                legacy_id = self.xmpp.LEGACY_MSG_ID_TYPE(legacy_id_str)
+        else:
+            legacy_id = self._xmpp_msg_id_to_legacy(session, xmpp_id)
+        if isinstance(entity, LegacyMUC):
+            mentions = await entity.parse_mentions(msg["body"])
+        else:
+            mentions = None
+        if previews := msg["link_previews"]:
+            link_previews = [dict_to_named_tuple(p, LinkPreview) for p in previews]
+        else:
+            link_previews = []
+        if legacy_id is None:
+            log.debug("Did not find legacy ID to correct")
+            new_legacy_msg_id = await session.on_text(
+                entity,
+                "Correction:" + msg["body"],
+                thread=thread,
+                mentions=mentions,
+                link_previews=link_previews,
+            )
+        elif (
+            not msg["body"].strip()
+            and config.CORRECTION_EMPTY_BODY_AS_RETRACTION
+            and entity.RETRACTION
+        ):
+            await session.on_retract(entity, legacy_id, thread=thread)
+            new_legacy_msg_id = None
+        elif entity.CORRECTION:
+            new_legacy_msg_id = await session.on_correct(
+                entity,
+                msg["body"],
+                legacy_id,
+                thread=thread,
+                mentions=mentions,
+                link_previews=link_previews,
+            )
+        else:
+            session.send_gateway_message(
+                "Last message correction is not supported by this legacy service. "
+                "Slidge will send your correction as new message."
+            )
+            if (
+                config.LAST_MESSAGE_CORRECTION_RETRACTION_WORKAROUND
+                and entity.RETRACTION
+                and legacy_id is not None
+            ):
+                if legacy_id is not None:
+                    session.send_gateway_message(
+                        "Slidge will attempt to retract the original message you wanted"
+                        " to edit."
+                    )
+                    await session.on_retract(entity, legacy_id, thread=thread)
+            new_legacy_msg_id = await session.on_text(
+                entity,
+                "Correction: " + msg["body"],
+                thread=thread,
+                mentions=mentions,
+                link_previews=link_previews,
+            )
+        if isinstance(entity, LegacyMUC):
+            if new_legacy_msg_id is not None:
+                self.xmpp.store.sent.set_group_message(
+                    session.user_pk, new_legacy_msg_id, msg.get_id()
+                )
+            await entity.echo(msg, new_legacy_msg_id)
+        else:
+            self.__ack(msg)
+            if new_legacy_msg_id is not None:
+                self.xmpp.store.sent.set_message(
+                    session.user_pk, new_legacy_msg_id, msg.get_id()
+                )
+    @exceptions_to_xmpp_errors
+    async def on_message_retract(self, msg: Message):
+        session, entity, thread = await self._get_session_entity_thread(msg)
+        if not entity.RETRACTION:
+            raise XMPPError(
+                "bad-request",
+                "This legacy service does not support message retraction.",
+            )
+        xmpp_id: str = msg["retract"]["id"]
+        legacy_id = self._xmpp_msg_id_to_legacy(session, xmpp_id)
+        if legacy_id:
+            await session.on_retract(entity, legacy_id, thread=thread)
+            if isinstance(entity, LegacyMUC):
+                await entity.echo(msg, None)
+        else:
+            log.debug("Ignored retraction from user")
+        self.__ack(msg)
+    @exceptions_to_xmpp_errors
+    async def on_reactions(self, msg: Message):
+        session, entity, thread = await self._get_session_entity_thread(msg)
+        react_to: str = msg["reactions"]["id"]
+        special_msg = session.SPECIAL_MSG_ID_PREFIX and react_to.startswith(
+            session.SPECIAL_MSG_ID_PREFIX
+        )
+        if special_msg:
+            legacy_id = react_to
+        else:
+            legacy_id = self._xmpp_msg_id_to_legacy(session, react_to)
+        if not legacy_id:
+            log.debug("Ignored reaction from user")
+            raise XMPPError(
+                "internal-server-error",
+                "Could not convert the XMPP msg ID to a legacy ID",
+            )
+        emojis = [
+            remove_emoji_variation_selector_16(r["value"]) for r in msg["reactions"]
+        ]
+        error_msg = None
+        entity = entity
+        if not special_msg:
+            if entity.REACTIONS_SINGLE_EMOJI and len(emojis) > 1:
+                error_msg = "Maximum 1 emoji/message"
+            if not error_msg and (subset := await entity.available_emojis(legacy_id)):
+                if not set(emojis).issubset(subset):
+                    error_msg = f"You can only react with the following emojis: {''.join(subset)}"
+        if error_msg:
+            session.send_gateway_message(error_msg)
+            if not isinstance(entity, LegacyMUC):
+                # no need to carbon for groups, we just don't echo the stanza
+                entity.react(legacy_id, carbon=True)  # type: ignore
+            await session.on_react(entity, legacy_id, [], thread=thread)
+            raise XMPPError("not-acceptable", text=error_msg)
+        await session.on_react(entity, legacy_id, emojis, thread=thread)
+        if isinstance(entity, LegacyMUC):
+            await entity.echo(msg, None)
+        else:
+            self.__ack(msg)
+        multi = self.xmpp.store.multi.get_xmpp_ids(session.user_pk, react_to)
+        if not multi:
+            return
+        multi = [m for m in multi if react_to != m]
+        if isinstance(entity, LegacyMUC):
+            for xmpp_id in multi:
+                mc = copy(msg)
+                mc["reactions"]["id"] = xmpp_id
+                await entity.echo(mc)
+        elif isinstance(entity, LegacyContact):
+            for xmpp_id in multi:
+                entity.react(legacy_id, emojis, xmpp_id=xmpp_id, carbon=True)
+    def __ack(self, msg: Message):
+        if not self.xmpp.PROPER_RECEIPTS:
+            self.xmpp.delivery_receipt.ack(msg)
+    async def __get_reply(
+        self, msg: Message, session: BaseSession, entity: Recipient
+    ) -> tuple[
+        str, str | int | None, LegacyContact | LegacyParticipant | None, str | None
+    ]:
+        try:
+            reply_to_msg_id = self._xmpp_msg_id_to_legacy(session, msg["reply"]["id"])
+        except XMPPError:
+            session.log.debug(
+                "Could not determine reply-to legacy msg ID, sending quote instead."
+            )
+            return msg["body"], None, None, None
+        reply_to_jid = JID(msg["reply"]["to"])
+        reply_to = None
+        if msg["type"] == "chat":
+            if reply_to_jid.bare != session.user_jid.bare:
+                try:
+                    reply_to = await session.contacts.by_jid(reply_to_jid)
+                except XMPPError:
+                    pass
+        elif msg["type"] == "groupchat":
+            nick = reply_to_jid.resource
+            try:
+                muc = await session.bookmarks.by_jid(reply_to_jid)
+            except XMPPError:
+                pass
+            else:
+                if nick != muc.user_nick:
+                    reply_to = await muc.get_participant(
+                        reply_to_jid.resource, store=False
+                    )
+        if msg.get_plugin("fallback", check=True) and (
+            isinstance(entity, LegacyMUC) or entity.REPLIES
+        ):
+            text = msg["fallback"].get_stripped_body(self.xmpp["xep_0461"].namespace)
+            try:
+                reply_fallback = msg["reply"].get_fallback_body()
+            except AttributeError:
+                reply_fallback = None
+        else:
+            text = msg["body"]
+            reply_fallback = None
+        return text, reply_to_msg_id, reply_to, reply_fallback
+    async def __send_url(
+        self, url: str, session: BaseSession, entity: Recipient, **kwargs
+    ) -> int | str | None:
+        async with self.xmpp.http.get(url) as response:
+            if response.status >= 400:
+                session.log.warning(
+                    "OOB url cannot be downloaded: %s, sending the URL as text"
+                    " instead.",
+                    response,
+                )
+                return await session.on_text(entity, url, **kwargs)
+            return await session.on_file(entity, url, http_response=response, **kwargs)
+    async def __send_bob(
+        self, from_: JID, cid: str, session: BaseSession, entity: Recipient, **kwargs
+    ) -> int | str | None:
+        sticker = self.xmpp.store.bob.get_sticker(cid)
+        if sticker is None:
+            await self.xmpp.plugin["xep_0231"].get_bob(from_, cid)
+            sticker = self.xmpp.store.bob.get_sticker(cid)
+        assert sticker is not None
+        return await session.on_sticker(entity, sticker, **kwargs)
+log = logging.getLogger(__name__)

slidge/core/dispatcher/muc/__init__.py ADDED Viewed

@@ -0,0 +1,12 @@
+from .admin import MucAdminMixin
+from .mam import MamMixin
+from .misc import MucMiscMixin
+from .owner import MucOwnerMixin
+from .ping import PingMixin
+class MucMixin(PingMixin, MamMixin, MucAdminMixin, MucOwnerMixin, MucMiscMixin):
+    pass
+__all__ = ("MucMixin",)

slidge/core/dispatcher/muc/admin.py ADDED Viewed

@@ -0,0 +1,98 @@
+from slixmpp import JID, CoroutineCallback, Iq, StanzaPath
+from slixmpp.exceptions import XMPPError
+from slixmpp.xmlstream import StanzaBase
+from ..util import DispatcherMixin, exceptions_to_xmpp_errors
+class MucAdminMixin(DispatcherMixin):
+    def __init__(self, xmpp) -> None:
+        super().__init__(xmpp)
+        self.xmpp.register_handler(
+            CoroutineCallback(
+                "MUCModerate",
+                StanzaPath("iq/apply_to/moderate"),
+                self.on_user_moderation,
+            )
+        )
+        self.xmpp.register_handler(
+            CoroutineCallback(
+                "MUCSetAffiliation",
+                StanzaPath("iq@type=set/mucadmin_query"),
+                self.on_user_set_affiliation,
+            )
+        )
+        self.xmpp.register_handler(
+            CoroutineCallback(
+                "MUCGetAffiliation",
+                StanzaPath("iq@type=get/mucadmin_query"),
+                self.on_muc_admin_query_get,
+            )
+        )
+    @exceptions_to_xmpp_errors
+    async def on_user_moderation(self, iq: StanzaBase) -> None:
+        assert isinstance(iq, Iq)
+        muc = await self.get_muc_from_stanza(iq)
+        apply_to = iq["apply_to"]
+        xmpp_id = apply_to["id"]
+        if not xmpp_id:
+            raise XMPPError("bad-request", "Missing moderated message ID")
+        moderate = apply_to["moderate"]
+        if not moderate["retract"]:
+            raise XMPPError(
+                "feature-not-implemented",
+                "Slidge only implements moderation/retraction",
+            )
+        legacy_id = self._xmpp_msg_id_to_legacy(muc.session, xmpp_id)
+        await muc.session.on_moderate(muc, legacy_id, moderate["reason"] or None)
+        iq.reply(clear=True).send()
+    @exceptions_to_xmpp_errors
+    async def on_user_set_affiliation(self, iq: StanzaBase) -> None:
+        assert isinstance(iq, Iq)
+        muc = await self.get_muc_from_stanza(iq)
+        item = iq["mucadmin_query"]["item"]
+        if item["jid"]:
+            contact = await muc.session.contacts.by_jid(JID(item["jid"]))
+        else:
+            part = await muc.get_participant(
+                item["nick"], fill_first=True, raise_if_not_found=True
+            )
+            assert part.contact is not None
+            contact = part.contact
+        if item["affiliation"]:
+            await muc.on_set_affiliation(
+                contact,
+                item["affiliation"],
+                item["reason"] or None,
+                item["nick"] or None,
+            )
+        elif item["role"] == "none":
+            await muc.on_kick(contact, item["reason"] or None)
+        iq.reply(clear=True).send()
+    @exceptions_to_xmpp_errors
+    async def on_muc_admin_query_get(self, iq: StanzaBase) -> None:
+        assert isinstance(iq, Iq)
+        affiliation = iq["mucadmin_query"]["item"]["affiliation"]
+        if not affiliation:
+            raise XMPPError("bad-request")
+        session = await self._get_session(iq, 1, logged=True)
+        muc = await session.bookmarks.by_jid(iq.get_to())
+        reply = iq.reply()
+        reply.enable("mucadmin_query")
+        async for participant in muc.get_participants():
+            if not participant.affiliation == affiliation:
+                continue
+            reply["mucadmin_query"].append(participant.mucadmin_item())
+        reply.send()

slidge/core/{gateway → dispatcher/muc}/mam.py RENAMED Viewed

@@ -1,42 +1,57 @@
+import asyncio
 from typing import TYPE_CHECKING
 from slixmpp import CoroutineCallback, Iq, StanzaPath
 from slixmpp.exceptions import XMPPError
+from slixmpp.xmlstream import StanzaBase
+from ... import config
+from ..util import DispatcherMixin, exceptions_to_xmpp_errors
 if TYPE_CHECKING:
-    from .base import BaseGateway
+    from slidge.core.gateway import BaseGateway
-class Mam:
+class MamMixin(DispatcherMixin):
     def __init__(self, xmpp: "BaseGateway"):
-        self.xmpp = xmpp
+        super().__init__(xmpp)
+        self.__mam_cleanup_task = xmpp.loop.create_task(self.__mam_cleanup())
         xmpp.register_handler(
             CoroutineCallback(
                 "MAM_query",
                 StanzaPath("iq@type=set/mam"),
-                self.__handle_mam,  # type:ignore
+                self.__handle_mam,
             )
         )
         xmpp.register_handler(
             CoroutineCallback(
                 "MAM_get_from",
                 StanzaPath("iq@type=get/mam"),
-                self.__handle_mam_get_form,  # type:ignore
+                self.__handle_mam_get_form,
             )
         )
         xmpp.register_handler(
             CoroutineCallback(
                 "MAM_get_meta",
                 StanzaPath("iq@type=get/mam_metadata"),
-                self.__handle_mam_metadata,  # type:ignore
+                self.__handle_mam_metadata,
             )
         )
+    async def __mam_cleanup(self):
+        if not config.MAM_MAX_DAYS:
+            return
+        while True:
+            await asyncio.sleep(3600 * 6)
+            self.xmpp.store.mam.nuke_older_than(config.MAM_MAX_DAYS)
+    @exceptions_to_xmpp_errors
     async def __handle_mam(self, iq: Iq):
-        muc = await self.xmpp.get_muc_from_stanza(iq)
+        muc = await self.get_muc_from_stanza(iq)
         await muc.send_mam(iq)
-    async def __handle_mam_get_form(self, iq: Iq):
+    async def __handle_mam_get_form(self, iq: StanzaBase):
+        assert isinstance(iq, Iq)
         ito = iq.get_to()
         if ito == self.xmpp.boundjid.bare:
@@ -44,12 +59,7 @@ class Mam:
                 text="No MAM on the component itself, use a JID with a resource"
             )
-        user = self.xmpp.store.users.get(iq.get_from())
-        if user is None:
-            raise XMPPError("registration-required")
-        session = self.xmpp.get_session_from_user(user)
+        session = await self._get_session(iq, 0, logged=True)
         await session.bookmarks.by_jid(ito)
         reply = iq.reply()
@@ -67,6 +77,7 @@ class Mam:
         reply["mam"].append(form)
         reply.send()
+    @exceptions_to_xmpp_errors
     async def __handle_mam_metadata(self, iq: Iq):
-        muc = await self.xmpp.get_muc_from_stanza(iq)
+        muc = await self.get_muc_from_stanza(iq)
         await muc.send_mam_metadata(iq)

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

slidge 0.2.0a9py3-none-any.whl → 0.2.0b0py3-none-any.whl