[3.2][Audio] Part 2

.github/CODEOWNERS

@@ -30,7 +30,7 @@ redbot/core/utils/dbtools.py             @mikeshardmind
 # Cogs
 redbot/cogs/admin/*                 @tekulvw
 redbot/cogs/alias/*                 @tekulvw
-redbot/cogs/audio/*                 @aikaterna
+redbot/cogs/audio/*                 @aikaterna @Drapersniper
 redbot/cogs/bank/*                  @tekulvw
 redbot/cogs/cleanup/*               @palmtree5
 redbot/cogs/customcom/*             @palmtree5

.gitignore

@@ -137,3 +137,6 @@ ENV/
 
 # pytest
 .pytest_cache/
+
+# Pre-commit hooks
+/.pre-commit-config.yaml

changelog.d/3047.bugfix.3.rst

@@ -0,0 +1 @@
+Escape track descriptions so that they do not break markdown.

changelog.d/audio/2904.dep.1.rst

@@ -1 +1 @@
-New dependency: ``databases[sqlite]`` .
+New dependency: ``databases[sqlite]``.

changelog.d/audio/2904.enhance.9.rst

@@ -0,0 +1,5 @@
+When playing a localtrack ``[p]play`` and ``[p]bumpplay`` no longer require the use of "localtracks\\" prefix.
+
+Before: ``[p]bumpplay localtracks\\ENM\\501 - Inside The Machine.mp3``
+Now: ``[p]bumpplay ENM\\501 - Inside The Machine.mp3``
+Now nested folders: ``[p]bumpplay Parent Folder\\Nested Folder\\track.mp3``

changelog.d/audio/2940.bugfix.1.rst

@@ -0,0 +1 @@
+Fix track index being off by 1 on ``[p]search`` command.

changelog.d/audio/2940.enhancement.1.rts

@@ -0,0 +1 @@
+Expanded local track support to all file formats (m3u, m4a, mp4, etc).

changelog.d/audio/2940.enhancement.2.rst

@@ -0,0 +1 @@
+Reset cooldown upon failure of commands that has a cooldown timer.

changelog.d/audio/2940.feature.1.rst

@@ -0,0 +1 @@
+``[p]bumpplay`` command has been added.

changelog.d/audio/2940.feature.2.rst

@@ -0,0 +1 @@
+``[p]shuffle`` command has an additional argument to tell the bot whether it should shuffle bumped tracks.

changelog.d/audio/2940.misc.1.rst

@@ -0,0 +1 @@
+DJ_ENABLED and DJ_ROLE settings are now stored on memory after first fetch, to reduce duplicated calls.

changelog.d/audio/3047.bugfix.1.rst

@@ -0,0 +1 @@
+Fix an issue where updating your Spotify and YouTube Data API tokens did not refresh them.

changelog.d/audio/3047.bugfix.2.rst

@@ -0,0 +1 @@
+Fix an issue where the blacklist was not being applied correctly.

changelog.d/audio/3047.bugfix.3.rst

@@ -0,0 +1 @@
+Fix an issue in ``[p]audioset restrictions blacklist list`` where it would call the list a `Whitelist`.

changelog.d/audio/3047.feature.1.rst

@@ -0,0 +1 @@
+Add global whitelist/blacklist commands.

changelog.d/audio/3104.misc.3.rst

@@ -0,0 +1 @@
+Add `cache.db` to the list of items not included in a backup.

changelog.d/audio/3152.misc.rst

@@ -0,0 +1 @@
+remove an undocumented API from audio

changelog.d/audio/3165.bugfix.1.rst

@@ -0,0 +1 @@
+Fixed an error that was thrown when running ``[p]audioset dj``.

changelog.d/audio/3165.enhance.1.rst

@@ -0,0 +1 @@
+Better error handling the player is unable to play multiple tracks in sequence.

changelog.d/audio/3201.feature.1.rst

@@ -0,0 +1 @@
+``[p]remove`` command now accepts an URL or Index, if an URL is used it will remove all tracks in the queue with that URL.

docs/guide_cog_creation.rst

@@ -21,7 +21,7 @@ To start off, be sure that you have installed Python 3.7.
 Next, you need to decide if you want to develop against the Stable or Develop version of Red.
 Depending on what your goal is should help determine which version you need.
 
-.. attention:: 
+.. attention::
     The Develop version may have changes on it which break compatibility with the Stable version and other cogs.
     If your goal is to support both versions, make sure you build compatibility layers or use separate branches to keep compatibility until the next Red release
 

redbot/cogs/audio/apis.py

@@ -11,19 +11,6 @@
 from collections import namedtuple
 from typing import Callable, Dict, List, Mapping, Optional, Tuple, Union
 
-try:
-    from sqlite3 import Error as SQLError
-    from databases import Database
-
-    HAS_SQL = True
-    _ERROR = None
-except ImportError as err:
-    _ERROR = "".join(traceback.format_exception_only(type(err), err)).strip()
-    HAS_SQL = False
-    SQLError = err.__class__
-    Database = None
-
-
 import aiohttp
 import discord
 import lavalink
@@ -32,11 +19,25 @@
 from redbot.core import Config, commands
 from redbot.core.bot import Red
 from redbot.core.i18n import Translator, cog_i18n
+
 from . import audio_dataclasses
 from .errors import InvalidTableError, SpotifyFetchError, YouTubeApiError, DatabaseError
 from .playlists import get_playlist
 from .utils import CacheLevel, Notifier, is_allowed, queue_duration, track_limit
 
+try:
+    from sqlite3 import Error as SQLError
+    from databases import Database
+
+    HAS_SQL = True
+    _ERROR = None
+except ImportError as err:
+    _ERROR = "".join(traceback.format_exception_only(type(err), err)).strip()
+    HAS_SQL = False
+    SQLError = err.__class__
+    Database: Callable = None
+
+
 log = logging.getLogger("red.audio.cache")
 _ = Translator("Audio", __file__)
 
@@ -57,13 +58,13 @@
 )
 
 _INSERT_YOUTUBE_TABLE = """
-        INSERT OR REPLACE INTO 
-        youtube(track_info, youtube_url, last_updated, last_fetched) 
+        INSERT OR REPLACE INTO
+        youtube(track_info, youtube_url, last_updated, last_fetched)
         VALUES (:track_info, :track_url, :last_updated, :last_fetched);
     """
 _QUERY_YOUTUBE_TABLE = "SELECT * FROM youtube WHERE track_info=:track;"
 _UPDATE_YOUTUBE_TABLE = """UPDATE youtube
-              SET last_fetched=:last_fetched 
+              SET last_fetched=:last_fetched
               WHERE track_info=:track;"""
 
 _DROP_SPOTIFY_TABLE = "DROP TABLE spotify;"
@@ -78,7 +79,7 @@
                             type TEXT,
                             uri TEXT,
                             track_name TEXT,
-                            artist_name TEXT, 
+                            artist_name TEXT,
                             song_url TEXT,
                             track_info TEXT,
                             last_updated TEXT,
@@ -87,15 +88,15 @@
                     """
 
 _INSERT_SPOTIFY_TABLE = """
-        INSERT OR REPLACE INTO 
-        spotify(id, type, uri, track_name, artist_name, 
-        song_url, track_info, last_updated, last_fetched) 
-        VALUES (:id, :type, :uri, :track_name, :artist_name, 
+        INSERT OR REPLACE INTO
+        spotify(id, type, uri, track_name, artist_name,
+        song_url, track_info, last_updated, last_fetched)
+        VALUES (:id, :type, :uri, :track_name, :artist_name,
         :song_url, :track_info, :last_updated, :last_fetched);
     """
 _QUERY_SPOTIFY_TABLE = "SELECT * FROM spotify WHERE uri=:uri;"
 _UPDATE_SPOTIFY_TABLE = """UPDATE spotify
-              SET last_fetched=:last_fetched 
+              SET last_fetched=:last_fetched
               WHERE uri=:uri;"""
 
 _DROP_LAVALINK_TABLE = "DROP TABLE lavalink;"
@@ -115,8 +116,8 @@
 )
 
 _INSERT_LAVALINK_TABLE = """
-        INSERT OR REPLACE INTO 
-        lavalink(query,  data, last_updated, last_fetched) 
+        INSERT OR REPLACE INTO
+        lavalink(query,  data, last_updated, last_fetched)
         VALUES (:query, :data, :last_updated, :last_fetched);
     """
 _QUERY_LAVALINK_TABLE = "SELECT * FROM lavalink WHERE query=:query;"
@@ -131,7 +132,7 @@
     " OR last_fetched LIKE :day7;"
 )
 _UPDATE_LAVALINK_TABLE = """UPDATE lavalink
-              SET last_fetched=:last_fetched 
+              SET last_fetched=:last_fetched
               WHERE query=:query;"""
 
 _PARSER = {
@@ -194,10 +195,9 @@ async def _make_get(self, url: str, headers: dict = None, params: dict = None) -
             return await r.json()
 
     async def _get_auth(self):
-        if self.client_id is None or self.client_secret is None:
-            tokens = await self.bot.get_shared_api_tokens("spotify")
-            self.client_id = tokens.get("client_id", "")
-            self.client_secret = tokens.get("client_secret", "")
+        tokens = await self.bot.get_shared_api_tokens("spotify")
+        self.client_id = tokens.get("client_id", "")
+        self.client_secret = tokens.get("client_secret", "")
 
     async def _request_token(self) -> dict:
         await self._get_auth()
@@ -278,10 +278,9 @@ def __init__(self, bot: Red, session: aiohttp.ClientSession):
         self.session = session
         self.api_key = None
 
-    async def _get_api_key(self,) -> Optional[str]:
-        if self.api_key is None:
-            tokens = await self.bot.get_shared_api_tokens("youtube")
-            self.api_key = tokens.get("api_key", "")
+    async def _get_api_key(self,) -> str:
+        tokens = await self.bot.get_shared_api_tokens("youtube")
+        self.api_key = tokens.get("api_key", "")
         return self.api_key
 
     async def get_call(self, query: str) -> Optional[str]:
@@ -310,8 +309,8 @@ async def get_call(self, query: str) -> Optional[str]:
 
 @cog_i18n(_)
 class MusicCache:
-    """
-    Handles music queries to the Spotify and Youtube Data API.
+    """Handles music queries to the Spotify and Youtube Data API.
+
     Always tries the Cache first.
     """
 
@@ -353,7 +352,7 @@ async def close(self):
             await self.database.execute(query="PRAGMA optimize;")
             await self.database.disconnect()
 
-    async def insert(self, table: str, values: List[dict]):
+    async def insert(self, table: str, values: List[Mapping]):
         # if table == "spotify":
         #     return
         if HAS_SQL:
@@ -414,7 +413,7 @@ async def fetch_all(self, table: str, query: str, values: Dict[str, str]) -> Lis
         return []
 
     @staticmethod
-    def _spotify_format_call(qtype: str, key: str) -> Tuple[str, dict]:
+    def _spotify_format_call(qtype: str, key: str) -> Tuple[str, Mapping]:
         params = {}
         if qtype == "album":
             query = "https://api.spotify.com/v1/albums/{0}/tracks".format(key)
@@ -484,7 +483,7 @@ async def _spotify_first_time_query(
                 if youtube_cache:
                     update = True
                     with contextlib.suppress(SQLError):
-                        val, update = await self.fetch_one(
+                        (val, update) = await self.fetch_one(
                             "youtube", "youtube_url", {"track": track_info}
                         )
                     if update:
@@ -545,7 +544,7 @@ async def _spotify_fetch_tracks(
     ) -> Union[dict, List[str]]:
 
         if recursive is False:
-            call, params = self._spotify_format_call(query_type, uri)
+            (call, params) = self._spotify_format_call(query_type, uri)
             results = await self.spotify_api.get_call(call, params)
         else:
             results = await self.spotify_api.get_call(recursive, params)
@@ -608,8 +607,7 @@ async def spotify_query(
         skip_youtube: bool = False,
         notifier: Optional[Notifier] = None,
     ) -> List[str]:
-        """
-        Queries the Database then falls back to Spotify and YouTube APIs.
+        """Queries the Database then falls back to Spotify and YouTube APIs.
 
         Parameters
         ----------
@@ -635,7 +633,7 @@ async def spotify_query(
         if query_type == "track" and cache_enabled:
             update = True
             with contextlib.suppress(SQLError):
-                val, update = await self.fetch_one(
+                (val, update) = await self.fetch_one(
                     "spotify", "track_info", {"uri": f"spotify:track:{uri}"}
                 )
             if update:
@@ -730,7 +728,7 @@ async def spotify_enqueue(
                 if youtube_cache:
                     update = True
                     with contextlib.suppress(SQLError):
-                        val, update = await self.fetch_one(
+                        (val, update) = await self.fetch_one(
                             "youtube", "youtube_url", {"track": track_info}
                         )
                     if update:
@@ -745,7 +743,7 @@ async def spotify_enqueue(
 
                 if val:
                     try:
-                        result, called_api = await self.lavalink_query(
+                        (result, called_api) = await self.lavalink_query(
                             ctx, player, audio_dataclasses.Query.process_input(val)
                         )
                     except (RuntimeError, aiohttp.ServerDisconnectedError):
@@ -760,7 +758,7 @@ async def spotify_enqueue(
                         lock(ctx, False)
                         error_embed = discord.Embed(
                             colour=await ctx.embed_colour(),
-                            title=_("Player timedout, skipping remaning tracks."),
+                            title=_("Player timeout, skipping remaining tracks."),
                         )
                         await notifier.update_embed(error_embed)
                         break
@@ -771,16 +769,6 @@ async def spotify_enqueue(
                     key = "lavalink"
                     seconds = "???"
                     second_key = None
-                    # if track_count == 2:
-                    #     five_time = int(time.time()) - now
-                    # if track_count >= 2:
-                    # remain_tracks = total_tracks - track_count
-                    # time_remain = (remain_tracks / 2) * five_time
-                    # if track_count < total_tracks:
-                    #     seconds = dynamic_time(int(time_remain))
-                    # if track_count == total_tracks:
-                    #     seconds = "0s"
-                    # second_key = "lavalink_time"
                     await notifier.notify_user(
                         current=track_count,
                         total=total_tracks,
@@ -893,7 +881,9 @@ async def youtube_query(self, ctx: commands.Context, track_info: str) -> str:
         if cache_enabled:
             update = True
             with contextlib.suppress(SQLError):
-                val, update = await self.fetch_one("youtube", "youtube_url", {"track": track_info})
+                (val, update) = await self.fetch_one(
+                    "youtube", "youtube_url", {"track": track_info}
+                )
             if update:
                 val = None
         if val is None:
@@ -914,10 +904,8 @@ async def lavalink_query(
         query: audio_dataclasses.Query,
         forced: bool = False,
     ) -> Tuple[LoadResult, bool]:
-        """
-        A replacement for :code:`lavalink.Player.load_tracks`.
-        This will try to get a valid cached entry first if not found or if in valid
-        it will then call the lavalink API.
+        """A replacement for :code:`lavalink.Player.load_tracks`. This will try to get a valid
+        cached entry first if not found or if in valid it will then call the lavalink API.
 
         Parameters
         ----------
@@ -944,7 +932,7 @@ async def lavalink_query(
         if cache_enabled and not forced and not _raw_query.is_local:
             update = True
             with contextlib.suppress(SQLError):
-                val, update = await self.fetch_one("lavalink", "data", {"query": query})
+                (val, update) = await self.fetch_one("lavalink", "data", {"query": query})
             if update:
                 val = None
             if val:
@@ -1015,7 +1003,7 @@ async def run_all_pending_tasks(self):
             log.debug("Running pending writes to database")
             with contextlib.suppress(Exception):
                 tasks = {"update": [], "insert": []}
-                for k, task in self._tasks.items():
+                for (k, task) in self._tasks.items():
                     for t, args in task.items():
                         tasks[t].append(args)
                 self._tasks = {}
@@ -1087,7 +1075,7 @@ async def autoplay(self, player: lavalink.Player):
                 tracks = await self.play_random()
             if not tracks:
                 ctx = namedtuple("Context", "message")
-                results, called_api = await self.lavalink_query(
+                (results, called_api) = await self.lavalink_query(
                     ctx(player.channel.guild),
                     player,
                     audio_dataclasses.Query.process_input(_TOP_100_US),
@@ -1124,7 +1112,7 @@ async def autoplay(self, player: lavalink.Player):
                     continue
                 valid = True
 
-            track.extras = {"autoplay": True}
+            track.extras["autoplay"] = True
             player.add(player.channel.guild.me, track)
             self.bot.dispatch(
                 "red_audio_track_auto_play", player.channel.guild, track, player.channel.guild.me