def get_in_progress_tvshows(dummy_arg, page_no, letter):
def _process(item):
tmdb_id = item['media_id']
meta = metadata.tvshow_meta('tmdb_id', tmdb_id, meta_user_info)
watched_status = get_watched_status_tvshow(watched_info, tmdb_id,
meta.get('total_aired_eps'))
if watched_status[0] == 0: append(item)
check_trakt_refresh()
duplicates = set()
data = []
append = data.append
watched_indicators = settings.watched_indicators()
paginate = settings.paginate()
limit = settings.page_limit()
meta_user_info = metadata.retrieve_user_info()
watched_info = get_watched_info_tv(watched_indicators)
prelim_data = [{
'media_id': i[0],
'title': i[3]
} for i in watched_info
if not (i[0] in duplicates or duplicates.add(i[0]))]
threads = list(make_thread_list(_process, prelim_data, Thread))
[i.join() for i in threads]
original_list = sort_for_article(data, 'title', settings.ignore_articles())
if paginate:
final_list, total_pages = paginate_list(original_list, page_no, letter,
limit)
else:
final_list, total_pages = original_list, 1
return final_list, total_pages
def build_add_to_remove_from_list(meta='', media_type='', orig_mode='', from_search=''):
try: from urlparse import parse_qsl
except ImportError: from urllib.parse import parse_qsl
import json
from modules.settings import trakt_list_subscriptions, watched_indicators
from modules.nav_utils import build_url
params = dict(parse_qsl(sys.argv[2].replace('?','')))
media_type = params.get('media_type', '')
orig_mode = params.get('orig_mode', '')
from_search = params.get('from_search', '')
meta = json.loads(params.get('meta', None))
main_listing = [('Add to...', 'add'), ('Remove from...', 'remove')]
mlc = selection_dialog([i[0] for i in main_listing], [i[1] for i in main_listing], 'Choose Add to or Remove from...')
if mlc == None: return
string = "Choose Selection to Add Item To" if mlc == 'add' else "Choose Selection to Remove Item From"
heading = 'Add to ' if mlc == 'add' else 'Remove from '
listing = [(heading + 'Trakt List', 'trakt'), (heading + 'Fen Favourites', 'favourites')]
if not trakt_list_subscriptions(): listing.append((heading + 'Fen Subscriptions', 'subscriptions'))
if media_type == 'tvshow' and watched_indicators() == 0: listing.append((heading + 'Fen Next Episode', 'unwatched_next_episode'))
if mlc == 'remove': listing.append((heading + 'Cache (Re-cache %s Info)' % ('Movie' if media_type == 'movie' else 'TV Show'), 'refresh'))
choice = selection_dialog([i[0] for i in listing], [i[1] for i in listing], string)
if choice == None: return
elif choice == 'trakt': url = {'mode': ('trakt.trakt_add_to_list' if mlc == 'add' else 'trakt.trakt_remove_from_list'), 'tmdb_id': meta["tmdb_id"], 'imdb_id': meta["imdb_id"], 'tvdb_id': meta["tvdb_id"], 'db_type': media_type}
elif choice == 'favourites': url = {'mode': ('add_to_favourites' if mlc == 'add' else 'remove_from_favourites'), 'db_type': media_type, 'tmdb_id': meta["tmdb_id"], 'title': meta['title']}
elif choice == 'subscriptions': url = {'mode': 'subscriptions_add_remove', 'action': mlc, 'db_type': media_type, 'tmdb_id': meta["tmdb_id"], 'orig_mode': orig_mode}
elif choice == 'unwatched_next_episode': url = {'mode': 'add_next_episode_unwatched', 'action': mlc, 'title': meta["title"], 'tmdb_id': meta["tmdb_id"], 'imdb_id': meta["imdb_id"]}
elif choice == 'refresh': url = {'mode': 'refresh_cached_data', 'db_type': media_type, 'id_type': 'tmdb_id', 'media_id': meta['tmdb_id']}
xbmc.executebuiltin('XBMC.RunPlugin(%s)' % build_url(url))
def mark_as_watched_unwatched_movie(params):
action = params.get('action')
db_type = 'movie'
tmdb_id = params.get('tmdb_id')
title = params.get('title')
year = params.get('year')
refresh = params.get('refresh', 'true')
from_playback = params.get('from_playback', 'false')
watched_indicators = settings.watched_indicators()
if watched_indicators == 1:
if from_playback == 'true' and trakt_official_status(db_type) == False:
skip_trakt_mark = True
else:
skip_trakt_mark = False
if skip_trakt_mark: kodi_utils.sleep(3000)
elif not trakt_watched_unwatched(action, 'movies', tmdb_id):
return kodi_utils.notification(32574)
clear_trakt_collection_watchlist_data('watchlist', db_type)
data_base = TRAKT_DB
data_base = TRAKT_DB
else:
data_base = WATCHED_DB
mark_as_watched_unwatched(db_type,
tmdb_id,
action,
title=title,
data_base=data_base)
erase_bookmark(db_type, tmdb_id)
if settings.sync_kodi_library_watchstatus():
from modules.kodi_library import mark_as_watched_unwatched_kodi_library
mark_as_watched_unwatched_kodi_library(db_type, action, title, year)
refresh_container(refresh)
def erase_bookmark(db_type, tmdb_id, season='', episode='', refresh='false'):
try:
watched_indicators = settings.watched_indicators()
if watched_indicators == 1:
bookmarks = get_bookmarks(db_type, watched_indicators)
if db_type == 'episode':
season, episode = int(season), int(episode)
try:
resume_point, curr_time = detect_bookmark(
bookmarks, tmdb_id, season, episode)
except:
return
trakt_progress('clear_progress', db_type, tmdb_id, 0, season,
episode)
database_file = TRAKT_DB
else:
database_file = WATCHED_DB
dbcon = database.connect(database_file)
dbcur = dbcon.cursor()
dbcur.execute(
"DELETE FROM progress where db_type=? and media_id=? and season = ? and episode = ?",
(db_type, tmdb_id, season, episode))
dbcon.commit()
refresh_container(refresh)
except:
pass
def set_bookmark(db_type,
tmdb_id,
curr_time,
total_time,
season='',
episode=''):
try:
erase_bookmark(db_type, tmdb_id, season, episode)
adjusted_current_time = float(curr_time) - 5
resume_point = round(adjusted_current_time / float(total_time) * 100,
1)
watched_indicators = settings.watched_indicators()
if watched_indicators == 1:
trakt_progress('set_progress', db_type, tmdb_id, resume_point,
season, episode)
database_file = TRAKT_DB
else:
database_file = WATCHED_DB
dbcon = database.connect(database_file)
dbcur = dbcon.cursor()
dbcur.execute("INSERT INTO progress VALUES (?, ?, ?, ?, ?, ?)",
(db_type, tmdb_id, season, episode, str(resume_point),
str(curr_time)))
dbcon.commit()
if settings.sync_kodi_library_watchstatus():
from modules.kodi_library import set_bookmark_kodi_library
set_bookmark_kodi_library(db_type, tmdb_id, curr_time, total_time,
season, episode)
except:
pass
def get_info(self):
self.meta_user_info = metadata.retrieve_user_info()
self.watched_indicators = settings.watched_indicators()
self.watched_info = get_watched_info_tv(self.watched_indicators)
self.all_episodes = settings.default_all_episodes()
self.include_year_in_title = settings.include_year_in_title('tvshow')
self.open_extras = settings.extras_open_action('tvshow')
def get_info(self):
self.meta_user_info = metadata.retrieve_user_info()
self.watched_indicators = settings.watched_indicators()
self.watched_info = get_watched_info_movie(self.watched_indicators)
self.bookmarks = get_bookmarks('movie', self.watched_indicators)
self.include_year_in_title = settings.include_year_in_title('movie')
self.open_extras = settings.extras_open_action('movie')
def get_unwatched_next_episodes():
try:
if settings.watched_indicators() in (1, 2):
from apis.trakt_api import trakt_fetch_collection_watchlist, get_trakt_tvshow_id
data = trakt_fetch_collection_watchlist('watchlist', 'tvshow')
return [{
"tmdb_id": get_trakt_tvshow_id(i['media_ids']),
"season": 1,
"episode": 0,
"unwatched": True
} for i in data]
else:
settings.check_database(WATCHED_DB)
dbcon = database.connect(WATCHED_DB)
dbcur = dbcon.cursor()
dbcur.execute('''SELECT media_id FROM unwatched_next_episode''')
unwatched = dbcur.fetchall()
return [{
"tmdb_id": i[0],
"season": 1,
"episode": 0,
"unwatched": True
} for i in unwatched]
except:
return []
def get_tvshow_info():
meta_user_info = metadata.retrieve_user_info()
watched_indicators = settings.watched_indicators()
watched_info = get_watched_info_tv(watched_indicators)
all_episodes = settings.default_all_episodes()
include_year_in_title = settings.include_year_in_title('tvshow')
open_extras = settings.extras_open_action('tvshow')
return meta_user_info, watched_indicators, watched_info, all_episodes, include_year_in_title, open_extras
def get_episode_info():
meta_user_info = metadata.retrieve_user_info()
watched_indicators = settings.watched_indicators()
watched_info = indicators.get_watched_info_tv(watched_indicators)
show_unaired = settings.show_unaired()
thumb_fanart = settings.thumb_fanart()
is_widget = kodi_utils.external_browse()
current_date = get_datetime()
adjust_hours = settings.date_offset()
bookmarks = indicators.get_bookmarks('episode', watched_indicators)
return meta_user_info, watched_indicators, watched_info, show_unaired, thumb_fanart, is_widget, current_date, adjust_hours, bookmarks
def worker(self):
threads = []
self.watched_indicators = settings.watched_indicators()
self.all_trailers = settings.all_trailers()
self.watched_info, self.use_trakt = get_watched_info_movie()
self.meta_user_info = tikimeta.retrieve_user_info()
window.clearProperty('fen_fanart_error')
for item_position, item in enumerate(self.list):
threads.append(
Thread(target=self.set_info, args=(item_position, item)))
[i.start() for i in threads]
[i.join() for i in threads]
self.build_movie_content()
def mark_as_watched_unwatched_tvshow(params):
action = params.get('action')
tmdb_id = params.get('tmdb_id')
try:
tvdb_id = int(params.get('tvdb_id', '0'))
except:
tvdb_id = 0
watched_indicators = settings.watched_indicators()
kodi_utils.progressDialogBG.create(ls(32577), '')
if watched_indicators == 1:
if not trakt_watched_unwatched(action, 'shows', tmdb_id, tvdb_id):
return kodi_utils.notification(32574)
clear_trakt_collection_watchlist_data('watchlist', 'tvshow')
data_base = TRAKT_DB
else:
data_base = WATCHED_DB
title = params.get('title', '')
year = params.get('year', '')
meta_user_info = metadata.retrieve_user_info()
adjust_hours = settings.date_offset()
current_date = get_datetime()
insert_list = []
insert_append = insert_list.append
meta = metadata.tvshow_meta('tmdb_id', tmdb_id, meta_user_info)
season_data = meta['season_data']
season_data = [i for i in season_data if i['season_number'] > 0]
total = len(season_data)
last_played = get_last_played_value(data_base)
for count, item in enumerate(season_data, 1):
season_number = item['season_number']
ep_data = metadata.season_episodes_meta(season_number, meta,
meta_user_info)
for ep in ep_data:
season_number = ep['season']
ep_number = ep['episode']
display = 'S%.2dE%.2d' % (int(season_number), int(ep_number))
kodi_utils.progressDialogBG.update(
int(float(count) / float(total) * 100), ls(32577),
'%s' % display)
episode_date, premiered = adjust_premiered_date(
ep['premiered'], adjust_hours)
if not episode_date or current_date < episode_date: continue
insert_append(
make_batch_insert(action, 'episode', tmdb_id, season_number,
ep_number, last_played, title))
batch_mark_as_watched_unwatched(insert_list, action, data_base)
batch_erase_bookmark(insert_list, action, watched_indicators)
kodi_utils.progressDialogBG.close()
if settings.sync_kodi_library_watchstatus():
batch_mark_kodi_library(action, insert_list, title, year)
refresh_container()
def mark_episode_as_watched_unwatched(params=None):
from modules.next_episode import add_next_episode_unwatched
params = dict(parse_qsl(sys.argv[2].replace('?',
''))) if not params else params
action = 'mark_as_watched' if params.get(
'action') == 'mark_as_watched' else 'mark_as_unwatched'
media_id = params.get('media_id')
tvdb_id = int(params.get('tvdb_id', '0'))
imdb_id = params.get('imdb_id')
season = int(params.get('season'))
episode = int(params.get('episode'))
title = params.get('title')
year = params.get('year')
refresh = params.get('refresh', 'true')
from_playback = params.get('from_playback', 'false')
watched_indicators = settings.watched_indicators()
if season == 0:
from modules.nav_utils import notification
notification(
'Specials cannot be marked as %s' %
('Watched' if action == 'mark_as_watched' else 'Unwatched'),
time=5000)
return
if watched_indicators in (1, 2):
import time
from apis.trakt_api import trakt_watched_unwatched, trakt_official_status
if from_playback == 'true' and trakt_official_status(
'episode') == False:
skip_trakt_mark = True
else:
skip_trakt_mark = False
if not skip_trakt_mark:
trakt_watched_unwatched(action, 'episode', imdb_id, tvdb_id,
season, episode)
if skip_trakt_mark: time.sleep(3)
clear_trakt_watched_data('tvshow')
clear_trakt_collection_watchlist_data('watchlist', 'tvshow')
if watched_indicators in (0, 1):
mark_as_watched_unwatched('episode', media_id, action, season, episode,
title)
erase_bookmark('episode', media_id, season, episode)
if action == 'mark_as_watched':
add_next_episode_unwatched('remove', media_id, silent=True)
if settings.sync_kodi_library_watchstatus():
from modules.kodi_library import mark_as_watched_unwatched_kodi_library
mark_as_watched_unwatched_kodi_library('episode', action, title, year,
season, episode)
refresh_container(refresh)
def get_in_progress_episodes():
watched_indicators = settings.watched_indicators()
if watched_indicators == 1: database_file = TRAKT_DB
else: database_file = WATCHED_DB
dbcon = database.connect(database_file)
dbcur = dbcon.cursor()
dbcur.execute(
'''SELECT media_id, season, episode, resume_point FROM progress WHERE db_type=? ORDER BY rowid DESC''',
('episode', ))
data = dbcur.fetchall()
episode_list = reversed([{
'tmdb_id': i[0],
'season': int(i[1]),
'episode': int(i[2]),
'resume_point': float(i[3])
} for i in data])
return episode_list
def in_progress_tvshow(db_type, page_no, letter):
from modules.utils import title_key
from modules.nav_utils import paginate_list
paginate = settings.paginate()
limit = settings.page_limit()
check_meta_database()
if settings.watched_indicators() in (1, 2):
from apis.trakt_api import trakt_indicators_tv
items = trakt_indicators_tv()
data = [(i[0], i[3]) for i in items if i[1] > len(i[2])]
else:
from modules.indicators_bookmarks import get_watched_status_tvshow, get_watched_info_tv
def _process(item):
meta = tvshow_meta('tmdb_id', item[0], meta_user_info)
watched_status = get_watched_status_tvshow(
watched_info, use_trakt, meta['tmdb_id'],
meta.get('total_episodes'))
if not watched_status[0] == 1: data.append(item)
data = []
threads = []
settings.check_database(WATCHED_DB)
dbcon = database.connect(WATCHED_DB)
dbcur = dbcon.cursor()
dbcur.execute(
'''SELECT media_id, title, last_played FROM watched_status WHERE db_type=? ORDER BY rowid DESC''',
('episode', ))
rows1 = dbcur.fetchall()
in_progress_result = list(set([i for i in rows1]))
watched_info, use_trakt = get_watched_info_tv()
meta_user_info = retrieve_user_info()
window.setProperty('fen_fanart_error', 'true')
for item in in_progress_result:
threads.append(Thread(target=_process, args=(item, )))
[i.start() for i in threads]
[i.join() for i in threads]
data = sorted(data, key=lambda k: title_key(k[1]))
original_list = [{'media_id': i[0]} for i in data]
if paginate:
final_list, total_pages = paginate_list(original_list, page_no, letter,
limit)
else:
final_list, total_pages = original_list, 1
return final_list, total_pages
def build_next_episode():
nextep_settings = nextep_content_settings()
include_unwatched = nextep_settings['include_unwatched']
indicators = watched_indicators()
watched_info = get_watched_info_tv(indicators)
data = get_next_episodes(watched_info)
if indicators == 1:
list_type = 'next_episode_trakt'
try: hidden_data = trakt_get_hidden_items('progress_watched')
except: hidden_data = []
data = [i for i in data if not i['tmdb_id'] in hidden_data]
else: list_type = 'next_episode_fen'
if include_unwatched:
try: unwatched = [{'tmdb_id': get_trakt_tvshow_id(i['media_ids']), 'season': 1, 'episode': 0, 'unwatched': True} \
for i in trakt_fetch_collection_watchlist('watchlist', 'tvshow')]
except: unwatched = []
data += unwatched
build_single_episode(list_type, data)
def get_watched_info_tv():
info = []
use_trakt = False
try:
if settings.watched_indicators() in (1, 2):
from apis.trakt_api import trakt_indicators_tv
use_trakt = True
info = trakt_indicators_tv()
else:
use_trakt = False
settings.check_database(WATCHED_DB)
dbcon = database.connect(WATCHED_DB)
dbcur = dbcon.cursor()
dbcur.execute(
"SELECT media_id, season, episode, title FROM watched_status WHERE db_type = ?",
('episode', ))
info = dbcur.fetchall()
dbcon.close()
except:
pass
return info, use_trakt
def get_in_progress_movies(dummy_arg, page_no, letter):
check_trakt_refresh()
watched_indicators = settings.watched_indicators()
paginate = settings.paginate()
limit = settings.page_limit()
if watched_indicators == 1: database_file = TRAKT_DB
else: database_file = WATCHED_DB
dbcon = database.connect(database_file)
dbcur = dbcon.cursor()
dbcur.execute(
'''SELECT media_id FROM progress WHERE db_type=? ORDER BY rowid DESC''',
('movie', ))
rows = dbcur.fetchall()
data = reversed([i[0] for i in rows if not i[0] == ''])
original_list = [{'media_id': i} for i in data]
if paginate:
final_list, total_pages = paginate_list(original_list, page_no, letter,
limit)
else:
final_list, total_pages = original_list, 1
return final_list, total_pages
def get_watched_items(db_type, page_no, letter):
paginate = settings.paginate()
limit = settings.page_limit()
watched_indicators = settings.watched_indicators()
if db_type == 'tvshow':
from threading import Thread
from modules.utils import make_thread_list
def _process(item):
tmdb_id = item['media_id']
meta = metadata.tvshow_meta('tmdb_id', tmdb_id, meta_user_info)
watched_status = get_watched_status_tvshow(
watched_info, tmdb_id, meta.get('total_aired_eps'))
if watched_status[0] == 1: append(item)
meta_user_info = metadata.retrieve_user_info()
watched_info = get_watched_info_tv(watched_indicators)
duplicates = set()
data = []
append = data.append
prelim_data = [{
'media_id': i[0],
'title': i[3]
} for i in watched_info
if not (i[0] in duplicates or duplicates.add(i[0]))]
threads = list(make_thread_list(_process, prelim_data, Thread))
[i.join() for i in threads]
original_list = sort_for_article(data, 'title',
settings.ignore_articles())
else:
watched_info = get_watched_info_movie(watched_indicators)
data = [{'media_id': i[0], 'title': i[1]} for i in watched_info]
original_list = sort_for_article(data, 'title',
settings.ignore_articles())
if paginate:
final_list, total_pages = paginate_list(original_list, page_no, letter,
limit)
else:
final_list, total_pages = original_list, 1
return final_list, total_pages
def process_eps(item, nextep_settings, nextep_display_settings, watched_info,
use_trakt, meta_user_info):
try:
meta = tvshow_meta('tmdb_id', item['tmdb_id'], meta_user_info)
include_unaired = nextep_settings['include_unaired']
season = item['season']
episode = item['episode']
unwatched = item.get('unwatched', False)
seasons_data = all_episodes_meta(meta['tmdb_id'], meta['tvdb_id'],
meta['tvdb_summary']['airedSeasons'],
meta['season_data'], meta_user_info)
curr_season_data = [
i for i in seasons_data if i['season_number'] == season
][0]
season = season if episode < curr_season_data[
'episode_count'] else season + 1
episode = episode + 1 if episode < curr_season_data[
'episode_count'] else 1
if settings.watched_indicators() in (1, 2):
resformat = "%Y-%m-%dT%H:%M:%S.%fZ"
curr_last_played = item.get('last_played',
'2000-01-01T00:00:00.000Z')
else:
resformat = "%Y-%m-%d %H:%M:%S"
curr_last_played = item.get('last_played', '2000-01-01 00:00:00')
datetime_object = jsondate_to_datetime(curr_last_played, resformat)
result.append(
build_episode(
{
"season": season,
"episode": episode,
"meta": meta,
"curr_last_played_parsed": datetime_object,
"action": "next_episode",
"unwatched": unwatched,
"nextep_display_settings": nextep_display_settings,
'include_unaired': include_unaired
}, watched_info, use_trakt, meta_user_info))
except:
pass
def mark_movie_as_watched_unwatched(params=None):
params = dict(parse_qsl(sys.argv[2].replace('?',
''))) if not params else params
action = params.get('action')
db_type = 'movie'
media_id = params.get('media_id')
title = params.get('title')
year = params.get('year')
refresh = params.get('refresh', 'true')
watched_indicators = settings.watched_indicators()
if watched_indicators in (1, 2):
from apis.trakt_api import trakt_watched_unwatched
trakt_watched_unwatched(action, 'movies', media_id)
clear_trakt_watched_data(db_type)
clear_trakt_collection_watchlist_data('watchlist', 'movie')
if watched_indicators in (0, 1):
mark_as_watched_unwatched(db_type, media_id, action, title=title)
erase_bookmark(db_type, media_id)
if settings.sync_kodi_library_watchstatus():
from modules.kodi_library import mark_as_watched_unwatched_kodi_library
mark_as_watched_unwatched_kodi_library(db_type, action, title, year)
refresh_container()
def mark_as_watched_unwatched_episode(params):
action = params.get('action')
db_type = 'episode'
tmdb_id = params.get('tmdb_id')
try:
tvdb_id = int(params.get('tvdb_id', '0'))
except:
tvdb_id = 0
season = int(params.get('season'))
episode = int(params.get('episode'))
title = params.get('title')
year = params.get('year')
refresh = params.get('refresh', 'true')
from_playback = params.get('from_playback', 'false')
watched_indicators = settings.watched_indicators()
if season == 0:
kodi_utils.notification(32490)
return
if watched_indicators == 1:
if from_playback == 'true' and trakt_official_status(db_type) == False:
skip_trakt_mark = True
else:
skip_trakt_mark = False
if skip_trakt_mark: kodi_utils.sleep(3000)
elif not trakt_watched_unwatched(action, db_type, tmdb_id, tvdb_id,
season, episode):
return kodi_utils.notification(32574)
clear_trakt_collection_watchlist_data('watchlist', 'tvshow')
data_base = TRAKT_DB
else:
data_base = WATCHED_DB
mark_as_watched_unwatched(db_type, tmdb_id, action, season, episode, title,
data_base)
erase_bookmark(db_type, tmdb_id, season, episode)
if settings.sync_kodi_library_watchstatus():
from modules.kodi_library import mark_as_watched_unwatched_kodi_library
mark_as_watched_unwatched_kodi_library(db_type, action, title, year,
season, episode)
refresh_container(refresh)
def build_season_list(params):
def _process():
running_ep_count = total_aired_eps
def _unaired_status():
if episode_count == 0: return True
season_date_start = adjust_premiered_date(air_date, 0)[0]
if not season_date_start or current_date < season_date_start:
return True
return False
for item in season_data:
try:
listitem = make_listitem()
set_property = listitem.setProperty
cm = []
cm_append = cm.append
item_get = item.get
overview = item_get('overview')
name = item_get('name')
poster_path = item_get('poster_path')
air_date = item_get('air_date')
season_number = item_get('season_number')
episode_count = item_get('episode_count')
season_poster = 'https://image.tmdb.org/t/p/%s%s' % (
image_resolution,
poster_path) if poster_path is not None else show_poster
if season_number == 0: unaired = False
else:
unaired = _unaired_status()
if unaired:
if not show_unaired: return
episode_count = 0
else:
running_ep_count -= episode_count
if running_ep_count < 0:
episode_count = running_ep_count + episode_count
try:
year = air_date.split('-')[0]
except:
year = show_year
plot = overview if overview != '' else show_plot
title = name if use_season_title and name != '' else '%s %s' % (
season_str, string(season_number))
if unaired: title = unaired_label % title
playcount, overlay, watched, unwatched = get_watched_status_season(
watched_info, string(tmdb_id), season_number,
episode_count)
url_params = build_url({
'mode': 'build_episode_list',
'tmdb_id': tmdb_id,
'season': season_number
})
extras_params = build_url({
'mode': 'extras_menu_choice',
'tmdb_id': tmdb_id,
'db_type': 'tvshow',
'is_widget': is_widget
})
options_params = build_url({
'mode': 'options_menu_choice',
'content': 'season',
'tmdb_id': tmdb_id
})
cm_append((extras_str, run_plugin % extras_params))
cm_append((options_str, run_plugin % options_params))
if not playcount:
watched_params = build_url({
'mode': 'mark_as_watched_unwatched_season',
'action': 'mark_as_watched',
'title': show_title,
'year': show_year,
'tmdb_id': tmdb_id,
'tvdb_id': tvdb_id,
'season': season_number
})
cm_append((watched_str % watched_title,
run_plugin % watched_params))
if watched:
unwatched_params = build_url({
'mode': 'mark_as_watched_unwatched_season',
'action': 'mark_as_unwatched',
'title': show_title,
'year': show_year,
'tmdb_id': tmdb_id,
'tvdb_id': tvdb_id,
'season': season_number
})
cm_append((unwatched_str % watched_title,
run_plugin % unwatched_params))
listitem.setLabel(title)
listitem.setContentLookup(False)
listitem.addContextMenuItems(cm)
listitem.setArt({
'poster': season_poster,
'icon': season_poster,
'thumb': season_poster,
'fanart': fanart,
'banner': banner,
'clearart': clearart,
'clearlogo': clearlogo,
'landscape': landscape,
'tvshow.clearart': clearart,
'tvshow.clearlogo': clearlogo,
'tvshow.landscape': landscape,
'tvshow.banner': banner
})
listitem.setCast(cast)
listitem.setUniqueIDs({
'imdb': imdb_id,
'tmdb': string(tmdb_id),
'tvdb': string(tvdb_id)
})
listitem.setInfo(
'video', {
'mediatype': 'season',
'trailer': trailer,
'title': title,
'size': '0',
'duration': episode_run_time,
'plot': plot,
'rating': rating,
'premiered': premiered,
'studio': studio,
'year': year,
'genre': genre,
'mpaa': mpaa,
'tvshowtitle': show_title,
'imdbnumber': imdb_id,
'votes': votes,
'season': season_number,
'playcount': playcount,
'overlay': overlay
})
set_property('watchedepisodes', string(watched))
set_property('unwatchedepisodes', string(unwatched))
set_property('totalepisodes', string(episode_count))
if is_widget:
set_property('fen_widget', 'true')
set_property('fen_playcount', string(playcount))
set_property('fen_extras_menu_params', extras_params)
set_property('fen_options_menu_params', options_params)
else:
set_property('fen_widget', 'false')
yield (url_params, listitem, True)
except:
pass
__handle__ = int(argv[1])
meta_user_info = metadata.retrieve_user_info()
watched_indicators = settings.watched_indicators()
watched_info = get_watched_info_tv(watched_indicators)
show_unaired = settings.show_unaired()
is_widget = kodi_utils.external_browse()
current_date = get_datetime()
image_resolution = meta_user_info['image_resolution']['poster']
poster_main, poster_backup, fanart_main, fanart_backup = settings.get_art_provider(
)
meta = metadata.tvshow_meta('tmdb_id', params['tmdb_id'], meta_user_info)
meta_get = meta.get
season_data = meta_get('season_data')
if not season_data: return
tmdb_id, tvdb_id, imdb_id = meta_get('tmdb_id'), meta_get(
'tvdb_id'), meta_get('imdb_id')
show_title, show_year, show_plot, banner = meta_get('title'), meta_get(
'year'), meta_get('plot'), meta_get('banner')
show_poster = meta_get(poster_main) or meta_get(
poster_backup) or poster_empty
fanart = meta_get(fanart_main) or meta_get(fanart_backup) or fanart_empty
clearlogo, clearart, landscape = meta_get('clearlogo'), meta_get(
'clearart'), meta_get('landscape')
cast, mpaa, votes = meta_get('cast'), meta_get('mpaa'), meta_get('votes')
trailer, genre, studio = string(
meta_get('trailer')), meta_get('genre'), meta_get('studio')
episode_run_time, rating, premiered = meta_get(
'episode_run_time'), meta_get('rating'), meta_get('premiered')
total_seasons = meta_get('total_seasons')
total_aired_eps = meta_get('total_aired_eps')
if not settings.show_specials():
season_data = [i for i in season_data if not i['season_number'] == 0]
season_data.sort(key=lambda k: k['season_number'])
use_season_title = settings.use_season_title()
watched_title = 'Trakt' if watched_indicators == 1 else 'Fen'
kodi_utils.add_items(__handle__, list(_process()))
kodi_utils.set_content(__handle__, 'seasons')
kodi_utils.end_directory(__handle__)
kodi_utils.set_view_mode('view.seasons', 'seasons')
def next_episode_context_choice():
from modules.utils import selection_dialog
from modules.nav_utils import toggle_setting, build_url
params = dict(parse_qsl(sys.argv[2].replace('?', '')))
content_settings = settings.nextep_content_settings()
display_settings = settings.nextep_display_settings()
airdate_replacement = [('%d-%m-%Y', 'Day-Month-Year'),
('%Y-%m-%d', 'Year-Month-Day'),
('%m-%d-%Y', 'Month-Day-Year')]
sort_type_status = ('Recently Watched', 'Airdate',
'Title')[content_settings['sort_type']]
sort_order_status = ('Descending',
'Ascending')[content_settings['sort_order']]
toggle_sort_order_SETTING = ('nextep.sort_order',
('0' if sort_order_status == 'Ascending' else
'1'))
cache_to_disk_status = str(content_settings['cache_to_disk'])
toggle_cache_to_disk_SETTING = ('nextep.cache_to_disk',
('true' if cache_to_disk_status == 'False'
else 'false'))
unaired_status = str(content_settings['include_unaired'])
toggle_unaired_SETTING = ('nextep.include_unaired',
('true'
if unaired_status == 'False' else 'false'))
unwatched_status = str(content_settings['include_unwatched'])
toggle_unwatched_SETTING = ('nextep.include_unwatched',
('true'
if unwatched_status == 'False' else 'false'))
airdate_status = str(display_settings['include_airdate'])
toggle_airdate_SETTING = ('nextep.include_airdate',
('true'
if airdate_status == 'False' else 'false'))
airdate_format = settings.nextep_airdate_format()
airdate_format_status = [
airdate_format.replace(i[0], i[1]) for i in airdate_replacement
if i[0] == airdate_format
][0]
airdate_highlight = display_settings['airdate_colour'].capitalize()
unaired_highlight = display_settings['unaired_colour'].capitalize()
unwatched_highlight = display_settings['unwatched_colour'].capitalize()
choices = [
('MANAGE IN PROGRESS SHOWS', 'manage_in_progress'),
('SORT TYPE: [I]Currently [B]%s[/B][/I]' % sort_type_status,
'Sort Type'),
('SORT ORDER: [I]Currently [B]%s[/B][/I]' % sort_order_status,
'toggle_cache_to_disk'),
('CACHE TO DISK: [I]Currently [B]%s[/B][/I]' % cache_to_disk_status,
'toggle_cache_to_disk'),
('INCLUDE UNAIRED EPISODES: [I]Currently [B]%s[/B][/I]' %
unaired_status, 'toggle_unaired'),
('INCLUDE WATCHLIST/UNWATCHED TV: [I]Currently [B]%s[/B][/I]' %
unwatched_status, 'toggle_unwatched'),
('INCLUDE AIRDATE: [I]Currently [B]%s[/B][/I]' % airdate_status,
'toggle_airdate'),
('AIRDATE FORMAT: [I]Currently [B]%s[/B][/I]' % airdate_format_status,
'Airdate Format'),
('AIRDATE HIGHLIGHT: [I]Currently [B]%s[/B][/I]' % airdate_highlight,
'Airdate'),
('UNAIRED HIGHLIGHT: [I]Currently [B]%s[/B][/I]' % unaired_highlight,
'Unaired'),
('UNWATCHED HIGHLIGHT: [I]Currently [B]%s[/B][/I]' %
unwatched_highlight, 'Unwatched')
]
if settings.watched_indicators() == 0:
choices.append(('MANAGE UNWATCHED TV SHOWS', 'manage_unwatched'))
if settings.watched_indicators() in (1, 2):
choices.append(('CLEAR TRAKT CACHE', 'clear_cache'))
string = 'Next Episode Manager'
dialog_list = [i[0] for i in choices]
function_list = [i[1] for i in choices]
choice = selection_dialog(dialog_list, function_list, string)
if not choice: return
if choice in ('toggle_sort_order', 'toggle_cache_to_disk',
'toggle_unaired', 'toggle_unwatched', 'toggle_airdate'):
setting = eval(choice + '_SETTING')
toggle_setting(setting[0], setting[1])
elif choice == 'clear_cache':
from modules.nav_utils import clear_cache
clear_cache('trakt')
else:
if choice in ('manage_in_progress', 'manage_unwatched'):
xbmc.executebuiltin('Container.Update(%s)' %
build_url({
'mode': 'build_next_episode_manager',
'action': choice
}))
return
elif choice in ('Airdate', 'Unaired', 'Unwatched'):
function = next_episode_color_choice
else:
function = next_episode_options_choice
function(choice)
xbmc.executebuiltin("Container.Refresh")
xbmc.executebuiltin('RunPlugin(%s)' %
build_url({'mode': 'next_episode_context_choice'}))
def build_next_episode():
from modules.indicators_bookmarks import get_watched_info_tv
check_meta_database()
clear_all_trakt_cache_data(confirm=False)
sync_watched_trakt_to_fen()
try:
threads = []
seen = set()
ep_list = []
nextep_settings = settings.nextep_content_settings()
nextep_display_settings = settings.nextep_display_settings()
watched_info, use_trakt = get_watched_info_tv()
meta_user_info = retrieve_user_info()
cache_to_disk = nextep_settings['cache_to_disk']
nextep_display_settings['cache_to_disk'] = cache_to_disk
window.setProperty('fen_fanart_error', 'true')
if nextep_settings['include_unwatched']:
for i in get_unwatched_next_episodes():
ep_list.append(i)
if settings.watched_indicators() in (1, 2):
from apis.trakt_api import trakt_get_next_episodes
ep_list += trakt_get_next_episodes()
else:
settings.check_database(WATCHED_DB)
dbcon = database.connect(WATCHED_DB)
dbcur = dbcon.cursor()
dbcur.execute(
'''SELECT media_id, season, episode, last_played FROM watched_status WHERE db_type=?''',
('episode', ))
rows = dbcur.fetchall()
rows = sorted(rows, key=lambda x: (x[0], x[1], x[2]), reverse=True)
[
ep_list.append({
"tmdb_id": a,
"season": int(b),
"episode": int(c),
"last_played": d
}) for a, b, c, d in rows if not (a in seen or seen.add(a))
]
ep_list = [
x for x in ep_list
if x['tmdb_id'] not in check_for_next_episode_excludes()
]
ep_list = [i for i in ep_list if not i['tmdb_id'] == None]
for item in ep_list:
threads.append(
Thread(target=process_eps,
args=(item, nextep_settings, nextep_display_settings,
watched_info, use_trakt, meta_user_info)))
[i.start() for i in threads]
[i.join() for i in threads]
r = [i for i in result if i is not None]
r = sort_next_eps(r, nextep_settings)
item_list = [i['listitem'] for i in r]
for i in item_list:
xbmcplugin.addDirectoryItem(__handle__, i[0], i[1], i[2])
xbmcplugin.setContent(__handle__, 'episodes')
xbmcplugin.endOfDirectory(__handle__, cacheToDisc=cache_to_disk)
setView('view.episode_lists', 'episodes')
except:
from modules.nav_utils import notification
notification('Error getting Next Episode Info', time=3500)
pass
def build_next_episode_manager():
from modules.nav_utils import add_dir
from modules.indicators_bookmarks import get_watched_status_tvshow, get_watched_info_tv
def _process(tmdb_id, action):
try:
meta = tvshow_meta('tmdb_id', tmdb_id, meta_user_info)
title = meta['title']
if action == 'manage_unwatched':
action, display = 'remove', '[COLOR=%s][UNWATCHED][/COLOR] %s' % (
NEXT_EP_UNWATCHED, title)
url_params = {
'mode': 'add_next_episode_unwatched',
'action': 'remove',
'tmdb_id': tmdb_id,
'title': title
}
elif action == 'trakt_and_fen':
action, display = 'unhide' if tmdb_id in exclude_list else 'hide', '[COLOR=red][EXCLUDED][/COLOR] %s' % title if tmdb_id in exclude_list else '[COLOR=green][INCLUDED][/COLOR] %s' % title
url_params = {
"mode": "hide_unhide_trakt_items",
"action": action,
"media_type": "shows",
"media_id": meta['imdb_id'],
"section": "progress_watched"
}
else:
action, display = 'remove' if tmdb_id in exclude_list else 'add', '[COLOR=red][EXCLUDED][/COLOR] %s' % title if tmdb_id in exclude_list else '[COLOR=green][INCLUDED][/COLOR] %s' % title
url_params = {
'mode': 'add_to_remove_from_next_episode_excludes',
'action': action,
'title': title,
'media_id': tmdb_id
}
sorted_list.append({
'tmdb_id': tmdb_id,
'display': display,
'url_params': url_params,
'meta': json.dumps(meta)
})
except:
pass
check_meta_database()
clear_all_trakt_cache_data(confirm=False)
sync_watched_trakt_to_fen()
params = dict(parse_qsl(sys.argv[2].replace('?', '')))
NEXT_EP_UNWATCHED = __addon__.getSetting('nextep.unwatched_colour')
if not NEXT_EP_UNWATCHED or NEXT_EP_UNWATCHED == '':
NEXT_EP_UNWATCHED = 'red'
threads = []
sorted_list = []
action = params['action']
if action == 'manage_unwatched':
tmdb_list = [i['tmdb_id'] for i in get_unwatched_next_episodes()]
heading = 'Select Show to remove from Fen Next Episode:'
elif settings.watched_indicators() in (1, 2):
from apis.trakt_api import trakt_get_next_episodes
tmdb_list, exclude_list = trakt_get_next_episodes(include_hidden=True)
heading = 'Select Show to Hide/Unhide from Trakt Progress:'
action = 'trakt_and_fen'
else:
settings.check_database(WATCHED_DB)
dbcon = database.connect(WATCHED_DB)
dbcur = dbcon.cursor()
dbcur.execute(
'''SELECT media_id FROM watched_status WHERE db_type=? GROUP BY media_id''',
('episode', ))
rows = dbcur.fetchall()
tmdb_list = [row[0] for row in rows]
exclude_list = check_for_next_episode_excludes()
heading = 'Select Show to Include/Exclude in Fen Next Episode:'
add_dir({'mode': 'nill'},
'[I][COLOR=grey][B]INFO:[/B][/COLOR] [COLOR=grey2]%s[/COLOR][/I]' %
heading,
iconImage='settings.png')
if not tmdb_list:
from modules.nav_utils import notification
return notification('No Shows Present', time=5000)
meta_user_info = retrieve_user_info()
window.setProperty('fen_fanart_error', 'true')
for tmdb_id in tmdb_list:
threads.append(Thread(target=_process, args=(tmdb_id, action)))
[i.start() for i in threads]
[i.join() for i in threads]
sorted_items = sorted(sorted_list, key=lambda k: k['display'])
watched_info, use_trakt = get_watched_info_tv()
for i in sorted_items:
try:
cm = []
meta = json.loads(i['meta'])
playcount, overlay, total_watched, total_unwatched = get_watched_status_tvshow(
watched_info, use_trakt, meta['tmdb_id'],
meta.get('total_episodes'))
meta.update({
'playcount': playcount,
'overlay': overlay,
'total_watched': str(total_watched),
'total_unwatched': str(total_unwatched)
})
url = build_url(i['url_params'])
browse_url = build_url({
'mode': 'build_season_list',
'meta': i['meta']
})
cm.append(
("[B]Browse...[/B]", 'XBMC.Container.Update(%s)' % browse_url))
listitem = xbmcgui.ListItem(i['display'])
listitem.setProperty('watchedepisodes', str(total_watched))
listitem.setProperty('unwatchedepisodes', str(total_unwatched))
listitem.setProperty('totalepisodes', str(meta['total_episodes']))
listitem.setProperty('totalseasons', str(meta['total_seasons']))
listitem.addContextMenuItems(cm)
listitem.setArt({
'poster': meta['poster'],
'fanart': meta['fanart'],
'banner': meta['banner'],
'clearart': meta['clearart'],
'clearlogo': meta['clearlogo'],
'landscape': meta['landscape']
})
listitem.setCast(meta['cast'])
listitem.setInfo('video', remove_unwanted_info_keys(meta))
xbmcplugin.addDirectoryItem(__handle__,
url,
listitem,
isFolder=True)
except:
pass
xbmcplugin.setContent(__handle__, 'tvshows')
xbmcplugin.endOfDirectory(__handle__, cacheToDisc=False)
setView('view.main', 'tvshows')
def build_episode(item, watched_info, use_trakt, meta_user_info):
from modules.utils import make_day
def check_for_unaired():
if item.get('ignore_unaired', False): return False
try:
d = first_aired.split('-')
episode_date = date(int(d[0]), int(d[1]), int(d[2]))
except: episode_date = None
current_adjusted_date = settings.adjusted_datetime()
unaired = False
if not episode_date or current_adjusted_date < episode_date:
unaired = True
return unaired
def build_display():
if nextep_info:
display_first_aired = make_day(first_aired)
airdate = '[[COLOR %s]%s[/COLOR]] ' % (nextep_info['airdate_colour'], display_first_aired) if nextep_info['include_airdate'] else ''
highlight_color = nextep_info['unwatched_colour'] if item.get('unwatched', False) else nextep_info['unaired_colour'] if unaired else ''
italics_open, italics_close = ('[I]', '[/I]') if highlight_color else ('', '')
if highlight_color: episode_info = '%s[COLOR %s]%dx%.2d - %s[/COLOR]%s' % (italics_open, highlight_color, info['season'], info['episode'], info['title'], italics_close)
else: episode_info = '%s%dx%.2d - %s%s' % (italics_open, info['season'], info['episode'], info['title'], italics_close)
display = '%s%s: %s' % (airdate, title, episode_info)
elif trakt_calendar:
display_first_aired = make_day(first_aired)
display = '[%s] %s: %dx%.2d - %s' % (display_first_aired, title.upper(), info['season'], info['episode'], info['title'])
if unaired:
UNAIRED_EPISODE_COLOUR = settings.unaired_episode_colour()
if not UNAIRED_EPISODE_COLOUR or UNAIRED_EPISODE_COLOUR == '': UNAIRED_EPISODE_COLOUR = 'red'
displays = display.split(']')
display = '[COLOR %s]' % UNAIRED_EPISODE_COLOUR + displays[0] + '][/COLOR]' + displays[1]
else:
UNAIRED_EPISODE_COLOUR = settings.unaired_episode_colour()
if not UNAIRED_EPISODE_COLOUR or UNAIRED_EPISODE_COLOUR == '': UNAIRED_EPISODE_COLOUR = 'red'
color_tags = ('[COLOR %s]' % UNAIRED_EPISODE_COLOUR, '[/COLOR]') if unaired else ('', '')
display = '%s: %s%dx%.2d - %s%s' % (title.upper(), color_tags[0], info['season'], info['episode'], info['title'], color_tags[1])
return display
try:
cm = []
nextep_info = item.get('nextep_display_settings', None)
trakt_calendar = item.get('trakt_calendar', False)
watched_indicators = settings.watched_indicators()
action = item.get('action', '')
meta = item['meta']
tmdb_id = meta['tmdb_id']
tvdb_id = meta['tvdb_id']
imdb_id = meta["imdb_id"]
title = meta['title']
year = meta['year']
episodes_data = tikimeta.season_episodes_meta(tmdb_id, tvdb_id, item['season'], meta['tvdb_summary']['airedSeasons'], meta['season_data'], meta_user_info)
info = [i for i in episodes_data if i['episode'] == item['episode']][0]
first_aired = info['premiered']
season = info['season']
episode = info['episode']
unaired = check_for_unaired()
if unaired and not item.get('include_unaired', False): return
thumb = info['thumb'] if 'episodes' in info['thumb'] else meta['fanart']
playcount, overlay = get_watched_status(watched_info, use_trakt, 'episode', tmdb_id, season, episode)
resumetime = get_resumetime('episode', tmdb_id, season, episode)
info.update({'trailer': str(meta.get('trailer')), 'tvshowtitle': title,
'genre': meta.get('genre'), 'duration': meta.get('duration'), 'mpaa': meta.get('mpaa'),
'studio': meta.get('studio'), 'playcount': playcount, 'overlay': overlay})
query = title + ' S%.2dE%.2d' % (season, episode)
display = build_display()
rootname = '{0} ({1})'.format(title, year)
meta.update({'vid_type': 'episode', 'rootname': rootname, 'season': season,
'episode': episode, 'premiered': first_aired, 'ep_name': info['title'],
'plot': info['plot']})
meta_json = json.dumps(meta)
url_params = {'mode': 'play_media', 'vid_type': 'episode', 'tmdb_id': tmdb_id, 'query': query,
'tvshowtitle': meta['rootname'], 'season': season, 'episode': episode, 'meta': meta_json}
url = build_url(url_params)
browse_url = build_url({'mode': 'build_season_list', 'meta': meta_json})
playback_menu_params = {'mode': 'playback_menu', 'suggestion': query, 'play_params': json.dumps(url_params)}
(wstate, waction) = ('Watched', 'mark_as_watched') if playcount == 0 else ('Unwatched', 'mark_as_unwatched')
watched_title = 'Trakt' if watched_indicators in (1, 2) else "Fen"
watched_params = {"mode": "mark_episode_as_watched_unwatched", "action": waction, "media_id": tmdb_id, "imdb_id": imdb_id, "tvdb_id": tvdb_id, "season": season, "episode": episode, "title": title, "year": year}
if action == 'next_episode': nextep_manage_params = {"mode": "next_episode_context_choice"}
if not unaired: cm.append(("[B]Mark %s %s[/B]" % (wstate, watched_title),'RunPlugin(%s)' % build_url(watched_params)))
cm.append(("[B]Options[/B]",'RunPlugin(%s)' % build_url(playback_menu_params)))
if action == 'next_episode':
cm.append(("[B]Next Episode Manager[/B]",'RunPlugin(%s)'% build_url(nextep_manage_params)))
if nextep_info['cache_to_disk']: cm.append(("[B]Refresh...[/B]",'Container.Refresh()'))
cm.append(("[B]Browse...[/B]",'Container.Update(%s)' % browse_url))
cm.append(("[B]Extended Info[/B]", 'RunScript(script.extendedinfo,info=extendedtvinfo,id=%s)' % tmdb_id))
if not unaired and resumetime != '0': cm.append(("[B]Clear Progress[/B]", 'RunPlugin(%s)' % build_url({"mode": "watched_unwatched_erase_bookmark", "db_type": "episode", "media_id": tmdb_id, "season": season, "episode": episode, "refresh": "true"})))
listitem = xbmcgui.ListItem()
listitem.setLabel(display)
listitem.setProperty("resumetime", resumetime)
listitem.setArt({'poster': meta['poster'], 'fanart': meta['fanart'], 'thumb':thumb, 'banner': meta['banner'], 'clearart': meta['clearart'], 'clearlogo': meta['clearlogo'], 'landscape': meta['landscape']})
listitem.addContextMenuItems(cm)
listitem.setCast(meta['cast'])
listitem.setUniqueIDs({'imdb': str(imdb_id), 'tmdb': str(tmdb_id), 'tvdb': str(tvdb_id)})
info['title'] = display
listitem.setInfo('video', remove_unwanted_info_keys(info))
if is_widget:
try:
listitem.setProperties({'fen_widget': 'true', 'fen_playcount': str(playcount), 'fen_playback_menu_params': json.dumps(playback_menu_params)})
except:
listitem.setProperty("fen_widget", 'true')
listitem.setProperty("fen_playcount", str(playcount))
listitem.setProperty("fen_playback_menu_params", json.dumps(playback_menu_params))
return {'listitem': (url, listitem, False), 'curr_last_played_parsed': item.get('curr_last_played_parsed', ''), 'label': display, 'order': item.get('order', ''), 'name': query, 'first_aired': first_aired}
except: pass
def options_menu(params, meta=None):
def _builder():
for item in listing:
line1 = item[0]
line2 = item[1]
if line2 == '': line2 = line1
yield {'line1': line1, 'line2': line2}
content = params.get('content', None)
if not content: content = kodi_utils.container_content()[:-1]
season = params.get('season', None)
episode = params.get('episode', None)
if not meta:
function = metadata.movie_meta if content == 'movie' else metadata.tvshow_meta
meta_user_info = metadata.retrieve_user_info()
meta = function('tmdb_id', params['tmdb_id'], meta_user_info)
watched_indicators = settings.watched_indicators()
on_str, off_str, currently_str, open_str, settings_str = ls(32090), ls(
32027), ls(32598), ls(32641), ls(32247)
autoplay_status, autoplay_toggle, quality_setting = (on_str, 'false', 'autoplay_quality_%s' % content) if settings.auto_play(content) \
else (off_str, 'true', 'results_quality_%s' % content)
quality_filter_setting = 'autoplay_quality_%s' % content if autoplay_status == on_str else 'results_quality_%s' % content
autoplay_next_status, autoplay_next_toggle = (
on_str, 'false') if settings.autoplay_next_episode() else (off_str,
'true')
results_xml_style_status = get_setting('results.xml_style', 'Default')
results_filter_ignore_status, results_filter_ignore_toggle = (
on_str, 'false') if settings.ignore_results_filter() else (off_str,
'true')
results_sorting_status = get_setting('results.sort_order_display').replace(
'$ADDON[plugin.video.fen 32582]', ls(32582))
current_results_highlights_action = get_setting('highlight.type')
results_highlights_status = ls(
32240) if current_results_highlights_action == '0' else ls(
32583) if current_results_highlights_action == '1' else ls(32241)
current_subs_action = get_setting('subtitles.subs_action')
current_subs_action_status = 'Auto' if current_subs_action == '0' else ls(
32193) if current_subs_action == '1' else off_str
active_internal_scrapers = [
i.replace('_', '') for i in settings.active_internal_scrapers()
]
current_scrapers_status = ', '.join([
i for i in active_internal_scrapers
]) if len(active_internal_scrapers) > 0 else 'N/A'
current_quality_status = ', '.join(
settings.quality_filter(quality_setting))
uncached_torrents_status, uncached_torrents_toggle = (
on_str, 'false') if settings.display_uncached_torrents() else (off_str,
'true')
listing = []
base_str1 = '%s%s'
base_str2 = '%s: [B]%s[/B]' % (currently_str, '%s')
if content in ('movie', 'episode'):
multi_line = 'true'
listing += [(ls(32014), '', 'clear_and_rescrape')]
listing += [(ls(32006), '', 'rescrape_with_disabled')]
listing += [(ls(32135), '', 'scrape_with_custom_values')]
listing += [(base_str1 % (ls(32175), ' (%s)' % content),
base_str2 % autoplay_status, 'toggle_autoplay')]
if autoplay_status == on_str and content == 'episode':
listing += [
(base_str1 % (ls(32178), ''), base_str2 % autoplay_next_status,
'toggle_autoplay_next')
]
listing += [(base_str1 % (ls(32105), ' (%s)' % content),
base_str2 % current_quality_status, 'set_quality')]
listing += [(base_str1 % ('', '%s %s' % (ls(32055), ls(32533))),
base_str2 % current_scrapers_status, 'enable_scrapers')]
if autoplay_status == off_str:
listing += [(base_str1 % ('', ls(32140)),
base_str2 % results_xml_style_status,
'set_results_xml_display')]
listing += [
(base_str1 % ('', ls(32151)),
base_str2 % results_sorting_status, 'set_results_sorting')
]
listing += [(base_str1 % ('', ls(32138)),
base_str2 % results_highlights_status,
'set_results_highlights')]
listing += [(base_str1 % ('', ls(32686)),
base_str2 % results_filter_ignore_status,
'set_results_filter_ignore')]
listing += [(base_str1 % ('', ls(32183)),
base_str2 % current_subs_action_status, 'set_subs_action')
]
if 'external' in active_internal_scrapers:
listing += [(base_str1 % ('', ls(32160)),
base_str2 % uncached_torrents_status,
'toggle_torrents_display_uncached')]
else:
multi_line = 'false'
listing += [(ls(32046), '', 'extras_lists_choice')]
if content in ('movie', 'tvshow') and meta:
listing += [
(ls(32604) %
(ls(32028) if meta['mediatype'] == 'movie' else ls(32029)), '',
'clear_media_cache')
]
if watched_indicators == 1:
listing += [(ls(32497) % ls(32037), '', 'clear_trakt_cache')]
if content in ('movie', 'episode'):
listing += [(ls(32637), '', 'clear_scrapers_cache')]
listing += [('%s %s' % (ls(32118), ls(32513)), '',
'open_external_scrapers_manager')]
listing += [('%s %s %s' % (open_str, ls(32522), settings_str), '',
'open_scraper_settings')]
listing += [('%s %s %s' % (open_str, ls(32036), settings_str), '',
'open_fen_settings')]
listing += [(ls(32640), '', 'save_and_exit')]
list_items = list(_builder())
heading = ls(32646).replace('[B]', '').replace('[/B]', '')
kwargs = {
'items': json.dumps(list_items),
'heading': heading,
'enumerate': 'false',
'multi_choice': 'false',
'multi_line': multi_line
}
choice = kodi_utils.select_dialog([i[2] for i in listing], **kwargs)
if choice in (None, 'save_and_exit'): return
elif choice == 'clear_and_rescrape':
return clear_and_rescrape(content, meta, season, episode)
elif choice == 'rescrape_with_disabled':
return rescrape_with_disabled(content, meta, season, episode)
elif choice == 'scrape_with_custom_values':
return scrape_with_custom_values(content, meta, season, episode)
elif choice == 'toggle_autoplay':
set_setting('auto_play_%s' % content, autoplay_toggle)
elif choice == 'toggle_autoplay_next':
set_setting('autoplay_next_episode', autoplay_next_toggle)
elif choice == 'enable_scrapers':
enable_scrapers_choice()
elif choice == 'set_results_xml_display':
results_layout_choice()
elif choice == 'set_results_sorting':
results_sorting_choice()
elif choice == 'set_results_filter_ignore':
set_setting('ignore_results_filter', results_filter_ignore_toggle)
elif choice == 'set_results_highlights':
results_highlights_choice()
elif choice == 'set_quality':
set_quality_choice(quality_filter_setting)
elif choice == 'set_subs_action':
set_subtitle_choice()
elif choice == 'extras_lists_choice':
extras_lists_choice()
elif choice == 'clear_media_cache':
return refresh_cached_data(meta['mediatype'], 'tmdb_id',
meta['tmdb_id'], meta['tvdb_id'],
settings.get_language())
elif choice == 'toggle_torrents_display_uncached':
set_setting('torrent.display.uncached', uncached_torrents_toggle)
elif choice == 'clear_trakt_cache':
return clear_cache('trakt')
elif choice == 'clear_scrapers_cache':
return clear_scrapers_cache()
elif choice == 'open_external_scrapers_manager':
return external_scrapers_manager()
elif choice == 'open_scraper_settings':
return kodi_utils.execute_builtin(
'Addon.OpenSettings(script.module.fenomscrapers)')
elif choice == 'open_fen_settings':
return open_settings('0.0')
if choice == 'clear_trakt_cache' and content in ('movie', 'tvshow',
'season', 'episode'):
kodi_utils.execute_builtin('Container.Refresh')
kodi_utils.show_busy_dialog()
kodi_utils.sleep(200)
kodi_utils.hide_busy_dialog()
options_menu(params, meta=meta)
def get_watched_items(db_type, page_no, letter):
from modules.nav_utils import paginate_list
from modules.utils import title_key, to_utf8
watched_indicators = settings.watched_indicators()
paginate = settings.paginate()
limit = settings.page_limit()
if db_type == 'tvshow':
if watched_indicators in (1, 2):
from apis.trakt_api import trakt_indicators_tv
data = trakt_indicators_tv()
data = sorted(data, key=lambda tup: title_key(tup[3]))
original_list = [{
'media_id': i[0],
'title': i[3]
} for i in data if i[1] == len(i[2])]
else:
import tikimeta
meta_user_info = tikimeta.retrieve_user_info()
settings.check_database(WATCHED_DB)
dbcon = database.connect(WATCHED_DB)
dbcur = dbcon.cursor()
dbcur.execute(
"SELECT media_id, title FROM watched_status WHERE db_type = ?",
('episode', ))
rows = dbcur.fetchall()
dbcon.close()
watched_list = list(set(to_utf8([(i[0], i[1]) for i in rows])))
watched_info, use_trakt = get_watched_info_tv()
data = []
for item in watched_list:
meta = tikimeta.tvshow_meta('tmdb_id', item[0], meta_user_info)
watched = get_watched_status_tvshow(watched_info, use_trakt,
item[0],
meta.get('total_episodes'))
if watched[0] == 1: data.append(item)
else: pass
data = sorted(data, key=lambda tup: title_key(tup[1]))
original_list = [{'media_id': i[0], 'title': i[1]} for i in data]
else:
if watched_indicators in (1, 2):
from apis.trakt_api import trakt_indicators_movies
data = trakt_indicators_movies()
data = sorted(data, key=lambda tup: title_key(tup[1]))
original_list = [{'media_id': i[0], 'title': i[1]} for i in data]
else:
settings.check_database(WATCHED_DB)
dbcon = database.connect(WATCHED_DB)
dbcur = dbcon.cursor()
dbcur.execute(
"SELECT media_id, title FROM watched_status WHERE db_type = ?",
(db_type, ))
rows = dbcur.fetchall()
dbcon.close()
data = to_utf8([(i[0], i[1]) for i in rows])
data = sorted(data, key=lambda tup: title_key(tup[1]))
original_list = [{'media_id': i[0], 'title': i[1]} for i in data]
if paginate:
final_list, total_pages = paginate_list(original_list, page_no, letter,
limit)
else:
final_list, total_pages = original_list, 1
return final_list, total_pages
def mark_tv_show_as_watched_unwatched():
from modules.next_episode import add_next_episode_unwatched
params = dict(parse_qsl(sys.argv[2].replace('?', '')))
action = 'mark_as_watched' if params.get(
'action') == 'mark_as_watched' else 'mark_as_unwatched'
media_id = params.get('media_id')
tvdb_id = int(params.get('tvdb_id', '0'))
imdb_id = params.get('imdb_id')
watched_indicators = settings.watched_indicators()
if watched_indicators in (1, 2):
from apis.trakt_api import trakt_watched_unwatched
trakt_watched_unwatched(action, 'shows', imdb_id, tvdb_id)
clear_trakt_watched_data('tvshow')
clear_trakt_collection_watchlist_data('watchlist', 'tvshow')
if watched_indicators in (0, 1):
import tikimeta
bg_dialog = xbmcgui.DialogProgressBG()
bg_dialog.create('Please Wait', '')
title = params.get('title', '')
year = params.get('year', '')
try:
meta_user_info = json.loads(params.get('meta_user_info', ))
except:
meta_user_info = tikimeta.retrieve_user_info()
se_list = []
count = 1
meta = tikimeta.tvshow_meta('tmdb_id', media_id, meta_user_info)
season_data = tikimeta.all_episodes_meta(
media_id, tvdb_id, meta['tvdb_summary']['airedSeasons'],
meta['season_data'], meta_user_info)
total = sum([
i['episode_count'] for i in season_data if i['season_number'] > 0
])
for item in season_data:
season_number = item['season_number']
if season_number <= 0: continue
ep_data = tikimeta.season_episodes_meta(
media_id, tvdb_id, season_number,
meta['tvdb_summary']['airedSeasons'], meta['season_data'],
meta_user_info)
for ep in ep_data:
season_number = ep['season']
ep_number = ep['episode']
season_ep = '%.2d<>%.2d' % (int(season_number), int(ep_number))
display = 'Updating - S%.2dE%.2d' % (int(season_number),
int(ep_number))
bg_dialog.update(int(float(count) / float(total) * 100),
'Please Wait', '%s' % display)
count += 1
try:
first_aired = ep['premiered']
d = first_aired.split('-')
episode_date = date(int(d[0]), int(d[1]), int(d[2]))
except:
episode_date = date(2100, 10, 24)
if not settings.adjusted_datetime() > episode_date: continue
mark_as_watched_unwatched('episode', media_id, action,
season_number, ep_number, title)
se_list.append(season_ep)
bg_dialog.close()
if action == 'mark_as_watched':
add_next_episode_unwatched('remove', media_id, silent=True)
if settings.sync_kodi_library_watchstatus():
from modules.kodi_library import get_library_video, batch_mark_episodes_as_watched_unwatched_kodi_library
in_library = get_library_video('tvshow', title, year)
if not in_library:
refresh_container()
return
if not in_library: return
from modules.nav_utils import notification
notification('Browse back to Kodi Home Screen!!', time=7000)
xbmc.sleep(8500)
ep_dict = {
'action': action,
'tvshowid': in_library['tvshowid'],
'season_ep_list': se_list
}
if batch_mark_episodes_as_watched_unwatched_kodi_library(
in_library, ep_dict):
notification('Kodi Library Sync Complete', time=5000)
refresh_container()
