#!/usr/bin/env python
# -*- coding: utf-8 -*-
import sys
import signal
import datetime
from datetime import time
from time import mktime as mktime
import logging
import calendar
import itertools
import argparse
import textwrap
import os, sys
from xml.dom import minidom
import xml.etree.ElementTree as ET
import json
from pprint import pprint
import random
import re
from plexapi.server import PlexServer
import schedule
from time import sleep
from src import PseudoChannelDatabase
from src import Movie
from src import Commercial
from src import Episode
from src import Music
from src import Video
from src import PseudoDailyScheduleController
from src import PseudoChannelCommercial
from src import PseudoChannelRandomMovie
import pseudo_config as config
reload(sys)
sys.setdefaultencoding('utf-8')
class PseudoChannel():
PLEX = PlexServer(config.baseurl, config.token)
MEDIA = []
GKEY = config.gkey
USING_COMMERCIAL_INJECTION = config.useCommercialInjection
DAILY_UPDATE_TIME = config.dailyUpdateTime
APP_TIME_FORMAT_STR = '%I:%M:%S %p'
COMMERCIAL_PADDING_IN_SECONDS = config.commercialPadding
CONTROLLER_SERVER_PATH = config.controllerServerPath
CONTROLLER_SERVER_PORT = config.controllerServerPort
USE_OVERRIDE_CACHE = config.useDailyOverlapCache
DEBUG = config.debug_mode
ROTATE_LOG = config.rotateLog
USE_DIRTY_GAP_FIX = config.useDirtyGapFix
HTML_PSEUDO_TITLE = config.htmlPseudoTitle
def __init__(self):
logging.basicConfig(filename="pseudo-channel.log", level=logging.INFO)
self.db = PseudoChannelDatabase("pseudo-channel.db")
self.controller = PseudoDailyScheduleController(
config.baseurl,
config.token,
config.plexClients,
self.CONTROLLER_SERVER_PATH,
self.CONTROLLER_SERVER_PORT,
self.DEBUG,
self.HTML_PSEUDO_TITLE
)
self.movieMagic = PseudoChannelRandomMovie()
"""Database functions.
update_db(): Grab the media from the Plex DB and store it in the local pseudo-channel.db.
drop_db(): Drop the local database. Fresh start.
update_schedule(): Update schedule with user defined times.
drop_schedule(): Drop the user defined schedule table.
generate_daily_schedule(): Generates daily schedule based on the "schedule" table.
"""
# Print iterations progress
def print_progress(self, iteration, total, prefix='', suffix='', decimals=1, bar_length=100):
"""
Call in a loop to create terminal progress bar
@params:
iteration - Required : current iteration (Int)
total - Required : total iterations (Int)
prefix - Optional : prefix string (Str)
suffix - Optional : suffix string (Str)
decimals - Optional : positive number of decimals in percent complete (Int)
bar_length - Optional : character length of bar (Int)
"""
str_format = "{0:." + str(decimals) + "f}"
percents = str_format.format(100 * (iteration / float(total)))
filled_length = int(round(bar_length * iteration / float(total)))
bar = '█' * filled_length + '-' * (bar_length - filled_length)
sys.stdout.write('\r%s |%s| %s%s %s' % (prefix, bar, percents, '%', suffix)),
if iteration == total:
sys.stdout.write('\n')
sys.stdout.flush()
def update_db(self):
print("#### Updating Local Database")
self.db.create_tables()
libs_dict = config.plexLibraries
sections = self.PLEX.library.sections()
for section in sections:
for correct_lib_name, user_lib_name in libs_dict.items():
if section.title.lower() in [x.lower() for x in user_lib_name]:
if correct_lib_name == "Movies":
sectionMedia = self.PLEX.library.section(section.title).all()
for i, media in enumerate(sectionMedia):
self.db.add_movies_to_db(1, media.title, media.duration, media.key, section.title)
self.print_progress(
i + 1,
len(sectionMedia),
prefix = 'Progress '+section.title+": ",
suffix = 'Complete',
bar_length = 40
)
elif correct_lib_name == "TV Shows":
sectionMedia = self.PLEX.library.section(section.title).all()
for i, media in enumerate(sectionMedia):
backgroundImagePath = self.PLEX.library.section(section.title).get(media.title)
backgroundImgURL = ''
if isinstance(backgroundImagePath.art, str):
backgroundImgURL = config.baseurl+backgroundImagePath.art+"?X-Plex-Token="+config.token
self.db.add_shows_to_db(
2,
media.title,
media.duration if media.duration else 1,
'',
backgroundImgURL,
media.key,
section.title
)
self.print_progress(
i + 1,
len(sectionMedia),
prefix = 'Progress '+section.title+": ",
suffix = 'Complete',
bar_length = 40
)
#add all episodes of each tv show to episodes table
episodes = self.PLEX.library.section(section.title).get(media.title).episodes()
for episode in episodes:
duration = episode.duration
if duration:
self.db.add_episodes_to_db(
4,
episode.title,
duration,
episode.index,
episode.parentIndex,
media.title,
episode.key,
section.title
)
else:
self.db.add_episodes_to_db(
4,
episode.title,
0,
episode.index,
episode.parentIndex,
media.title,
episode.key,
section.title
)
elif correct_lib_name == "Commercials":
print "user_lib_name", section.title
sectionMedia = self.PLEX.library.section(section.title).all()
media_length = len(sectionMedia)
for i, media in enumerate(sectionMedia):
self.db.add_commercials_to_db(3, media.title, media.duration, media.key, section.title)
self.print_progress(
i + 1,
media_length,
prefix = 'Progress '+section.title+":",
suffix = 'Complete',
bar_length = 40
)
def update_schedule(self):
"""Changing dir to the schedules dir."""
abspath = os.path.abspath(__file__)
dname = os.path.dirname(abspath)
os.chdir(dname)
self.db.create_tables()
self.db.remove_all_scheduled_items()
scheduled_days_list = [
"mondays",
"tuesdays",
"wednesdays",
"thursdays",
"fridays",
"saturdays",
"sundays",
"weekdays",
"weekends",
"everyday"
]
section_dict = {
"TV Shows" : ["series", "shows", "tv", "episodes", "tv shows", "show"],
"Movies" : ["movie", "movies", "films", "film"],
"Videos" : ["video", "videos", "vid"],
"Music" : ["music", "songs", "song", "tune", "tunes"]
}
tree = ET.parse('pseudo_schedule.xml')
root = tree.getroot()
for child in root:
if child.tag in scheduled_days_list:
for time in child.iter("time"):
for key, value in section_dict.items():
if time.attrib['type'] == key or time.attrib['type'] in value:
title = time.attrib['title'] if 'title' in time.attrib else ''
natural_start_time = self.translate_time(time.text)
natural_end_time = 0
section = key
day_of_week = child.tag
strict_time = time.attrib['strict-time'] if 'strict-time' in time.attrib else 'false'
time_shift = time.attrib['time-shift'] if 'time-shift' in time.attrib else '1'
overlap_max = time.attrib['overlap-max'] if 'overlap-max' in time.attrib else ''
seriesOffset = time.attrib['series-offset'] if 'series-offset' in time.attrib else ''
xtra = time.attrib['xtra'] if 'xtra' in time.attrib else ''
# start_time_unix = self.translate_time(time.text)
now = datetime.datetime.now()
start_time_unix = mktime(
datetime.datetime.strptime(
self.translate_time(natural_start_time),
self.APP_TIME_FORMAT_STR).replace(day=now.day, month=now.month, year=now.year).timetuple()
)
print "Adding: ", time.tag, section, time.text, time.attrib['title']
self.db.add_schedule_to_db(
0, # mediaID
title, # title
0, # duration
natural_start_time, # startTime
natural_end_time, # endTime
day_of_week, # dayOfWeek
start_time_unix, # startTimeUnix
section, # section
strict_time, # strictTime
time_shift, # timeShift
overlap_max, # overlapMax
xtra, # xtra kargs (i.e. 'director=director')
)
def drop_db(self):
self.db.drop_db()
def drop_schedule(self):
self.db.drop_schedule()
def remove_all_scheduled_items():
self.db.remove_all_scheduled_items()
def translate_time(self, timestr):
try:
return datetime.datetime.strptime(timestr, '%I:%M %p').strftime(self.APP_TIME_FORMAT_STR)
except ValueError as e:
pass
try:
return datetime.datetime.strptime(timestr, '%I:%M:%S %p').strftime(self.APP_TIME_FORMAT_STR)
except ValueError as e:
pass
try:
return datetime.datetime.strptime(timestr, '%H:%M').strftime(self.APP_TIME_FORMAT_STR)
except ValueError as e:
pass
return timestr
def time_diff(self, time1,time2):
'''
*
* Getting the offest by comparing both times from the unix epoch time and getting the difference.
*
'''
timeA = datetime.datetime.strptime(time1, '%I:%M:%S %p')
timeB = datetime.datetime.strptime(time2, '%I:%M:%S %p')
timeAEpoch = calendar.timegm(timeA.timetuple())
timeBEpoch = calendar.timegm(timeB.timetuple())
tdelta = abs(timeAEpoch) - abs(timeBEpoch)
return int(tdelta/60)
'''
*
* Passing in the endtime from the prev episode and desired start time of this episode, calculate the best start time
* Returns time - for new start time
*
'''
def calculate_start_time(self, prevEndTime, intendedStartTime, timeGap, overlapMax):
self.TIME_GAP = timeGap
self.OVERLAP_GAP = timeGap
self.OVERLAP_MAX = overlapMax
time1 = prevEndTime.strftime('%I:%M:%S %p')
timeB = datetime.datetime.strptime(intendedStartTime, '%I:%M:%S %p').strftime(self.APP_TIME_FORMAT_STR)
print "++++ Previous End Time: ", time1, "Intended start time: ", timeB
timeDiff = self.time_diff(time1, timeB)
"""print("timeDiff "+ str(timeDiff))
print("startTimeUNIX: "+ str(intendedStartTime))"""
newTimeObj = timeB
newStartTime = timeB
'''
*
* If time difference is negative, then we know there is overlap
*
'''
if timeDiff < 0:
'''
*
* If there is an overlap, then the overlapGap var in config will determine the next increment. If it is set to "15", then the show will will bump up to the next 15 minute interval past the hour.
*
'''
#hourToUse = self.DAILY_UPDATE_TIME.split(':')[0]
#minuteToUse = self.DAILY_UPDATE_TIME.split(':')[1]
#now = datetime.datetime(1900, 1, 1, int(hourToUse), int(minuteToUse))
#timeset = [(now + datetime.timedelta(minutes=int(self.OVERLAP_GAP)*n)).strftime('%H:%M') for n in range((60*24)/int(self.OVERLAP_GAP))]
timeset=[datetime.time(h,m).strftime("%H:%M") for h,m in itertools.product(xrange(0,24),xrange(0,60,int(self.OVERLAP_GAP)))]
#print timeset
timeSetToUse = None
for time in timeset:
theTimeSetInterval = datetime.datetime.strptime(time, '%H:%M')
if theTimeSetInterval >= prevEndTime:
print "++++ There is overlap. Setting new time-interval:", theTimeSetInterval
newStartTime = theTimeSetInterval
break
elif (timeDiff >= 0) and (self.TIME_GAP != -1):
'''
*
* If this value is configured, then the timeGap var in config will determine the next increment.
* If it is set to "15", then the show will will bump up to the next 15 minute interval past the hour.
*
'''
#hourToUse = self.DAILY_UPDATE_TIME.split(':')[0]
#minuteToUse = self.DAILY_UPDATE_TIME.split(':')[1]
#now = datetime.datetime(1900, 1, 1, int(hourToUse), int(minuteToUse))
#timeset = [(now + datetime.timedelta(minutes=int(self.OVERLAP_GAP)*n)).strftime('%H:%M') for n in range((60*24)/int(self.OVERLAP_GAP))]
timeset=[datetime.time(h,m).strftime("%H:%M") for h,m in itertools.product(xrange(0,24),xrange(0,60,int(self.TIME_GAP)))]
#print timeset
for time in timeset:
theTimeSetInterval = datetime.datetime.strptime(time, '%H:%M')
tempTimeTwoStr = datetime.datetime.strptime(time1, self.APP_TIME_FORMAT_STR).strftime('%H:%M')
formatted_time_two = datetime.datetime.strptime(tempTimeTwoStr, '%H:%M')
if theTimeSetInterval >= formatted_time_two:
print "++++ Setting new time-interval:", theTimeSetInterval
newStartTime = theTimeSetInterval
break
else:
print("Not sure what to do here")
return newStartTime.strftime('%I:%M:%S %p')
def get_end_time_from_duration(self, startTime, duration):
time = datetime.datetime.strptime(startTime, '%I:%M:%S %p')
show_time_plus_duration = time + datetime.timedelta(milliseconds=duration)
return show_time_plus_duration
def generate_daily_schedule(self):
print("#### Generating Daily Schedule")
#logging.info("##### Dropping previous daily_schedule database")
#self.db.remove_all_daily_scheduled_items()
self.db.drop_daily_schedule_table()
self.db.create_daily_schedule_table()
if self.USING_COMMERCIAL_INJECTION:
self.commercials = PseudoChannelCommercial(
self.db.get_commercials(),
self.COMMERCIAL_PADDING_IN_SECONDS,
self.USE_DIRTY_GAP_FIX
)
schedule = self.db.get_schedule()
weekday_dict = {
"0" : ["mondays", "weekdays", "everyday"],
"1" : ["tuesdays", "weekdays", "everyday"],
"2" : ["wednesdays", "weekdays", "everyday"],
"3" : ["thursdays", "weekdays", "everyday"],
"4" : ["fridays", "weekdays", "everyday"],
"5" : ["saturdays", "weekends", "everyday"],
"6" : ["sundays", "weekends", "everyday"],
}
weekno = datetime.datetime.today().weekday()
schedule_advance_watcher = 0
for entry in schedule:
schedule_advance_watcher += 1
section = entry[9]
for key, val in weekday_dict.iteritems():
if str(entry[7]) in str(val) and int(weekno) == int(key):
if section == "TV Shows":
if str(entry[3]).lower() == "random":
next_episode = self.db.get_random_episode()
else:
next_episode = self.db.get_next_episode(entry[3])
if next_episode != None:
customSectionName = next_episode[9]
episode = Episode(
section, # section_type
next_episode[3], # title
entry[5], # natural_start_time
self.get_end_time_from_duration(self.translate_time(entry[5]), next_episode[4]), # natural_end_time
next_episode[4], # duration
entry[7], # day_of_week
entry[10], # is_strict_time
entry[11], # time_shift
entry[12], # overlap_max
next_episode[8] if len(next_episode) >= 9 else '', # plex id
customSectionName, # custom lib name
entry[3], # show_series_title
next_episode[5], # episode_number
next_episode[6], # season_number
)
self.MEDIA.append(episode)
else:
print("Cannot find TV Show Episode, {} in the local db".format(entry[3]))
elif section == "Movies":
if str(entry[3]).lower() == "random":
if(entry[13] != ''): # xtra params
"""
Using specified Movies library names
"""
movies_list = []
libs_dict = config.plexLibraries
sections = self.PLEX.library.sections()
for theSection in sections:
for correct_lib_name, user_lib_name in libs_dict.items():
if theSection.title.lower() in [x.lower() for x in user_lib_name]:
print "correct_lib_name", correct_lib_name
if correct_lib_name == "Movies":
print "entry[13]", entry[13]
movies = self.PLEX.library.section(theSection.title)
try:
thestr = entry[13]
regex = re.compile(r"\b(\w+)\s*:\s*([^:]*)(?=\s+\w+\s*:|$)")
d = dict(regex.findall(thestr))
# turn values into list
for key, val in d.iteritems():
d[key] = val.split(',')
for movie in movies.search(None, **d):
movies_list.append(movie)
"""the_movie = self.db.get_movie(self.movieMagic.get_random_movie_xtra(
self.db.get_movies(),# Movies DB
movies_list # XTRA List
)
)"""
except:
pass
if (len(movies_list) > 0):
the_movie = self.db.get_movie(random.choice(movies_list).title)
"""Updating movies table in the db with lastPlayedDate entry"""
self.db.update_movies_table_with_last_played_date(the_movie[3])
else:
print "movies_list", movies_list
print("For some reason, I've failed getting movie with xtra args.")
the_movie = self.db.get_random_movie()
"""Updating movies table in the db with lastPlayedDate entry"""
self.db.update_movies_table_with_last_played_date(the_movie[3])
else:
"""the_movie = self.db.get_movie(self.movieMagic.get_random_movie(
self.db.get_movies(),# Movies DB
)
)"""
the_movie = self.db.get_random_movie()
"""Updating movies table in the db with lastPlayedDate entry"""
self.db.update_movies_table_with_last_played_date(the_movie[3])
else:
the_movie = self.db.get_movie(entry[3])
if the_movie != None:
movie = Movie(
section, # section_type
the_movie[3], # title
entry[5], # natural_start_time
self.get_end_time_from_duration(entry[5], the_movie[4]), # natural_end_time
the_movie[4], # duration
entry[7], # day_of_week
entry[10], # is_strict_time
entry[11], # time_shift
entry[12], # overlap_max
the_movie[6], # plex id
the_movie[7] # custom lib name
)
self.MEDIA.append(movie)
else:
print str("Cannot find Movie, {} in the local db".format(entry[3])).encode('UTF-8')
elif section == "Music":
the_music = self.db.get_music(entry[3])
if the_music != None:
music = Music(
section, # section_type
the_music[3], # title
entry[5], # natural_start_time
self.get_end_time_from_duration(entry[5], the_music[4]), # natural_end_time
the_music[4], # duration
entry[7], # day_of_week
entry[10], # is_strict_time
entry[11], # time_shift
entry[12], # overlap_max
the_music[6], # plex id
the_music[7], # custom lib name
)
self.MEDIA.append(music)
else:
print str("Cannot find Music, {} in the local db".format(entry[3])).encode('UTF-8')
elif section == "Video":
the_video = self.db.get_video(entry[3])
if the_music != None:
video = Video(
section, # section_type
the_video[3], # title
entry[5], # natural_start_time
self.get_end_time_from_duration(entry[5], the_video[4]), # natural_end_time
the_video[4], # duration
entry[7], # day_of_week
entry[10], # is_strict_time
entry[11], # time_shift
entry[12], # overlap_max
the_video[6], # plex id
the_video[7], # custom lib name
)
self.MEDIA.append(video)
else:
print str("Cannot find Video, {} in the local db".format(entry[3])).encode('UTF-8')
else:
pass
"""If we reached the end of the scheduled items for today, add them to the daily schedule
"""
if schedule_advance_watcher >= len(schedule):
print "+++++ Finished processing time entries, recreating daily_schedule"
previous_episode = None
for entry in self.MEDIA:
if previous_episode != None:
natural_start_time = datetime.datetime.strptime(entry.natural_start_time, self.APP_TIME_FORMAT_STR)
natural_end_time = entry.natural_end_time
if entry.is_strict_time.lower() == "true":
print "++++ Strict-time: {}".format(str(entry.title))
entry.end_time = self.get_end_time_from_duration(
self.translate_time(entry.start_time),
entry.duration
)
"""Get List of Commercials to inject"""
if self.USING_COMMERCIAL_INJECTION:
list_of_commercials = self.commercials.get_commercials_to_place_between_media(
previous_episode,
entry
)
for commercial in list_of_commercials:
self.db.add_media_to_daily_schedule(commercial)
self.db.add_media_to_daily_schedule(entry)
previous_episode = entry
else:
try:
print "++++ NOT strict-time: {}".format(str(entry.title).encode(sys.stdout.encoding, errors='replace'))
except:
pass
try:
new_starttime = self.calculate_start_time(
previous_episode.end_time,
entry.natural_start_time,
previous_episode.time_shift,
""
)
except:
print("Error in calculate_start_time")
print "++++ New start time:", new_starttime
entry.start_time = datetime.datetime.strptime(new_starttime, self.APP_TIME_FORMAT_STR).strftime('%I:%M:%S %p')
entry.end_time = self.get_end_time_from_duration(entry.start_time, entry.duration)
"""Get List of Commercials to inject"""
if self.USING_COMMERCIAL_INJECTION:
list_of_commercials = self.commercials.get_commercials_to_place_between_media(
previous_episode,
entry
)
for commercial in list_of_commercials:
self.db.add_media_to_daily_schedule(commercial)
self.db.add_media_to_daily_schedule(entry)
previous_episode = entry
else:
self.db.add_media_to_daily_schedule(entry)
previous_episode = entry
#self.make_xml_schedule()
def run_commercial_injection(self):
pass
def make_xml_schedule(self):
self.controller.make_xml_schedule(self.db.get_daily_schedule())
def show_clients(self):
print "##### Connected Clients:"
for i, client in enumerate(self.PLEX.clients()):
print "+++++", str(i + 1)+".", "Client:", client.title
def show_schedule(self):
print "##### Daily Pseudo Schedule:"
daily_schedule = self.db.get_daily_schedule()
for i , entry in enumerate(daily_schedule):
print str("+++++ {} {} {} {} {} {}".format(str(i + 1)+".", entry[8], entry[11], entry[6], " - ", entry[3])).encode(sys.stdout.encoding, errors='replace')
def write_json_to_file(self, data, fileName):
fileName = fileName
writepath = './'
if os.path.exists(writepath+fileName):
os.remove(writepath+fileName)
mode = 'a' if os.path.exists(writepath) else 'w'
with open(writepath+fileName, mode) as f:
f.write(data)
def export_queue(self):
shows_table = self.db.get_shows_table()
json_string = json.dumps(shows_table)
print "+++++ Exporting queue "
self.write_json_to_file(json_string, "pseudo-queue.json")
print "+++++ Done."
self.export_daily_schedule()
def import_queue(self):
"""Dropping previous shows table before adding the imported data"""
#self.db.clear_shows_table()
with open('pseudo-queue.json') as data_file:
data = json.load(data_file)
#print(data)
for row in data:
print "lastEpisodeTitle:", row[5]
self.db.import_shows_table_by_row(
row[2],
row[3],
row[4],
row[5],
row[6],
row[7],
)
print "+++++ Done. Imported queue."
self.import_daily_schedule()
def export_daily_schedule(self):
daily_schedule_table = self.db.get_daily_schedule()
json_string = json.dumps(daily_schedule_table)
print "+++++ Exporting Daily Schedule "
self.write_json_to_file(json_string, "pseudo-daily_schedule.json")
print "+++++ Done."
def import_daily_schedule(self):
"""Dropping previous Daily Schedule table before adding the imported data"""
self.db.remove_all_daily_scheduled_items()
with open('pseudo-daily_schedule.json') as data_file:
data = json.load(data_file)
#pprint(data)
for row in data:
"""print row"""
self.db.import_daily_schedule_table_by_row(
row[2],
row[3],
row[4],
row[5],
row[6],
row[7],
row[8],
row[9],
row[10],
row[11],
row[12],
row[13],
)
print "+++++ Done. Imported Daily Schedule."
def get_daily_schedule_cache_as_json(self):
data = []
try:
with open('../.pseudo-cache/daily-schedule.json') as data_file:
data = json.load(data_file)
#pprint(data)
except IOError:
print ("----- Having issues opening the pseudo-cache file.")
return data
def save_daily_schedule_as_json(self):
daily_schedule_table = self.db.get_daily_schedule()
json_string = json.dumps(daily_schedule_table)
print "+++++ Saving Daily Schedule Cache "
self.save_file(json_string, 'daily-schedule.json', '../.pseudo-cache/')
def save_file(self, data, filename, path="./"):
fileName = filename
writepath = path
if not os.path.exists(writepath):
os.makedirs(writepath)
if os.path.exists(writepath+fileName):
os.remove(writepath+fileName)
mode = 'w'
with open(writepath+fileName, mode) as f:
f.write(data)
def rotate_log(self):
try:
os.remove('../pseudo-channel.log')
except OSError:
pass
try:
os.remove('./pseudo-channel.log')
except OSError:
pass
def signal_term_handler(self, signal, frame):
logging.info('+++++ got SIGTERM')
self.controller.stop_media()
self.exit_app()
sys.exit(0)
def exit_app(self):
logging.info(' - Exiting Pseudo TV & cleaning up.')
for i in self.MEDIA:
del i
self.MEDIA = None
self.controller = None
self.db = None
sleep(1)
if __name__ == '__main__':
pseudo_channel = PseudoChannel()
banner = textwrap.dedent('''\
# __ __
# |__)_ _ _| _ / |_ _ _ _ _| _
# | _)(-|_|(_|(_)\__| )(_|| )| )(-|. |_)\/
# | /
A Custom TV Channel for Plex
''')
parser = argparse.ArgumentParser(
formatter_class=argparse.RawDescriptionHelpFormatter,
description = banner)
'''
*
* Primary arguments: "python PseudoChannel.py -u -xml -g -r"
*
'''
parser.add_argument('-u', '--update',
action='store_true',
help='Update the local database with Plex libraries.')
parser.add_argument('-xml', '--xml',
action='store_true',
help='Update the local database with the pseudo_schedule.xml.')
parser.add_argument('-g', '--generate_schedule',
action='store_true',
help='Generate the daily schedule.')
parser.add_argument('-r', '--run',
action='store_true',
help='Run this program.')
'''
*
* Show connected clients: "python PseudoChannel.py -c"
*
'''
parser.add_argument('-c', '--show_clients',
action='store_true',
help='Show Plex clients.')
'''
*
* Show schedule (daily): "python PseudoChannel.py -s"
*
'''
parser.add_argument('-s', '--show_schedule',
action='store_true',
help='Show scheduled media for today.')
'''
*
* Make XML / HTML Schedule: "python PseudoChannel.py -m"
*
'''
parser.add_argument('-m', '--make_html',
action='store_true',
help='Makes the XML / HTML schedule based on the daily_schedule table.')
'''
*
* Export queue: "python PseudoChannel.py -e"
*
'''
parser.add_argument('-e', '--export_queue',
action='store_true',
help='Exports the current queue for episodes.')
'''
*
* Import queue: "python PseudoChannel.py -i"
*
'''
parser.add_argument('-i', '--import_queue',
action='store_true',
help='Imports the current queue for episodes.')
'''
*
* Export Daily Schedule: "python PseudoChannel.py -eds"
*
'''
parser.add_argument('-eds', '--export_daily_schedule',
action='store_true',
help='Exports the current Daily Schedule.')
'''
*
* Import Daily Schedule: "python PseudoChannel.py -ids"
*
'''
parser.add_argument('-ids', '--import_daily_schedule',
action='store_true',
help='Imports the current Daily Schedule.')
globals().update(vars(parser.parse_args()))
args = parser.parse_args()
if args.update:
pseudo_channel.update_db()
if args.xml:
pseudo_channel.update_schedule()
if args.show_clients:
pseudo_channel.show_clients()
if args.show_schedule:
pseudo_channel.show_schedule()
if args.export_queue:
pseudo_channel.export_queue()
if args.import_queue:
pseudo_channel.import_queue()
if args.export_daily_schedule:
pseudo_channel.export_daily_schedule()
if args.import_daily_schedule:
pseudo_channel.import_daily_schedule()
if args.generate_schedule:
if pseudo_channel.DEBUG:
pseudo_channel.generate_daily_schedule()
else:
try:
pseudo_channel.generate_daily_schedule()
except:
print("----- Recieved error when running generate_daily_schedule()")
if args.make_html:
pseudo_channel.make_xml_schedule()
if args.run:
print banner
print "+++++ To run this in the background:"
print "+++++", "screen -d -m bash -c 'python PseudoChannel.py -r; exec sh'"
"""Every minute on the minute check the DB startTimes of all media to
determine whether or not to play. Also, check the now_time to
see if it's midnight (or 23.59), if so then generate a new daily_schedule
"""
"""Every <user specified day> rotate log"""
dayToRotateLog = pseudo_channel.ROTATE_LOG.lower()
schedule.every().friday.at("00:00").do(pseudo_channel.rotate_log)
logging.info("+++++ Running PseudoChannel.py -r")
def trigger_what_should_be_playing_now():
def nearest(items, pivot):
return min(items, key=lambda x: abs(x - pivot))
daily_schedule = pseudo_channel.db.get_daily_schedule()
dates_list = [datetime.datetime.strptime(''.join(str(date[8])), "%I:%M:%S %p") for date in daily_schedule]
now = datetime.datetime.now()
now = now.replace(year=1900, month=1, day=1)
closest_media = nearest(dates_list, now)
print closest_media
prevItem = None
for item in daily_schedule:
item_time = datetime.datetime.strptime(''.join(str(item[8])), "%I:%M:%S %p")
if item_time == closest_media:
#print "Line 1088, Here", item
elapsed_time = closest_media - now
print elapsed_time.total_seconds()
try:
endTime = datetime.datetime.strptime(item[9], '%Y-%m-%d %H:%M:%S.%f')
except ValueError:
endTime = datetime.datetime.strptime(item[9], '%Y-%m-%d %H:%M:%S')
# we need to play the content and add an offest
if elapsed_time.total_seconds() < 0 and \
endTime > now:
print str("+++++ Queueing up {} to play right away.".format(item[3])).encode('UTF-8')
offset = int(abs(elapsed_time.total_seconds() * 1000))
pseudo_channel.controller.play(item, daily_schedule, offset)
break
elif elapsed_time.total_seconds() >= 0:
for itemTwo in daily_schedule:
item_timeTwo = datetime.datetime.strptime(''.join(str(itemTwo[8])), "%I:%M:%S %p")
try:
endTime = datetime.datetime.strptime(itemTwo[9], '%Y-%m-%d %H:%M:%S.%f')
except ValueError:
endTime = datetime.datetime.strptime(itemTwo[9], '%Y-%m-%d %H:%M:%S')
if item_timeTwo == closest_media and prevItem != None and \
endTime > now:
prevItem_time = datetime.datetime.strptime(''.join(str(prevItem[8])), "%I:%M:%S %p")
elapsed_timeTwo = prevItem_time - now
offsetTwo = int(abs(elapsed_timeTwo.total_seconds() * 1000))
if pseudo_channel.DEBUG:
print "+++++ Closest media was the next media " \
"but we were in the middle of something so triggering that instead."
print str("+++++ Queueing up '{}' to play right away.".format(prevItem[3])).encode('UTF-8')
pseudo_channel.controller.play(prevItem, daily_schedule, offsetTwo)
break
prevItem = itemTwo
def job_that_executes_once(item, schedulelist):
print str("##### Readying media: '{}'".format(item[3])).encode('UTF-8')
next_start_time = datetime.datetime.strptime(item[8], "%I:%M:%S %p")
now = datetime.datetime.now()
now = now.replace(year=1900, month=1, day=1)
time_diff = next_start_time - now
if time_diff.total_seconds() > 0:
print "+++++ Sleeping for {} seconds before playing: '{}'".format(time_diff.total_seconds(), item[3])
sleep(int(time_diff.total_seconds()))
if pseudo_channel.DEBUG:
print "+++++ Woke up!"
pseudo_channel.controller.play(item, schedulelist)
else:
pseudo_channel.controller.play(item, schedulelist)
return schedule.CancelJob
def generate_memory_schedule(schedulelist, isforupdate=False):
print "##### Generating Memory Schedule."
now = datetime.datetime.now()
now = now.replace(year=1900, month=1, day=1)
pseudo_cache = pseudo_channel.get_daily_schedule_cache_as_json()
prev_end_time_to_watch_for = None
if pseudo_channel.USE_OVERRIDE_CACHE and isforupdate:
for cached_item in pseudo_cache:
prev_start_time = datetime.datetime.strptime(cached_item[8], "%I:%M:%S %p")
try:
prev_end_time = datetime.datetime.strptime(cached_item[9], '%Y-%m-%d %H:%M:%S.%f')
except ValueError:
prev_end_time = datetime.datetime.strptime(cached_item[9], '%Y-%m-%d %H:%M:%S')
"""If update time is in between the prev media start / stop then there is overlap"""
if prev_start_time < now and prev_end_time > now:
try:
print "+++++ It looks like there is update schedule overlap", cached_item[3]
except:
pass
prev_end_time_to_watch_for = prev_end_time
for item in schedulelist:
trans_time = datetime.datetime.strptime(item[8], "%I:%M:%S %p").strftime("%H:%M")
new_start_time = datetime.datetime.strptime(item[8], "%I:%M:%S %p")
if prev_end_time_to_watch_for == None:
schedule.every().day.at(trans_time).do(job_that_executes_once, item, schedulelist).tag('daily-tasks')
else:
"""If prev end time is more then the start time of this media, skip it"""
if prev_end_time_to_watch_for > new_start_time:
try:
print "Skipping scheduling item do to cached overlap.", item[3]
except:
pass
continue
else:
schedule.every().day.at(trans_time).do(job_that_executes_once, item, schedulelist).tag('daily-tasks')
print "+++++ Done."
generate_memory_schedule(pseudo_channel.db.get_daily_schedule())
daily_update_time = datetime.datetime.strptime(
pseudo_channel.translate_time(
pseudo_channel.DAILY_UPDATE_TIME
),
pseudo_channel.APP_TIME_FORMAT_STR
).strftime('%H:%M')
def go_generate_daily_sched():
"""Saving current daily schedule as cached .json"""
pseudo_channel.save_daily_schedule_as_json()
schedule.clear('daily-tasks')
sleep(1)
try:
pseudo_channel.generate_daily_schedule()
except:
print("----- Recieved error when running generate_daily_schedule()")
generate_memory_schedule(pseudo_channel.db.get_daily_schedule(), True)
"""Commenting out below and leaving all updates to be handled by cron task"""
"""schedule.every().day.at(daily_update_time).do(
go_generate_daily_sched
).tag('daily-update')"""
sleep_before_triggering_play_now = 1
'''When the process is killed, stop any currently playing media & cleanup'''
signal.signal(signal.SIGTERM, pseudo_channel.signal_term_handler)
try:
while True:
schedule.run_pending()
sleep(1)
if sleep_before_triggering_play_now:
logging.info("+++++ Successfully started PseudoChannel.py")
trigger_what_should_be_playing_now()
sleep_before_triggering_play_now = 0
except KeyboardInterrupt:
print(' Manual break by user')
