🔖 Tag release

Add better detail of bot creation

Add badges

Add sample docker-compose.yml

Dockerfile

@@ -1,11 +1,11 @@
-# Python 3.7
+FROM python:3.7-slim
-FROM python:3.7
 
-# Update system
-RUN apt-get -y update
-RUN apt-get -y upgrade
 # Install ffmpeg
-RUN apt-get install -y ffmpeg
+RUN apt-get -y update && \
+    apt-get install -y --no-install-recommends ffmpeg && \
+    apt-get autoremove -y && \
+    apt-get clean && \
+    rm -rf /var/lib/apt/lists/*
 
 # All source code
 WORKDIR /src
@@ -14,11 +14,10 @@ WORKDIR /src
 COPY requirements.txt .
 
 # Install all dependencies.
-RUN pip install -r requirements.txt
+RUN pip install --no-cache-dir -r requirements.txt
 
 # Copy PlexBot over to src.
 COPY PlexBot/ PlexBot
 
 # Run the bot
-# CMD ["python", "-OO", "-m", "PlexBot"]
+CMD ["python", "-OO", "-m", "PlexBot"]
-CMD ["python", "-m", "PlexBot"]

Jenkinsfile

@@ -35,7 +35,7 @@ pipeline {
                 echo "Style check"
                 sh  ''' source /var/lib/jenkins/miniconda3/etc/profile.d/conda.sh
                         conda activate ${BUILD_TAG}
-                        pylint CHANGE_ME || true
+                        pylint PlexBot || true
                     '''
             }
         }
@@ -49,33 +49,26 @@ pipeline {
             steps {
                 sh  ''' source /var/lib/jenkins/miniconda3/etc/profile.d/conda.sh
                         conda activate ${BUILD_TAG}
-                        pwd
+                        ./deploy/build.sh
-                        ls
-                        python setup.py bdist_wheel
                     '''
             }
-            post {
+        }
-                always {
+        stage('Push Image') {
-                    // Archive unit tests for the future
+            when {
-                    archiveArtifacts (allowEmptyArchive: true,
+                expression {
-                                     artifacts: 'dist/*whl',
+                    currentBuild.result == 'SUCCESS'
-                                     fingerprint: true)
                 }
             }
+            steps {
+                sh './deploy/push.sh'
+            }
         }
     }
 
     post {
         always {
             sh 'conda remove --yes -n ${BUILD_TAG} --all'
-        }
+            sh 'docker system prune -a -f'
-        failure {
-            emailext (
-                subject: "FAILED: Job '${env.JOB_NAME} [${env.BUILD_NUMBER}]'",
-                body: """<p>FAILED: Job '${env.JOB_NAME} [${env.BUILD_NUMBER}]':</p>
-                         <p>Check console output at &QUOT;<a href='${env.BUILD_URL}'>${env.JOB_NAME} [${env.BUILD_NUMBER}]</a>&QUOT;</p>""",
-                recipientProviders: [[$class: 'DevelopersRecipientProvider']]
-            )
         }
     }
 }

PlexBot/__init__.py

@@ -1,3 +1,9 @@
+"""
+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
 from pathlib import Path
@@ -8,19 +14,33 @@ import yaml
 FORMAT = "%(asctime)s %(levelname)s: [%(filename)s:%(lineno)s - %(funcName)20s() ] %(message)s"
 
 logging.basicConfig(format=FORMAT)
-logger = logging.getLogger("PlexBot")
+root_log = logging.getLogger()
+plex_log = logging.getLogger("Plex")
+bot_log = logging.getLogger("Bot")
 
 
 def load_config(filename: str) -> Dict[str, str]:
+    """Loads config from yaml file
 
+    Grabs key/value config pairs from a file.
+
+    Args:
+        filename: str path to yaml file.
+
+    Returns:
+        Dict[str, str] Values from config file.
+
+    Raises:
+        FileNotFound Configuration file not found.
+    """
     # All config files should be in /config
     # for docker deployment.
     filename = Path("/config", filename)
     try:
-        with open(filename, "r") as f:
+        with open(filename, "r") as config_file:
-            config = yaml.safe_load(f)
+            config = yaml.safe_load(config_file)
     except FileNotFoundError:
-        logging.fatal("Configuration file not found.")
+        root_log.fatal("Configuration file not found.")
         sys.exit(-1)
 
     # Convert str level type to logging constant
@@ -31,7 +51,9 @@ def load_config(filename: str) -> Dict[str, str]:
         "ERROR": logging.ERROR,
         "CRITICAL": logging.CRITICAL,
     }
-    level = config["general"]["log_level"]
+
-    config["general"]["log_level"] = levels[level.upper()]
+    config["root"]["log_level"] = levels[config["root"]["log_level"].upper()]
+    config["plex"]["log_level"] = levels[config["plex"]["log_level"].upper()]
+    config["discord"]["log_level"] = levels[config["discord"]["log_level"].upper()]
 
     return config

PlexBot/__main__.py

@@ -1,11 +1,14 @@
+"""
+Main entrypoint script.
+Sets up loggers and initiates bot.
+"""
 import logging
 
 from discord.ext.commands import Bot
 
-from . import FORMAT
+from . import load_config
 from .bot import General
 from .bot import Plex
-from PlexBot import load_config
 
 # Load config from file
 config = load_config("config.yaml")
@@ -16,12 +19,14 @@ TOKEN = config["discord"]["token"]
 BASE_URL = config["plex"]["base_url"]
 PLEX_TOKEN = config["plex"]["token"]
 LIBRARY_NAME = config["plex"]["library_name"]
-LOG_LEVEL = config["general"]["log_level"]
 
 # Set appropiate log level
-logger = logging.getLogger("PlexBot")
+root_log = logging.getLogger()
-logging.basicConfig(format=FORMAT)
+plex_log = logging.getLogger("Plex")
-logger.setLevel(LOG_LEVEL)
+bot_log = logging.getLogger("Bot")
+
+plex_log.setLevel(config["plex"]["log_level"])
+bot_log.setLevel(config["discord"]["log_level"])
 
 bot = Bot(command_prefix=BOT_PREFIX)
 bot.add_cog(General(bot))

PlexBot/__version__.py

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

PlexBot/bot.py

@@ -1,3 +1,4 @@
+"""All discord bot and Plex api interactions."""
 import asyncio
 import io
 import logging
@@ -12,116 +13,283 @@ from fuzzywuzzy import fuzz
 from plexapi.exceptions import Unauthorized
 from plexapi.server import PlexServer
 
-logger = logging.getLogger("PlexBot")
+root_log = logging.getLogger()
+plex_log = logging.getLogger("Plex")
+bot_log = logging.getLogger("Bot")
 
 
 class General(commands.Cog):
+    """General commands
+
+    Manage general bot behavior
+    """
+
     def __init__(self, bot):
+        """Initialize commands
+
+        Args:
+            bot: discord.ext.command.Bot, bind for cogs
+
+        Returns:
+            None
+
+        Raises:
+            None
+        """
         self.bot = bot
 
     @command()
-    async def kill(self, ctx):
+    async def kill(self, ctx, *args):
-        await ctx.send(f"Stopping upon the request of {ctx.author.mention}")
+        """Kill the bot
+
+        Args:
+            ctx: discord.ext.commands.Context message context from command
+            *args: optional flags
+
+        Returns:
+            None
+
+        Raises:
+            None
+        """
+        if "silent" not in args:
+            await ctx.send(f"Stopping upon the request of {ctx.author.mention}")
+
         await self.bot.close()
-        logger.info(f"Stopping upon the request of {ctx.author.mention}")
+        bot_log.info("Stopping upon the request of %s", ctx.author.mention)
+
+    @command()
+    async def cleanup(self, ctx, limit=250):
+        """Delete old messages from bot
+
+        Args:
+            ctx: discord.ext.commands.Context message context from command
+            limit: int number of messages to go back by to delete. Default 250
+
+        Raises:
+            None
+
+        Returns:
+            None
+        """
+        channel = ctx.message.channel
+
+        try:
+            async for i in channel.history(limit=limit):
+                # Only delete messages sent by self
+                if i.author == self.bot.user:
+                    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):
-    def __init__(self, bot, base_url, plex_token, lib_name, bot_prefix) -> None:
+    """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.
+
+    """
+
+    # pylint: disable=too-many-instance-attributes
+    # All are necessary to detect global interactions
+    # within the bot.
+
+    def __init__(
+        self, bot, base_url: str, plex_token: str, lib_name: str, bot_prefix: str
+    ):
+        """Initializes Plex resources
+
+        Connects to Plex library and sets up
+        all asyncronous communications.
+
+        Args:
+            bot: discord.ext.command.Bot, bind for cogs
+            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
+
+        Returns:
+            None
+        """
+
         self.bot = bot
         self.base_url = base_url
         self.plex_token = plex_token
         self.library_name = lib_name
         self.bot_prefix = bot_prefix
 
+        # Log fatal invalid plex token
         try:
             self.pms = PlexServer(self.base_url, self.plex_token)
         except Unauthorized:
-            logger.fatal("Invalid Plex token, stopping...")
+            plex_log.fatal("Invalid Plex token, stopping...")
             raise Unauthorized("Invalid Plex token")
 
         self.music = self.pms.library.section(self.library_name)
+        plex_log.debug("Connected to plex library: %s", self.library_name)
 
-        self.vc = None
+        # Initialize necessary vars
+        self.voice_channel = None
         self.current_track = None
+        self.np_message_id = None
+        self.ctx = None
+
+        # Initialize events
         self.play_queue = asyncio.Queue()
         self.play_next_event = asyncio.Event()
 
+        bot_log.info("Started bot successfully")
         self.bot.loop.create_task(self._audio_player_task())
 
-        logger.info("Started bot successfully")
+    def _search_tracks(self, title: str):
+        """Search the Plex music db
 
-    def _search_tracks(self, title):
+        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 closest matching title
+            None if song can't be found.
+
+        Raises:
+            None
+        """
         tracks = self.music.searchTracks()
         score = [None, -1]
         for i in tracks:
-            s = fuzz.ratio(title.lower(), i.title.lower())
+            ratio = fuzz.ratio(title.lower(), i.title.lower())
-            if s > score[1]:
+            if ratio > score[1]:
                 score[0] = i
-                score[1] = s
+                score[1] = ratio
-            elif s == score[1]:
+            elif ratio == score[1]:
                 score[0] = i
 
         return score[0]
 
-    @command()
-    async def hello(self, ctx, *, member: discord.member = None):
-        member = member or ctx.author
-        await ctx.send(f"Hello {member}")
-
     async def _play(self):
+        """Heavy lifting of playing songs
+
+        Grabs the appropiate streaming URL, sends the `now playing`
+        message, and initiates playback in the vc.
+
+        Args:
+            None
+
+        Returns:
+            None
+
+        Raises:
+            None
+        """
         track_url = self.current_track.getStreamURL()
         audio_stream = FFmpegPCMAudio(track_url)
 
-        while self.vc.is_playing():
+        while self.voice_channel.is_playing():
             asyncio.sleep(2)
 
-        self.vc.play(audio_stream, after=self._toggle_next)
+        self.voice_channel.play(audio_stream, after=self._toggle_next)
 
-        logger.debug(f"Playing {self.current_track.title}")
+        plex_log.debug("%s - URL: %s", self.current_track, track_url)
-        logger.debug(f"URL: {track_url}")
 
-        embed, f = self._build_embed(self.current_track)
+        embed, img = self._build_embed(self.current_track)
-        await self.ctx.send(embed=embed, file=f)
+        self.np_message_id = await self.ctx.send(embed=embed, file=img)
 
     async def _audio_player_task(self):
+        """Coroutine to handle playback and queuing
+
+        Always-running function awaiting new songs to be added.
+        Auto disconnects from VC if idle for > 15 seconds.
+        Handles auto deletion of now playing song notifications.
+
+        Args:
+            None
+
+        Returns:
+            None
+
+        Raises:
+            None
+        """
         while True:
             self.play_next_event.clear()
-            if self.vc:
+            if self.voice_channel:
                 try:
                     # Disconnect after 15 seconds idle
                     async with timeout(15):
                         self.current_track = await self.play_queue.get()
                 except asyncio.TimeoutError:
-                    await self.vc.disconnect()
+                    await self.voice_channel.disconnect()
-                    self.vc = None
+                    self.voice_channel = None
 
             if not self.current_track:
                 self.current_track = await self.play_queue.get()
 
             await self._play()
             await self.play_next_event.wait()
+            await self.np_message_id.delete()
 
     def _toggle_next(self, error=None):
+        """Callback for vc playback
+
+        Clears current track, then activates _audio_player_task
+        to play next in queue or disconnect.
+
+        Args:
+            error: Optional parameter required for discord.py callback
+
+        Returns:
+            None
+
+        Raises:
+            None
+        """
         self.current_track = None
         self.bot.loop.call_soon_threadsafe(self.play_next_event.set)
 
-    def _build_embed(self, track, t="play"):
+    def _build_embed(self, track, type_="play"):
         """Creates a pretty embed card.
+
+        Builds a helpful status embed with the following info:
+        Status, song title, album, artistm and album art. All
+        pertitent information is grabbed dynamically from the Plex db.
+
+        Args:
+            track: plexapi.audio.Track object of song
+            type_: Type of card to make (play, queue).
+
+        Returns:
+            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
         img_stream = urlopen(track.thumbUrl)
         img = io.BytesIO(img_stream.read())
 
         # Attach to discord embed
-        f = discord.File(img, filename="image0.png")
+        art_file = discord.File(img, filename="image0.png")
         # Get appropiate status message
-        if t == "play":
+        if type_ == "play":
             title = f"Now Playing - {track.title}"
-        elif t == "queue":
+        elif type_ == "queue":
             title = f"Added to queue - {track.title}"
         else:
-            raise ValueError(f"Unsupported type of embed {t}")
+            raise ValueError(f"Unsupported type of embed {type_}")
 
         # Include song details
         descrip = f"{track.album().title} - {track.artist().title}"
@@ -134,13 +302,33 @@ class Plex(commands.Cog):
         # Point to file attached with ctx object.
         embed.set_thumbnail(url="attachment://image0.png")
 
-        return embed, f
+        bot_log.debug("Built embed for %s", track.title)
+
+        return embed, art_file
 
     @command()
     async def play(self, ctx, *args):
+        """User command to start playback
 
-        if not len(args):
+        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
+
+        if not args:
             await ctx.send(f"Usage: {self.bot_prefix}play TITLE_OF_SONG")
+            bot_log.debug("Failed to play, invalid usage")
             return
 
         title = " ".join(args)
@@ -149,62 +337,152 @@ class Plex(commands.Cog):
         # 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
+
         # Fail if user not in vc
-        elif not ctx.author.voice:
+        if not ctx.author.voice:
             await ctx.send("Join a voice channel first!")
+            bot_log.debug("Failed to play, requester not in voice channel")
             return
 
         # Connect to voice if not already
-        if not self.vc:
+        if not self.voice_channel:
-            self.vc = await ctx.author.voice.channel.connect()
+            self.voice_channel = await ctx.author.voice.channel.connect()
-            logger.debug("Connected to vc.")
+            bot_log.debug("Connected to vc.")
 
         # Specific add to queue message
-        if self.vc.is_playing():
+        if self.voice_channel.is_playing():
-            embed, f = self._build_embed(track, t="queue")
+            bot_log.debug("Added to queue - %s", title)
-            await ctx.send(embed=embed, file=f)
+            embed, img = self._build_embed(track, type_="queue")
+            await ctx.send(embed=embed, file=img)
 
-        # Save the context to use with async callbacks
-        self.ctx = ctx
         # Add the song to the async queue
         await self.play_queue.put(track)
 
     @command()
     async def stop(self, ctx):
-        if self.vc:
+        """User command to stop playback
-            self.vc.stop()
+
-            await self.vc.disconnect()
+        Stops playback and disconnects from vc.
-            self.vc = None
+
+        Args:
+            ctx: discord.ext.commands.Context message context from command
+
+        Returns:
+            None
+
+        Raises:
+            None
+        """
+        if self.voice_channel:
+            self.voice_channel.stop()
+            await self.voice_channel.disconnect()
+            self.voice_channel = None
             self.ctx = None
+            bot_log.debug("Stopped")
             await ctx.send(":stop_button: Stopped")
 
     @command()
     async def pause(self, ctx):
-        if self.vc:
+        """User command to pause playback
-            self.vc.pause()
+
+        Pauses playback, but doesn't reset anything
+        to allow playback resuming.
+
+        Args:
+            ctx: discord.ext.commands.Context message context from command
+
+        Returns:
+            None
+
+        Raises:
+            None
+        """
+        if self.voice_channel:
+            self.voice_channel.pause()
+            bot_log.debug("Paused")
             await ctx.send(":play_pause: Paused")
 
     @command()
     async def resume(self, ctx):
-        if self.vc:
+        """User command to resume playback
-            self.vc.resume()
+
+        Args:
+            ctx: discord.ext.commands.Context message context from command
+
+        Returns:
+            None
+
+        Raises:
+            None
+        """
+        if self.voice_channel:
+            self.voice_channel.resume()
+            bot_log.debug("Resumed")
             await ctx.send(":play_pause: Resumed")
 
     @command()
     async def skip(self, ctx):
-        logger.debug("Skip")
+        """User command to skip song in queue
-        if self.vc:
+
-            self.vc.stop()
+        Skips currently playing song. If no other songs in
+        queue, stops playback, otherwise moves to next song.
+
+        Args:
+            ctx: discord.ext.commands.Context message context from command
+
+        Returns:
+            None
+
+        Raises:
+            None
+        """
+        bot_log.debug("Skip")
+        if self.voice_channel:
+            self.voice_channel.stop()
+            bot_log.debug("Skipped")
             self._toggle_next()
 
-    @command()
+    @command(name="np")
-    async def np(self, ctx):
+    async def now_playing(self, ctx):
+        """User command to get currently playing song.
+
+        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
+        """
         if self.current_track:
-            embed, f = self._build_embed(self.current_track)
+            embed, img = self._build_embed(self.current_track)
-            await ctx.send(embed=embed, file=f)
+            bot_log.debug("Now playing")
+            if self.np_message_id:
+                await self.np_message_id.delete()
+                bot_log.debug("Deleted old np status")
+
+            bot_log.debug("Created np status")
+            self.np_message_id = await ctx.send(embed=embed, file=img)
 
     @command()
     async def clear(self, ctx):
+        """User command to clear play queue.
+
+        Args:
+            ctx: discord.ext.commands.Context message context from command
+
+        Returns:
+            None
+
+        Raises:
+            None
+        """
         self.play_queue = asyncio.Queue()
+        bot_log.debug("Cleared queue")
         await ctx.send(":boom: Queue cleared.")

README.md

@@ -1,28 +1,70 @@
 # Plex-Bot
 
+[![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)
+![black badge](https://img.shields.io/badge/code%20style-black-000000.svg)
+
 A Python-based Plex music bot for discord.
 
+![screenshot](assets/screenshot.png)
+
 ## Setup
 
 Plex-Bot runs entirely in a Docker container. Ensure you have Docker and docker-compose installed according to the official Docker [documentation](https://docs.docker.com/get-docker/).
 
-1.  Clone the repository and `cd` into it:
+1. Create a new folder and `cd` into it:
 
-```
+   ```bash
-$ git clone https://github.com/jarulsamy/Plex-Bot
+   mkdir Plex-Bot
-$ cd Plex-Bot
+   cd Plex-Bot
-```
+   ```
 
-2. Create a configuration folder:
+2. Make a `docker-compose.yml` file or use this sample:
 
-Create a new `config` folder and copy the sample config file into it:
+   ```yml
+   version: "3"
+   services:
+     plex-bot:
+       container_name: "PlexBot"
+       image: jarulsamy/plex-bot:latest
+       environment:
+         - PUID=1000
+         - PGID=1000
+         - TZ=America/Denver
+       # Required dir for configuration files
+       volumes:
+         - "./config:/config:ro"
+       restart: "unless-stopped"
+   ```
 
-```
+3. Create a new `config` folder and create a config file like this::
-$ mkdir config
-$ cp sample-config.yaml config/config.yaml
-```
 
-3.  Create a Discord bot application:
+    ```bash
+    mkdir config
+    cd config
+    touch config.yaml
+    ```
+
+   ```yml
+   # Create a file called config.yaml with the following contents
+
+   root:
+     log_level: "info"
+
+   discord:
+     prefix: "?"
+     token: "<BOT_TOKEN>"
+     log_level: "debug"
+
+   plex:
+     base_url: "<BASE_URL>"
+     token: "<PLEX_TOKEN>"
+     library_name: "<LIBRARY_NAME>"
+     log_level: "debug"
+   ```
+
+4. Create a Discord bot application:
 
     1. Go to the Discord developer portal, [here](https://discord.com/developers/applications).
 
@@ -38,23 +80,38 @@ $ cp sample-config.yaml config/config.yaml
     6. Click Create Bot User
         This will provide you with your bot Username and Token
 
-    7. Fill in all the necessary numbers in `config/config.yaml`
+    7. Fill in the bot token in `config/config.yaml`
 
-4. Get your plex token:
+5. Get your plex token:
 
-   Refer to the official [plex documentation](https://support.plex.tv/articles/204059436-finding-an-authentication-token-x-plex-token/).
+     * Refer to the official [plex documentation](https://support.plex.tv/articles/204059436-finding-an-authentication-token-x-plex-token/).
 
-   Add it to `config/config.yaml` in the appropiate spot.
+     * Add it to `config/config.yaml` in the appropiate spot.
 
-5. Start the service:
+6. 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.
-$ docker-compose up --build
+
+7. Start the service:
+
+   ```bash
+   docker-compose up -d
+   ```
+
+## Logs
+
+You can view the logs with the following command
+
+```bash
+docker-compose logs -f CONTAINER_NAME_OR_ID
+
+# For example
+docker-compose logs -f PlexBot
 ```
 
 ## Usage
 
-```
+```text
 General:
   kill - Stop the bot.
 Plex:
@@ -71,11 +128,4 @@ Type ?help command for more info on a command.
 You can also type ?help category for more info on a category.
 ```
 
-## Support
-
-Reach out to me at one of the following places!
-
--   Email (Best) at joshua.gf.arul@gmail.com
--   Twitter at <a href="http://twitter.com/jarulsamy_" target="_blank">`@jarulsamy_`</a>
-
 * * *

deploy/build.sh

@@ -0,0 +1,14 @@
+#!/usr/bin/env bash
+
+VERSION=$(python PlexBot/__version__.py)
+
+docker build -t "jarulsamy/plex-bot:$VERSION" .
+
+if [ $? -eq 0 ]
+then
+  echo "Successfully build docker image."
+  exit 0
+else
+  echo "Failed to build docker image." >&2
+  exit 1
+fi

deploy/push.sh

@@ -0,0 +1,14 @@
+#!/usr/bin/env bash
+
+VERSION=$(python PlexBot/__version__.py)
+
+docker push "jarulsamy/plex-bot:$VERSION"
+
+if [ $? -eq 0 ]
+then
+  echo "Successfully pushed docker image."
+  exit 0
+else
+  echo "Failed to push docker image." >&2
+  exit 1
+fi

docker-compose.yml

@@ -2,7 +2,7 @@ version: "3"
 services:
   plex-bot:
     container_name: "PlexBot"
-    build: .
+    image: jarulsamy/plex-bot:latest
     environment:
       - PUID=1000
       - PGID=1000
@@ -10,4 +10,4 @@ services:
     # Required dir for configuration files
     volumes:
       - "./config:/config:ro"
-    restart: "no"
+    restart: "unless-stopped"

requirements.txt

@@ -1,7 +1,6 @@
 discord.py==1.3.4
 PlexAPI==4.0.0
 fuzzywuzzy==0.18.0
-python-Levenshtein==0.12.0
 pynacl==1.4.0
 ffmpeg==1.4
 PyYAML==5.3.1

sample-config.yaml

@@ -1,12 +1,13 @@
-general:
+root:
-  # Options: debug, info, warning, error, critical
   log_level: "info"
 
 discord:
   prefix: "?"
   token: "<BOT_TOKEN>"
+  log_level: "debug"
 
 plex:
   base_url: "<BASE_URL>"
   token: "<PLEX_TOKEN>"
   library_name: "<LIBRARY_NAME>"
+  log_level: "debug"