def subscriptions_update_interval():
try: from urlparse import parse_qsl
except ImportError: from urllib.parse import parse_qsl
from modules.nav_utils import toggle_setting
import time
from datetime import datetime, timedelta
from modules.nav_utils import open_settings
params = dict(parse_qsl(sys.argv[2].replace('?','')))
subscription_timer = __addon__.getSetting('subscription_timer')
if params['update_type'] == 'interval':
subscriptions_update_label = 'subscriptions_update_label1'
intervals = [('1 Hour', 1), ('2 Hours', 2), ('4 Hours', 4), ('8 Hours', 8), ('12 Hours', 12), ('16 Hours', 16), ('24 Hours', 24)]
try: last_run_time = datetime.strptime(__addon__.getSetting('service_time'), "%Y-%m-%d %H:%M:%S") - timedelta(hours=int(subscription_timer))
except TypeError: last_run_time = datetime(*(time.strptime(__addon__.getSetting('service_time'), "%Y-%m-%d %H:%M:%S")[0:6])) - timedelta(hours=int(subscription_timer))
choice = selection_dialog([i[0] for i in intervals], intervals, 'Fen - Choose Subscription Update Interval')
if not choice: choice = ('24 Hours', 24)
interval = str(choice[1])
interval_display = choice[0]
new_run_time = last_run_time + timedelta(hours=int(interval))
new_run_time = new_run_time.strftime("%Y-%m-%d %H:%M:%S")
else:
subscriptions_update_label = 'subscriptions_update_label2'
intervals = []
for i in range(24): intervals.append(('%02d:00' % i, i))
choice = selection_dialog([i[0] for i in intervals], intervals, 'Fen - Choose Daily Subscription Update Time')
if not choice: choice = ('06:00', 6)
sub_hour = choice[1]
interval_display = choice[0]
interval = subscription_timer
now = datetime.today()
sub_day = now.day + 1 if sub_hour == 0 else now.day
new_run_time = now.replace(day=sub_day, hour=sub_hour, minute=0, second=0, microsecond=0) + timedelta(days=1)
difference = new_run_time - now
if '1 day' in str(difference): new_run_time = now.replace(day=sub_day, hour=sub_hour, minute=0, second=0, microsecond=0)
new_run_time = new_run_time.strftime("%Y-%m-%d %H:%M:%S")
toggle_setting('subscription_timer', interval)
toggle_setting(subscriptions_update_label, interval_display)
toggle_setting('service_time', new_run_time)
return open_settings('8.7')
actor_image = params.get('actor_image', 'None')
if 'media_results' in mode:
media_type = params.get('media_type')
page_no = int(params.get('new_page', '1'))
letter = params.get('new_letter', 'None')
People((actor_id, actor_name,
actor_image)).media_results(media_type, page_no, letter)
else:
action_code = 'People(%s).%s()' % (
(actor_id, actor_name, actor_image), mode.split('.')[1])
action_object = compile(action_code, 'people_search_string', 'exec')
exec(action_object)
elif '_settings' in mode:
if mode == 'open_settings':
from modules.nav_utils import open_settings
open_settings(params.get('query'))
elif mode == 'backup_settings':
from modules.nav_utils import backup_settings
backup_settings()
elif mode == 'restore_settings':
from modules.nav_utils import restore_settings
restore_settings()
elif mode == 'open_ext_settings':
from modules.utils import open_ext_settings
open_ext_settings(params.get("addon"))
elif mode == 'clean_settings':
from modules.nav_utils import clean_settings
clean_settings()
elif mode == 'switch_settings':
from modules.utils import switch_settings
switch_settings()
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 routing(argv2):
params = dict(parse_qsl(argv2.replace('?','')))
mode = params.get('mode', 'navigator.main')
if 'navigator.' in mode:
from indexers.navigator import Navigator
exec('Navigator(params).%s()' % mode.split('.')[1])
elif 'discover.' in mode:
if mode in ('discover.remove_from_history', 'discover.remove_all_history'):
if mode == 'discover.remove_from_history':
from indexers.discover import remove_from_history
params['silent'] = False
remove_from_history(params)
elif mode == 'discover.remove_all_history':
from indexers.discover import remove_all_history
params['silent'] = True
remove_all_history(params)
else:
from indexers.discover import Discover
exec('Discover(params).%s()' % mode.split('.')[1])
elif 'furk.' in mode:
if mode == 'furk.browse_packs':
from modules.sources import Sources
Sources().furkPacks(params['file_name'], params['file_id'], params['highlight'])
elif mode == 'furk.add_to_files':
from indexers.furk import add_to_files
add_to_files(params['item_id'])
elif mode == 'furk.remove_from_files':
from indexers.furk import remove_from_files
remove_from_files(params['item_id'])
elif mode == 'furk.remove_from_downloads':
from indexers.furk import remove_from_downloads
remove_from_downloads(params['item_id'])
elif mode == 'furk.remove_from_files':
from indexers.furk import add_uncached_file
add_uncached_file(params['id'])
elif mode == 'furk.myfiles_protect_unprotect':
from indexers.furk import myfiles_protect_unprotect
myfiles_protect_unprotect(params['action'], params['name'], params['item_id'])
elif mode == 'furk.browse_audio_album':
from indexers.furk import browse_audio_album
browse_audio_album(params.get('t_file', None), params.get('item_path', None))
else:
from modules.utils import manual_function_import
function = manual_function_import('indexers.furk', mode.split('.')[-1])
function(params)
elif 'easynews.' in mode:
from modules.utils import manual_function_import
function = manual_function_import('indexers.easynews', mode.split('.')[-1])
function(params)
elif '_play' in mode or 'play_' in mode and not 'autoplay' in mode:
if mode == 'play_media':
from modules.sources import Sources
if 'params' in params:
import json
params = json.loads(params['params'])
Sources().playback_prep(params)
elif mode == 'play_display_results':
from modules.sources import Sources
Sources().display_results()
elif mode == 'play_file':
from modules.sources import Sources
Sources().play_file(params['title'], params['source'])
elif mode == 'media_play':
from modules.player import FenPlayer
FenPlayer().run(params.get('url', None), params.get('media_type', None))
elif mode == 'play_fetch_random':
from modules.random_play import play_fetch_random
play_fetch_random(params['tmdb_id'])
elif 'choice' in mode:
from indexers import dialogs
if mode == 'scraper_color_choice':
dialogs.scraper_color_choice(params['setting'])
elif mode == 'scraper_dialog_color_choice':
dialogs.scraper_dialog_color_choice(params['setting'])
elif mode == 'scraper_quality_color_choice':
dialogs.scraper_quality_color_choice(params['setting'])
elif mode == 'imdb_images_choice':
dialogs.imdb_images_choice(params['imdb_id'], params['rootname'])
elif mode == 'set_quality_choice':
dialogs.set_quality_choice(params['quality_setting'])
elif mode == 'results_sorting_choice':
dialogs.results_sorting_choice()
elif mode == 'results_layout_choice':
dialogs.results_layout_choice()
elif mode == 'options_menu_choice':
dialogs.options_menu(params)
elif mode == 'meta_language_choice':
dialogs.meta_language_choice()
elif mode == 'extras_menu_choice':
dialogs.extras_menu(params)
elif mode == 'enable_scrapers_choice':
dialogs.enable_scrapers_choice()
elif mode == 'favorites_choice':
dialogs.favorites_choice(params)
elif mode == 'trakt_manager_choice':
dialogs.trakt_manager_choice(params)
elif mode == 'folder_scraper_manager_choice':
dialogs.folder_scraper_manager_choice()
elif mode == 'set_language_filter_choice':
dialogs.set_language_filter_choice(params['filter_setting'])
elif mode == 'media_extra_info_choice':
dialogs.media_extra_info(params['media_type'], params['meta'])
elif mode == 'extras_lists_choice':
dialogs.extras_lists_choice()
elif 'trakt.' in mode or 'trakt_' in mode:
if mode == 'get_trakt_my_calendar':
from indexers.episodes_single import get_trakt_my_calendar
get_trakt_my_calendar(params)
elif 'trakt.list' in mode:
from modules.utils import manual_function_import
function = manual_function_import('indexers.trakt_lists', mode.split('.')[-1])
function(params)
elif 'trakt.' in mode:
from modules.utils import manual_function_import
function = manual_function_import('apis.trakt_api', mode.split('.')[-1])
function(params)
else:
from apis.trakt_api import hide_unhide_trakt_items
hide_unhide_trakt_items(params['action'], params['media_type'], params['media_id'], params['section'])
elif 'build' in mode:
if mode == 'build_movie_list':
from indexers.movies import Movies
Movies(params).fetch_list()
elif mode == 'build_tvshow_list':
from indexers.tvshows import TVShows
TVShows(params).fetch_list()
elif mode == 'build_season_list':
from indexers.seasons import build_season_list
build_season_list(params)
elif mode == 'build_episode_list':
from indexers.episodes import build_episode_list
build_episode_list(params)
elif mode == 'build_next_episode':
from indexers.episodes_single import build_next_episode
build_next_episode()
elif mode == 'build_in_progress_episode':
from indexers.episodes_single import build_in_progress_episode
build_in_progress_episode()
elif mode == 'build_navigate_to_page':
from modules.nav_utils import build_navigate_to_page
build_navigate_to_page(params)
elif mode == 'build_next_episode_manager':
from indexers.next_episode import build_next_episode_manager
build_next_episode_manager(params)
elif mode == 'imdb_build_user_lists':
from indexers.imdb import imdb_build_user_lists
imdb_build_user_lists(params.get('db_type'))
elif mode == 'build_popular_people':
from indexers.people import popular_people
popular_people()
elif mode == 'imdb_build_keyword_results':
from indexers.imdb import imdb_build_keyword_results
imdb_build_keyword_results(params['db_type'], params['query'])
elif 'favourites' in mode:
from modules.favourites import Favourites
exec('Favourites(params).%s()' % mode)
elif 'watched_unwatched' in mode:
if mode == 'mark_as_watched_unwatched_episode':
from modules.watched_status import mark_as_watched_unwatched_episode
mark_as_watched_unwatched_episode(params)
elif mode == 'mark_as_watched_unwatched_season':
from modules.watched_status import mark_as_watched_unwatched_season
mark_as_watched_unwatched_season(params)
elif mode == 'mark_as_watched_unwatched_tvshow':
from modules.watched_status import mark_as_watched_unwatched_tvshow
mark_as_watched_unwatched_tvshow(params)
elif mode == 'mark_as_watched_unwatched_movie':
from modules.watched_status import mark_as_watched_unwatched_movie
mark_as_watched_unwatched_movie(params)
elif mode == 'watched_unwatched_erase_bookmark':
from modules.watched_status import erase_bookmark
erase_bookmark(params.get('db_type'), params.get('tmdb_id'), params.get('season', ''), params.get('episode', ''), params.get('refresh', 'false'))
elif 'myaccounts' in mode:
action = mode.split('.')[1]
if action == 'open':
from modules.nav_utils import open_MyAccounts
open_MyAccounts(params)
else:
from modules.nav_utils import sync_MyAccounts
sync_MyAccounts()
elif 'toggle' in mode:
if mode == 'toggle_jump_to':
from modules.nav_utils import toggle_jump_to
toggle_jump_to()
elif mode == 'toggle_provider':
from modules.utils import toggle_provider
toggle_provider()
elif mode == 'toggle_language_invoker':
from modules.nav_utils import toggle_language_invoker
toggle_language_invoker()
elif 'history' in mode:
if mode == 'search_history':
from indexers.history import search_history
search_history(params)
elif mode == 'clear_search_history':
from modules.history import clear_search_history
clear_search_history()
elif mode == 'remove_from_history':
from modules.history import remove_from_search_history
remove_from_search_history(params)
elif 'real_debrid' in mode:
if mode == 'real_debrid.rd_torrent_cloud':
from indexers.real_debrid import rd_torrent_cloud
rd_torrent_cloud()
if mode == 'real_debrid.rd_downloads':
from indexers.real_debrid import rd_downloads
rd_downloads()
elif mode == 'real_debrid.browse_rd_cloud':
from indexers.real_debrid import browse_rd_cloud
browse_rd_cloud(params['id'])
elif mode == 'real_debrid.resolve_rd':
from indexers.real_debrid import resolve_rd
resolve_rd(params)
elif mode == 'real_debrid.rd_account_info':
from indexers.real_debrid import rd_account_info
rd_account_info()
elif mode == 'real_debrid.delete':
from indexers.real_debrid import rd_delete
rd_delete(params.get('id'), params.get('cache_type'))
elif mode == 'real_debrid.delete_download_link':
from indexers.real_debrid import delete_download_link
delete_download_link(params['download_id'])
elif 'premiumize' in mode:
if mode == 'premiumize.pm_torrent_cloud':
from indexers.premiumize import pm_torrent_cloud
pm_torrent_cloud(params.get('id', None), params.get('folder_name', None))
elif mode == 'premiumize.pm_transfers':
from indexers.premiumize import pm_transfers
pm_transfers()
elif mode == 'premiumize.pm_account_info':
from indexers.premiumize import pm_account_info
pm_account_info()
elif mode == 'premiumize.rename':
from indexers.premiumize import pm_rename
pm_rename(params.get('file_type'), params.get('id'), params.get('name'))
elif mode == 'premiumize.delete':
from indexers.premiumize import pm_delete
pm_delete(params.get('file_type'), params.get('id'))
elif 'alldebrid' in mode:
if mode == 'alldebrid.ad_torrent_cloud':
from indexers.alldebrid import ad_torrent_cloud
ad_torrent_cloud(params.get('id', None))
elif mode == 'alldebrid.browse_ad_cloud':
from indexers.alldebrid import browse_ad_cloud
browse_ad_cloud(params['folder'])
elif mode == 'alldebrid.resolve_ad':
from indexers.alldebrid import resolve_ad
resolve_ad(params)
elif mode == 'alldebrid.ad_account_info':
from indexers.alldebrid import ad_account_info
ad_account_info()
elif 'people_search' in mode:
from indexers import people
if 'person_data_dialog' in mode:
people.person_data_dialog(params)
elif '.search' in mode:
people.person_search(params.get('actor_name', None))
elif '_settings' in mode:
if mode == 'open_settings':
from modules.nav_utils import open_settings
open_settings(params.get('query'))
elif mode == 'clean_settings':
from modules.nav_utils import clean_settings
clean_settings()
elif mode == 'erase_all_settings':
from modules.nav_utils import erase_all_settings
erase_all_settings()
elif mode == 'external_settings':
from modules.nav_utils import open_settings
open_settings(params.get('query', '0.0'), params.get('ext_addon'))
elif mode == 'clear_settings_window_properties':
from modules.kodi_utils import clear_settings_window_properties
clear_settings_window_properties()
elif '_cache' in mode:
from modules import nav_utils
if mode == 'clear_cache':
nav_utils.clear_cache(params.get('cache'))
elif mode == 'clear_all_cache':
nav_utils.clear_all_cache()
elif '_image' in mode:
from indexers.images import Images
Images().run(params)
elif 'service_functions' in mode:
from services import service_functions
exec('service_functions.%s().run()' % mode.split('.')[1])
elif '_text' in mode:
if mode == 'show_text':
from modules.kodi_utils import show_text
show_text(params.get('heading'), params.get('text', None), params.get('file', None), params.get('font_size', 'small'))
elif mode == 'show_text_media':
from modules.kodi_utils import show_text_media
show_text(params.get('heading'), params.get('text', None), params.get('file', None), params.get('meta'), {})
elif '_view' in mode:
from modules import kodi_utils
if mode == 'choose_view':
kodi_utils.choose_view(params['view_type'], params.get('content', ''))
elif mode == 'set_view':
kodi_utils.set_view(params['view_type'])
##EXTRA modes##
elif mode == 'manual_add_magnet_to_cloud':
from modules.debrid import manual_add_magnet_to_cloud
manual_add_magnet_to_cloud(params)
elif mode == 'debrid.browse_packs':
from modules.sources import Sources
Sources().debridPacks(params['provider'], params['name'], params['magnet_url'], params['info_hash'], params['highlight'])
elif mode == 'get_search_term':
from modules.nav_utils import get_search_term
get_search_term(params)
elif mode == 'link_folders':
from modules.nav_utils import link_folders
link_folders(params['service'], params['folder_name'], params['action'])
elif mode == 'downloader':
from modules.downloader import runner
runner(params)
elif mode == 'clean_databases':
from caches import clean_databases
clean_databases()
elif mode == 'refresh_artwork':
from modules.nav_utils import refresh_artwork
refresh_artwork()
def download(url):
from modules.nav_utils import hide_busy_dialog, notification
from modules.utils import clean_file_name, clean_title
from modules import settings
# from modules.utils import logger
if url == None:
hide_busy_dialog()
notification('No URL found for Download. Pick another Source', 6000)
return
params = dict(parse_qsl(sys.argv[2].replace('?','')))
json_meta = params.get('meta')
if json_meta:
meta = json.loads(json_meta)
db_type = meta.get('vid_type')
title = meta.get('search_title')
year = meta.get('year')
image = meta.get('poster')
season = meta.get('season')
episode = meta.get('episode')
name = params.get('name')
else:
db_type = params.get('db_type')
image = params.get('image')
title = params.get('name')
title = clean_file_name(title)
media_folder = settings.download_directory(db_type)
if not media_folder:
hide_busy_dialog()
resp = xbmcgui.Dialog().yesno(
"No Download folder set!",
"Fen requires you to set Download Folders.",
"Would you like to set a folder now?")
if resp:
from modules.nav_utils import open_settings
return open_settings('7.0')
else:
return
if db_type in ('movie', 'episode'):
folder_rootname = '%s (%s)' % (title, year)
folder = os.path.join(media_folder, folder_rootname + '/')
else:
folder = media_folder
if db_type == 'episode':
folder = os.path.join(folder, 'Season ' + str(season))
try: headers = dict(parse_qsl(url.rsplit('|', 1)[1]))
except: headers = dict('')
dest = None
url = url.split('|')[0]
if not 'http' in url:
from apis.furk_api import FurkAPI
from indexers.furk import filter_furk_tlist, seas_ep_query_list
t_files = FurkAPI().t_files(url)
t_files = [i for i in t_files if 'video' in i['ct'] and 'bitrate' in i]
name, url = filter_furk_tlist(t_files, (None if db_type == 'movie' else seas_ep_query_list(season, episode)))[0:2]
dest = os.path.join(folder, name)
if db_type == 'archive':
ext = 'zip'
if db_type == 'audio':
ext = os.path.splitext(urlparse(url).path)[1][1:]
if not ext in ['wav', 'mp3', 'ogg', 'flac', 'wma', 'aac']: ext = 'mp3'
else:
ext = os.path.splitext(urlparse(url).path)[1][1:]
if not ext in ['mp4', 'mkv', 'flv', 'avi', 'mpg']: ext = 'mp4'
if not dest:
name_url = unquote(url)
file_name = clean_title(name_url.split('/')[-1])
if clean_title(title).lower() in file_name.lower():
transname = os.path.splitext(urlparse(name_url).path)[0].split('/')[-1]
else:
try: transname = name.translate(None, '\/:*?"<>|').strip('.')
except: transname = os.path.splitext(urlparse(name_url).path)[0].split('/')[-1]
dest = os.path.join(folder, transname + '.' + ext)
sysheaders = quote_plus(json.dumps(headers))
sysurl = quote_plus(url)
systitle = quote_plus(transname)
sysimage = quote_plus(image)
sysfolder = quote_plus(folder)
sysdest = quote_plus(dest)
script = inspect.getfile(inspect.currentframe())
cmd = 'RunScript(%s, %s, %s, %s, %s, %s, %s)' % (script, sysurl, sysdest, systitle, sysimage, sysfolder, sysheaders)
xbmc.executebuiltin(cmd)
def subscriptions_add_list(db_type):
from modules.trakt_cache import clear_trakt_list_data
from apis.trakt_api import get_trakt_list_selection
from modules.nav_utils import show_busy_dialog, hide_busy_dialog, open_settings
movie_subscriptions = Subscriptions('movie')
tvshow_subscriptions = Subscriptions('tvshow')
variables = ('Movies', 'movies', 'movie', 'trakt.subscriptions_movie',
'trakt.subscriptions_movie_display', '8.14',
movie_subscriptions) if db_type == 'movie' else (
'TV Shows', 'shows', 'show', 'trakt.subscriptions_show',
'trakt.subscriptions_show_display', '8.15',
tvshow_subscriptions)
dialog_display = variables[0]
trakt_list_type = variables[1]
trakt_dbtype = variables[2]
main_setting = variables[3]
display_setting = variables[4]
open_setting = variables[5]
subscription_function = variables[6]
clear_library, cancelled, supplied_list = (False for _ in range(3))
path = settings.movies_directory(
) if db_type == 'movie' else settings.tv_show_directory()
if xbmcgui.Dialog().yesno(
'Fen Subscriptions',
'Are you sure you have set your Fen [B]%s[/B] Subscription Folder as a Source for the Kodi Library?'
% db_type.upper(), '', '', 'Already Done', 'I\'ll Do It Now'):
return xbmc.executebuiltin('ActivateWindow(videos,files,return)')
for i in ('my_lists', 'liked_lists'):
try:
clear_trakt_list_data(i)
except:
pass
trakt_list = get_trakt_list_selection(list_choice='subscriptions')
if not trakt_list: return open_settings(open_setting)
__addon__.setSetting(main_setting, json.dumps(trakt_list))
__addon__.setSetting(display_setting, trakt_list['name'])
if trakt_list['name'].lower() == 'none': return open_settings(open_setting)
if not xbmcgui.Dialog().yesno(
'Are you sure?',
'Fen will add all [B]%s[/B] from [B]%s[/B] to your Fen Subscriptions, and monitor this list for changes. Do you wish to continue?'
% (dialog_display, trakt_list['name'])):
__addon__.setSetting(main_setting, '')
__addon__.setSetting(display_setting, 'none')
return open_settings(open_setting)
current_subscriptions = subscription_function.get_subscriptions()
if len(current_subscriptions) > 0:
if not xbmcgui.Dialog().yesno(
'Current Subscriptions Found!',
'You have items in your [B]%s[/B] Subscription. Fen will delete these before continuing (may take some time). Do you wish to continue?'
% (dialog_display)):
return open_settings(open_setting)
clear_library = True
show_busy_dialog()
subscription_function.clear_subscriptions(confirm=False,
silent=True,
db_type=db_type)
hide_busy_dialog()
dialog = xbmcgui.DialogProgressBG()
dialog.create('Please Wait', 'Preparing Trakt List Info...')
if trakt_list['name'] in ('Collection', 'Watchlist'):
from modules.trakt_cache import clear_trakt_collection_watchlist_data
from apis.trakt_api import trakt_fetch_collection_watchlist
list_contents = trakt_fetch_collection_watchlist(
trakt_list['name'].lower(), trakt_list_type)
else:
from apis.trakt_api import get_trakt_list_contents
from modules.trakt_cache import clear_trakt_list_contents_data
list_contents = get_trakt_list_contents(trakt_list['user'],
trakt_list['slug'])
list_contents = [{
'media_ids': i[trakt_dbtype]['ids'],
'title': i[trakt_dbtype]['title']
} for i in list_contents if i['type'] == trakt_dbtype]
for i in list_contents:
if i['media_ids']['tmdb'] == None:
i['media_ids']['tmdb'] = get_trakt_tvshow_id(i['media_ids'])
threads = []
list_length = len(list_contents)
for count, item in enumerate(list_contents, 1):
subscription_function.add_trakt_subscription_listitem(
db_type, item['media_ids'], count, list_length, path, dialog)
dialog.close()
end_dialog = 'Operation Cancelled! Not all items from [B]%s[/B] were added.' if cancelled else '[B]%s[/B] added to Subscriptions.'
xbmcgui.Dialog().ok('Fen Subscriptions', end_dialog % trakt_list['name'])
if clear_library:
if xbmcgui.Dialog().yesno(
'Fen Subscriptions',
'Do you wish to clear Kodi\'s Library of your previous Subscription items?'
):
import time
xbmc.executebuiltin('CleanLibrary(video)')
time.sleep(3)
while xbmc.getCondVisibility("Window.IsVisible(ProgressDialog)"):
time.sleep(1)
if xbmcgui.Dialog().yesno(
'Fen Subscriptions',
'Do you wish to scan your new Subscription list into Kodi\'s Library?'
):
xbmc.executebuiltin('UpdateLibrary(video)')
def playback_menu(from_results=False, suggestion=None, list_name=None, play_params=None):
try: from urlparse import parse_qsl
except ImportError: from urllib.parse import parse_qsl
from modules.nav_utils import toggle_setting, build_url, open_settings, clear_cache, cached_page_clear, clear_and_rescrape
from modules import settings
params = dict(parse_qsl(sys.argv[2].replace('?','')))
content = xbmc.getInfoLabel('Container.Content')
if not content: content = params.get('content', None)
from_results = params.get('from_results', from_results)
suggestion = params.get('suggestion', suggestion)
list_name = params.get('list_name', list_name)
play_params = params.get('play_params', play_params)
autoplay_status, autoplay_toggle, filter_setting = ('On', 'false', 'autoplay_quality') if settings.auto_play() else ('Off', 'true', 'results_quality')
quality_filter_setting = 'autoplay' if autoplay_status == 'On' else 'results'
autoplay_next_status, autoplay_next_toggle = ('On', 'false') if settings.autoplay_next_episode() else ('Off', 'true')
display_mode = settings.display_mode()
display_mode_status = 'Directory' if display_mode == 0 else 'Very Simple Directory' if display_mode == 1 else 'Dialog'
autoplay_hevc_status = settings.autoplay_hevc()
current_subs_action_status = __addon__.getSetting('subtitles.subs_action')
active_scrapers = [i.replace('-', '').replace('folder', 'f') for i in settings.active_scrapers()]
current_scrapers_status = ', '.join([i.upper()[:3] for i in active_scrapers]) if len(active_scrapers) > 0 else 'NONE'
current_filter_status = ', '.join(settings.quality_filter(filter_setting))
indicators_status, indicators_toggle = ('Trakt', '0') if settings.watched_indicators() in (1, 2) else ('Fen', '1')
cached_torrents_status, cached_torrents_toggle = ('On', 'false') if __addon__.getSetting('torrent.check.cache') =='true' else ('Off', 'true')
uncached_torrents_status, uncached_torrents_toggle = ('On', 'false') if __addon__.getSetting('torrent.display.uncached') =='true' else ('Off', 'true')
active_cloud_store = settings.active_store_torrent_to_cloud()
active_cloud_store_status = ', '.join([i[1] for i in active_cloud_store]) if len(active_cloud_store) > 0 else 'NONE'
furk_easy_suggestion = params.get('suggestion', '')
listing = []
if play_params: listing += [('RESCRAPE & SELECT SOURCE', 'rescrape_select')]
listing += [('AUTOPLAY: [I]Currently [B]%s[/B][/I]' % autoplay_status, 'toggle_autoplay')]
if autoplay_status == 'On':
listing += [('HEVC AUTOPLAY FILTER: [I]Currently [B]%s[/B][/I]' % autoplay_hevc_status, 'set_autoplay_hevc')]
listing += [('AUTOPLAY NEXT EPISODE: [I]Currently [B]%s[/B][/I]' % autoplay_next_status, 'toggle_autoplay_next')]
listing += [('ENABLE SCRAPERS: [I]Currently [B]%s[/B][/I]' % current_scrapers_status, 'enable_scrapers')]
if autoplay_status == 'Off':
listing += [('DISPLAY MODE: [I]Currently [B]%s[/B][/I]' % display_mode_status, 'set_display_mode')]
listing += [('QUALITY FILTERS: [I]Currently [B]%s[/B][/I]' % current_filter_status, 'set_filters')]
listing += [('DOWNLOAD SUBTITLES: [I]Currently [B]%s[/B][/I]' % current_subs_action_status, 'set_subs_action')]
if settings.cache_page(): listing += [('CLEAR RESUME BROWSING PAGE', 'clear_cache_page')]
listing += [('SWITCH INDICATOR PROVIDER: [I]Currently [B]%s[/B][/I]' % indicators_status, 'toggle_indicators')]
if 'external' in active_scrapers:
listing += [('CHECK FOR CACHED TORRENTS: [I]Currently [B]%s[/B][/I]' % cached_torrents_status, 'toggle_cached_torrents')]
if cached_torrents_status == 'On':
listing += [(' - SHOW UNCACHED TORRENTS: [I]Currently [B]%s[/B][/I]' % uncached_torrents_status, 'toggle_torrents_display_uncached')]
listing += [(' - ADD TORRENTS TO CLOUD: [I]Currently [B]%s[/B][/I]' % active_cloud_store_status, 'set_active_cloud_store')]
if content in ('movies', 'episodes', 'movie', 'episode'): listing += [('FURK/EASYNEWS SEARCH: [B][I]%s[/I][/B]' % furk_easy_suggestion, 'search_directly')]
if settings.watched_indicators() in (1,2): listing += [('CLEAR TRAKT CACHE', 'clear_trakt_cache')]
listing += [('EXTERNAL SCRAPERS MANAGER', 'open_external_scrapers_manager')]
listing += [('OPEN TIKI META SETTINGS', 'open_meta_settings')]
listing += [('OPEN OPENSCRAPERS SETTINGS', 'open_scraper_settings')]
listing += [('OPEN FEN SETTINGS', 'open_fen_settings')]
listing += [('[B]SAVE SETTINGS AND EXIT[/B]', 'save_and_exit')]
xbmc.sleep(500)
choice = selection_dialog([i[0] for i in listing], [i[1] for i in listing], 'Fen Options...')
if choice == 'rescrape_select': return clear_and_rescrape(play_params)
elif choice == 'toggle_autoplay': toggle_setting('auto_play', autoplay_toggle)
elif choice == 'set_autoplay_hevc': set_autoplay_hevc()
elif choice == 'toggle_autoplay_next': toggle_setting('autoplay_next_episode', autoplay_next_toggle)
elif choice == 'enable_scrapers': enable_scrapers()
elif choice == 'set_display_mode': set_display_mode()
elif choice == 'set_filters': set_quality(quality_filter_setting)
elif choice == 'set_subs_action': set_subtitle_action()
elif choice == 'clear_cache_page': cached_page_clear(action=list_name)
elif choice == 'toggle_indicators': toggle_setting('watched_indicators', indicators_toggle)
elif choice == 'toggle_cached_torrents': toggle_setting('torrent.check.cache', cached_torrents_toggle)
elif choice == 'toggle_torrents_display_uncached': toggle_setting('torrent.display.uncached', uncached_torrents_toggle)
elif choice == 'set_active_cloud_store': set_active_cloud_store(active_cloud_store)
elif choice == 'search_directly': furk_easynews_direct_search_choice(suggestion, from_results, list_name)
elif choice == 'clear_trakt_cache': clear_cache('trakt')
elif choice == 'open_external_scrapers_manager': external_scrapers_manager()
elif choice == 'open_meta_settings': xbmc.executebuiltin('Addon.OpenSettings(script.module.tikimeta)')
elif choice == 'open_scraper_settings': xbmc.executebuiltin('Addon.OpenSettings(script.module.openscrapers)')
elif choice == 'open_fen_settings': open_settings('0.0')
if choice in ('clear_cache_page', 'toggle_indicators', 'clear_trakt_cache') and content in ('movies', 'tvshows', 'seasons', 'episodes'): xbmc.executebuiltin('Container.Refresh')
if choice in (None, 'rescrape_select', 'save_and_exit', 'clear_cache_page', 'toggle_indicators', 'clear_trakt_cache', 'search_directly', 'open_meta_settings', 'open_scraper_settings', 'open_fen_settings', 'open_external_scrapers_manager'): return
xbmc.executebuiltin('RunPlugin(%s)' % build_url({'mode': 'playback_menu', 'from_results': from_results, 'suggestion': suggestion, 'list_name': list_name, 'play_params': play_params}))