disagreement 0.1.0rc3__py3-none-any.whl → 0.3.0b1__py3-none-any.whl

disagreement/voice_client.py

@@ -1,162 +1,244 @@
-# disagreement/voice_client.py
-"""Voice gateway and UDP audio client."""
-
-from __future__ import annotations
-
-import asyncio
-import contextlib
-import socket
-from typing import Optional, Sequence
-
-import aiohttp
-
-from .audio import AudioSource, FFmpegAudioSource
-
-
-class VoiceClient:
-    """Handles the Discord voice WebSocket connection and UDP streaming."""
-
-    def __init__(
-        self,
-        endpoint: str,
-        session_id: str,
-        token: str,
-        guild_id: int,
-        user_id: int,
-        *,
-        ws=None,
-        udp: Optional[socket.socket] = None,
-        loop: Optional[asyncio.AbstractEventLoop] = None,
-        verbose: bool = False,
-    ) -> None:
-        self.endpoint = endpoint
-        self.session_id = session_id
-        self.token = token
-        self.guild_id = str(guild_id)
-        self.user_id = str(user_id)
-        self._ws: Optional[aiohttp.ClientWebSocketResponse] = ws
-        self._udp = udp
-        self._session: Optional[aiohttp.ClientSession] = None
-        self._heartbeat_task: Optional[asyncio.Task] = None
-        self._heartbeat_interval: Optional[float] = None
-        self._loop = loop or asyncio.get_event_loop()
-        self.verbose = verbose
-        self.ssrc: Optional[int] = None
-        self.secret_key: Optional[Sequence[int]] = None
-        self._server_ip: Optional[str] = None
-        self._server_port: Optional[int] = None
-        self._current_source: Optional[AudioSource] = None
-        self._play_task: Optional[asyncio.Task] = None
-
-    async def connect(self) -> None:
-        if self._ws is None:
-            self._session = aiohttp.ClientSession()
-            self._ws = await self._session.ws_connect(self.endpoint)
-
-        hello = await self._ws.receive_json()
-        self._heartbeat_interval = hello["d"]["heartbeat_interval"] / 1000
-        self._heartbeat_task = self._loop.create_task(self._heartbeat())
-
-        await self._ws.send_json(
-            {
-                "op": 0,
-                "d": {
-                    "server_id": self.guild_id,
-                    "user_id": self.user_id,
-                    "session_id": self.session_id,
-                    "token": self.token,
-                },
-            }
-        )
-
-        ready = await self._ws.receive_json()
-        data = ready["d"]
-        self.ssrc = data["ssrc"]
-        self._server_ip = data["ip"]
-        self._server_port = data["port"]
-
-        if self._udp is None:
-            self._udp = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
-        self._udp.connect((self._server_ip, self._server_port))
-
-        await self._ws.send_json(
-            {
-                "op": 1,
-                "d": {
-                    "protocol": "udp",
-                    "data": {
-                        "address": self._udp.getsockname()[0],
-                        "port": self._udp.getsockname()[1],
-                        "mode": "xsalsa20_poly1305",
-                    },
-                },
-            }
-        )
-
-        session_desc = await self._ws.receive_json()
-        self.secret_key = session_desc["d"].get("secret_key")
-
-    async def _heartbeat(self) -> None:
-        assert self._ws is not None
-        assert self._heartbeat_interval is not None
-        try:
-            while True:
-                await self._ws.send_json({"op": 3, "d": int(self._loop.time() * 1000)})
-                await asyncio.sleep(self._heartbeat_interval)
-        except asyncio.CancelledError:
-            pass
-
-    async def send_audio_frame(self, frame: bytes) -> None:
-        if not self._udp:
-            raise RuntimeError("UDP socket not initialised")
-        self._udp.send(frame)
-
-    async def _play_loop(self) -> None:
-        assert self._current_source is not None
-        try:
-            while True:
-                data = await self._current_source.read()
-                if not data:
-                    break
-                await self.send_audio_frame(data)
-        finally:
-            await self._current_source.close()
-            self._current_source = None
-            self._play_task = None
-
-    async def stop(self) -> None:
-        if self._play_task:
-            self._play_task.cancel()
-            with contextlib.suppress(asyncio.CancelledError):
-                await self._play_task
-            self._play_task = None
-        if self._current_source:
-            await self._current_source.close()
-            self._current_source = None
-
-    async def play(self, source: AudioSource, *, wait: bool = True) -> None:
-        """|coro| Play an :class:`AudioSource` on the voice connection."""
-
-        await self.stop()
-        self._current_source = source
-        self._play_task = self._loop.create_task(self._play_loop())
-        if wait:
-            await self._play_task
-
-    async def play_file(self, filename: str, *, wait: bool = True) -> None:
-        """|coro| Stream an audio file or URL using FFmpeg."""
-
-        await self.play(FFmpegAudioSource(filename), wait=wait)
-
-    async def close(self) -> None:
-        await self.stop()
-        if self._heartbeat_task:
-            self._heartbeat_task.cancel()
-            with contextlib.suppress(asyncio.CancelledError):
-                await self._heartbeat_task
-        if self._ws:
-            await self._ws.close()
-        if self._session:
-            await self._session.close()
-        if self._udp:
-            self._udp.close()
+# disagreement/voice_client.py
+"""Voice gateway and UDP audio client."""
+
+from __future__ import annotations
+
+import asyncio
+import contextlib
+import socket
+import threading
+from typing import TYPE_CHECKING, Optional, Sequence
+
+import aiohttp
+# The following import is correct, but may be flagged by Pylance if the virtual
+# environment is not configured correctly.
+from nacl.secret import SecretBox
+
+from .audio import AudioSink, AudioSource, FFmpegAudioSource
+from .models import User
+
+if TYPE_CHECKING:
+    from .client import Client
+
+
+class VoiceClient:
+    """Handles the Discord voice WebSocket connection and UDP streaming."""
+
+    def __init__(
+        self,
+        client: Client,
+        endpoint: str,
+        session_id: str,
+        token: str,
+        guild_id: int,
+        user_id: int,
+        *,
+        ws=None,
+        udp: Optional[socket.socket] = None,
+        loop: Optional[asyncio.AbstractEventLoop] = None,
+        verbose: bool = False,
+    ) -> None:
+        self.client = client
+        self.endpoint = endpoint
+        self.session_id = session_id
+        self.token = token
+        self.guild_id = str(guild_id)
+        self.user_id = str(user_id)
+        self._ws: Optional[aiohttp.ClientWebSocketResponse] = ws
+        self._udp = udp
+        self._session: Optional[aiohttp.ClientSession] = None
+        self._heartbeat_task: Optional[asyncio.Task] = None
+        self._receive_task: Optional[asyncio.Task] = None
+        self._udp_receive_thread: Optional[threading.Thread] = None
+        self._heartbeat_interval: Optional[float] = None
+        try:
+            self._loop = loop or asyncio.get_running_loop()
+        except RuntimeError:
+            self._loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(self._loop)
+        self.verbose = verbose
+        self.ssrc: Optional[int] = None
+        self.secret_key: Optional[Sequence[int]] = None
+        self._server_ip: Optional[str] = None
+        self._server_port: Optional[int] = None
+        self._current_source: Optional[AudioSource] = None
+        self._play_task: Optional[asyncio.Task] = None
+        self._sink: Optional[AudioSink] = None
+        self._ssrc_map: dict[int, int] = {}
+        self._ssrc_lock = threading.Lock()
+
+    async def connect(self) -> None:
+        if self._ws is None:
+            self._session = aiohttp.ClientSession()
+            self._ws = await self._session.ws_connect(self.endpoint)
+
+        hello = await self._ws.receive_json()
+        self._heartbeat_interval = hello["d"]["heartbeat_interval"] / 1000
+        self._heartbeat_task = self._loop.create_task(self._heartbeat())
+
+        await self._ws.send_json(
+            {
+                "op": 0,
+                "d": {
+                    "server_id": self.guild_id,
+                    "user_id": self.user_id,
+                    "session_id": self.session_id,
+                    "token": self.token,
+                },
+            }
+        )
+
+        ready = await self._ws.receive_json()
+        data = ready["d"]
+        self.ssrc = data["ssrc"]
+        self._server_ip = data["ip"]
+        self._server_port = data["port"]
+
+        if self._udp is None:
+            self._udp = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        self._udp.connect((self._server_ip, self._server_port))
+
+        await self._ws.send_json(
+            {
+                "op": 1,
+                "d": {
+                    "protocol": "udp",
+                    "data": {
+                        "address": self._udp.getsockname()[0],
+                        "port": self._udp.getsockname()[1],
+                        "mode": "xsalsa20_poly1305",
+                    },
+                },
+            }
+        )
+
+        session_desc = await self._ws.receive_json()
+        self.secret_key = session_desc["d"].get("secret_key")
+
+    async def _heartbeat(self) -> None:
+        assert self._ws is not None
+        assert self._heartbeat_interval is not None
+        try:
+            while True:
+                await self._ws.send_json({"op": 3, "d": int(self._loop.time() * 1000)})
+                await asyncio.sleep(self._heartbeat_interval)
+        except asyncio.CancelledError:
+            pass
+
+    async def _receive_loop(self) -> None:
+        assert self._ws is not None
+        while True:
+            try:
+                msg = await self._ws.receive_json()
+                op = msg.get("op")
+                data = msg.get("d")
+                if op == 5:  # Speaking
+                    user_id = int(data["user_id"])
+                    ssrc = data["ssrc"]
+                    with self._ssrc_lock:
+                        self._ssrc_map[ssrc] = user_id
+            except (asyncio.CancelledError, aiohttp.ClientError):
+                break
+
+    def _udp_receive_loop(self) -> None:
+        assert self._udp is not None
+        assert self.secret_key is not None
+        box = SecretBox(bytes(self.secret_key))
+        while True:
+            try:
+                packet = self._udp.recv(4096)
+                if len(packet) < 12:
+                    continue
+
+                ssrc = int.from_bytes(packet[8:12], "big")
+                with self._ssrc_lock:
+                    if ssrc not in self._ssrc_map:
+                        continue
+                    user_id = self._ssrc_map[ssrc]
+                user = self.client._users.get(str(user_id))
+                if not user:
+                    continue
+
+                decrypted = box.decrypt(packet[12:])
+                if self._sink:
+                    self._sink.write(user, decrypted)
+            except (socket.error, asyncio.CancelledError):
+                break
+            except Exception as e:
+                if self.verbose:
+                    print(f"Error in UDP receive loop: {e}")
+
+    async def send_audio_frame(self, frame: bytes) -> None:
+        if not self._udp:
+            raise RuntimeError("UDP socket not initialised")
+        self._udp.send(frame)
+
+    async def _play_loop(self) -> None:
+        assert self._current_source is not None
+        try:
+            while True:
+                data = await self._current_source.read()
+                if not data:
+                    break
+                await self.send_audio_frame(data)
+        finally:
+            await self._current_source.close()
+            self._current_source = None
+            self._play_task = None
+
+    async def stop(self) -> None:
+        if self._play_task:
+            self._play_task.cancel()
+            with contextlib.suppress(asyncio.CancelledError):
+                await self._play_task
+            self._play_task = None
+        if self._current_source:
+            await self._current_source.close()
+            self._current_source = None
+
+    async def play(self, source: AudioSource, *, wait: bool = True) -> None:
+        """|coro| Play an :class:`AudioSource` on the voice connection."""
+
+        await self.stop()
+        self._current_source = source
+        self._play_task = self._loop.create_task(self._play_loop())
+        if wait:
+            await self._play_task
+
+    async def play_file(self, filename: str, *, wait: bool = True) -> None:
+        """|coro| Stream an audio file or URL using FFmpeg."""
+
+        await self.play(FFmpegAudioSource(filename), wait=wait)
+
+    def listen(self, sink: AudioSink) -> None:
+        """Start listening to voice and routing to a sink."""
+        if not isinstance(sink, AudioSink):
+            raise TypeError("sink must be an AudioSink instance")
+
+        self._sink = sink
+        if not self._udp_receive_thread:
+            self._udp_receive_thread = threading.Thread(
+                target=self._udp_receive_loop, daemon=True
+            )
+            self._udp_receive_thread.start()
+
+    async def close(self) -> None:
+        await self.stop()
+        if self._heartbeat_task:
+            self._heartbeat_task.cancel()
+            with contextlib.suppress(asyncio.CancelledError):
+                await self._heartbeat_task
+        if self._receive_task:
+            self._receive_task.cancel()
+            with contextlib.suppress(asyncio.CancelledError):
+                await self._receive_task
+        if self._ws:
+            await self._ws.close()
+        if self._session:
+            await self._session.close()
+        if self._udp:
+            self._udp.close()
+        if self._udp_receive_thread:
+            self._udp_receive_thread.join(timeout=1)
+        if self._sink:
+            self._sink.close()

{disagreement-0.1.0rc3.dist-info → disagreement-0.3.0b1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: disagreement
-Version: 0.1.0rc3
+Version: 0.3.0b1
 Summary: A Python library for the Discord API.
 Author-email: Slipstream <me@slipstreamm.dev>
 License: BSD 3-Clause
@@ -23,6 +23,7 @@ Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: aiohttp<4.0.0,>=3.9.0
+Requires-Dist: PyNaCl<2.0.0,>=1.5.0
 Provides-Extra: test
 Requires-Dist: pytest>=8.0.0; extra == "test"
 Requires-Dist: pytest-asyncio>=1.0.0; extra == "test"
@@ -119,6 +120,22 @@ setup_logging(logging.INFO)
 setup_logging(logging.DEBUG, file="bot.log")
 ```
 
+### HTTP Session Options
+
+Pass additional keyword arguments to ``aiohttp.ClientSession`` using the
+``http_options`` parameter when constructing :class:`disagreement.Client`:
+
+```python
+client = disagreement.Client(
+    token=token,
+    http_options={"proxy": "http://localhost:8080"},
+)
+```
+
+These options are forwarded to ``HTTPClient`` when it creates the underlying
+``aiohttp.ClientSession``. You can specify a custom ``connector`` or any other
+session parameter supported by ``aiohttp``.
+
 ### Defining Subcommands with `AppCommandGroup`
 
 ```python

{disagreement-0.1.0rc3.dist-info → disagreement-0.3.0b1.dist-info}/RECORD

@@ -1,20 +1,21 @@
-disagreement/__init__.py,sha256=FAY6OvLuMyjkrBWEzl3tFemLgyWR-AUL-my3oeN-HB0,1169
-disagreement/audio.py,sha256=P6inobI8CNhNVkaRKU58RMYtLq1RrSREioF0Mui5VlA,3351
-disagreement/cache.py,sha256=juabGFl4naQih5OUIVN2aN-vAfw2ZC2cI38s4nGEn8U,1525
-disagreement/client.py,sha256=ig5ZBCIPnAYxShhQzW9qPSRkauGnNo16DO4RzPCHLo8,52973
-disagreement/color.py,sha256=g-1ynMGCUbY0f6jJXzMLS1aJFoZg91bdMetFkZgaCC0,2387
+disagreement/__init__.py,sha256=byWcO3yzDBdtlF2I-7f72JVlNnwQnbu88kr2PUeKIdY,1183
+disagreement/audio.py,sha256=nJ2A8glYVZwH5HgsqxOwqCgkOuWi0-bmgccPaV5K8-Y,3739
+disagreement/cache.py,sha256=2BACo4s2n4TyJejgNlheWjFOT6AWJHweHhO_LPhwkdI,2505
+disagreement/caching.py,sha256=_AKdhdWYOhMw2r6u0rVpdoU9_fwjzzDlxhTs73tgUXg,3839
+disagreement/client.py,sha256=e72n9zgOUWGCjfSB0zIhFQ2WvOJijWzKrxrPRtpL7Gc,65682
+disagreement/color.py,sha256=0RumZU9geS51rmmywwotmkXFc8RyQghOviRGGrHmvW4,4495
 disagreement/components.py,sha256=tEYJ2RHVpIFtZuPPxZ0v8ssUw_x7ybhYBzHNsRiXXvU,5250
-disagreement/enums.py,sha256=CP03oF28maaPUVckOfE_tnVIm2ZOc5WL8mWlocmjeOQ,9785
+disagreement/enums.py,sha256=Km9rzmbkYdBpba3fDAv9YYtXDROoRpKuQfkMavsiY0s,11069
 disagreement/error_handler.py,sha256=c2lb6aTMnhTtITQuR6axZUtEaasYKUgmdSxAHEkeq50,1028
 disagreement/errors.py,sha256=XiYVPy8uFUGVi_EIf81yK7QbC7KyN4JHplSJSWw2RRk,3185
-disagreement/event_dispatcher.py,sha256=mp4LVhIj0SW1P2NruqbYpZoYH33X5rXvkAl3-RK40kE,11460
-disagreement/gateway.py,sha256=EnRQKdYzeQ08h_Rx2J5vg1p5b47fWetkwIWrhXyUOXE,24132
-disagreement/http.py,sha256=6T1z3O6D0IL3qrUhtY-bwsnMR16a_zCMVMUU98QwKsc,31395
+disagreement/event_dispatcher.py,sha256=gdT5n9JzuWH6MXMvc4ZcoeyoSMJ9v973xC5rpufaTeY,11479
+disagreement/gateway.py,sha256=Orub9imXCvq7zKqBZqYxozMaI45B23SjCDaeYzB2SHI,26920
+disagreement/http.py,sha256=zA3I9QUMHNjvIxDUiAeCVFaMUyn1QdERfJ6dsxQr2A0,40864
 disagreement/hybrid_context.py,sha256=VYCmcreTZdPBU9v-Cy48W38vgWO2t8nM2ulC6_z4HjU,1095
 disagreement/i18n.py,sha256=1L4rcFuKP0XjHk9dVwbNh4BkLk2ZlxxZ_-tecGWa9S0,718
 disagreement/interactions.py,sha256=aUZwwEOLsEds15i6G-rxmSSDCDmaxz_cfoTYS4tv6Ao,21735
 disagreement/logging_config.py,sha256=4q6baQPE6X_0lfaBTFMU1uqc03x5SbJqo2hsApdDFac,686
-disagreement/models.py,sha256=IkPBT5Ki0IpDr2_NCIhiYSSL4aI28MakJ_PMZ81JcAA,75053
+disagreement/models.py,sha256=m88dlN8FrCZclb8p_lW6okljAVAnFib7-pkh1yKl1fk,95201
 disagreement/oauth.py,sha256=TfDdCwg1J7osM9wDi61dtNBA5BrQk5DeQrrHsYycH34,2810
 disagreement/permissions.py,sha256=7g5cIlg-evHXOL0-pmtT5EwqcB-stXot1HZSLz724sE,3008
 disagreement/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -22,23 +23,23 @@ disagreement/rate_limiter.py,sha256=ubwR_UTPs2MotipBdtqpgwQKx0IHt2I3cdfFcXTFv7g,
 disagreement/shard_manager.py,sha256=e9F8tx_4IEOlTX3-S3t51lfJToc6Ue3RVBzoNAiVKxs,2161
 disagreement/typing.py,sha256=_1oFWfZ4HyH5Q3bnF7CO24s79z-3_B5Qb69kWiwLhhU,1242
 disagreement/utils.py,sha256=mz7foTCOAmUv9n8EcdZeiFarwqB14xHOG8o0p8tFuKA,2014
-disagreement/voice_client.py,sha256=i_67gJ-SQWi9YH-pgtFM8N0lCYznyuQImyL-mf2O7KQ,5384
+disagreement/voice_client.py,sha256=ygle5grurpSKF-0y5YG6vwF7Ise5Pf1uNjz55mr6Y_4,8717
 disagreement/ext/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 disagreement/ext/loader.py,sha256=9_uULvNAa-a6UiaeQhWglwgIrHEPKbf9bnWtSL1KV5Q,1408
 disagreement/ext/tasks.py,sha256=b14KI-btikbrjPlD76md3Ggt6znrxPqr7TDarU4PYBg,7269
 disagreement/ext/app_commands/__init__.py,sha256=mnQLIuGP9SzqGMPEn5YgOh2eIU7lcYoDXP06vtXZfTA,1014
-disagreement/ext/app_commands/commands.py,sha256=0O5fJQg2esTQzx2FyEpM2ZrrLckNmv8fs3TIPnr1Q_s,19020
+disagreement/ext/app_commands/commands.py,sha256=xjrVPScEezdVxVq524_E2Gm2sTa-yq44TbGMu0gyA2o,19018
 disagreement/ext/app_commands/context.py,sha256=Xcm4Ka5K5uTQGviixF5LeCDdOdF9YQS5F7lZi2m--8s,20831
 disagreement/ext/app_commands/converters.py,sha256=J1VEmo-7H9K7kGPJodu5FX4RmFFI1BuzhlQAEs2MsD4,21036
 disagreement/ext/app_commands/decorators.py,sha256=dKiD4ZEsafRoPvfgn9zuQ9vvXXo2qYTMquHvyUM1604,23251
-disagreement/ext/app_commands/handler.py,sha256=36E58u8S7x-Ciop6kT6g7DdsPS2Wwo7rcvoBd7jmhWQ,26331
+disagreement/ext/app_commands/handler.py,sha256=KCMi5NEusuyLYo7Vk4sqLqXAJI5r3ppI0MNLUh0kU2c,28781
 disagreement/ext/app_commands/hybrid.py,sha256=u3kHNbVfY3-liymgzEIkFO5YV3WM_DqwytzdN9EXWMY,3330
-disagreement/ext/commands/__init__.py,sha256=HxZWVfc4qvP_bCRbKTVZoMqXFq19Gj4mQvRumvQiApQ,1130
+disagreement/ext/commands/__init__.py,sha256=Zko_qVPz1WUjBLcR2bnS3mKMX_YmU4AZ8kuFw9bvRRg,1363
 disagreement/ext/commands/cog.py,sha256=-F2ZOXXC07r96xlt9NomRgqlIqlcxzBiha2Zhg1DVp4,6845
 disagreement/ext/commands/converters.py,sha256=mh8xJr1FIiah6bdYy0KsdccfYcPii2Yc_IdhzCTw5uE,5864
-disagreement/ext/commands/core.py,sha256=xHeqenDqh2xiH7n9UyZl12sI1c0erorLPwi3uusmm1E,19525
-disagreement/ext/commands/decorators.py,sha256=Ox_D9KCFtMa-RiljFjOcsPb3stmDStRKeLw1DVeOdAw,6608
-disagreement/ext/commands/errors.py,sha256=cG5sPA-osUq2gts5scrl5yT-BHEYVHLTb4TULjAmbaY,2065
+disagreement/ext/commands/core.py,sha256=l6-rAAzeVERASyKd-qp2ttHlt5YgzuFwHTR4_JtXZnw,27053
+disagreement/ext/commands/decorators.py,sha256=BdhfiTsetu-oOIZn7gwUu2YDAmlzio7ijYFvov7m9pA,10469
+disagreement/ext/commands/errors.py,sha256=L6losXKye62BqDl42fXxgkuAkG92W-OcqH9uwEgabb8,2301
 disagreement/ext/commands/help.py,sha256=yw0ydupOsPwmnhsIIoxa93xjj9MAcBcGfD8BXa7V8G8,1456
 disagreement/ext/commands/view.py,sha256=3Wo4gGJX9fb65qw8yHFwMjnAeJvMJAx19rZNHz-ZDUs,3315
 disagreement/ui/__init__.py,sha256=PLA6eHiq9cu7JDOKS-7MKtaFhlqswjbI4AEUlpnbgO0,307
@@ -46,9 +47,9 @@ disagreement/ui/button.py,sha256=GHbY3-yMrvv6u674-qYONocuC1e2a0flEWjPKwJXKDo,316
 disagreement/ui/item.py,sha256=bm-EmQEZpe8Kt8JrRw-o0uQdccgjErORcFsBqaXOcV8,1112
 disagreement/ui/modal.py,sha256=w0ZEVslXzx2-RWUP4jdVB54zDuT81jpueVWZ70byFnI,4137
 disagreement/ui/select.py,sha256=XjWRlWkA09QZaDDLn-wDDOWIuj0Mb4VCWJEOAaExZXw,3018
-disagreement/ui/view.py,sha256=QhWoYt39QKXwl1X6Mkm5gNNEqd8bt7O505lSpiG0L04,5567
-disagreement-0.1.0rc3.dist-info/licenses/LICENSE,sha256=zfmtgJhVFHnqT7a8LAQFthXu5bP7EEHmEL99trV66Ew,1474
-disagreement-0.1.0rc3.dist-info/METADATA,sha256=4pe1v3qHLPGJD35qHIHxdI81xIiM0MdVKjS6HGsTYYs,4889
-disagreement-0.1.0rc3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-disagreement-0.1.0rc3.dist-info/top_level.txt,sha256=t7FY_3iaYhdB6X6y9VybJ2j7UZbVeRUe9wRgH8d5Gtk,13
-disagreement-0.1.0rc3.dist-info/RECORD,,
+disagreement/ui/view.py,sha256=bmDcX-YG-_exTVTfvMCDozo4D1vRQNFlXc8Ap21DVKE,5859
+disagreement-0.3.0b1.dist-info/licenses/LICENSE,sha256=zfmtgJhVFHnqT7a8LAQFthXu5bP7EEHmEL99trV66Ew,1474
+disagreement-0.3.0b1.dist-info/METADATA,sha256=NRhQzjjYG7vcD7X9RQYr_alVA4SnCQJvJbf8Sz1J0Tc,5417
+disagreement-0.3.0b1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+disagreement-0.3.0b1.dist-info/top_level.txt,sha256=t7FY_3iaYhdB6X6y9VybJ2j7UZbVeRUe9wRgH8d5Gtk,13
+disagreement-0.3.0b1.dist-info/RECORD,,