def should_update_media(type, plex_object):
"""
Whether given plex media object rating should be updated
:param type: the type of media
:param plex_object: the plex object containing rating and ratingKey
:return: True if should be updated, False if not
"""
if type is "movie":
db_movie = Movie.select().where(Movie.plex_id == plex_object.ratingKey)
if db_movie.exists():
if util.check_media_needs_update(db_movie, plex_object):
return True
else:
return True
elif type is "show":
# getting show and episodes from show
db_show = Show.select().where(Show.plex_id == plex_object.ratingKey)
db_episodes = Episode.select().where(Episode.parent_plex_id == plex_object.ratingKey)
if db_show.exists():
if util.check_media_needs_update(db_show, plex_object):
return True
# if show doesn't need update, maybe a single episode need one
for episode in db_episodes:
if util.check_media_needs_update(episode, plex_object, check_rating=False):
return True
else:
return True
elif type is "episode":
db_episode = Episode.select().where(Episode.plex_id == plex_object.ratingKey)
if db_episode.exists():
if util.check_media_needs_update(db_episode, plex_object):
return True
else:
return True
return False
def _parse_episodejokes(sheet):
"""
Parses joke sheet.
Imports episodejokes.
Will not update.
"""
episodes = list(Episode.select())
for row in sheet:
for episode in episodes:
joke = Joke.get(Joke.code == row['code'])
if episode.code == 's02e03':
episode.title = '\xc2\xa1Amigos!'
if episode.code == 's01e13':
episode.title = 'Beef Consomm\xc3\xa9'
if row[episode.title] in ['1', 'f', 'b']:
ej_dict = {}
ej_dict['joke'] = joke
ej_dict['episode'] = episode
ej_dict['joke_type'] = row[episode.title]
ej_dict['code'] = '%sj%s' % (ej_dict['episode'].code, ej_dict['joke'].code)
try:
EpisodeJoke.get(EpisodeJoke.code == ej_dict['code'])
except EpisodeJoke.DoesNotExist:
EpisodeJoke(**ej_dict).save()
def _admin_output():
output = {}
output['joke_main'] = ''
output['joke_details'] = ''
output['joke_connections'] = ''
for joke in Joke.select():
for episode in Episode.select().where(Episode.season == 4).order_by(
Episode.number):
try:
ej = EpisodeJoke.get(episode=episode, joke=joke)
output['joke_main'] += '%s\t' % ej.joke_type
output['joke_details'] += '\'%s\t' % ej.details
if ej.connections():
output['joke_connections'] += '\'%s\t' % ej.connections(
)[0]['text']
else:
output['joke_connections'] += '\t'
except EpisodeJoke.DoesNotExist:
output['joke_main'] += '\t'
output['joke_details'] += '\t'
output['joke_connections'] += '\t'
output['joke_main'] += '\n'
output['joke_details'] += '\n'
output['joke_connections'] += '\n'
return render_template('_output.html', **output)
def _parse_episodejokes(sheet):
"""
Parses joke sheet.
Imports episodejokes.
Will not update.
"""
episodes = list(Episode.select())
for row in sheet:
for episode in episodes:
joke = Joke.get(Joke.code == row['code'])
if episode.code == 's02e03':
episode.title = '\xc2\xa1Amigos!'
if episode.code == 's01e13':
episode.title = 'Beef Consomm\xc3\xa9'
if row[episode.title] in ['1', 'f', 'b']:
ej_dict = {}
ej_dict['joke'] = joke
ej_dict['episode'] = episode
ej_dict['joke_type'] = row[episode.title]
ej_dict['code'] = '%sj%s' % (ej_dict['episode'].code,
ej_dict['joke'].code)
try:
EpisodeJoke.get(EpisodeJoke.code == ej_dict['code'])
except EpisodeJoke.DoesNotExist:
EpisodeJoke(**ej_dict).save()
def _parse_episodejoke_details(sheet, sheet_num):
"""
Parses the details, origin and connection sheets.
Adds data to existing episodejokes.
"""
FIELDS = [None, None, None, 'details', None, 'connection']
field = FIELDS[int(sheet_num)]
episodes = list(Episode.select())
for row in sheet:
for episode in episodes:
joke = Joke.get(Joke.code == row['code'])
if episode.code == 's02e03':
episode.title = '\xc2\xa1Amigos!'
if episode.code == 's01e13':
episode.title = 'Beef Consomm\xc3\xa9'
if row[episode.title]:
if field:
ej_code = '%sj%s' % (episode.code, joke.code)
payload = {}
payload[field] = row[episode.title]
EpisodeJoke.update(**payload).where(
EpisodeJoke.code == ej_code).execute()
def process_search_torrent():
res = []
eps = Episode.select().join(Show).where(
Show.is_active == True, Episode.status == models.WANTED,
Episode.firstaired < datetime.datetime.now())
for e in eps:
c = search.get_search_client(settings.search_client)
torrents = c.search(e.show.seriesname, e.get_code())
# Create default filters for episode code
fns = [{'key': 'name', 'value': e.get_code(), 'operator': 'in'}]
# Add filters from show settings
fns.extend(json.loads(e.show.filters))
filters = [
build_filter(**f) for f in fns if f['key'] in c.valid_filters
]
for fl in filters:
torrents = filter(fl, torrents)
msg = {'msg': 'No hash found for {e}'.format(e=e), 'stat': 'fail'}
if len(torrents) > 0:
e.magnet_hash = torrents[0]['hash']
e.status = models.FOUND
e.save()
msg['msg'] = 'Saved hash for {e}'.format(e=e)
msg['stat'] = 'ok'
res.append(msg)
return res
def process_search_torrent():
res = []
eps = Episode.select().join(Show).where(
Show.is_active == True,
Episode.status == models.WANTED,
Episode.firstaired < datetime.datetime.now()
)
for e in eps:
c = search.get_search_client(settings.search_client)
torrents = c.search(e.show.seriesname, e.get_code())
# Create default filters for episode code
fns = [{'key': 'name', 'value': e.get_code(), 'operator': 'in'}]
# Add filters from show settings
fns.extend(json.loads(e.show.filters))
filters = [build_filter(**f) for f in fns
if f['key'] in c.valid_filters]
for fl in filters:
torrents = filter(fl, torrents)
msg = {'msg': 'No hash found for {e}'.format(e=e), 'stat': 'fail'}
if len(torrents) > 0:
e.magnet_hash = torrents[0]['hash']
e.status = models.FOUND
e.save()
msg['msg'] = 'Saved hash for {e}'.format(e=e)
msg['stat'] = 'ok'
res.append(msg)
return res
def build_regression_csv():
"""
Builds an episode-based CSV for @stiles to do our regression.
Outputs a list of episodes with joke counts and ratings.
"""
with open('data/regression.csv', 'wb') as csvfile:
regressionwriter = csv.DictWriter(csvfile, ['episode_name', 'episode_id', 'jokes', 'rating'])
regressionwriter.writerow({'episode_name': 'episode_name', 'episode_id': 'episode_id', 'jokes': 'jokes', 'rating': 'rating'})
for episode in Episode.select():
episode_dict = {}
episode_dict['episode_name'] = episode.title.encode('utf-8')
episode_dict['episode_id'] = episode.number
episode_dict['rating'] = episode.rating
episode_dict['jokes'] = EpisodeJoke.select().where(EpisodeJoke.episode == episode).count()
regressionwriter.writerow(episode_dict)
def _all_seasons():
output = []
SEASONS = [1, 2, 3]
if app_config.IMPORT_NEW_SEASON is True:
SEASONS.append(4)
for season in SEASONS:
season_dict = {}
season_dict['season'] = season
season_dict['episodes'] = []
for episode in Episode.select().where(Episode.season == season):
season_dict['episodes'].append({
'url': 'episode-%s.html' % episode.code,
'text': '%s: %s' % (episode.episode, episode.title),
'episode': episode.episode,
'code': episode.code
})
season_dict['episodes'] = sorted(season_dict['episodes'], key=lambda episode: episode['episode'])
output.append(season_dict)
return output
def update_episode_rating(database, episode, imdb_episodes, imdb_id, plex_object, season):
"""
Update the episode rating if it is outdated
:param database: connection to the Plex DB
:param episode: the episode object from Plex
:param imdb_episodes: the IMDB episodes object containing the rating
:param imdb_id: the IMDB id from the parent show
:param plex_object: the parent plex object
:param season: the season from which this episode is beloning to
:return: True if updated, False if not
"""
db_episode = Episode.select().where(Episode.plex_id == episode.ratingKey)
if not db_episode.exists():
if imdb_episodes is None:
imdb_episodes = imdb.get_season_from_imdb(imdb_id, season.index)
if update_imdb_episode_rating(database, episode,
imdb_episodes, plex_object, season):
logger.debug("Created episode '{e.title}' '{e.index}' "
"with new ratings".format(e=episode))
return True
else:
return False
else:
# check if we need to update this item
need_update = False
if db_episode.get().rating is not episode.rating:
need_update = True
elif db_episode.get().last_update > datetime.now() - timedelta(days=-7):
need_update = True
if need_update:
if imdb_episodes is None:
imdb_episodes = imdb.get_season_from_imdb(imdb_id, season.index)
if update_imdb_episode_rating(database, episode,
imdb_episodes, plex_object,
season, db_episode):
logger.debug("Update episode '{e.title}' '{e.index}' "
"with new ratings".format(e=episode))
return True
else:
return False
return False
def process_download_torrent():
res = []
eps = Episode.select().join(Show).where(
Show.is_active == True,
Episode.status == models.FOUND
)
tc = clients.get_torrent_client(settings.client)
for e in eps:
try:
tc.add_magnet_hash(e.magnet_hash, e.get_download_dir())
e.status = models.DOWNLOADING
e.save()
res.append({
'msg': 'Started downloading {e}'.format(e=e),
'stat': 'ok'
})
except Exception, ex:
res.append({
'msg': 'Failed to add {e} to client: {ex}'.format(e=e, ex=ex),
'stat': 'fail'
})
def process_download_torrent():
res = []
eps = Episode.select().join(Show).where(Show.is_active == True,
Episode.status == models.FOUND)
tc = clients.get_torrent_client(settings.client)
for e in eps:
try:
tc.add_magnet_hash(e.magnet_hash, e.get_download_dir())
e.status = models.DOWNLOADING
e.save()
res.append({
'msg': 'Started downloading {e}'.format(e=e),
'stat': 'ok'
})
except Exception, ex:
res.append({
'msg':
'Failed to add {e} to client: {ex}'.format(e=e, ex=ex),
'stat':
'fail'
})
def build_regression_csv():
"""
Builds an episode-based CSV for @stiles to do our regression.
Outputs a list of episodes with joke counts and ratings.
"""
with open('data/regression.csv', 'wb') as csvfile:
regressionwriter = csv.DictWriter(
csvfile, ['episode_name', 'episode_id', 'jokes', 'rating'])
regressionwriter.writerow({
'episode_name': 'episode_name',
'episode_id': 'episode_id',
'jokes': 'jokes',
'rating': 'rating'
})
for episode in Episode.select():
episode_dict = {}
episode_dict['episode_name'] = episode.title.encode('utf-8')
episode_dict['episode_id'] = episode.number
episode_dict['rating'] = episode.rating
episode_dict['jokes'] = EpisodeJoke.select().where(
EpisodeJoke.episode == episode).count()
regressionwriter.writerow(episode_dict)
def _admin_output():
output = {}
output['joke_main'] = ''
output['joke_details'] = ''
output['joke_connections'] = ''
for joke in Joke.select():
for episode in Episode.select().where(Episode.season == 4).order_by(Episode.number):
try:
ej = EpisodeJoke.get(episode=episode, joke=joke)
output['joke_main'] += '%s\t' % ej.joke_type
output['joke_details'] += '\'%s\t' % ej.details
if ej.connections():
output['joke_connections'] += '\'%s\t' % ej.connections()[0]['text']
else:
output['joke_connections'] += '\t'
except EpisodeJoke.DoesNotExist:
output['joke_main'] += '\t'
output['joke_details'] += '\t'
output['joke_connections'] += '\t'
output['joke_main'] += '\n'
output['joke_details'] += '\n'
output['joke_connections'] += '\n'
return render_template('_output.html', **output)
def _all_seasons():
output = []
SEASONS = [1, 2, 3]
if app_config.IMPORT_NEW_SEASON is True:
SEASONS.append(4)
for season in SEASONS:
season_dict = {}
season_dict['season'] = season
season_dict['episodes'] = []
for episode in Episode.select().where(Episode.season == season):
season_dict['episodes'].append({
'url':
'episode-%s.html' % episode.code,
'text':
'%s: %s' % (episode.episode, episode.title),
'episode':
episode.episode,
'code':
episode.code
})
season_dict['episodes'] = sorted(
season_dict['episodes'], key=lambda episode: episode['episode'])
output.append(season_dict)
return output
def _parse_episodejoke_details(sheet, sheet_num):
"""
Parses the details, origin and connection sheets.
Adds data to existing episodejokes.
"""
FIELDS = [None, None, None, 'details', None, 'connection']
field = FIELDS[int(sheet_num)]
episodes = list(Episode.select())
for row in sheet:
for episode in episodes:
joke = Joke.get(Joke.code == row['code'])
if episode.code == 's02e03':
episode.title = '\xc2\xa1Amigos!'
if episode.code == 's01e13':
episode.title = 'Beef Consomm\xc3\xa9'
if row[episode.title]:
if field:
ej_code = '%sj%s' % (episode.code, joke.code)
payload = {}
payload[field] = row[episode.title]
EpisodeJoke.update(**payload).where(EpisodeJoke.code == ej_code).execute()
def render_pages():
render()
local('rm -rf www/episode*.html')
local('rm -rf www/joke*.html')
_render_iterable(Joke.select(), 'joke', 'code')
_render_iterable(Episode.select(), 'episode', 'code')
def get_show(show_id):
c = {
'show': Show.get(id=show_id),
'episodes': Episode.select().join(Show).where(Show.id == show_id)
}
return render_template('show.html', **c)
def get_show(show_id):
c = {
'show': Show.get(id=show_id),
'episodes': Episode.select().join(Show).where(Show.id == show_id)
}
return render_template('show.html', **c)
def render_pages():
render()
local('rm -rf www/episode*.html')
local('rm -rf www/joke*.html')
_render_iterable(Joke.select(), 'joke', 'code')
_render_iterable(Episode.select(), 'episode', 'code')
