gigidsss/Plex-Bot-Music
1
0
Fork 0
mirror of https://github.com/jarulsamy/Plex-Bot.git synced 2024-08-19 15:01:55 +02:00
Code Issues Projects Releases Wiki Activity

Compare commits

base: gigidsss:master
Branches Tags
gigidsss:master
gigidsss:hotfix
gigidsss:dev
gigidsss:v1.0.3
gigidsss:v1.0.2
gigidsss:v1.0.1
gigidsss:v1.0.0
gigidsss:v0.0.6
gigidsss:v0.0.4
gigidsss:v0.0.3
gigidsss:v0.0.2
gigidsss:v0.0.1
..
compare: gigidsss:v0.0.6
Branches Tags
gigidsss:master
gigidsss:hotfix
gigidsss:dev
gigidsss:v1.0.3
gigidsss:v1.0.2
gigidsss:v1.0.1
gigidsss:v1.0.0
gigidsss:v0.0.6
gigidsss:v0.0.4
gigidsss:v0.0.3
gigidsss:v0.0.2
gigidsss:v0.0.1

No commits in common. "master" and "v0.0.6" have entirely different histories.
master ... v0.0.6

18 changed files with 177 additions and 887 deletions
Show Stats Expand all files Collapse all files

6
Dockerfile
View File

@ -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/*
@ -16,7 +14,7 @@ WORKDIR /src
COPY requirements.txt .
# Install all dependencies.
RUN pip install --no-cache-dir -r requirements.txt
RUN pip install --only-binary all --no-cache-dir -r requirements.txt
# Copy PlexBot over to src.
COPY PlexBot/ PlexBot

18
Jenkinsfile vendored
View File

@ -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,12 +47,19 @@ pipeline {
}
}
steps {
sh './deploy/build.sh'
sh ''' source /var/lib/jenkins/miniconda3/etc/profile.d/conda.sh
conda activate ${BUILD_TAG}
python deploy/build.py
'''
}
}
stage('Push Image') {
steps {
sh './deploy/push.sh'
post {
always {
// Archive unit tests for the future
archiveArtifacts (allowEmptyArchive: true,
artifacts: 'dist/*whl',
fingerprint: true)
sh 'python deploy/push.py'
}
}
}
}

17
Makefile
View File

@ -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

15
PlexBot/__init__.py
View File

@ -1,5 +1,7 @@
"""
Plex music bot for discord.
"""Plex music bot for discord.
Do not import this module, it is intended to be
used exclusively within a docker environment.
"""
import logging
@ -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

29
PlexBot/__main__.py
View File

@ -1,6 +1,7 @@
"""
Main entrypoint script.
Sets up loggers and initiates bot.
"""Main entrypoint for bot
Sets up loggers and initiates bot.
"""
import logging
@ -11,11 +12,7 @@ from .bot import General
from .bot import Plex
# Load config from file
configdir = "config"
from os import geteuid
if geteuid() == 0:
configdir = "/config"
config = load_config(configdir,"config.yaml")
config = load_config("config.yaml")
BOT_PREFIX = config["discord"]["prefix"]
TOKEN = config["discord"]["token"]
@ -24,11 +21,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 +29,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)

7
PlexBot/__version__.py
View File

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

748
PlexBot/bot.py
View File

@ -1,64 +1,31 @@
"""All discord bot and Plex api interactions."""
""" All discord bot and Plex api interactions"""
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):
"""
Initializes Plex resources
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.
@ -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.plex_token = kwargs["plex_token"]
self.library_name = kwargs["lib_name"]
self.bot_prefix = bot.command_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
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:
@ -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 for track
"""Search the Plex music db
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)
try:
return results[0]
except IndexError:
raise MediaNotFoundError("Track cannot be found")
tracks = self.music.searchTracks()
score = [None, -1]
for i in tracks:
ratio = fuzz.ratio(title.lower(), i.title.lower())
if ratio > score[1]:
score[0] = i
score[1] = ratio
elif ratio == score[1]:
score[0] = i
def _search_albums(self, title: str):
"""
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()
return score[0]
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():
bot_log.debug("waiting for track to finish")
await asyncio.sleep(2)
bot_log.debug("track finished")
while self.voice_channel.is_playing():
asyncio.sleep(2)
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)
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")
embed, img = self._build_embed(self.current_track)
self.np_message_id = await self.ctx.send(embed=embed, file=img)
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_track(track, type_="play"):
"""
Creates a pretty embed card for tracks
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, 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 = requests.get(track.thumbUrl, stream=True).raw
img = io.BytesIO(img_stream.read())
# Attach to discord embed
art_file = discord.File(img, filename="image0.png")
else:
art_file = None
img_stream = urlopen(track.thumbUrl)
img = io.BytesIO(img_stream.read())
# 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 play song
"""User command to start playback
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:
track = self._search_tracks(title)
except MediaNotFoundError:
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)
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:
await self._validate(ctx)
except VoiceChannelError:
pass
# 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")
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):
"""
User command to skip song in queue
async def skip(self, ctx):
"""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
if args:
n = int(args[0])
bot_log.debug("Skipping "+str(n))
bot_log.debug("Skip")
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()
bot_log.debug("Deleted old np status")
except discord.errors.NotFound:
pass
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(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")

10
PlexBot/exceptions.py
View File

@ -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

147
README.md
View File

@ -1,74 +1,28 @@
# 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)
![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. Create a new folder and `cd` into it:
1. Clone the repository and `cd` into it:
```bash
mkdir Plex-Bot
cd Plex-Bot
```
```
$ git clone https://github.com/jarulsamy/Plex-Bot
$ cd Plex-Bot
```
2. Make a `docker-compose.yml` file or use this sample:
2. Create a configuration folder:
```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"
```
Create a new `config` folder and copy the sample config file into it:
3. Create a new `config` folder and create a config file like this::
```
$ mkdir config
$ cp sample-config.yaml config/config.yaml
```
```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"
lyrics:
token: "none" # Add your token here if you enable lyrics
```
4. Create a Discord bot application:
3. Create a Discord bot application:
1. Go to the Discord developer portal, [here](https://discord.com/developers/applications).
@ -84,69 +38,44 @@ Plex-Bot runs entirely in a Docker container. Ensure you have Docker and docker-
6. Click Create Bot User
This will provide you with your bot Username and Token
7. Fill in the bot token in `config/config.yaml`
7. Fill in all the necessary numbers in `config/config.yaml`
5. Get your plex token:
4. 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.
6. Get your Lyrics Genius token (Optional):
5. Start the service:
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:
```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
```
$ docker-compose up --build
```
## Usage
```text
```
General:
kill [silent] - Halt the bot [silently].
help - Print this help message.
cleanup - Delete old messages from the bot.
kill - Stop 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.
lyrics - Print the lyrics of the song (Requires Genius API)
np - Print the current playing song.
stop - Halt playback and leave vc.
pause - Pause playback.
resume - Resume playback.
clear - Clear play queue.
np - View currently playing song.
pause - Pause currently playing song.
play - Play a song from the Plex library.
resume - Resume a paused song.
skip - Skip a song.
stop - Stop playing.
​No Category:
help Shows this message
[] - Optional args.
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>
* * *

BIN
assets/screenshot.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 17 KiB

8
deploy/build.py Normal file
View File

@ -0,0 +1,8 @@
import os
import sys
sys.path.append("PlexBot")
from __version__ import VERSION
sys.exit(os.system(f"docker build -t jarulsamy/plex-bot:{VERSION} ."))

14
deploy/build.sh
View File

@ -1,14 +0,0 @@
#!/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

8
deploy/push.py Executable file
View File

@ -0,0 +1,8 @@
import os
import sys
sys.path.append("PlexBot")
from __version__ import VERSION
sys.exit(os.system(f"docker push jarulsamy/plex-bot:{VERSION}"))

14
deploy/push.sh
View File

@ -1,14 +0,0 @@
#!/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

4
docker-compose.yml
View File

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

13
docker-compose_dev.yml
View File

@ -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"

3
requirements.txt
View File

@ -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

3
sample-config.yaml
View File

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