def premiumize_transfer_cleanup():
"""
Cleanup transfers created by Seren at Premiumize
:return: None
:rtype: NOne
"""
service = premiumize.Premiumize()
premiumize_transfers = PremiumizeTransfers()
fair_usage = int(service.get_used_space())
threshold = g.get_int_setting("premiumize.threshold")
if fair_usage < threshold:
g.log("Premiumize Fair Usage below threshold, no cleanup required")
return
seren_transfers = premiumize_transfers.get_premiumize_transfers()
if seren_transfers is None:
g.log("Failed to cleanup transfers, API error", "error")
return
if len(seren_transfers) == 0:
g.log("No Premiumize transfers have been created")
return
g.log(
"Premiumize Fair Usage is above threshold, cleaning up Seren transfers"
)
for i in seren_transfers:
service.delete_transfer(i["transfer_id"])
premiumize_transfers.remove_premiumize_transfer(i["transfer_id"])
def resolve(self, item_id):
try:
details = premiumize.Premiumize().item_details(item_id)
url = details.get('link', '')
return url
except:
from resources.lib.modules import log_utils
log_utils.error('PM_CLOUD: ')
return None
def _premiumize_worker(self, torrent_list):
hash_list = [i['hash'] for i in torrent_list]
if len(hash_list) == 0:
return
premiumize_cache = premiumize.Premiumize().hash_check(hash_list)
premiumize_cache = premiumize_cache['response']
count = 0
for i in torrent_list:
if premiumize_cache[count] is True:
i['debrid_provider'] = 'premiumize'
self.store_torrent(i)
count += 1
def list_premiumize_transfers(self):
from resources.lib.debrid import premiumize
transfer_list = premiumize.Premiumize().list_transfers()
if len(transfer_list['transfers']
) == 0 or 'transfers' not in transfer_list:
g.close_directory(self.view_type)
return
for i in transfer_list['transfers']:
title = '{} - {}% : {}' \
.format(g.color_string(i['status'].title()), g.UNICODE(i['progress'] * 100), i['name'][:50] + "...")
g.add_directory_item(title)
g.close_directory(self.view_type)
def __init__(self, uncached_source, silent=False):
if not g.premiumize_enabled():
raise DebridNotEnabled
super(_PremiumizeCacheAssist, self).__init__(uncached_source, silent)
self.debrid_slug = "premiumize"
self.debrid_readable = "Premiumize"
self.debrid = premiumize.Premiumize()
self.transfer_info = self.debrid.create_transfer(uncached_source["magnet"])
self.transfer_id = self.transfer_info["id"]
self._update_status()
self.transfer_id = self.transfer_info["id"]
def list_premiumize_transfers(self):
from resources.lib.debrid import premiumize
transfer_list = premiumize.Premiumize().list_transfers()
if len(transfer_list['transfers']
) == 0 or "transfers" not in transfer_list:
g.close_directory(self.view_type)
return
for i in transfer_list['transfers']:
title = "{} - {}% : {}".format(
g.color_string(i['status'].title().title()),
g.UNICODE(i['progress'] * 100),
(i['name'][:50] + "...") if len(i['name']) > 50 else i['name'])
g.add_directory_item(title, is_playable=False, is_folder=False)
g.close_directory(self.view_type)
def account_notifications():
from resources.lib.debrid import real_debrid
from resources.lib.debrid import premiumize
import time
if tools.getSetting('realdebrid.enabled') == 'true':
premium_status = real_debrid.RealDebrid().get_url('user')['type']
if premium_status == 'free':
tools.showDialog.notification('%s: Real Debrid' % tools.addonName,
tools.lang(32051))
if tools.getSetting('premiumize.enabled') == 'true':
premium_status = premiumize.Premiumize().account_info()['premium_until']
if time.time() > premium_status:
tools.showDialog.notification('%s: Premiumize' % tools.addonName,
tools.lang(32052))
def debrid_resolvers(order_matters=True):
try:
ad_enabled = control.setting('alldebrid.token') != '' and control.setting('alldebrid.enable') == 'true'
pm_enabled = control.setting('premiumize.token') != '' and control.setting('premiumize.enable') == 'true'
rd_enabled = control.setting('realdebrid.token') != '' and control.setting('realdebrid.enable') == 'true'
premium_resolvers = []
if ad_enabled: premium_resolvers.append(alldebrid.AllDebrid())
if pm_enabled: premium_resolvers.append(premiumize.Premiumize())
if rd_enabled: premium_resolvers.append(realdebrid.RealDebrid())
if order_matters:
premium_resolvers.sort(key=lambda x: get_priority(x))
# log_utils.log('premium_resolvers sorted = %s' % str(premium_resolvers), __name__, log_utils.LOGDEBUG)
return premium_resolvers
except:
log_utils.error()
def list_premiumize_transfers(self):
from resources.lib.debrid import premiumize
transfer_list = premiumize.Premiumize().list_transfers()
if len(transfer_list['transfers']
) == 0 or 'transfers' not in transfer_list:
tools.closeDirectory(self.view_type)
return
for i in transfer_list['transfers']:
title = '%s - %s%% : %s' % \
(tools.colorString(i['status'].title()), str(i['progress'] * 100), i['name'][:50] + "...")
tools.addDirectoryItem(title,
'',
None,
None,
isPlayable=False,
isFolder=False,
isAction=True)
tools.closeDirectory(self.view_type)
def premiumize_transfer_cleanup():
from resources.lib.debrid import premiumize
from resources.lib.modules import database
premiumize = premiumize.Premiumize()
fair_usage = int(premiumize.get_used_space())
threshold = int(tools.getSetting('premiumize.threshold'))
if fair_usage < threshold:
tools.log('Premiumize Fair Usage below threshold, no cleanup required')
return
seren_transfers = database.get_premiumize_transfers()
if len(seren_transfers) == 0:
tools.log('No Premiumize transfers have been created')
return
tools.log('Premiumize Fair Usage is above threshold, cleaning up Seren transfers')
for i in seren_transfers:
premiumize.delete_transfer(i['transfer_id'])
database.remove_premiumize_transfer(i['transfer_id'])
def getHosterList(self):
thread_pool = ThreadPool()
try:
hosters = {'premium': {}, 'free': []}
try:
if tools.getSetting(
'premiumize.enabled') == 'true' and tools.getSetting(
'premiumize.hosters') == 'true':
thread_pool.put(Premiumize.Premiumize().get_hosters,
hosters)
except:
pass
try:
if tools.getSetting(
'realdebrid.enabled') == 'true' and tools.getSetting(
'rd.hosters') == 'true':
thread_pool.put(real_debrid.RealDebrid().get_hosters,
hosters)
except:
pass
try:
if tools.getSetting(
'alldebrid.enabled') == 'true' and tools.getSetting(
'alldebrid.hosters') == 'true':
thread_pool.put(all_debrid.AllDebrid().get_hosters,
hosters)
except:
pass
thread_pool.wait_completion()
return hosters
except:
import traceback
traceback.print_exc()
def get_init_list(self):
items = premiumize.Premiumize().list_folder('')
self._format_items(items)
def sources(self, data, hostDict):
sources = []
if not data: return sources
try:
title = data['tvshowtitle'] if 'tvshowtitle' in data else data[
'title']
title = title.replace('&', 'and').replace('Special Victims Unit',
'SVU')
aliases = data['aliases']
episode_title = data['title'] if 'tvshowtitle' in data else None
self.year = data['year']
hdlr = 'S%02dE%02d' % (int(data['season']), int(
data['episode'])) if 'tvshowtitle' in data else self.year
self.season = str(
data['season']) if 'tvshowtitle' in data else None
self.episode = str(
data['episode']) if 'tvshowtitle' in data else None
query_list = self.episode_query_list(
) if 'tvshowtitle' in data else self.year_query_list()
# log_utils.log('query_list = %s' % query_list)
cloud_files = premiumize.Premiumize().my_files_all()
if not cloud_files: return sources
cloud_files = [
i for i in cloud_files if i['path'].lower().endswith(
tuple(supported_video_extensions()))
] # this only lets folder names thru with known video extensions..?
if not cloud_files: return sources
ignoreM2ts = getSetting('pm_cloud.ignore.m2ts') == 'true'
extras_filter = cloud_utils.extras_filter()
except:
from resources.lib.modules import log_utils
log_utils.error('PM_CLOUD: ')
return sources
for item in cloud_files:
is_m2ts = False
try:
name = item.get('name', '')
invalids = ('.img', '.bin', '.dat', '.mpls', '.mpl', '.bdmv',
'.bdm', '.disc')
if name.lower().endswith(invalids): continue
path = item.get('path', '').lower()
if not cloud_utils.cloud_check_title(title, aliases, path):
continue
rt = cloud_utils.release_title_format(name)
if any(value in rt for value in extras_filter): continue
if name.endswith('m2ts'):
if ignoreM2ts: continue
name = item.get('path', '').split('/')[0]
if name in str(sources): continue
if all(not bool(re.search(i, rt)) for i in query_list):
continue # check if this newly added causes any movie titles that do not have the year to get dropped
is_m2ts = True
m2ts_files = [
i for i in cloud_files if name in i.get('path')
]
largest = sorted(m2ts_files,
key=lambda k: k['size'],
reverse=True)[0]
url_id = largest.get('id', '')
size = largest.get('size', '')
else:
if all(not bool(re.search(i, rt)) for i in query_list):
if 'tvshowtitle' in data:
season_folder_list = self.season_folder_list()
if all(not bool(re.search(i, path))
for i in season_folder_list):
continue
episode_list = self.episode_list()
if all(not bool(re.search(i, rt))
for i in episode_list):
continue
else:
if all(not bool(re.search(i, path))
for i in query_list):
continue
name = item.get('path', '').split('/')[0]
if item.get('size') < 52428800: continue
url_id = item.get('id', '')
size = item.get('size', '')
name_info = fs_utils.info_from_name(name, title, self.year,
hdlr, episode_title)
quality, info = fs_utils.get_release_quality(name_info, name)
try:
dsize, isize = fs_utils.convert_size(size, to='GB')
info.insert(0, isize)
except:
dsize = 0
if is_m2ts: info.append('M2TS')
info = ' | '.join(info)
sources.append({
'provider': 'pm_cloud',
'source': 'cloud',
'debrid': 'Premiumize.me',
'seeders': '',
'hash': '',
'name': name,
'name_info': name_info,
'quality': quality,
'language': 'en',
'url': url_id,
'info': info,
'direct': True,
'debridonly': True,
'size': dsize
})
except:
from resources.lib.modules import log_utils
log_utils.error('PM_CLOUD: ')
return sources
return sources
def get_folder(self, list_item):
items = premiumize.Premiumize().list_folder(list_item['id'])
self._format_items(items)
def premiumize_downloader(self, torrent_object):
current_percent = 0
debrid = premiumize.Premiumize()
try:
transfer_id = debrid.create_transfer(
torrent_object['magnet'])['id']
tools.showDialog.notification(tools.addonName, tools.lang(32072))
database.add_assist_torrent(transfer_id, 'premiumize', 'queued',
torrent_object['release_title'],
str(current_percent))
except:
import traceback
traceback.print_exc()
tools.log('Failed to start premiumize debrid transfer', 'error')
return
timestamp = time.time()
while not monitor.abortRequested():
try:
if monitor.waitForAbort(120):
break
transfer_status = [
i for i in debrid.list_transfers()['transfers']
if i['id'] == transfer_id
][0]
current_percent = transfer_status['progress']
if transfer_status['status'] == 'finished':
database.add_assist_torrent(
transfer_id, 'premiumize', transfer_status['status'],
torrent_object['release_title'], str(current_percent))
if not self.notified:
tools.showDialog.notification(
tools.addonName + ': %s' % self.title,
tools.lang(40299) % self.title,
time=5000)
debrid.delete_transfer(transfer_id)
database.add_premiumize_transfer(transfer_id)
from resources.lib.common import maintenance
maintenance.premiumize_transfer_cleanup()
break
if current_percent == transfer_status['progress']:
if timestamp == (time.time() + 10800):
database.add_assist_torrent(
transfer_id, 'premiumize', 'failed',
torrent_object['release_title'],
str(current_percent))
debrid.delete_transfer(transfer_id)
tools.showDialog.notification(
tools.addonName,
tools.lang(40300) % self.title)
break
continue
else:
database.add_assist_torrent(
transfer_id, 'premiumize', transfer_status['status'],
torrent_object['release_title'], str(current_percent))
except:
database.add_assist_torrent(transfer_id, 'premiumize',
'failed',
torrent_object['release_title'],
str(current_percent))
debrid.delete_transfer(transfer_id)
break
return
####################################################
#---Premium Services
####################################################
elif action == 'premiumNavigator':
from resources.lib.menus import navigator
navigator.Navigator().premium_services()
if action and action.startswith('pm_'):
if action == 'pm_ServiceNavigator':
from resources.lib.menus import navigator
navigator.Navigator().premiumize_service()
elif action == 'pm_AccountInfo':
from resources.lib.debrid import premiumize
premiumize.Premiumize().account_info_to_dialog()
# elif action == 'pm_Authorize':
# from resources.lib.debrid import premiumize
# premiumize.Premiumize().auth()
elif action == 'pm_MyFiles':
from resources.lib.debrid import premiumize
premiumize.Premiumize().my_files_to_listItem(id, name)
elif action == 'pm_Transfers':
from resources.lib.debrid import premiumize
premiumize.Premiumize().user_transfers_to_listItem()
elif action == 'pm_Rename':
from resources.lib.debrid import premiumize
def router(params):
action = params.get('action')
id = params.get('id')
name = params.get('name')
title = params.get('title')
year = params.get('year')
imdb = params.get('imdb')
tmdb = params.get('tmdb')
tvdb = params.get('tvdb')
season = params.get('season')
episode = params.get('episode')
tvshowtitle = params.get('tvshowtitle')
type = params.get('type')
url = params.get('url')
query = params.get('query')
source = params.get('source')
if action is None:
from resources.lib.menus import navigator
isUpdate = control.homeWindow.getProperty('venom.updated')
if isUpdate == 'true':
control.execute(
'RunPlugin(plugin://plugin.video.venom/?action=tools_cleanSettings)'
)
control.homeWindow.clearProperty('venom.updated')
from resources.lib.modules import changelog
changelog.get()
navigator.Navigator().root()
####################################################
#---MOVIES
####################################################
elif action == 'movieNavigator':
from resources.lib.menus import navigator
navigator.Navigator().movies()
elif action == 'movieliteNavigator':
from resources.lib.menus import navigator
navigator.Navigator().movies(lite=True)
elif action == 'mymovieNavigator':
from resources.lib.menus import navigator
navigator.Navigator().mymovies()
elif action == 'mymovieliteNavigator':
from resources.lib.menus import navigator
navigator.Navigator().mymovies(lite=True)
elif action == 'movies':
from resources.lib.menus import movies
movies.Movies().get(url)
elif action == 'moviePage':
from resources.lib.menus import movies
movies.Movies().get(url)
elif action == 'tmdbmovies':
from resources.lib.menus import movies
movies.Movies().getTMDb(url)
elif action == 'tmdbmoviePage':
from resources.lib.menus import movies
movies.Movies().getTMDb(url)
elif action == 'movieSearch':
from resources.lib.menus import movies
movies.Movies().search()
elif action == 'movieSearchnew':
from resources.lib.menus import movies
movies.Movies().search_new()
elif action == 'movieSearchterm':
from resources.lib.menus import movies
movies.Movies().search_term(name)
elif action == 'moviePerson':
from resources.lib.menus import movies
movies.Movies().person()
elif action == 'movieGenres':
from resources.lib.menus import movies
movies.Movies().genres()
elif action == 'movieLanguages':
from resources.lib.menus import movies
movies.Movies().languages()
elif action == 'movieCertificates':
from resources.lib.menus import movies
movies.Movies().certifications()
elif action == 'movieYears':
from resources.lib.menus import movies
movies.Movies().years()
elif action == 'moviePersons':
from resources.lib.menus import movies
movies.Movies().persons(url)
elif action == 'moviesUnfinished':
from resources.lib.menus import movies
movies.Movies().unfinished(url)
elif action == 'movieUserlists':
from resources.lib.menus import movies
movies.Movies().userlists()
elif action == 'movies_traktUnfinishedManager':
from resources.lib.menus import movies
movies.Movies().unfinishedManager()
####################################################
#---Collections
####################################################
elif action and action.startswith('collections'):
if action == 'collections_Navigator':
from resources.lib.menus import collections
collections.Collections().collections_Navigator()
elif action == 'collections_Boxset':
from resources.lib.menus import collections
collections.Collections().collections_Boxset()
elif action == 'collections_Kids':
from resources.lib.menus import collections
collections.Collections().collections_Kids()
elif action == 'collections_BoxsetKids':
from resources.lib.menus import collections
collections.Collections().collections_BoxsetKids()
elif action == 'collections_Superhero':
from resources.lib.menus import collections
collections.Collections().collections_Superhero()
elif action == 'collections_MartialArts':
from resources.lib.menus import collections
collections.Collections().collections_martial_arts()
elif action == 'collections_MartialArtsActors':
from resources.lib.menus import collections
collections.Collections().collections_martial_arts_actors()
elif action == 'collections':
from resources.lib.menus import collections
collections.Collections().get(url)
####################################################
#---Furk
####################################################
elif action and action.startswith('furk'):
if action == "furkNavigator":
from resources.lib.menus import navigator
navigator.Navigator().furk()
elif action == "furkUserFiles":
from resources.lib.menus import furk
furk.Furk().user_files()
elif action == "furkMetaSearch":
from resources.lib.menus import furk
furk.Furk().furk_meta_search(url)
elif action == "furkSearch":
from resources.lib.menus import furk
furk.Furk().search()
elif action == "furkSearchNew":
from resources.lib.menus import furk
furk.Furk().search_new()
####################################################
# TV Shows
####################################################
# if action and action.startswith('tv_'):
elif action == 'tvNavigator':
from resources.lib.menus import navigator
navigator.Navigator().tvshows()
elif action == 'tvliteNavigator':
from resources.lib.menus import navigator
navigator.Navigator().tvshows(lite=True)
elif action == 'mytvNavigator':
from resources.lib.menus import navigator
navigator.Navigator().mytvshows()
elif action == 'mytvliteNavigator':
from resources.lib.menus import navigator
navigator.Navigator().mytvshows(lite=True)
elif action == 'tvshows':
from resources.lib.menus import tvshows
tvshows.TVshows().get(url)
elif action == 'tvshowPage':
from resources.lib.menus import tvshows
tvshows.TVshows().get(url)
elif action == 'tmdbTvshows':
from resources.lib.menus import tvshows
tvshows.TVshows().getTMDb(url)
elif action == 'tmdbTvshowPage':
from resources.lib.menus import tvshows
tvshows.TVshows().getTMDb(url)
elif action == 'tvmazeTvshows':
from resources.lib.menus import tvshows
tvshows.TVshows().getTVmaze(url)
elif action == 'tvmazeTvshowPage':
from resources.lib.menus import tvshows
tvshows.TVshows().getTVmaze(url)
elif action == 'tvSearch':
from resources.lib.menus import tvshows
tvshows.TVshows().search()
elif action == 'tvSearchnew':
from resources.lib.menus import tvshows
tvshows.TVshows().search_new()
elif action == 'tvSearchterm':
from resources.lib.menus import tvshows
tvshows.TVshows().search_term(name)
elif action == 'tvPerson':
from resources.lib.menus import tvshows
tvshows.TVshows().person()
elif action == 'tvGenres':
from resources.lib.menus import tvshows
tvshows.TVshows().genres()
elif action == 'tvNetworks':
from resources.lib.menus import tvshows
tvshows.TVshows().networks()
elif action == 'tvLanguages':
from resources.lib.menus import tvshows
tvshows.TVshows().languages()
elif action == 'tvCertificates':
from resources.lib.menus import tvshows
tvshows.TVshows().certifications()
elif action == 'tvPersons':
from resources.lib.menus import tvshows
tvshows.TVshows().persons(url)
elif action == 'tvUserlists':
from resources.lib.menus import tvshows
tvshows.TVshows().userlists()
elif action == 'tvOriginals':
from resources.lib.menus import tvshows
tvshows.TVshows().originals()
elif action == 'shows_traktHiddenManager':
from resources.lib.menus import tvshows
tvshows.TVshows().traktHiddenManager()
####################################################
#---SEASONS
####################################################
elif action == 'seasons':
from resources.lib.menus import seasons
art = params.get('art')
seasons.Seasons().get(tvshowtitle, year, imdb, tmdb, tvdb, art)
####################################################
#---EPISODES
####################################################
elif action == 'episodes':
from resources.lib.menus import episodes
meta = params.get('meta')
episodes.Episodes().get(tvshowtitle, year, imdb, tmdb, tvdb, meta,
season, episode)
elif action == 'calendar':
from resources.lib.menus import episodes
episodes.Episodes().calendar(url)
elif action == 'upcomingProgress':
from resources.lib.menus import episodes
episodes.Episodes().upcoming_progress(url)
elif action == 'calendars':
from resources.lib.menus import episodes
episodes.Episodes().calendars()
elif action == 'episodesUnfinished':
from resources.lib.menus import episodes
episodes.Episodes().unfinished(url)
elif action == 'episodesUserlists':
from resources.lib.menus import episodes
episodes.Episodes().userlists()
elif action == 'episodes_traktUnfinishedManager':
from resources.lib.menus import episodes
episodes.Episodes().unfinishedManager()
####################################################
#---Premium Services
####################################################
elif action == 'premiumNavigator':
from resources.lib.menus import navigator
navigator.Navigator().premium_services()
elif action and action.startswith('pm_'):
if action == 'pm_ServiceNavigator':
from resources.lib.menus import navigator
navigator.Navigator().premiumize_service()
elif action == 'pm_AccountInfo':
from resources.lib.debrid import premiumize
premiumize.Premiumize().account_info_to_dialog()
# elif action == 'pm_Authorize':
# from resources.lib.debrid import premiumize
# premiumize.Premiumize().auth()
elif action == 'pm_MyFiles':
from resources.lib.debrid import premiumize
premiumize.Premiumize().my_files_to_listItem(id, name)
elif action == 'pm_Transfers':
from resources.lib.debrid import premiumize
premiumize.Premiumize().user_transfers_to_listItem()
elif action == 'pm_Rename':
from resources.lib.debrid import premiumize
premiumize.Premiumize().rename(type, id, name)
elif action == 'pm_Delete':
from resources.lib.debrid import premiumize
premiumize.Premiumize().delete(type, id, name)
elif action == 'pm_DeleteTransfer':
from resources.lib.debrid import premiumize
premiumize.Premiumize().delete_transfer(id, name)
elif action == 'pm_ClearFinishedTransfers': # disabled for now till PM fixes
from resources.lib.debrid import premiumize
premiumize.Premiumize().clear_finished_transfers()
elif action and action.startswith('rd_'):
if action == 'rd_ServiceNavigator':
from resources.lib.menus import navigator
navigator.Navigator().realdebrid_service()
elif action == 'rd_AccountInfo':
from resources.lib.debrid import realdebrid
realdebrid.RealDebrid().account_info_to_dialog()
# elif action == 'rd_Authorize':
# from resources.lib.debrid import realdebrid
# realdebrid.RealDebrid().auth()
elif action == 'rd_UserTorrentsToListItem':
from resources.lib.debrid import realdebrid
realdebrid.RealDebrid().user_torrents_to_listItem()
elif action == 'rd_MyDownloads':
from resources.lib.debrid import realdebrid
realdebrid.RealDebrid().my_downloads_to_listItem(int(query))
elif action == 'rd_BrowseUserTorrents':
from resources.lib.debrid import realdebrid
realdebrid.RealDebrid().browse_user_torrents(id)
elif action == 'rd_DeleteUserTorrent':
from resources.lib.debrid import realdebrid
realdebrid.RealDebrid().delete_user_torrent(id, name)
elif action == 'rd_DeleteDownload':
from resources.lib.debrid import realdebrid
realdebrid.RealDebrid().delete_download(id, name)
elif action and action.startswith('ad_'):
if action == 'ad_ServiceNavigator':
from resources.lib.menus import navigator
navigator.Navigator().alldebrid_service()
elif action == 'ad_AccountInfo':
from resources.lib.debrid import alldebrid
alldebrid.AllDebrid().account_info_to_dialog()
# elif action == 'ad_Authorize':
# from resources.lib.debrid import alldebrid
# alldebrid.AllDebrid().auth()
elif action == 'ad_Transfers':
from resources.lib.debrid import alldebrid
alldebrid.AllDebrid().user_transfers_to_listItem()
elif action == 'ad_CloudStorage':
from resources.lib.debrid import alldebrid
alldebrid.AllDebrid().user_cloud_to_listItem()
elif action == 'ad_BrowseUserCloud':
from resources.lib.debrid import alldebrid
alldebrid.AllDebrid().browse_user_cloud(source)
elif action == 'ad_DeleteTransfer':
from resources.lib.debrid import alldebrid
alldebrid.AllDebrid().delete_transfer(id, name, silent=False)
elif action == 'ad_RestartTransfer':
from resources.lib.debrid import alldebrid
alldebrid.AllDebrid().restart_transfer(id, name, silent=False)
####################################################
#---Anime
####################################################
elif action and action.startswith('anime_'):
if action == 'anime_Navigator':
from resources.lib.menus import navigator
navigator.Navigator().anime()
elif action == 'anime_Movies':
from resources.lib.menus import movies
movies.Movies().get(url)
elif action == 'anime_TVshows':
from resources.lib.menus import tvshows
tvshows.TVshows().get(url)
####################################################
#---YouTube
####################################################
elif action == 'youtube':
from resources.lib.menus import youtube
if id is None: youtube.yt_index().root(action)
else: youtube.yt_index().get(action, id)
elif action == 'sectionItem':
pass # Placeholder. This is a non-clickable menu item for notes, etc.
####################################################
#---Download
####################################################
elif action and action.startswith('download'):
if action == 'downloadNavigator':
from resources.lib.menus import navigator
navigator.Navigator().downloads()
elif action == 'download':
caller = params.get('caller')
image = params.get('image')
if caller == 'sources': # future, move to downloader module for pack support
control.busy()
try:
from json import loads as jsloads
from resources.lib.modules import sources
from resources.lib.modules import downloader
downloader.download(
name, image,
sources.Sources().sourcesResolve(jsloads(source)[0]),
title)
except:
import traceback
traceback.print_exc()
if caller == 'premiumize':
control.busy()
try:
from resources.lib.modules import downloader
from resources.lib.debrid import premiumize
downloader.download(
name, image,
premiumize.Premiumize().add_headers_to_url(
url.replace(' ', '%20')))
except:
import traceback
traceback.print_exc()
if caller == 'realdebrid':
control.busy()
try:
from resources.lib.modules import downloader
from resources.lib.debrid import realdebrid
if type == 'unrestrict':
downloader.download(
name, image,
realdebrid.RealDebrid().unrestrict_link(
url.replace(' ', '%20')))
else:
downloader.download(name, image,
url.replace(' ', '%20'))
except:
import traceback
traceback.print_exc()
if caller == 'alldebrid':
control.busy()
try:
from resources.lib.modules import downloader
from resources.lib.debrid import alldebrid
downloader.download(
name, image,
alldebrid.AllDebrid().unrestrict_link(
url.replace(' ', '%20')))
except:
import traceback
traceback.print_exc()
####################################################
#---Tools
####################################################
elif action and action.startswith('tools_'):
if action == 'tools_ShowNews':
from resources.lib.modules import newsinfo
newsinfo.news()
elif action == 'tools_ShowChangelog':
from resources.lib.modules import changelog
changelog.get()
elif action == 'tools_ShowHelp':
from resources.help import help
help.get(name)
elif action == 'tools_LanguageInvoker':
from resources.lib.modules import language_invoker
language_invoker.set_reuselanguageinvoker()
elif action == 'tools_toolNavigator':
from resources.lib.menus import navigator
navigator.Navigator().tools()
elif action == 'tools_traktToolsNavigator':
from resources.lib.menus import navigator
navigator.Navigator().traktTools()
elif action == 'tools_searchNavigator':
from resources.lib.menus import navigator
navigator.Navigator().search()
elif action == 'tools_viewsNavigator':
from resources.lib.menus import navigator
navigator.Navigator().views()
elif action == 'tools_addView':
from resources.lib.modules import views
content = params.get('content')
views.addView(content)
elif action == 'tools_resetViewTypes':
from resources.lib.modules import views
views.clearViews()
elif action == 'tools_cleanSettings':
from resources.lib.modules import clean_settings
clean_settings.clean_settings()
elif action == 'tools_openMyAccount':
from myaccounts import openMASettings
from resources.lib.modules import my_accounts
openMASettings(query)
control.sleep(500)
while control.condVisibility('Window.IsVisible(addonsettings)'
) or control.homeWindow.getProperty(
'myaccounts.active') == 'true':
control.sleep(500)
control.sleep(100)
my_accounts.syncMyAccounts()
control.sleep(100)
if params.get('opensettings') == 'true':
control.openSettings(params.get('query2'),
'plugin.video.venom')
elif action == 'tools_syncMyAccount':
from resources.lib.modules import my_accounts
my_accounts.syncMyAccounts()
if params.get('opensettings') == 'true':
control.openSettings(query, 'plugin.video.venom')
elif action == 'tools_traktAcctMyAccounts':
control.execute(
'RunScript(script.module.myaccounts, action=traktAcct)')
elif action == 'tools_adAcctMyAccounts':
control.execute(
'RunScript(script.module.myaccounts, action=alldebridAcct)')
elif action == 'tools_pmAcctMyAccounts':
control.execute(
'RunScript(script.module.myaccounts, action=premiumizeAcct)')
elif action == 'tools_rdAcctMyAccounts':
control.execute(
'RunScript(script.module.myaccounts, action=realdebridAcct)')
elif action == 'tools_openSettings':
control.openSettings(query)
elif action == 'tools_contextVenomSettings':
control.openSettings('0.0', 'context.venom')
control.trigger_widget_refresh()
elif action == 'tools_fenomscrapersSettings':
control.openSettings('0.0', 'script.module.fenomscrapers')
elif action == 'tools_traktManager':
from resources.lib.modules import trakt
watched = (params.get('watched')
== 'True') if params.get('watched') else None
unfinished = (params.get('unfinished')
== 'True') if params.get('unfinished') else False
trakt.manager(name,
imdb,
tvdb,
season,
episode,
watched=watched,
unfinished=unfinished)
elif action == 'tools_cachesyncMovies':
from resources.lib.modules import trakt
trakt.cachesyncMovies(int(params.get('timeout')))
elif action == 'tools_cachesyncTVShows':
from resources.lib.modules import trakt
trakt.cachesyncTVShows(int(params.get('timeout')))
elif action == 'tools_syncTraktProgress':
from resources.lib.modules import trakt
trakt.sync_progress()
elif action == 'tools_syncTraktWatched':
from resources.lib.modules import trakt
trakt.sync_watched()
####################################################
#---Play
####################################################
elif action and action.startswith('play_'):
if action == 'play_Item':
from resources.lib.modules import sources
premiered = params.get('premiered')
meta = params.get('meta')
select = params.get('select')
rescrape = params.get('rescrape')
sources.Sources().play(title, year, imdb, tmdb, tvdb, season,
episode, tvshowtitle, premiered, meta,
select, rescrape)
# if episode and control.homeWindow.getProperty('venom.isplaying.playlist') != 'true':
# if int(episode) != 1: control.playlist.clear()
# import xbmc
# enable_playnext = control.setting('enable.playnext') == 'true'
# media_type = 'movie' if tvshowtitle is None else 'episode'
# rescrape = params.get('rescrape')
# select = params.get('select')
# if control.homeWindow.getProperty('venom.isplaying.playlist') == 'true' or enable_playnext is False or media_type == 'movie' or rescrape or select == '0':
# try:
# if control.homeWindow.getProperty('venom.isplaying.playlist') == 'true':
# xbmc.log('[ plugin.video.venom ] venom.isplaying.playlist = %s' % control.homeWindow.getProperty('venom.isplaying.playlist'), 1)
# from resources.lib.modules import sources
# premiered = params.get('premiered')
# meta = params.get('meta')
# xbmc.log('[ plugin.video.venom ] control.playlist.size() = %s' % control.playlist.size(), 1)
# xbmc.log('[ plugin.video.venom ] control.playlist.getposition() = %s' % control.playlist.getposition(), 1)
# xbmc.log('[ plugin.video.venom ] Calling....sources.Sources().play()', 1)
# if int(control.playlist.getposition()) == -1 or (int(control.playlist.getposition()) == (control.playlist.size() - 1)):
# control.homeWindow.clearProperty('venom.isplaying.playlist')
# sources.Sources().play(title, year, imdb, tmdb, tvdb, season, episode, tvshowtitle, premiered, meta, select, rescrape)
# except:
# import traceback
# traceback.print_exc()
# else:
# try:
# xbmc.log('[ plugin.video.venom ] control.playlist.size() = %s' % control.playlist.size(), 1)
# is_widget = 'plugin' not in control.infoLabel('Container.PluginName')
# if is_widget:
# control.playlist.clear()
# control.cancelPlayback()
# # control.playlist.clear()
# # control.cancelPlayback()
# if control.playlist.size() <= 1:
# current_ep = episode
# xbmc.log('[ plugin.video.venom ] current_ep = %s' % current_ep, 1)
# from json import dumps as jsdumps
# from resources.lib.menus import episodes
# meta = params.get('meta')
# items = episodes.Episodes().get(tvshowtitle, year, imdb, tmdb, tvdb, meta, season, episode, create_directory=False)
# control.playlist.clear()
# for i in items:
# title = i['title']
# systitle = quote_plus(title)
# year = i['year']
# imdb = i['imdb']
# tmdb = i['tmdb']
# tvdb = i['tvdb']
# season = i['season']
# episode = i['episode']
# tvshowtitle = i['tvshowtitle']
# systvshowtitle = quote_plus(tvshowtitle)
# premiered = i['premiered']
# sysmeta = quote_plus(jsdumps(i))
# url = 'plugin://plugin.video.venom/?action=play_Item&title=%s&year=%s&imdb=%s&tmdb=%s&tvdb=%s&season=%s&episode=%s&tvshowtitle=%s&premiered=%s&meta=%s&select=1' % (
# systitle, year, imdb, tmdb, tvdb, season, episode, systvshowtitle, premiered, sysmeta)
# item = control.item(label=title, offscreen=True)
# # item.setProperty('IsPlayable', 'true')
# control.playlist.add(url=url, listitem=item)
# control.homeWindow.setProperty('venom.isplaying.playlist', 'true')
# playlist_urls = [control.playlist[i].getPath() for i in range(control.playlist.size())]
# xbmc.log('[ plugin.video.venom ] control.playlist.size() = %s' % control.playlist.size(), 1)
# xbmc.log('[ plugin.video.venom ] playlist_urls = %s' % playlist_urls, 1)
# xbmc.log('[ plugin.video.venom ] Calling....control.player2().play(control.playlist)', 1)
# control.player2().play(control.playlist)
# return
# except:
# control.homeWindow.clearProperty('venom.isplaying.playlist')
# import traceback
# traceback.print_exc()
elif action == "play_preScrapeNext":
from resources.lib.modules.player import PlayNext
PlayNext().prescrapeNext()
elif action == "play_nextWindowXML":
from resources.lib.modules.player import PlayNext
play_next = PlayNext()
play_next.display_xml()
del play_next
elif action == 'play_All': # context menu works same as "Play from Here"
control.player2().play(control.playlist)
elif action == 'play_URL':
caller = params.get('caller')
if caller == 'realdebrid':
from resources.lib.debrid import realdebrid
if type == 'unrestrict':
control.player.play(
realdebrid.RealDebrid().unrestrict_link(
url.replace(' ', '%20')))
else:
control.player.play(url.replace(' ', '%20'))
elif caller == 'alldebrid':
from resources.lib.debrid import alldebrid
if type == 'unrestrict':
control.player.play(alldebrid.AllDebrid().unrestrict_link(
url.replace(' ', '%20')))
else:
control.player.play(url.replace(' ', '%20'))
else:
control.player.play(url.replace(' ', '%20'))
elif action == 'play_EpisodesList': # global context option
from json import dumps as jsdumps
from resources.lib.menus import episodes
meta = params.get('meta')
items = episodes.Episodes().get(tvshowtitle,
year,
imdb,
tmdb,
tvdb,
meta,
season,
episode,
create_directory=False)
control.playlist.clear()
for i in items:
title = i['title']
systitle = quote_plus(title)
year = i['year']
imdb = i['imdb']
tmdb = i['tmdb']
tvdb = i['tvdb']
season = i['season']
episode = i['episode']
tvshowtitle = i['tvshowtitle']
systvshowtitle = quote_plus(tvshowtitle)
premiered = i['premiered']
sysmeta = quote_plus(jsdumps(i))
url = 'plugin://plugin.video.venom/?action=play_Item&title=%s&year=%s&imdb=%s&tmdb=%s&tvdb=%s&season=%s&episode=%s&tvshowtitle=%s&premiered=%s&meta=%s&select=1' % (
systitle, year, imdb, tmdb, tvdb, season, episode,
systvshowtitle, premiered, sysmeta)
item = control.item(label=title, offscreen=True)
control.playlist.add(url=url, listitem=item)
control.player2().play(control.playlist)
elif action == 'play_Trailer':
from resources.lib.modules import trailer
windowedtrailer = params.get('windowedtrailer')
windowedtrailer = int(windowedtrailer) if windowedtrailer in (
"0", "1") else 0
trailer.Trailer().play(type, name, year, url, imdb,
windowedtrailer)
elif action == 'play_Random':
rtype = params.get('rtype')
if rtype == 'movie':
from resources.lib.menus import movies
rlist = movies.Movies().get(url, create_directory=False)
xbmc.log('movie rlist=%s' % rlist, 1)
xbmc.log('url=%s' % url, 1)
r = 'plugin://plugin.video.venom/?action=play_Item'
elif rtype == 'episode':
from resources.lib.menus import episodes
meta = params.get('meta')
rlist = episodes.Episodes().get(tvshowtitle,
year,
imdb,
tmdb,
tvdb,
meta,
season,
create_directory=False)
r = 'plugin://plugin.video.venom/?action=play_Item'
elif rtype == 'season':
from resources.lib.menus import seasons
art = params.get('art')
rlist = seasons.Seasons().get(tvshowtitle,
year,
imdb,
tmdb,
tvdb,
art,
create_directory=False)
r = 'plugin://plugin.video.venom/?action=play_Random&rtype=episode'
elif rtype == 'show':
from resources.lib.menus import tvshows
rlist = tvshows.TVshows().get(url, create_directory=False)
r = 'plugin://plugin.video.venom/?action=play_Random&rtype=season'
from random import randint
from json import dumps as jsdumps
try:
rand = randint(1, len(rlist)) - 1
for p in [
'title', 'year', 'imdb', 'tmdb', 'tvdb', 'season',
'episode', 'tvshowtitle', 'premiered', 'select'
]:
if rtype == "show" and p == "tvshowtitle":
try:
r += '&' + p + '=' + quote_plus(
rlist[rand]['title'])
except:
pass
else:
try:
r += '&' + p + '=' + quote_plus(str(
rlist[rand][p]))
except:
pass
try:
r += '&meta=' + quote_plus(jsdumps(rlist[rand]))
except:
r += '&meta=' + quote_plus("{}")
if rtype == "movie":
try:
control.notification(
title=32536,
message='%s (%s)' %
(rlist[rand]['title'], rlist[rand]['year']))
except:
pass
elif rtype == "episode":
try:
control.notification(title=32536,
message='%s - %01dx%02d - %s' %
(rlist[rand]['tvshowtitle'],
int(rlist[rand]['season']),
int(rlist[rand]['episode']),
rlist[rand]['title']))
except:
pass
control.execute('RunPlugin(%s)' % r)
except:
control.notification(message=32537)
elif action == 'play': # for support of old style .strm library files
from resources.lib.modules import sources
premiered = params.get('premiered')
meta = params.get('meta')
select = params.get('select')
rescrape = params.get('rescrape')
sources.Sources().play(title, year, imdb, tmdb, tvdb, season, episode,
tvshowtitle, premiered, meta, select, rescrape)
####################################################
#---Playlist
####################################################
elif action and action.startswith('playlist_'):
if action == 'playlist_Manager':
from resources.lib.modules import playlist
art = params.get('art')
meta = params.get('meta')
playlist.playlistManager(name, url, meta, art)
elif action == 'playlist_Show':
from resources.lib.modules import playlist
playlist.playlistShow()
elif action == 'playlist_Clear':
from resources.lib.modules import playlist
playlist.playlistClear()
elif action == 'playlist_QueueItem':
control.queueItem()
if name is None: control.notification(title=35515, message=35519)
else: control.notification(title=name, message=35519)
####################################################
#---Playcount
####################################################
elif action and action.startswith('playcount_'):
if action == 'playcount_Movie':
from resources.lib.modules import playcount
playcount.movies(name, imdb, query)
elif action == 'playcount_Episode':
from resources.lib.modules import playcount
playcount.episodes(name, imdb, tvdb, season, episode, query)
elif action == 'playcount_TVShow':
from resources.lib.modules import playcount
playcount.tvshows(name, imdb, tvdb, season, query)
####################################################
#---Source Actions
####################################################
elif action == 'alterSources':
from resources.lib.modules import sources
meta = params.get('meta')
sources.Sources().alterSources(url, meta)
elif action == 'showDebridPack':
from resources.lib.modules.sources import Sources
caller = params.get('caller')
Sources().debridPackDialog(caller, name, url, source)
elif action == 'sourceInfo':
from resources.lib.modules.sources import Sources
Sources().sourceInfo(source)
elif action == 'cacheTorrent':
caller = params.get('caller')
pack = True if type == 'pack' else False
if caller == 'RD':
from resources.lib.debrid.realdebrid import RealDebrid as debrid_function
elif caller == 'PM':
from resources.lib.debrid.premiumize import Premiumize as debrid_function
elif caller == 'AD':
from resources.lib.debrid.alldebrid import AllDebrid as debrid_function
success = debrid_function().add_uncached_torrent(url, pack=pack)
if success:
from resources.lib.modules import sources
meta = params.get('meta')
items = params.get('items')
sources.Sources().playItem(title, items, source, meta)
####################################################
#---Library Actions
####################################################
elif action and action.startswith('library_'):
if action == 'library_Navigator':
from resources.lib.menus import navigator
navigator.Navigator().library()
elif action == 'library_movieToLibrary':
from resources.lib.modules import library
library.libmovies().add(name, title, year, imdb, tmdb)
elif action == 'library_moviesToLibrary':
from resources.lib.modules import library
library.libmovies().range(url, name)
elif action == 'library_moviesListToLibrary':
from resources.lib.menus import movies
movies.Movies().moviesListToLibrary(url)
elif action == 'library_moviesToLibrarySilent':
from resources.lib.modules import library
library.libmovies().silent(url)
elif action == 'library_tvshowToLibrary':
from resources.lib.modules import library
library.libtvshows().add(tvshowtitle, year, imdb, tmdb, tvdb)
elif action == 'library_tvshowsToLibrary':
from resources.lib.modules import library
library.libtvshows().range(url, name)
elif action == 'library_tvshowsListToLibrary':
from resources.lib.menus import tvshows
tvshows.TVshows().tvshowsListToLibrary(url)
elif action == 'library_tvshowsToLibrarySilent':
from resources.lib.modules import library
library.libtvshows().silent(url)
elif action == 'library_update':
control.notification(message=32085)
from resources.lib.modules import library
library.libepisodes().update()
library.libmovies().list_update()
library.libtvshows().list_update()
while True:
if control.condVisibility('Library.IsScanningVideo'):
control.sleep(3000)
continue
else:
break
control.sleep(1000)
control.notification(message=32086)
elif action == 'library_clean':
from resources.lib.modules import library
library.lib_tools().clean()
elif action == 'library_setup':
from resources.lib.modules import library
library.lib_tools().total_setup()
elif action == 'library_service':
from resources.lib.modules import library
library.lib_tools().service()
####################################################
#---Cache
####################################################
elif action and action.startswith('cache_'):
if action == 'cache_Navigator':
from resources.lib.menus import navigator
navigator.Navigator().cf()
elif action == 'cache_clearAll':
from resources.lib.menus import navigator
navigator.Navigator().clearCacheAll()
elif action == 'cache_clearSources':
from resources.lib.menus import navigator
navigator.Navigator().clearCacheProviders()
elif action == 'cache_clearMeta':
from resources.lib.menus import navigator
navigator.Navigator().clearCacheMeta()
elif action == 'cache_clearCache':
from resources.lib.menus import navigator
navigator.Navigator().clearCache()
elif action == 'cache_clearSearch':
from resources.lib.menus import navigator
navigator.Navigator().clearCacheSearch()
elif action == 'cache_clearSearchPhrase':
from resources.lib.menus import navigator
navigator.Navigator().clearCacheSearchPhrase(source, name)
elif action == 'cache_clearBookmarks':
from resources.lib.menus import navigator
navigator.Navigator().clearBookmarks()
elif action == 'cache_clearBookmark':
from resources.lib.menus import navigator
navigator.Navigator().clearBookmark(name, year)
elif action == 'cache_clearKodiBookmark': # context.venom action call only
from resources.lib.database import cache
cache.clear_local_bookmark(url)
def resolve(self, sources, args, pack_select=False):
try:
stream_link = None
loop_count = 0
# Begin resolving links
for i in sources:
debrid_provider = i.get('debrid_provider',
'None').replace('_', ' ')
loop_count += 1
try:
if self.is_canceled():
self.close()
return
if 'size' in i:
i['info'].append(tools.source_size_display(i['size']))
self.setProperty('release_title',
tools.display_string(i['release_title']))
self.setProperty('debrid_provider', debrid_provider)
self.setProperty('source_provider', i['provider'])
self.setProperty('source_resolution', i['quality'])
self.setProperty('source_info', " ".join(i['info']))
if i['type'] == 'torrent':
stream_link = self.resolve_source(
self.resolvers[i['debrid_provider']], i, args,
pack_select)
if stream_link is None:
tools.log('Failed to resolve for torrent %s' %
i['release_title'])
continue
else:
self.return_data = stream_link
self.close()
return
elif i['type'] == 'hoster' or i['type'] == 'cloud':
if i['url'] is None:
continue
if i['type'] == 'cloud' and i[
'debrid_provider'] == 'premiumize':
selected_file = Premiumize.Premiumize(
).item_details(i['url'])
if tools.getSetting(
'premiumize.transcoded') == 'true':
url = selected_file['stream_link']
else:
url = selected_file['link']
self.return_data = url
self.close()
return
if 'provider_imports' in i:
provider = i['provider_imports']
providerModule = __import__(
'%s.%s' % (provider[0], provider[1]),
fromlist=[''])
providerModule = providerModule.source()
try:
i['url'] = providerModule.resolve(i['url'])
except:
import traceback
traceback.print_exc()
pass
if 'debrid_provider' in i:
stream_link = self.resolve_source(
self.resolvers[i['debrid_provider']], i, args,
pack_select)
if stream_link is None:
continue
else:
try:
requests.head(stream_link, timeout=1)
except requests.exceptions.RequestException:
tools.log(
'Head Request failed link likely dead, skipping'
)
continue
elif i['url'].startswith('http'):
try:
ext = i['url'].split('?')[0]
ext = ext.split('&')[0]
ext = ext.split('|')[0]
ext = ext.rsplit('.')[-1]
ext = ext.replace('/', '').lower()
if ext == 'rar': raise Exception()
try:
headers = i['url'].rsplit('|', 1)[1]
except:
headers = ''
headers = tools.quote_plus(headers).replace(
'%3D', '=') if ' ' in headers else headers
headers = dict(tools.parse_qsl(headers))
live_check = requests.head(i['url'],
headers=headers,
timeout=10)
if not live_check.status_code == 200:
tools.log(
'Head Request failed link likely dead, skipping'
)
continue
stream_link = i['url']
except:
import traceback
traceback.print_exc()
stream_link = None
elif tools.file_exists(i['url']):
stream_link = i['url']
if stream_link is None:
continue
else:
if stream_link.endswith('.rar'):
continue
self.return_data = stream_link
self.close()
return
continue
except:
import traceback
traceback.print_exc()
continue
self.close()
return
except:
import traceback
traceback.print_exc()
self.close()
return
