Cleanup

Author: jareddantis

.vscode/settings.json

@@ -11,5 +11,6 @@
         "--disable=too-few-public-methods",
         "--disable=too-many-return-statements",
         "--disable=too-many-branches"
-    ]
+    ],
+    "editor.formatOnSave": true
 }

bot/cogs/debug.py renamed to bot/cogs/debug/__init__.py

@@ -8,7 +8,7 @@
 from nextcord.ext import application_checks
 from nextcord.ext.commands import Cog
 
-from bot.dataclass.custom_embed import CustomEmbed
+from bot.models.custom_embed import CustomEmbed
 from bot.utils.embeds import create_success_embed
 from bot.utils.logger import create_logger
 from bot.utils.paginator import Paginator

bot/cogs/player/__init__.py

@@ -23,7 +23,7 @@
 from nextcord.ext.commands import Cog
 from requests import HTTPError, codes
 
-from bot.dataclass.custom_embed import CustomEmbed
+from bot.models.custom_embed import CustomEmbed
 from bot.utils.constants import RELEASE, SPOTIFY_403_ERR_MSG
 from bot.utils.embeds import create_error_embed, create_success_embed
 from bot.utils.exceptions import (
@@ -42,7 +42,7 @@
 from .jockey import Jockey
 
 if TYPE_CHECKING:
-  from bot.dataclass.queue_item import QueueItem
+  from bot.models.queue_item import QueueItem
   from bot.utils.blanco import BlancoBot
 
 

bot/cogs/player/lavalink_client.py renamed to bot/cogs/player/helpers/lavalink_search.py

@@ -8,7 +8,7 @@
 
 from mafic import Playlist, SearchType, TrackLoadException
 
-from bot.dataclass.lavalink_result import LavalinkResult
+from bot.models.lavalink_result import LavalinkResult
 from bot.utils.constants import BLACKLIST
 from bot.utils.exceptions import LavalinkSearchError
 from bot.utils.fuzzy import check_similarity

bot/cogs/player/track_finder.py renamed to bot/cogs/player/helpers/lavalink_track.py

@@ -1,23 +1,29 @@
+"""
+Lavalink track helpers, which take care of finding a matching
+playable Lavalink track for a QueueItem, caching it, and
+invalidating it when necessary.
+"""
+
 from typing import TYPE_CHECKING, List, Optional, Tuple
 
 from mafic import SearchType
 
 from bot.database.redis import REDIS
 from bot.utils.constants import CONFIDENCE_THRESHOLD
 from bot.utils.exceptions import LavalinkSearchError
+from bot.utils.fuzzy import rank_results
 from bot.utils.logger import create_logger
 from bot.utils.musicbrainz import annotate_track
 
-from .jockey_helpers import rank_results
-from .lavalink_client import get_deezer_matches, get_deezer_track, get_youtube_matches
+from .lavalink_search import get_deezer_matches, get_deezer_track, get_youtube_matches
 
 if TYPE_CHECKING:
   from mafic import Node, Track
 
-  from bot.dataclass.lavalink_result import LavalinkResult
-  from bot.dataclass.queue_item import QueueItem
+  from bot.models.lavalink_result import LavalinkResult
+  from bot.models.queue_item import QueueItem
 
-  from .lavalink_client import LavalinkSearchError
+  from .lavalink_search import LavalinkSearchError
 
 LOGGER = create_logger('track_finder')
 
@@ -112,19 +118,36 @@ async def find_lavalink_track(
   return lavalink_track
 
 
+def invalidate_cached_track(item: 'QueueItem'):
+  """
+  Removes a cached Lavalink track from Redis.
+
+  :param item: The QueueItem to invalidate the track for.
+  """
+  if REDIS is None:
+    return
+
+  redis_key, redis_key_type = _determine_cache_key(item)
+
+  # Invalidate cached Lavalink track
+  if redis_key is not None and redis_key_type is not None:
+    REDIS.invalidate_lavalink_track(redis_key, key_type=redis_key_type)
+  else:
+    LOGGER.warning("Could not invalidate cached track for `%s': no key", item.title)
+
+
 def _get_cached_track(
   item: 'QueueItem',
 ) -> Tuple[Optional[str], Optional[str], Optional[str]]:
-  redis_key = None
-  redis_key_type = None
-  if item.spotify_id is not None:
-    redis_key = item.spotify_id
-    redis_key_type = 'spotify_id'
-  elif item.isrc is not None:
-    redis_key = item.isrc
-    redis_key_type = 'isrc'
+  """
+  Gets a cached Lavalink track from Redis.
+
+  :param item: The QueueItem to get the cached track for.
+  """
 
+  redis_key, redis_key_type = _determine_cache_key(item)
   cached = None
+
   if REDIS is not None and redis_key is not None and redis_key_type is not None:
     cached = REDIS.get_lavalink_track(redis_key, key_type=redis_key_type)
 
@@ -136,10 +159,37 @@ def _set_cached_track(
   key: Optional[str] = None,
   key_type: Optional[str] = None,
 ):
+  """
+  Caches a Lavalink track in Redis.
+
+  :param lavalink_track: The Lavalink track to cache.
+  :param key: The key to cache the track under.
+  :param key_type: The type of key to cache the track under.
+  """
   if REDIS is not None and key_type is not None and key is not None:
     REDIS.set_lavalink_track(key, lavalink_track, key_type=key_type)
 
 
+def _determine_cache_key(item: 'QueueItem') -> Tuple[Optional[str], Optional[str]]:
+  """
+  Determines the Redis key and key type for caching a Lavalink track.
+
+  :param item: The QueueItem to determine the cache key for.
+  """
+
+  redis_key = None
+  redis_key_type = None
+
+  if item.spotify_id is not None:
+    redis_key = item.spotify_id
+    redis_key_type = 'spotify_id'
+  elif item.isrc is not None:
+    redis_key = item.isrc
+    redis_key_type = 'isrc'
+
+  return redis_key, redis_key_type
+
+
 async def _append_deezer_results_for_isrc(
   results: List['LavalinkResult'],
   node: 'Node',

bot/cogs/player/jockey_helpers.py renamed to bot/cogs/player/helpers/parsers.py

@@ -1,22 +1,21 @@
 """
-Helper functions for the music player.
+Playback query parsers for the Player cog.
 """
 
-from typing import TYPE_CHECKING, List, Tuple, TypeVar
+from typing import TYPE_CHECKING, List
 
 from mafic import SearchType
 from requests.status_codes import codes
 from spotipy.exceptions import SpotifyException
 
-from bot.database.redis import REDIS
-from bot.dataclass.queue_item import QueueItem
+from bot.models.queue_item import QueueItem
 from bot.utils.constants import CONFIDENCE_THRESHOLD
 from bot.utils.exceptions import (
   JockeyException,
   LavalinkInvalidIdentifierError,
   SpotifyNoResultsError,
 )
-from bot.utils.fuzzy import check_similarity_weighted
+from bot.utils.fuzzy import rank_results
 from bot.utils.logger import create_logger
 from bot.utils.spotify_client import Spotify
 from bot.utils.url import (
@@ -32,85 +31,17 @@
   get_ytlistid_from_url,
 )
 
-from .lavalink_client import (
+from .lavalink_search import (
   get_soundcloud_matches,
   get_youtube_matches,
 )
 
 if TYPE_CHECKING:
   from mafic import Node
 
-from bot.dataclass.spotify import SpotifyTrack
+from bot.models.spotify import SpotifyTrack
 
 LOGGER = create_logger('jockey_helpers')
-T = TypeVar('T')
-
-
-def rank_results(
-  query: str, results: List[T], result_type: SearchType
-) -> List[Tuple[T, int]]:
-  """
-  Ranks search results based on similarity to a fuzzy query.
-
-  :param query: The query to check against.
-  :param results: The results to rank. Can be mafic.Track, dataclass.SpotifyTrack,
-      or any object with a title and author string attribute.
-  :param result_type: The type of result. See ResultType.
-  :return: A list of tuples containing the result and its similarity to the query.
-  """
-  # Rank results
-  similarities = [
-    check_similarity_weighted(
-      query,
-      f'{result.title} {result.author}',  # type: ignore
-      int(100 * (0.8**i)),
-    )
-    for i, result in enumerate(results)
-  ]
-  ranked = sorted(zip(results, similarities), key=lambda x: x[1], reverse=True)
-
-  # Print confidences for debugging
-  type_name = 'YouTube'
-  if result_type == SearchType.SPOTIFY_SEARCH:
-    type_name = 'Spotify'
-  elif result_type == SearchType.DEEZER_SEARCH:
-    type_name = 'Deezer'
-  LOGGER.debug('%s results and confidences for "%s":', type_name, query)
-  for result, confidence in ranked:
-    LOGGER.debug(
-      '  %3d  %-20s  %-25s',
-      confidence,
-      result.author[:20],  # type: ignore
-      result.title[:25],  # type: ignore
-    )
-
-  return ranked
-
-
-def invalidate_lavalink_track(item: QueueItem):
-  """
-  Removes a cached Lavalink track from Redis.
-
-  :param item: The QueueItem to invalidate the track for.
-  """
-  if REDIS is None:
-    return
-
-  # Determine key type
-  redis_key = None
-  redis_key_type = None
-  if item.spotify_id is not None:
-    redis_key = item.spotify_id
-    redis_key_type = 'spotify_id'
-  elif item.isrc is not None:
-    redis_key = item.isrc
-    redis_key_type = 'isrc'
-
-  # Invalidate cached Lavalink track
-  if redis_key is not None and redis_key_type is not None:
-    REDIS.invalidate_lavalink_track(redis_key, key_type=redis_key_type)
-  else:
-    LOGGER.warning("Could not invalidate cached track for `%s': no key", item.title)
 
 
 async def parse_query(

bot/cogs/player/queue.py renamed to bot/cogs/player/helpers/queue_manager.py

@@ -5,7 +5,7 @@
 from random import shuffle
 from typing import TYPE_CHECKING, List, Tuple
 
-from bot.dataclass.queue_item import QueueItem
+from bot.models.queue_item import QueueItem
 from bot.utils.exceptions import EmptyQueueError, EndOfQueueError
 from bot.utils.logger import create_logger
 

bot/cogs/player/scrobbler.py renamed to bot/cogs/player/helpers/scrobble_handler.py

@@ -9,7 +9,7 @@
 if TYPE_CHECKING:
   from nextcord.abc import Connectable
 
-  from bot.dataclass.queue_item import QueueItem
+  from bot.models.queue_item import QueueItem
   from bot.utils.blanco import BlancoBot
 
 

bot/cogs/player/jockey.py

@@ -17,7 +17,7 @@
   VoiceChannel,
 )
 
-from bot.dataclass.custom_embed import CustomEmbed
+from bot.models.custom_embed import CustomEmbed
 from bot.utils.constants import UNPAUSE_THRESHOLD
 from bot.utils.embeds import create_error_embed
 from bot.utils.exceptions import (
@@ -31,17 +31,17 @@
 from bot.utils.time import human_readable_time
 from bot.views.now_playing import NowPlayingView
 
-from .jockey_helpers import invalidate_lavalink_track, parse_query
-from .queue import QueueManager
-from .scrobbler import ScrobbleHandler
-from .track_finder import find_lavalink_track
+from .helpers.lavalink_track import find_lavalink_track, invalidate_cached_track
+from .helpers.parsers import parse_query
+from .helpers.queue_manager import QueueManager
+from .helpers.scrobble_handler import ScrobbleHandler
 
 if TYPE_CHECKING:
   from mafic import Track
   from nextcord import Embed
   from nextcord.abc import Connectable, Messageable
 
-  from bot.dataclass.queue_item import QueueItem
+  from bot.models.queue_item import QueueItem
   from bot.utils.blanco import BlancoBot
 
 
@@ -241,7 +241,7 @@ async def _play(self, item: 'QueueItem', position: Optional[int] = None):
           wait_time += 0.1
 
         # Remove cached Lavalink track and try again
-        invalidate_lavalink_track(item)
+        invalidate_cached_track(item)
         has_retried = True
       else:
         # Clear pause timestamp for new track

bot/database/__init__.py

@@ -5,7 +5,7 @@
 import sqlite3 as sql
 from typing import List, Optional
 
-from bot.dataclass.oauth import LastfmAuth, OAuth
+from bot.models.oauth import LastfmAuth, OAuth
 from bot.utils.logger import create_logger
 
 from .migrations import run_migrations