fix voice connection, now fix voice recording 😭

Author: DA-344

discord/abc.py

@@ -55,7 +55,7 @@
 from .role import Role
 from .scheduled_events import ScheduledEvent
 from .sticker import GuildSticker, StickerItem
-from .voice_client import VoiceClient, VoiceProtocol
+from .voice import VoiceClient, VoiceProtocol
 
 __all__ = (
     "Snowflake",

discord/client.py

@@ -61,19 +61,19 @@
 from .ui.view import View
 from .user import ClientUser, User
 from .utils import MISSING
-from .voice_client import VoiceClient
+from .voice import VoiceClient
 from .webhook import Webhook
 from .widget import Widget
 
 if TYPE_CHECKING:
     from .abc import GuildChannel, PrivateChannel, Snowflake, SnowflakeTime
     from .channel import DMChannel
-    from .interaction import Interaction
+    from .interactions import Interaction
     from .member import Member
     from .message import Message
     from .poll import Poll
     from .ui.item import Item
-    from .voice_client import VoiceProtocol
+    from .voice import VoiceProtocol
 
 __all__ = ("Client",)
 
@@ -467,7 +467,7 @@ def _schedule_event(
         return task
 
     def dispatch(self, event: str, *args: Any, **kwargs: Any) -> None:
-        _log.debug("Dispatching event %s", event)
+        logging.getLogger('discord.state').debug("Dispatching event %s", event)
         method = f"on_{event}"
 
         listeners = self._listeners.get(event)
@@ -789,7 +789,16 @@ async def start(self, token: str, *, reconnect: bool = True) -> None:
         await self.login(token)
         await self.connect(reconnect=reconnect)
 
-    def run(self, *args: Any, **kwargs: Any) -> None:
+    def run(
+        self,
+        token: str,
+        *,
+        reconnect: bool = True,
+        log_handler: logging.Handler | None = MISSING,
+        log_formatter: logging.Formatter = MISSING,
+        log_level: int = MISSING,
+        root_logger: bool = False,
+    ) -> None:
         """A blocking call that abstracts away the event loop
         initialisation from you.
 
@@ -815,39 +824,25 @@ def run(self, *args: Any, **kwargs: Any) -> None:
         """
         loop = self.loop
 
-        try:
-            loop.add_signal_handler(signal.SIGINT, loop.stop)
-            loop.add_signal_handler(signal.SIGTERM, loop.stop)
-        except (NotImplementedError, RuntimeError):
-            pass
-
         async def runner():
-            try:
-                await self.start(*args, **kwargs)
-            finally:
-                if not self.is_closed():
-                    await self.close()
-
-        def stop_loop_on_completion(f):
-            loop.stop()
+            async with self:
+                await self.start(token, reconnect=reconnect)
+
+        if log_handler is not None:
+            utils.setup_logging(
+                handler=log_handler,
+                formatter=log_formatter,
+                level=log_level,
+                root=root_logger,
+            )
 
-        future = asyncio.ensure_future(runner(), loop=loop)
-        future.add_done_callback(stop_loop_on_completion)
         try:
-            loop.run_forever()
+            asyncio.run(runner())
         except KeyboardInterrupt:
-            _log.info("Received signal to terminate bot and event loop.")
-        finally:
-            future.remove_done_callback(stop_loop_on_completion)
-            _log.info("Cleaning up tasks.")
-            _cleanup_loop(loop)
-
-        if not future.cancelled():
-            try:
-                return future.result()
-            except KeyboardInterrupt:
-                # I am unsure why this gets raised here but suppress it anyway
-                return None
+            # nothing to do here
+            # `asyncio.run` handles the loop cleanup
+            # and `self.start` closes all sockets and the HTTPClient instance.
+            return
 
     # properties
 

discord/commands/context.py

@@ -48,7 +48,7 @@
     from ..permissions import Permissions
     from ..state import ConnectionState
     from ..user import User
-    from ..voice_client import VoiceClient
+    from ..voice import VoiceClient
     from ..webhook import WebhookMessage
     from .core import ApplicationCommand, Option
 

discord/ext/commands/context.py

@@ -41,7 +41,7 @@
     from discord.member import Member
     from discord.state import ConnectionState
     from discord.user import ClientUser, User
-    from discord.voice_client import VoiceProtocol
+    from discord.voice import VoiceProtocol
 
     from .bot import AutoShardedBot, Bot
     from .cog import Cog

discord/guild.py

@@ -111,8 +111,8 @@
     from .types.guild import GuildFeature, MFALevel
     from .types.member import Member as MemberPayload
     from .types.threads import Thread as ThreadPayload
-    from .types.voice import GuildVoiceState
-    from .voice_client import VoiceClient
+    from .types.voice import VoiceState as GuildVoiceState
+    from .voice import VoiceClient
     from .webhook import Webhook
 
     VocalGuildChannel = Union[VoiceChannel, StageChannel]

discord/player.py

@@ -41,12 +41,13 @@
 from typing import IO, TYPE_CHECKING, Any, Callable, Generic, TypeVar
 
 from .errors import ClientException
+from .enums import SpeakingState
 from .oggparse import OggStream
-from .opus import Encoder as OpusEncoder
+from .opus import Encoder as OpusEncoder, OPUS_SILENCE
 from .utils import MISSING
 
 if TYPE_CHECKING:
-    from .voice_client import VoiceClient
+    from .voice import VoiceClient
 
 
 AT = TypeVar("AT", bound="AudioSource")
@@ -732,7 +733,6 @@ def __init__(self, source: AudioSource, client: VoiceClient, *, after=None):
         self._resumed: threading.Event = threading.Event()
         self._resumed.set()  # we are not paused
         self._current_error: Exception | None = None
-        self._connected: threading.Event = client._connected
         self._lock: threading.Lock = threading.Lock()
         self._played_frames_offset: int = 0
 
@@ -742,58 +742,60 @@ def __init__(self, source: AudioSource, client: VoiceClient, *, after=None):
     def _do_run(self) -> None:
         # attempt to read first audio segment from source before starting
         # some sources can take a few seconds and may cause problems
-        first_data = self.source.read()
         self.loops = 0
         self._start = time.perf_counter()
 
         # getattr lookup speed ups
-        play_audio = self.client.send_audio_packet
-        self._speak(True)
+        client = self.client
+        play_audio = client.send_audio_packet
+        self._speak(SpeakingState.voice)
 
         while not self._end.is_set():
             # are we paused?
             if not self._resumed.is_set():
+                self.send_silence()
                 # wait until we aren't
                 self._resumed.wait()
                 continue
 
-            # are we disconnected from voice?
-            if not self._connected.is_set():
-                # wait until we are connected
-                self._connected.wait()
-                # reset our internal data
-                self._played_frames_offset += self.loops
-                self.loops = 0
-                self._start = time.perf_counter()
-
-            self.loops += 1
-
-            # Send the data read from the start of the function if it is not None
-            if first_data is not None:
-                data = first_data
-                first_data = None
-            # Else read the next bit from the source
-            else:
-                data = self.source.read()
+            data = self.source.read()
 
             if not data:
                 self.stop()
                 break
 
+            # are we disconnected from voice?
+            if not client.is_connected():
+                _log.debug('Not connected, waiting for %ss...', client.timeout)
+                # wait until we are connected, but not forever
+                connected = client.wait_until_connected(client.timeout)
+                if self._end.is_set() or not connected:
+                    _log.debug('Aborting playback')
+                    return
+                _log.debug('Reconnected, resuming playback')
+                self._speak(SpeakingState.voice)
+                # reset our internal data
+                self.loops = 0
+                self._start = time.perf_counter()
+
             play_audio(data, encode=not self.source.is_opus())
+            self.loops += 1
             next_time = self._start + self.DELAY * self.loops
             delay = max(0, self.DELAY + (next_time - time.perf_counter()))
             time.sleep(delay)
 
+        if client.is_connected():
+            self.send_silence()
+
     def run(self) -> None:
         try:
             self._do_run()
         except Exception as exc:
             self._current_error = exc
             self.stop()
         finally:
-            self.source.cleanup()
             self._call_after()
+            self.source.cleanup()
 
     def _call_after(self) -> None:
         error = self._current_error
@@ -802,32 +804,29 @@ def _call_after(self) -> None:
             try:
                 self.after(error)
             except Exception as exc:
-                _log.exception("Calling the after function failed.")
                 exc.__context__ = error
-                traceback.print_exception(type(exc), exc, exc.__traceback__)
+                _log.exception("Calling the after function failed.", exc_info=exc)
         elif error:
             msg = f"Exception in voice thread {self.name}"
             _log.exception(msg, exc_info=error)
-            print(msg, file=sys.stderr)
-            traceback.print_exception(type(error), error, error.__traceback__)
 
     def stop(self) -> None:
         self._end.set()
         self._resumed.set()
-        self._speak(False)
+        self._speak(SpeakingState.none)
 
     def pause(self, *, update_speaking: bool = True) -> None:
         self._resumed.clear()
         if update_speaking:
-            self._speak(False)
+            self._speak(SpeakingState.none)
 
     def resume(self, *, update_speaking: bool = True) -> None:
         self._played_frames_offset += self.loops
         self.loops = 0
         self._start = time.perf_counter()
         self._resumed.set()
         if update_speaking:
-            self._speak(True)
+            self._speak(SpeakingState.voice)
 
     def is_playing(self) -> bool:
         return self._resumed.is_set() and not self._end.is_set()
@@ -841,14 +840,21 @@ def _set_source(self, source: AudioSource) -> None:
             self.source = source
             self.resume(update_speaking=False)
 
-    def _speak(self, speaking: bool) -> None:
+    def _speak(self, state: SpeakingState) -> None:
         try:
             asyncio.run_coroutine_threadsafe(
-                self.client.ws.speak(speaking), self.client.loop
+                self.client.ws.speak(state), self.client.loop
             )
         except Exception as e:
             _log.info("Speaking call in player failed: %s", e)
 
     def played_frames(self) -> int:
         """Gets the number of 20ms frames played since the start of the audio file."""
         return self._played_frames_offset + self.loops
+
+    def send_silence(self, count: int = 5) -> None:
+        try:
+            for n in range(count):
+                self.client.send_audio_packet(OPUS_SILENCE, encode=False)
+        except Exception:
+            pass

discord/raw_models.py

@@ -972,7 +972,6 @@ class RawVoiceStateUpdateEvent(_PayloadLike):
         "suppress",
         "requested_to_speak_at",
         "afk",
-        "channel",
         "guild_id",
         "channel_id",
         "_state",

discord/state.py

@@ -88,7 +88,7 @@
     from .types.poll import Poll as PollPayload
     from .types.sticker import GuildSticker as GuildStickerPayload
     from .types.user import User as UserPayload
-    from .voice_client import VoiceClient
+    from .voice import VoiceClient
 
     T = TypeVar("T")
     CS = TypeVar("CS", bound="ConnectionState")