Dockerfile

@@ -1,10 +1,8 @@
 FROM python:3.7-slim
 
-LABEL maintainer="Joshua Arulsamy <joshua.gf.arul@gmail.com>"
-
 # Install ffmpeg
 RUN apt-get -y update && \
-    apt-get install -y --no-install-recommends ffmpeg=7:4.1.6-1~deb10u1 && \
+    apt-get install -y --no-install-recommends ffmpeg && \
     apt-get autoremove -y && \
     apt-get clean && \
     rm -rf /var/lib/apt/lists/*

Jenkinsfile

@@ -25,7 +25,6 @@ pipeline {
                 sh  ''' conda create --yes -n ${BUILD_TAG} python
                         source /var/lib/jenkins/miniconda3/etc/profile.d/conda.sh
                         conda activate ${BUILD_TAG}
-                        pip install -r requirements.txt
                         pip install pylint
                     '''
             }
@@ -48,10 +47,18 @@ pipeline {
                 }
             }
             steps {
-                sh  './deploy/build.sh'
+                sh  ''' source /var/lib/jenkins/miniconda3/etc/profile.d/conda.sh
+                        conda activate ${BUILD_TAG}
+                        ./deploy/build.sh
+                    '''
             }
         }
         stage('Push Image') {
+            when {
+                expression {
+                    currentBuild.result == 'SUCCESS'
+                }
+            }
             steps {
                 sh './deploy/push.sh'
             }

Makefile

@@ -1,17 +0,0 @@
-.PHONY: help pull build clean
-.DEFAULT_GOAL: build
-
-help:
-	@echo "make pull"
-	@echo "       Start docker container with pull"
-	@echo "make build"
-	@echo "       Start docker container rebuilding container"
-
-pull:
-	docker-compose up
-
-build:
-	docker-compose -f docker-compose_dev.yml up --build
-
-clean:
-	docker system prune -a

PlexBot/__init__.py

@@ -1,6 +1,8 @@
 """
 Plex music bot for discord.
 
+Do not import this module, it is intended to be
+used exclusively within a docker environment.
 """
 import logging
 import sys
@@ -17,7 +19,7 @@ plex_log = logging.getLogger("Plex")
 bot_log = logging.getLogger("Bot")
 
 
-def load_config(basedir: str,filename: str) -> Dict[str, str]:
+def load_config(filename: str) -> Dict[str, str]:
     """Loads config from yaml file
 
     Grabs key/value config pairs from a file.
@@ -33,12 +35,12 @@ def load_config(basedir: str,filename: str) -> Dict[str, str]:
     """
     # All config files should be in /config
     # for docker deployment.
-    filename = Path(basedir, filename)
+    filename = Path("/config", filename)
     try:
         with open(filename, "r") as config_file:
             config = yaml.safe_load(config_file)
     except FileNotFoundError:
-        root_log.fatal("Configuration file not found at '"+str(filename)+"'.")
+        root_log.fatal("Configuration file not found.")
         sys.exit(-1)
 
     # Convert str level type to logging constant
@@ -54,7 +56,4 @@ def load_config(basedir: str,filename: str) -> Dict[str, str]:
     config["plex"]["log_level"] = levels[config["plex"]["log_level"].upper()]
     config["discord"]["log_level"] = levels[config["discord"]["log_level"].upper()]
 
-    if config["lyrics"] and config["lyrics"]["token"].lower() == "none":
-        config["lyrics"] = None
-
     return config

PlexBot/__main__.py

@@ -11,11 +11,7 @@ from .bot import General
 from .bot import Plex
 
 # Load config from file
-configdir = "config"
+config = load_config("config.yaml")
-from os import geteuid
-if geteuid() == 0:
-    configdir = "/config"
-config = load_config(configdir,"config.yaml")
 
 BOT_PREFIX = config["discord"]["prefix"]
 TOKEN = config["discord"]["token"]
@@ -24,11 +20,6 @@ BASE_URL = config["plex"]["base_url"]
 PLEX_TOKEN = config["plex"]["token"]
 LIBRARY_NAME = config["plex"]["library_name"]
 
-if config["lyrics"]:
-    LYRICS_TOKEN = config["lyrics"]["token"]
-else:
-    LYRICS_TOKEN = None
-    
 # Set appropiate log level
 root_log = logging.getLogger()
 plex_log = logging.getLogger("Plex")
@@ -37,16 +28,7 @@ bot_log = logging.getLogger("Bot")
 plex_log.setLevel(config["plex"]["log_level"])
 bot_log.setLevel(config["discord"]["log_level"])
 
-plex_args = {
-    "base_url": BASE_URL,
-    "plex_token": PLEX_TOKEN,
-    "lib_name": LIBRARY_NAME,
-    "lyrics_token": LYRICS_TOKEN,
-}
-
 bot = Bot(command_prefix=BOT_PREFIX)
-# Remove help command, we have our own custom one.
-bot.remove_command("help")
 bot.add_cog(General(bot))
-bot.add_cog(Plex(bot, **plex_args))
+bot.add_cog(Plex(bot, BASE_URL, PLEX_TOKEN, LIBRARY_NAME, BOT_PREFIX))
 bot.run(TOKEN)

PlexBot/__version__.py

@@ -1,5 +1,5 @@
 """Track version number of package."""
-VERSION = "1.0.3"
+VERSION = "1.0.0"
 
 if __name__ == "__main__":
     print(VERSION)

PlexBot/bot.py

@@ -3,62 +3,29 @@ import asyncio
 import io
 import logging
 from urllib.request import urlopen
-import requests
 
 import discord
 from async_timeout import timeout
 from discord import FFmpegPCMAudio
 from discord.ext import commands
 from discord.ext.commands import command
+from fuzzywuzzy import fuzz
 from plexapi.exceptions import Unauthorized
-from plexapi.exceptions import NotFound
 from plexapi.server import PlexServer
 
-from .exceptions import MediaNotFoundError
-from .exceptions import VoiceChannelError
-
 root_log = logging.getLogger()
 plex_log = logging.getLogger("Plex")
 bot_log = logging.getLogger("Bot")
 
-help_text = """
-General:
-    kill [silent] - Halt the bot [silently].
-    help - Print this help message.
-    cleanup - Delete old messages from the bot.
-
-Plex:
-    play <SONG_NAME> - Play a song from the plex server.
-    album <ALBUM_NAME> - Queue an entire album to play.
-    playlist <PLAYLIST_NAME> - Queue an entire playlist to play.
-    show_playlists <ARG> <ARG> - Query for playlists with a name matching any of the arguments.
-    lyrics - Print the lyrics of the song (Requires Genius API)
-    np - Print the current playing song.
-    q - Print the current queue (This can take very long!)
-    stop - Halt playback and leave vc.
-    loop - Loop the current song.
-    loopq - Loop the current queue.
-    unloop - Disable looping the current track.
-    unloopq - Disable looping the current queue.
-    pause - Pause playback.
-    resume - Resume playback.
-    skip - Skip the current song. Give a number as argument to skip more than 1.
-    clear - Clear play queue.
-
-[] - Optional args.
-"""
-
 
 class General(commands.Cog):
-    """
+    """General commands
-    General commands
 
     Manage general bot behavior
     """
 
     def __init__(self, bot):
-        """
+        """Initialize commands
-        Initialize commands
 
         Args:
             bot: discord.ext.command.Bot, bind for cogs
@@ -73,8 +40,7 @@ class General(commands.Cog):
 
     @command()
     async def kill(self, ctx, *args):
-        """
+        """Kill the bot
-        Kill the bot
 
         Args:
             ctx: discord.ext.commands.Context message context from command
@@ -92,27 +58,9 @@ class General(commands.Cog):
         await self.bot.close()
         bot_log.info("Stopping upon the request of %s", ctx.author.mention)
 
-    @command(name="help")
-    async def help(self, ctx):
-        """
-        Prints command help
-
-        Args:
-            ctx: discord.ext.commands.Context message context from command
-
-        Returns:
-            None
-
-        Raise:
-            None
-        """
-
-        await ctx.send(f"```{help_text}```")
-
     @command()
     async def cleanup(self, ctx, limit=250):
-        """
+        """Delete old messages from bot
-        Delete old messages from bot
 
         Args:
             ctx: discord.ext.commands.Context message context from command
@@ -135,35 +83,27 @@ class General(commands.Cog):
                     except (discord.Forbidden, discord.NotFound, discord.HTTPException):
                         pass
 
-            async for i in channel.history(limit=limit):
-                if i.author == ctx.message.author and i.content.startswith(
-                    self.bot.command_prefix
-                ):
-                    try:
-                        await i.delete()
-                    except (discord.Forbidden, discord.NotFound, discord.HTTPException):
-                        pass
-
         except discord.Forbidden:
             bot_log.info("Unable to delete messages, insufficient permissions.")
             await ctx.send("I don't have the necessary permissions to delete messages.")
 
 
 class Plex(commands.Cog):
-    """
+    """Discord commands pertinent to interacting with Plex
-    Discord commands pertinent to interacting with Plex
+
+        Contains user commands such as play, pause, resume, stop, etc.
+        Grabs, and parses all data from plex database.
 
-    Contains user commands such as play, pause, resume, stop, etc.
-    Grabs, and parses all data from plex database.
     """
 
     # pylint: disable=too-many-instance-attributes
     # All are necessary to detect global interactions
     # within the bot.
 
-    def __init__(self, bot, **kwargs):
+    def __init__(
-        """
+        self, bot, base_url: str, plex_token: str, lib_name: str, bot_prefix: str
-        Initializes Plex resources
+    ):
+        """Initializes Plex resources
 
         Connects to Plex library and sets up
         all asyncronous communications.
@@ -173,6 +113,7 @@ class Plex(commands.Cog):
             base_url: str url to Plex server
             plex_token: str X-Token of Plex server
             lib_name: str name of Plex library to search through
+            bot_prefix: str prefix used to interact with bots
 
         Raises:
             plexapi.exceptions.Unauthorized: Invalid Plex token
@@ -182,17 +123,10 @@ class Plex(commands.Cog):
         """
 
         self.bot = bot
-        self.base_url = kwargs["base_url"]
+        self.base_url = base_url
-        self.plex_token = kwargs["plex_token"]
+        self.plex_token = plex_token
-        self.library_name = kwargs["lib_name"]
+        self.library_name = lib_name
-        self.bot_prefix = bot.command_prefix
+        self.bot_prefix = bot_prefix
-
-        if kwargs["lyrics_token"]:
-            import lyricsgenius
-            self.genius = lyricsgenius.Genius(kwargs["lyrics_token"])
-        else:
-            plex_log.warning("No lyrics token specified, lyrics disabled")
-            self.genius = None
 
         # Log fatal invalid plex token
         try:
@@ -207,10 +141,7 @@ class Plex(commands.Cog):
         # Initialize necessary vars
         self.voice_channel = None
         self.current_track = None
-        self.is_looping = False
-        self.loop_queue = None
         self.np_message_id = None
-        self.show_queue_message_ids = []
         self.ctx = None
 
         # Initialize events
@@ -221,73 +152,35 @@ class Plex(commands.Cog):
         self.bot.loop.create_task(self._audio_player_task())
 
     def _search_tracks(self, title: str):
-        """
+        """Search the Plex music db
-        Search the Plex music db for track
+
+        Uses a fuzzy search algorithm to find the closest matching song
+        title in the Plex music database.
 
         Args:
             title: str title of song to search for
 
         Returns:
-            plexapi.audio.Track pointing to best matching title
+            plexapi.audio.Track pointing to closest matching title
+            None if song can't be found.
 
         Raises:
-            MediaNotFoundError: Title of track can't be found in plex db
+            None
         """
-        results = self.music.searchTracks(title=title, maxresults=1)
+        tracks = self.music.searchTracks()
-        try:
+        score = [None, -1]
-            return results[0]
+        for i in tracks:
-        except IndexError:
+            ratio = fuzz.ratio(title.lower(), i.title.lower())
-            raise MediaNotFoundError("Track cannot be found")
+            if ratio > score[1]:
+                score[0] = i
+                score[1] = ratio
+            elif ratio == score[1]:
+                score[0] = i
 
-    def _search_albums(self, title: str):
+        return score[0]
-        """
-        Search the Plex music db for album
-
-        Args:
-            title: str title of album to search for
-
-        Returns:
-            plexapi.audio.Album pointing to best matching title
-
-        Raises:
-            MediaNotFoundError: Title of album can't be found in plex db
-        """
-        results = self.music.searchAlbums(title=title, maxresults=1)
-        try:
-            return results[0]
-        except IndexError:
-            raise MediaNotFoundError("Album cannot be found")
-
-    def _search_playlists(self, title: str):
-        """
-        Search the Plex music db for playlist
-
-        Args:
-            title: str title of playlist to search for
-
-        Returns:
-            plexapi.playlist pointing to best matching title
-
-        Raises:
-            MediaNotFoundError: Title of playlist can't be found in plex db
-        """
-        try:
-            return self.pms.playlist(title)
-        except NotFound:
-            raise MediaNotFoundError("Playlist cannot be found")
-
-    def _get_playlists(self):
-        """
-        Search the Plex music db for playlist
-
-        Returns:
-            List of plexapi.playlist
-        """
-        return self.pms.playlists()
 
     async def _play(self):
-        """
+        """Heavy lifting of playing songs
-        Heavy lifting of playing songs
 
         Grabs the appropiate streaming URL, sends the `now playing`
         message, and initiates playback in the vc.
@@ -304,45 +197,18 @@ class Plex(commands.Cog):
         track_url = self.current_track.getStreamURL()
         audio_stream = FFmpegPCMAudio(track_url)
 
-        while self.voice_channel and self.voice_channel.is_playing():
+        while self.voice_channel.is_playing():
-            bot_log.debug("waiting for track to finish")
+            asyncio.sleep(2)
-            await asyncio.sleep(2)
-        bot_log.debug("track finished")
 
-        if self.voice_channel:
+        self.voice_channel.play(audio_stream, after=self._toggle_next)
-            self.voice_channel.play(audio_stream, after=self._toggle_next)
 
-            plex_log.debug("%s - URL: %s", self.current_track, track_url)
+        plex_log.debug("%s - URL: %s", self.current_track, track_url)
 
-            embed, img = self._build_embed_track(self.current_track)
+        embed, img = self._build_embed(self.current_track)
-            self.np_message_id = await self.ctx.send(embed=embed, file=img)
+        self.np_message_id = await self.ctx.send(embed=embed, file=img)
-
-    async def _play_next(self):
-        try:
-            from asyncio.exceptions import CancelledError
-        except ImportError:
-            from concurrent.futures._base import CancelledError
-        if self.is_looping:
-            self.current_track = self.is_looping
-        else:
-            try:
-                self.current_track = await self.play_queue.get()
-            except CancelledError:
-                bot_log.debug("failed to pop queue")
-
-            if not self.current_track and self.loop_queue:
-                bot_log.debug("swapping loop queue and play queue")
-                for item in self.loop_queue:
-                    await self.play_queue.put(item)
-
-                try:
-                    self.current_track = await self.play_queue.get()
-                except CancelledError:
-                    bot_log.debug("failed to pop queue")
 
     async def _audio_player_task(self):
-        """
+        """Coroutine to handle playback and queuing
-        Coroutine to handle playback and queuing
 
         Always-running function awaiting new songs to be added.
         Auto disconnects from VC if idle for > 15 seconds.
@@ -363,23 +229,20 @@ class Plex(commands.Cog):
                 try:
                     # Disconnect after 15 seconds idle
                     async with timeout(15):
-                        await self._play_next()
+                        self.current_track = await self.play_queue.get()
                 except asyncio.TimeoutError:
-                    bot_log("timeout - disconnecting")
                     await self.voice_channel.disconnect()
                     self.voice_channel = None
 
             if not self.current_track:
-                await self._play_next()
+                self.current_track = await self.play_queue.get()
 
             await self._play()
             await self.play_next_event.wait()
-            if self.np_message_id:
+            await self.np_message_id.delete()
-                await self.np_message_id.delete()
 
     def _toggle_next(self, error=None):
-        """
+        """Callback for vc playback
-        Callback for vc playback
 
         Clears current track, then activates _audio_player_task
         to play next in queue or disconnect.
@@ -396,13 +259,11 @@ class Plex(commands.Cog):
         self.current_track = None
         self.bot.loop.call_soon_threadsafe(self.play_next_event.set)
 
-    @staticmethod
+    def _build_embed(self, track, type_="play"):
-    def _build_embed_track(track, type_="play"):
+        """Creates a pretty embed card.
-        """
-        Creates a pretty embed card for tracks
 
         Builds a helpful status embed with the following info:
-        Status, song title, album, artist and album art. All
+        Status, song title, album, artistm and album art. All
         pertitent information is grabbed dynamically from the Plex db.
 
         Args:
@@ -410,29 +271,23 @@ class Plex(commands.Cog):
             type_: Type of card to make (play, queue).
 
         Returns:
-            embed: discord.embed fully constructed payload.
+            embed: discord.embed fully constructed img payload.
             thumb_art: io.BytesIO of album thumbnail img.
 
         Raises:
             ValueError: Unsupported type of embed {type_}
         """
         # Grab the relevant thumbnail
-        if track.thumbUrl:
+        img_stream = urlopen(track.thumbUrl)
-            img_stream = requests.get(track.thumbUrl, stream=True).raw
+        img = io.BytesIO(img_stream.read())
-            img = io.BytesIO(img_stream.read())
-
-            # Attach to discord embed
-            art_file = discord.File(img, filename="image0.png")
-        else:
-            art_file = None
 
+        # Attach to discord embed
+        art_file = discord.File(img, filename="image0.png")
         # Get appropiate status message
         if type_ == "play":
             title = f"Now Playing - {track.title}"
         elif type_ == "queue":
             title = f"Added to queue - {track.title}"
-        elif type_ == "queued":
-            title = f"Next in line - {track.title}"
         else:
             raise ValueError(f"Unsupported type of embed {type_}")
 
@@ -447,116 +302,13 @@ class Plex(commands.Cog):
         # Point to file attached with ctx object.
         embed.set_thumbnail(url="attachment://image0.png")
 
-        bot_log.debug("Built embed for track - %s", track.title)
+        bot_log.debug("Built embed for %s", track.title)
 
         return embed, art_file
 
-    @staticmethod
-    def _build_embed_album(album):
-        """
-        Creates a pretty embed card for albums
-
-        Builds a helpful status embed with the following info:
-        album, artist, and album art. All pertitent information
-        is grabbed dynamically from the Plex db.
-
-        Args:
-            album: plexapi.audio.Album object of album
-
-        Returns:
-            embed: discord.embed fully constructed payload.
-            thumb_art: io.BytesIO of album thumbnail img.
-
-        Raises:
-            None
-        """
-        # Grab the relevant thumbnail
-        img_stream = requests.get(album.thumbUrl, stream=True).raw
-        img = io.BytesIO(img_stream.read())
-
-        # Attach to discord embed
-        art_file = discord.File(img, filename="image0.png")
-        title = "Added album to queue"
-        descrip = f"{album.title} - {album.artist().title}"
-
-        embed = discord.Embed(
-            title=title, description=descrip, colour=discord.Color.red()
-        )
-        embed.set_author(name="Plex")
-        embed.set_thumbnail(url="attachment://image0.png")
-        bot_log.debug("Built embed for album - %s", album.title)
-
-        return embed, art_file
-
-    @staticmethod
-    def _build_embed_playlist(self, playlist, title, descrip):
-        """
-        Creates a pretty embed card for playlists
-
-        Builds a helpful status embed with the following info:
-        playlist art. All pertitent information
-        is grabbed dynamically from the Plex db.
-
-        Args:
-            playlist: plexapi.playlist object of playlist
-
-        Returns:
-            embed: discord.embed fully constructed payload.
-            thumb_art: io.BytesIO of playlist thumbnail img.
-
-        Raises:
-            None
-        """
-        # Grab the relevant thumbnail
-        try:
-            img_stream = requests.get(self.pms.url(playlist.composite, True), stream=True).raw
-            img = io.BytesIO(img_stream.read())
-        except:
-            raise MediaNotFoundError("no image available")
-
-        # Attach to discord embed
-        art_file = discord.File(img, filename="image0.png")
-
-        embed = discord.Embed(
-            title=title, description=descrip, colour=discord.Color.red()
-        )
-        embed.set_author(name="Plex")
-        embed.set_thumbnail(url="attachment://image0.png")
-        bot_log.debug("Built embed for playlist - %s", playlist.title)
-
-        return embed, art_file
-
-    async def _validate(self, ctx):
-        """
-        Ensures user is in a vc
-
-        Args:
-            ctx: discord.ext.commands.Context message context from command
-
-        Returns:
-            None
-
-        Raises:
-            VoiceChannelError: Author not in voice channel
-        """
-        # Fail if user not in vc
-        if not ctx.author.voice:
-            await ctx.send("Join a voice channel first!")
-            bot_log.debug("Failed to play, requester not in voice channel")
-            raise VoiceChannelError
-
-        # Connect to voice if not already
-        if not self.voice_channel:
-            try:
-                self.voice_channel = await ctx.author.voice.channel.connect()
-                bot_log.debug("Connected to vc.")
-            except asyncio.exceptions.TimeoutError:
-                bot_log.debug("Cannot connect to vc - timeout")
-
     @command()
     async def play(self, ctx, *args):
-        """
+        """User command to start playback
-        User command to play song
 
         Searchs plex db and either, initiates playback, or
         adds to queue. Handles invalid usage from the user.
@@ -573,188 +325,44 @@ class Plex(commands.Cog):
         """
         # Save the context to use with async callbacks
         self.ctx = ctx
-        title = " ".join(args)
 
-        try:
+        if not args:
-            track = self._search_tracks(title)
+            await ctx.send(f"Usage: {self.bot_prefix}play TITLE_OF_SONG")
-        except MediaNotFoundError:
+            bot_log.debug("Failed to play, invalid usage")
+            return
+
+        title = " ".join(args)
+        track = self._search_tracks(title)
+
+        # Fail if song title can't be found
+        if not track:
             await ctx.send(f"Can't find song: {title}")
             bot_log.debug("Failed to play, can't find song - %s", title)
             return
 
-        try:
+        # Fail if user not in vc
-            await self._validate(ctx)
+        if not ctx.author.voice:
-        except VoiceChannelError:
+            await ctx.send("Join a voice channel first!")
-            pass
+            bot_log.debug("Failed to play, requester not in voice channel")
+            return
+
+        # Connect to voice if not already
+        if not self.voice_channel:
+            self.voice_channel = await ctx.author.voice.channel.connect()
+            bot_log.debug("Connected to vc.")
 
         # Specific add to queue message
-        if self.voice_channel and self.voice_channel.is_playing():
+        if self.voice_channel.is_playing():
             bot_log.debug("Added to queue - %s", title)
-            embed, img = self._build_embed_track(track, type_="queue")
+            embed, img = self._build_embed(track, type_="queue")
             await ctx.send(embed=embed, file=img)
 
         # Add the song to the async queue
         await self.play_queue.put(track)
 
-    @command()
-    async def album(self, ctx, *args):
-        """
-        User command to play song
-
-        Searchs plex db and either, initiates playback, or
-        adds to queue. Handles invalid usage from the user.
-
-        Args:
-            ctx: discord.ext.commands.Context message context from command
-            *args: Title of song to play
-
-        Returns:
-            None
-
-        Raises:
-            None
-        """
-        # Save the context to use with async callbacks
-        self.ctx = ctx
-        title = " ".join(args)
-
-        try:
-            album = self._search_albums(title)
-        except MediaNotFoundError:
-            await ctx.send(f"Can't find album: {title}")
-            bot_log.debug("Failed to queue album, can't find - %s", title)
-            return
-
-        try:
-            await self._validate(ctx)
-        except VoiceChannelError:
-            pass
-
-        bot_log.debug("Added to queue - %s", title)
-        embed, img = self._build_embed_album(album)
-        await ctx.send(embed=embed, file=img)
-
-        for track in album.tracks():
-            await self.play_queue.put(track)
-
-    async def play_playlist(self, title, shuffle=False):
-        try:
-            playlist = self._search_playlists(title)
-        except MediaNotFoundError:
-            await self.ctx.send(f"Can't find playlist: {title}")
-            bot_log.debug("Failed to queue playlist, can't find - %s", title)
-            return
-
-        try:
-            await self._validate(self.ctx)
-        except VoiceChannelError:
-            pass
-
-        try:
-            embed, img = self._build_embed_playlist(self, playlist, "Added playlist to queue", playlist.title)
-            await self.ctx.send(embed=embed, file=img)
-
-            items = [ item for item in playlist.items() if item.TYPE == "track" ]
-            if shuffle:
-                from random import shuffle
-                shuffle(items)
-
-            for item in items:
-                await self.play_queue.put(item)
-
-            bot_log.debug("Added to queue - %s", title)
-
-        except MediaNotFoundError:
-            await self.ctx.send(message="Playlist "+title+" seems to be empty!")
-            bot_log.debug("Playlist empty - %s", title)
-
-    @command()
-    async def playlist(self, ctx, *args):
-        """
-        User command to play playlist
-
-        Searchs plex db and either, initiates playback, or
-        adds to queue. Handles invalid usage from the user.
-
-        Args:
-            ctx: discord.ext.commands.Context message context from command
-            *args: Title of playlist to play
-
-        Returns:
-            None
-
-        Raises:
-            None
-        """
-        # Save the context to use with async callbacks
-        self.ctx = ctx
-        title = " ".join(args)
-        await self.play_playlist(title)
-
-    @command()
-    async def playlist_shuffle(self, ctx, *args):
-        """
-        User command to play playlist in shuffle mode
-
-        Searchs plex db and either, initiates playback, or
-        adds to queue. Handles invalid usage from the user.
-
-        Args:
-            ctx: discord.ext.commands.Context message context from command
-            *args: Title of playlist to play
-
-        Returns:
-            None
-
-        Raises:
-            None
-        """
-        # Save the context to use with async callbacks
-        self.ctx = ctx
-        title = " ".join(args)
-        await self.play_playlist(title,shuffle=True)
-
-
-    @command()
-    async def show_playlists(self, ctx, *args):
-        """
-        User command to show playlists
-
-        Searchs plex db and shows playlists matching.
-
-        Args:
-            ctx: discord.ext.commands.Context message context from command
-            *args: String filter for playlist names
-
-        Returns:
-            None
-
-        Raises:
-            None
-        """
-        # Save the context to use with async callbacks
-        self.ctx = ctx
-
-        playlists = self._get_playlists()
-
-        try:
-            await self._validate(ctx)
-        except VoiceChannelError:
-            pass
-
-        for playlist in playlists:
-            if args and not any(arg in playlist.title for arg in args):
-                continue
-            from datetime import timedelta
-            if playlist.duration:
-                seconds = playlist.duration / 1000
-                embed, img = self._build_embed_playlist(self, playlist, playlist.title, "{:0>8}".format(str(timedelta(seconds=seconds))))
-                await ctx.send(embed=embed, file=img)
-
     @command()
     async def stop(self, ctx):
-        """
+        """User command to stop playback
-        User command to stop playback
 
         Stops playback and disconnects from vc.
 
@@ -775,84 +383,9 @@ class Plex(commands.Cog):
             bot_log.debug("Stopped")
             await ctx.send(":stop_button: Stopped")
 
-    @command()
-    async def loop(self, ctx):
-        """
-        User command to activate looping the current track
-
-        Args:
-            ctx: discord.ext.commands.Context message context from command
-
-        Returns:
-            None
-
-        Raises:
-            None
-        """
-        bot_log.debug("Looping "+str(self.current_track))
-        self.is_looping = self.current_track
-
-    @command()
-    async def loopq(self, ctx):
-        """
-        User command to activate looping the current queue
-
-        Args:
-            ctx: discord.ext.commands.Context message context from command
-
-        Returns:
-            None
-
-        Raises:
-            None
-        """
-        bot_log.debug("Looping current queue")
-        if self.current_track:
-            self.loop_queue = [ self.current_track ]
-        else:
-            self.loop_queue = []
-        for item in self.play_queue._queue:
-            self.loop_queue.append(item)
-
-    @command()
-    async def unloop(self, ctx):
-        """
-        User command to deactivate looping the current track
-
-        Args:
-            ctx: discord.ext.commands.Context message context from command
-
-        Returns:
-            None
-
-        Raises:
-            None
-        """
-        bot_log.debug("Looping current queue")
-        self.is_looping = False
-
-    @command()
-    async def unloopq(self, ctx):
-        """
-        User command to deactivate looping the current queue
-
-        Args:
-            ctx: discord.ext.commands.Context message context from command
-
-        Returns:
-            None
-
-        Raises:
-            None
-        """
-        bot_log.debug("Unlooping")
-        self.loop_queue = None
-
-
     @command()
     async def pause(self, ctx):
-        """
+        """User command to pause playback
-        User command to pause playback
 
         Pauses playback, but doesn't reset anything
         to allow playback resuming.
@@ -873,8 +406,7 @@ class Plex(commands.Cog):
 
     @command()
     async def resume(self, ctx):
-        """
+        """User command to resume playback
-        User command to resume playback
 
         Args:
             ctx: discord.ext.commands.Context message context from command
@@ -891,9 +423,8 @@ class Plex(commands.Cog):
             await ctx.send(":play_pause: Resumed")
 
     @command()
-    async def skip(self, ctx, *args):
+    async def skip(self, ctx):
-        """
+        """User command to skip song in queue
-        User command to skip song in queue
 
         Skips currently playing song. If no other songs in
         queue, stops playback, otherwise moves to next song.
@@ -907,22 +438,15 @@ class Plex(commands.Cog):
         Raises:
             None
         """
-        n = 1
+        bot_log.debug("Skip")
-        if args:
-            n = int(args[0])
-        bot_log.debug("Skipping "+str(n))
         if self.voice_channel:
             self.voice_channel.stop()
             bot_log.debug("Skipped")
-            if n>1:
-                for i in range(n-1):
-                    await self.play_queue.get()
             self._toggle_next()
 
     @command(name="np")
     async def now_playing(self, ctx):
-        """
+        """User command to get currently playing song.
-        User command to get currently playing song.
 
         Deletes old `now playing` status message,
         Creates a new one with up to date information.
@@ -937,55 +461,18 @@ class Plex(commands.Cog):
             None
         """
         if self.current_track:
-            embed, img = self._build_embed_track(self.current_track,type_="play")
+            embed, img = self._build_embed(self.current_track)
             bot_log.debug("Now playing")
             if self.np_message_id:
-                try:
+                await self.np_message_id.delete()
-                    await self.np_message_id.delete()
+                bot_log.debug("Deleted old np status")
-                    bot_log.debug("Deleted old np status")
-                except discord.errors.NotFound:
-                    pass
 
             bot_log.debug("Created np status")
             self.np_message_id = await ctx.send(embed=embed, file=img)
 
-    @command(name="q")
-    async def show_queue(self, ctx):
-        """
-        User command to print the current queue
-
-        Deletes old `now playing` status message,
-        Creates a new one with up to date information.
-
-        Args:
-            ctx: discord.ext.commands.Context message context from command
-
-        Returns:
-            None
-
-        Raises:
-            None
-        """
-        bot_log.debug("Deleted old queue messages")
-        for msg in self.show_queue_message_ids:
-            await msg.delete()
-
-        # need to do this in order to avoid errors when queue is modified during inspection
-        elems = []
-        for track in self.play_queue._queue:
-            elems.append(track)
-
-        for track in elems:
-            embed, img = self._build_embed_track(track,type_="queued")
-            bot_log.debug("Show queue")
-
-            bot_log.debug("Created queue message")
-            self.show_queue_message_ids.append(await ctx.send(embed=embed, file=img))
-
     @command()
     async def clear(self, ctx):
-        """
+        """User command to clear play queue.
-        User command to clear play queue.
 
         Args:
             ctx: discord.ext.commands.Context message context from command
@@ -997,58 +484,5 @@ class Plex(commands.Cog):
             None
         """
         self.play_queue = asyncio.Queue()
-        self.loop_queue = None
         bot_log.debug("Cleared queue")
         await ctx.send(":boom: Queue cleared.")
-
-    @command()
-    async def lyrics(self, ctx):
-        """
-        User command to get lyrics of a song.
-
-        Args:
-            ctx: discord.ext.commands.Context message context from command
-
-            Returns:
-                None
-
-            Raises:
-                None
-        """
-        if not self.current_track:
-            plex_log.info("No song currently playing")
-            return
-
-        if self.genius:
-            plex_log.info(
-                "Searching for %s, %s",
-                self.current_track.title,
-                self.current_track.artist().title,
-            )
-            try:
-                song = self.genius.search_song(
-                    self.current_track.title, self.current_track.artist().title
-                )
-            except TypeError:
-                self.genius = None
-                plex_log.error("Invalid genius token, disabling lyrics")
-                return
-
-            try:
-                lyrics = song.lyrics
-                # Split into 1950 char chunks
-                # Discord max message length is 2000
-                lines = [(lyrics[i : i + 1950]) for i in range(0, len(lyrics), 1950)]
-
-                for i in lines:
-                    if i == "":
-                        continue
-                    # Apply code block format
-                    i = f"```{i}```"
-                    await ctx.send(i)
-
-            except (IndexError, TypeError):
-                plex_log.info("Could not find lyrics")
-                await ctx.send("Can't find lyrics for this song.")
-        else:
-            plex_log.warning("Attempted lyrics without valid token")

PlexBot/exceptions.py

@@ -1,10 +0,0 @@
-class MediaNotFoundError(Exception):
-    """Raised when a PlexAPI media resource cannot be found."""
-
-    pass
-
-
-class VoiceChannelError(Exception):
-    """Raised when user is not connected to a voice channel."""
-
-    pass

README.md

@@ -1,6 +1,5 @@
 # Plex-Bot
 
-[![Codacy Badge](https://api.codacy.com/project/badge/Grade/c93b8ff976ce4205a95046487917476b)](https://app.codacy.com/manual/jarulsamy/Plex-Bot?utm_source=github.com&utm_medium=referral&utm_content=jarulsamy/Plex-Bot&utm_campaign=Badge_Grade_Dashboard)
 [![GPLv3 license](https://img.shields.io/badge/License-GPLv3-blue.svg)](http://perso.crans.org/besson/LICENSE.html)
 ![docker pulls](https://img.shields.io/docker/pulls/jarulsamy/plex-bot)
 ![docker img size](https://img.shields.io/docker/image-size/jarulsamy/plex-bot)
@@ -63,9 +62,6 @@ Plex-Bot runs entirely in a Docker container. Ensure you have Docker and docker-
      token: "<PLEX_TOKEN>"
      library_name: "<LIBRARY_NAME>"
      log_level: "debug"
-
-   lyrics:
-     token: "none" # Add your token here if you enable lyrics
    ```
 
 4. Create a Discord bot application:
@@ -92,25 +88,11 @@ Plex-Bot runs entirely in a Docker container. Ensure you have Docker and docker-
 
      * Add it to `config/config.yaml` in the appropiate spot.
 
-6. Get your Lyrics Genius token (Optional):
+6. Customize remaining settings
-
-   If you would like to enable the lyrics feature of the bot, you need to signup for a free GeniusLyrics account, [here](https://genius.com/api-clients).
-
-   After you make an account:
-
-   1. Click New API Client
-
-   2. Set the app website url to: `https://github.com/jarulsamy/Plex-Bot`
-
-   3. Set the redirect url to: `http://localhost`
-
-   4. Copy the **Client Access Token** and replace `None` with your token in `config/config.yaml`
-
-7. Customize remaining settings
 
     Set any remaining settings in the config file that you would like. Such as music library, and base url of the Plex server.
 
-8. Start the service:
+7. Start the service:
 
    ```bash
    docker-compose up -d
@@ -131,22 +113,19 @@ docker-compose logs -f PlexBot
 
 ```text
 General:
-    kill [silent] - Halt the bot [silently].
+  kill - Stop the bot.
-    help - Print this help message.
-    cleanup - Delete old messages from the bot.
-
 Plex:
-    play <SONG_NAME> - Play a song from the plex server.
+  np - View currently playing song.
-    album <ALBUM_NAME> - Queue an entire album to play.
+  pause - Pause currently playing song.
-    playlist <PLAYLIST_NAME> - Queue an entire playlist to play.
+  play - Play a song from the Plex library.
-    lyrics - Print the lyrics of the song (Requires Genius API)
+  resume - Resume a paused song.
-    np - Print the current playing song.
+  skip - Skip a song.
-    stop - Halt playback and leave vc.
+  stop - Stop playing.
-    pause - Pause playback.
+​No Category:
-    resume - Resume playback.
+  help   Shows this message
-    clear - Clear play queue.
 
-[] - Optional args.
+Type ?help command for more info on a command.
+You can also type ?help category for more info on a category.
 ```
 
 * * *

docker-compose_dev.yml

@@ -1,13 +0,0 @@
-version: "3"
-services:
-  plex-bot:
-    container_name: "PlexBot"
-    build: .
-    environment:
-      - PUID=1000
-      - PGID=1000
-      - TZ=America/Denver
-    # Required dir for configuration files
-    volumes:
-      - "./config:/config:ro"
-    restart: "no"

requirements.txt

@@ -1,7 +1,6 @@
-discord.py==1.4.1
+discord.py==1.3.4
 PlexAPI==4.0.0
 fuzzywuzzy==0.18.0
 pynacl==1.4.0
 ffmpeg==1.4
 PyYAML==5.3.1
-lyricsgenius==2.0.0

sample-config.yaml

@@ -11,6 +11,3 @@ plex:
   token: "<PLEX_TOKEN>"
   library_name: "<LIBRARY_NAME>"
   log_level: "debug"
-
-lyrics:
-  token: <CLIENT_ACCESS_TOKEN>