def get_request(url):
try:
try: response = session.get(url)
except requests.exceptions.SSLError:
response = session.get(url, verify=False)
except requests.exceptions.ConnectionError:
notification(message=32024)
from resources.lib.modules import log_utils
log_utils.error()
return None
try:
if response.status_code in (200, 201): return response.json()
elif response.status_code == 404:
if getSetting('debug.level') == '1':
from resources.lib.modules import log_utils
log_utils.log('TMDb get_request() failed: (404:NOT FOUND) - URL: %s' % url, level=log_utils.LOGDEBUG)
return '404:NOT FOUND'
elif 'Retry-After' in response.headers: # API REQUESTS ARE BEING THROTTLED, INTRODUCE WAIT TIME (TMDb removed rate-limit on 12-6-20)
throttleTime = response.headers['Retry-After']
notification(message='TMDb Throttling Applied, Sleeping for %s seconds' % throttleTime)
sleep((int(throttleTime) + 1) * 1000)
return get_request(url)
else:
if getSetting('debug.level') == '1':
from resources.lib.modules import log_utils
log_utils.log('TMDb get_request() failed: URL: %s\n msg : TMDB Response: %s' % (url, response.text), __name__, log_utils.LOGDEBUG)
return None
except:
from resources.lib.modules import log_utils
log_utils.error()
return None
def create_session_id(self):
try:
from resources.lib.modules.control import setSetting
if getSetting('tmdb.username') == '' or getSetting('tmdb.password') == '': return notification(message='TMDb Account info missing', icon='ERROR')
url = self.auth_base_link + '/token/new?api_key=%s' % API_key
result = requests.get(url).json()
token = result.get('request_token')
url2 = self.auth_base_link + '/token/validate_with_login?api_key=%s' % API_key
post2 = {"username": "******" % getSetting('tmdb.username'),
"password": "******" % getSetting('tmdb.password'),
"request_token": "%s" % token}
result2 = requests.post(url2, data=post2).json()
url3 = self.auth_base_link + '/session/new?api_key=%s' % API_key
post3 = {"request_token": "%s" % token}
result3 = requests.post(url3, data=post3).json()
if result3.get('success') is True:
session_id = result3.get('session_id')
msg = '%s' % ('username ='******'\n password ='******'\n token = ' + token + '\n confirm?')
if yesnoDialog(msg, '', ''):
setSetting('tmdb.session_id', session_id)
notification(message='TMDb Successfully Authorized')
else: notification(message='TMDb Authorization Cancelled')
except:
from resources.lib.modules import log_utils
log_utils.error()
def get_request(url):
try:
try:
result = session.get(url, headers=headers, timeout=5)
except requests.exceptions.SSLError:
result = session.get(url, headers=headers, verify=False)
except requests.exceptions.ConnectionError:
notification(message='FANART.TV server Problems')
from resources.lib.modules import log_utils
log_utils.error()
return None
if '200' in str(result):
return result.json()
elif 'Not found' in str(result.text):
if getSetting('debug.level') != '1': return None
from resources.lib.modules import log_utils
log_utils.log('requests.get() failed - FANART.TV URL: %s (NOT FOUND)' %
url,
level=log_utils.LOGDEBUG)
else:
if getSetting('debug.level') != '1': return None
from resources.lib.modules import log_utils
from resources.lib.modules.client import parseDOM
title = parseDOM(result.text, 'title')[0]
log_utils.log('requests.get() failed - FANART.TV URL: %s (%s)' %
(url, title),
level=log_utils.LOGDEBUG)
def get_request(url):
try:
try:
result = session.get(url, headers=headers, timeout=5)
except requests.exceptions.SSLError:
result = session.get(url, headers=headers, verify=False)
except requests.exceptions.ConnectionError:
notification(message='FANART.TV Temporary Server Problems')
from resources.lib.modules import log_utils
log_utils.error()
return None
try:
if result.status_code in (200, 201): return result.json()
elif result.status_code == 404:
if getSetting('debug.level') == '1':
from resources.lib.modules import log_utils
log_utils.log(
'FANART.TV get_request() failed: (404:NOT FOUND) - URL: %s'
% url,
level=log_utils.LOGDEBUG)
return '404:NOT FOUND'
else:
if getSetting('debug.level') == '1':
from resources.lib.modules import log_utils
from resources.lib.modules.client import parseDOM
title = parseDOM(result.text, 'title')[0]
log_utils.log('FANART.TV get_request() failed - URL: %s (%s)' %
(url, title),
level=log_utils.LOGDEBUG)
return None
except:
from resources.lib.modules import log_utils
log_utils.error()
return None
def log(msg, caller=None, level=LOGINFO):
debug_enabled = getSetting('debug.enabled') == 'true'
if not debug_enabled: return
debug_level = getSetting('debug.level')
if level == LOGDEBUG and debug_level != '1': return
debug_location = getSetting('debug.location')
if isinstance(msg, int): msg = lang(msg) # for strings.po translations
try:
if not msg.isprintable(
): # ex. "\n" is not a printable character so returns False on those cases
msg = '%s (NORMALIZED by log_utils.log())' % normalize(msg)
if isinstance(msg, bytes):
msg = '%s (ENCODED by log_utils.log())' % msg.decode(
'utf-8', errors='replace')
if caller is not None and level != LOGERROR:
func = inspect.currentframe().f_back.f_code
line_number = inspect.currentframe().f_back.f_lineno
caller = "%s.%s()" % (caller, func.co_name)
msg = 'From func name: %s Line # :%s\n msg : %s' % (
caller, line_number, msg)
elif caller is not None and level == LOGERROR:
msg = 'From func name: %s.%s() Line # :%s\n msg : %s' % (
caller[0], caller[1], caller[2], msg)
if debug_location == '1':
log_file = joinPath(LOGPATH, 'dg.log')
if not existsPath(log_file):
f = open(log_file, 'w')
f.close()
reverse_log = getSetting('debug.reversed') == 'true'
if not reverse_log:
with open(log_file, 'a', encoding='utf-8'
) as f: # with auto cleans up and closes
line = '[%s %s] %s: %s' % (
datetime.now().date(), str(datetime.now().time())[:8],
DEBUGPREFIX % debug_list[level], msg)
f.write(line.rstrip('\r\n') + '\n')
# f.writelines([line1, line2]) ## maybe an option for the 2 lines without using "\n"
else:
with open(log_file, 'r+', encoding='utf-8') as f:
line = '[%s %s] %s: %s' % (
datetime.now().date(), str(datetime.now().time())[:8],
DEBUGPREFIX % debug_list[level], msg)
log_file = f.read()
f.seek(0, 0)
f.write(line.rstrip('\r\n') + '\n' + log_file)
else:
import xbmc
xbmc.log('%s: %s' % (DEBUGPREFIX % debug_list[level], msg), level)
except Exception as e:
import traceback
traceback.print_exc()
import xbmc
xbmc.log(
'[ plugin.video.dg ] log_utils.log() Logging Failure: %s' % (e),
LOGERROR)
def tmdb_sort():
sort = int(getSetting('sort.movies.type'))
tmdb_sort = 'original_order'
if sort == 1: tmdb_sort = 'title'
if sort in (2, 3): tmdb_sort = 'vote_average'
if sort in (4, 5, 6): tmdb_sort = 'release_date' # primary_release_date
tmdb_sort_order = '.asc' if int(getSetting('sort.movies.order')) == 0 else '.desc'
sort_string = tmdb_sort + tmdb_sort_order
return sort_string
def enabledCheck(cloud_scraper):
parent_dict = {'ad_cloud': 'alldebrid', 'pm_cloud': 'premiumize', 'rd_cloud': 'realdebrid'}
try:
parent_setting = parent_dict[cloud_scraper]
if getSetting(parent_setting + '.enable') == 'true' and getSetting(cloud_scraper + '.enabled') == 'true': return True
else: return False
except:
from resources.lib.modules import log_utils
log_utils.error()
return False
def __init__(self):
self.list = []
self.meta = []
self.enable_fanarttv = getSetting('enable.fanarttv') == 'true'
self.lang = apiLanguage()['tmdb']
self.show_link = base_link + 'tv/%s?api_key=%s&language=%s&append_to_response=credits,content_ratings,external_ids,alternative_titles,videos' % ('%s', API_key, self.lang)
# 'append_to_response=translations, aggregate_credits' (DO NOT USE, response data way to massive and bogs the response time)
self.art_link = base_link + 'tv/%s/images?api_key=%s' % ('%s', API_key)
self.tvdb_key = getSetting('tvdb.api.key')
self.imdb_user = getSetting('imdb.user').replace('ur', '')
self.user = str(self.imdb_user) + str(self.tvdb_key)
self.date_time = datetime.now()
self.today_date = (self.date_time).strftime('%Y-%m-%d')
def __init__(self):
last = []
self.count = 40
self.list = []
self.meta = []
self.threads = []
self.lang = apiLanguage()['tvdb']
self.base_link = 'https://api.tvmaze.com'
self.tvmaze_info_link = 'https://api.tvmaze.com/shows/%s?embed=cast'
self.tvdb_key = getSetting('tvdb.api.key')
self.imdb_user = getSetting('imdb.user').replace('ur', '')
self.user = str(self.imdb_user) + str(self.tvdb_key)
self.enable_fanarttv = getSetting('enable.fanarttv') == 'true'
def setView(content, viewType):
if content:
control.content(int(sys.argv[1]), content)
if control.getSetting('auto-view') == 'true':
views = control.getSetting('viewType2')
if views == '50' and control.getKodiVersion >= 17 and control.skin == 'skin.estuary':
views = '55'
if views == '500' and control.getKodiVersion >= 17 and control.skin == 'skin.estuary':
views = '50'
return control.execute("Container.SetViewMode(%s)" % views)
else:
views = control.getCurrentViewId()
return control.execute("Container.SetViewMode(%s)" % views)
def __init__(self, *args, **kwargs):
super(SourceResultsXML, self).__init__(self, args)
self.window_id = 2000
self.results = kwargs.get('results')
self.uncached = kwargs.get('uncached')
self.total_results = str(len(self.results))
self.meta = kwargs.get('meta')
self.info = None
self.cm = None
self.make_items()
self.set_properties()
self.dnlds_enabled = True if getSetting('downloads') == 'true' and (
getSetting('movie.download.path') != ''
or getSetting('tv.download.path') != '') else False
def revoke_session_id(self):
try:
from resources.lib.modules.control import setSetting
if getSetting('tmdb.session_id') == '': return
url = self.auth_base_link + '/session?api_key=%s' % API_key
post = {"session_id": "%s" % getSetting('tmdb.session_id')}
result = requests.delete(url, data=post).json()
if result.get('success') is True:
setSetting('tmdb.session_id', '')
notification(message='TMDb session_id successfully deleted')
else: notification(message='TMDb session_id deletion FAILED', icon='ERROR')
except:
from resources.lib.modules import log_utils
log_utils.error()
def __init__(self, *args, **kwargs):
super(PlayNextXML, self).__init__(self, args)
self.window_id = 3011
self.meta = kwargs.get('meta')
self.playing_file = self.getPlayingFile()
self.duration = self.getTotalTime() - self.getTime()
self.default_action = int(getSetting('playnext.default.action'))
self.closed = False
def kitsu_headers(self):
token = control.getSetting("kitsu.token")
headers = {
'Content-Type': 'application/vnd.api+json',
'Accept': 'application/vnd.api+json',
'Authorization': "Bearer {}".format(token),
}
return headers
def __init__(self):
self.list = []
self.meta = []
self.enable_fanarttv = getSetting('enable.fanarttv') == 'true'
self.lang = apiLanguage()['tmdb']
self.movie_link = base_link + 'movie/%s?api_key=%s&language=%s&append_to_response=credits,release_dates,videos,alternative_titles' % ('%s', API_key, self.lang)
### other "append_to_response" options external_ids,images,content_ratings, translations
self.art_link = base_link + 'movie/%s/images?api_key=%s' % ('%s', API_key)
self.external_ids = base_link + 'movie/%s/external_ids?api_key=%s' % ('%s', API_key)
# self.user = str(self.imdb_user) + str(API_key)
self.user = str(API_key)
def __init__(self, *args, **kwargs):
super(TraktHiddenManagerXML, self).__init__(self, args)
self.window_id = 2040
self.results = kwargs.get('results')
self.total_results = str(len(self.results))
self.chosen_hide = []
self.chosen_unhide = []
self.hide_watched = getSetting(
'trakt.HiddenManager.hideWatched') == 'true'
self.make_items()
self.set_properties()
self.hasVideo = False
def kitsu_scrobbleAnime(self, kitsu_id, status):
user_id = int(control.getSetting("kitsu.userid"))
libraryEntry_url = 'https://kitsu.io/api/edge/library-entries/'
libraryScrobble_url = libraryEntry_url + '?filter[animeId]=%s&filter[userId]=%d' %(kitsu_id, user_id)
libraryScrobble_resp = requests.get(libraryScrobble_url).text
item_dict = json.loads(libraryScrobble_resp)
if len(item_dict['data']) == 0:
data = status
item_type = 'anime'
final_dict = {
"data": {
"type": "libraryEntries",
"attributes": data,
"relationships":{
"user":{
"data":{
"id": user_id,
"type": "users"
}
},
"anime":{
"data":{
"id": kitsu_id,
"type": item_type
}
}
}
}
}
data = json.dumps(final_dict, separators=(',',':'))
libraryEntry_post = requests.post(libraryEntry_url, headers=self.kitsu_headers(), data=data)
if libraryEntry_post.status_code != 201:
dialog = xbmcgui.Dialog()
dialog.ok('Kitsu', 'Kitsu scrobble error. Unable to track episode. Try relogging in to resolve error.')
else:
_id = item_dict['data'][0]['id']
final_dict = {
'data': {
'id': _id,
'type': 'libraryEntries',
'attributes': status
}
}
data = json.dumps(final_dict, separators=(',',':'))
libraryEntry_patch = requests.patch(libraryEntry_url + _id, headers=self.kitsu_headers(), data=data)
if libraryEntry_patch.status_code != 200:
dialog = xbmcgui.Dialog()
dialog.ok('Kitsu', 'Kitsu scrobble error. Unable to track episode. Try relogging in to resolve error.')
def kitsu_login(self):
try:
token_url = 'https://kitsu.io/api/oauth/token'
resp = requests.post(
token_url,
params={
"grant_type": "password",
"username": '******' % (control.getSetting("kitsu.email")),
"password": '******' % (control.getSetting("kitsu.password"))
})
token = json.loads(resp.text)['access_token']
control.setSetting("kitsu.token", token)
useridScrobble_resp = requests.get(
'https://kitsu.io/api/edge/users?filter[self]=true',
headers=self.kitsu_headers())
userid = json.loads(useridScrobble_resp.text)['data'][0]['id']
control.setSetting("kitsu.userid", userid)
control.setSetting("kitsu.login_auth", 'Kitsu')
dialog = xbmcgui.Dialog()
dialog.ok('Kitsu', 'Login successful')
except:
dialog = xbmcgui.Dialog()
dialog.ok('Kitsu', 'Login error. Incorrect email or password.')
def kitsu_scrobbleAnime(self, kitsu_id, status_data):
user_id = int(control.getSetting("kitsu.userid"))
libraryEntry_url = 'https://kitsu.io/api/edge/library-entries/'
libraryScrobble_url = libraryEntry_url + '?filter[animeId]=%s&filter[userId]=%d' %(kitsu_id, user_id)
libraryScrobble_resp = requests.get(libraryScrobble_url).text
item_dict = json.loads(libraryScrobble_resp)
if len(item_dict['data']) == 0:
item_type = 'anime'
final_dict = {
"data": {
"type": "libraryEntries",
"attributes": status_data,
"relationships":{
"user":{
"data":{
"id": user_id,
"type": "users"
}
},
"anime":{
"data":{
"id": kitsu_id,
"type": item_type
}
}
}
}
}
data = json.dumps(final_dict, separators=(',',':'))
libraryEntry_post = requests.post(libraryEntry_url, headers=self.kitsu_headers(), data=data)
if libraryEntry_post.status_code != 201:
dialog = xbmcgui.Dialog()
dialog.ok('Kitsu', 'Kitsu scrobble error. Unable to track episode. Try relogging in to resolve error.')
else:
_id = item_dict['data'][0]['id']
final_dict = {
'data': {
'id': _id,
'type': 'libraryEntries',
'attributes': status_data
}
}
data = json.dumps(final_dict, separators=(',',':'))
libraryEntry_patch = requests.patch(libraryEntry_url + _id, headers=self.kitsu_headers(), data=data)
if libraryEntry_patch.status_code != 200:
dialog = xbmcgui.Dialog()
dialog.ok('Kitsu', 'Kitsu scrobble error. Unable to track episode. Try relogging in to resolve error.')
def getSeasonCount(imdb, season=None, season_special=False):
if not imdb.startswith('tt'): return None
try:
if not traktIndicators: return None
result = trakt.seasonCount(imdb=imdb)
if not result: return None
if not season: return result
else:
if getSetting('tv.specials') == 'true' and season_special: result = result[int(season)]
else:
if int(season) > len(result): return None
result = result[int(season) - 1]
return result
except:
from resources.lib.modules import log_utils
log_utils.error()
return None
def colorString(text, color=None):
try:
text = text.encode('utf-8')
except:
try:
text = bytes(text).decode('utf-8')
text = str(text)
except:
pass
pass
if color is 'default' or color is '' or color is None:
color = control.getSetting('my_ColorChoice')
if color is '': color = 'none'
try:
return '[COLOR ' + str(color) + ']' + text + '[/COLOR]'
except:
return '[COLOR ' + str(color) + ']' + text + '[/COLOR]'
def update(anidetails, id):
anime_id = id
episodenumber = anidetails[0]
episodecount = anidetails[1]
user_id = int(control.getSetting("kitsu.userid"))
item_type = 'anime'
if episodenumber < episodecount:
update = ['current', episodenumber]
else:
update = ['completed', episodenumber]
data = {'status': update[0], 'progress': update[1]}
final_dict = {
"data": {
"type": "libraryEntries",
"attributes": data,
"relationships": {
"user": {
"data": {
"id": user_id,
"type": "users"
}
},
"media": {
"data": {
"id": anime_id,
"kind": item_type
}
}
}
}
}
data = json.dumps(final_dict, separators=(',', ':'))
send = requests.post("https://kitsu.io/api/edge/library-entries",
headers=kitsu_headers(),
data=data)
print send
return True
def update(anidetails, id):
anime_id = id
episodenumber = anidetails[0]
episodecount = anidetails[1]
user_id = int(control.getSetting("kitsu.userid"))
item_type = 'anime'
if episodenumber < episodecount:
update = ['current', episodenumber]
else:
update = ['completed', episodenumber]
data = {'status': update[0],
'progress': update[1]
}
final_dict = {
"data": {
"type": "libraryEntries",
"attributes": data,
"relationships":{
"user":{
"data":{
"id": user_id,
"type": "users"
}
},
"media":{
"data":{
"id": anime_id,
"kind": item_type
}
}
}
}
}
data = json.dumps(final_dict, separators=(',',':'))
send = requests.post("https://kitsu.io/api/edge/library-entries", headers=kitsu_headers(), data=data)
print send
return True
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_folders = realdebrid.RealDebrid().user_torrents()
if not cloud_folders: return sources
cloud_folders = [i for i in cloud_folders if i['status'] == 'downloaded']
if not cloud_folders: return sources
ignoreM2ts = getSetting('rd_cloud.ignore.m2ts') == 'true'
extras_filter = cloud_utils.extras_filter()
except:
from resources.lib.modules import log_utils
log_utils.error('RD_CLOUD: ')
return sources
for folder in cloud_folders:
is_m2ts = False
try:
folder_name = folder.get('filename', '')
if not cloud_utils.cloud_check_title(title, aliases, folder_name): continue
id = folder.get('id', '')
torrent_info = realdebrid.RealDebrid().torrent_info(id)
folder_files = torrent_info['files']
folder_files = [i for i in folder_files if i['selected'] == 1]
except:
from resources.lib.modules import log_utils
log_utils.error('RD_CLOUD: ')
return sources
for file in folder_files:
try:
name = file.get('path').lstrip('/')
rt = cloud_utils.release_title_format(name)
if not name.lower().endswith(tuple(supported_video_extensions())): continue
if any(value in rt for value in extras_filter): continue
if name.endswith('m2ts'):
if ignoreM2ts: continue
name = folder_name
rt = cloud_utils.release_title_format(name)
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
largest = sorted(folder_files, key=lambda k: k['bytes'], reverse=True)[0]
index_pos = folder_files.index(largest)
size = largest['bytes']
try: link = torrent_info['links'][index_pos]
except: link = torrent_info['links'][0]
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()
nl = name.lower()
if all(not bool(re.search(i, nl)) 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, folder_name)) for i in query_list): continue
name = folder_name
if file.get('bytes') < 52428800: continue
name = name.split('/')
name = name[len(name)-1]
index_pos = folder_files.index(file)
link = torrent_info['links'][index_pos]
size = file.get('bytes', '')
name_info = fs_utils.info_from_name(name, title, self.year, hdlr, episode_title)
hash = folder.get('hash', '')
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': 'rd_cloud', 'source': 'cloud', 'debrid': 'Real-Debrid', 'seeders': '', 'hash': hash, 'name': name, 'name_info': name_info,
'quality': quality, 'language': 'en', 'url': link, 'info': info, 'direct': True, 'debridonly': True, 'size': dsize})
except:
from resources.lib.modules import log_utils
log_utils.error('RD_CLOUD: ')
return sources
return sources
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 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)
try:
cloud_folders = alldebrid.AllDebrid().user_cloud()['magnets']
except:
return sources
if not cloud_folders: return sources
cloud_folders = [i for i in cloud_folders if i['statusCode'] == 4]
if not cloud_folders: return sources
ignoreM2ts = getSetting('ad_cloud.ignore.m2ts') == 'true'
extras_filter = cloud_utils.extras_filter()
except:
from resources.lib.modules import log_utils
log_utils.error('AD_CLOUD: ')
return sources
for folder in cloud_folders:
is_m2ts = False
try:
folder_name = folder.get('filename')
if not cloud_utils.cloud_check_title(title, aliases,
folder_name):
continue
files = folder.get('links', '')
# files = [i for i in files if i['filename'].lower().endswith(tuple(supported_video_extensions()))]
if not files: continue
except:
from resources.lib.modules import log_utils
log_utils.error('AD_CLOUD: ')
return sources
for file in files:
try:
name = file.get('filename', '')
if name.lower().endswith(invalid_extensions): continue
path = folder.get('filename', '').lower()
rt = cloud_utils.release_title_format(name)
if any(value in rt for value in extras_filter): continue
if '.m2ts' in str(file.get('files')):
if ignoreM2ts: continue
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 files if name == i.get('filename')
]
largest = sorted(m2ts_files,
key=lambda k: k['size'],
reverse=True)[0]
link = largest.get('link', '')
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 = folder.get('filename', '')
link = file.get('link', '')
size = file.get('size', '')
name_info = fs_utils.info_from_name(
name, title, self.year, hdlr, episode_title)
hash = folder.get('hash', '')
seeders = folder.get('seeders', '')
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': 'ad_cloud',
'source': 'cloud',
'debrid': 'AllDebrid',
'seeders': seeders,
'hash': hash,
'name': name,
'name_info': name_info,
'quality': quality,
'language': 'en',
'url': link,
'info': info,
'direct': True,
'debridonly': True,
'size': dsize
})
except:
from resources.lib.modules import log_utils
log_utils.error('AD_CLOUD: ')
return sources
return sources
def BUILDS():
setView('addons', 'views')
CreateDir('Kodi Version Check', 'url', 'getKodiVersion', MENU_ICON,
MENU_FANART, 'Check My Kodi Version.')
CreateDir('Current Profile Check', 'url', 'checkCurrentProfile', MENU_ICON,
MENU_FANART, 'Check My Current Profile.')
wizard1 = control.setting('enable_wiz1')
if wizard1 != 'false':
try:
name = unicode(control.getSetting('name1'))
url = unicode(control.getSetting('url1'))
img = unicode(control.getSetting('img1'))
fanart = unicode(control.getSetting('img1'))
CreateDir('[Wizard] ' + name,
url,
'install_build',
img,
fanart,
'My Custom Build.',
isFolder=False)
except:
pass
wizard2 = control.setting('enable_wiz2')
if wizard2 != 'false':
try:
name = unicode(control.getSetting('name2'))
url = unicode(control.getSetting('url2'))
img = unicode(control.getSetting('img2'))
fanart = unicode(control.getSetting('img2'))
CreateDir('[Wizard] ' + name,
url,
'install_build',
img,
fanart,
'My Custom Build.',
isFolder=False)
except:
pass
wizard3 = control.setting('enable_wiz3')
if wizard3 != 'false':
try:
name = unicode(control.getSetting('name3'))
url = unicode(control.getSetting('url3'))
img = unicode(control.getSetting('img3'))
fanart = unicode(control.getSetting('img3'))
CreateDir('[Wizard] ' + name,
url,
'install_build',
img,
fanart,
'My Custom Build.',
isFolder=False)
except:
pass
CreateDir('[I]Swap Skin[/I]', 'url', 'skinSWAP', MENU_ICON, MENU_FANART,
'Swap to Default Skin.')
CreateDir('[I]Force Close Kodi[/I]', 'url', 'Force_Close', MENU_ICON,
MENU_FANART, 'Force Close Kodi.')
CreateDir('[I]Reload Skin[/I]', 'url', 'reloadMySkin', MENU_ICON,
MENU_FANART, 'Reload Current Skin.')
CreateDir('[I]Reload Profile[/I]', 'url', 'reloadProfile', MENU_ICON,
MENU_FANART, 'Reload My User Profile.')
CreateDir('[I]Fresh Start[/I]', 'url', 'fresh_start', MENU_ICON,
MENU_FANART, 'Wipe Kodi like a Factory Reset.')
CreateDir('Wizard Settings', 'url', 'wizSettings', MENU_ICON, MENU_FANART,
'Open up Wizard Settings.')
def kitsu_login(self):
try:
token_url = 'https://kitsu.io/api/oauth/token'
resp = requests.post(token_url, params={"grant_type": "password", "username": '******' %(control.getSetting("kitsu.email")), "password": '******' %(control.getSetting("kitsu.password"))})
token = json.loads(resp.text)['access_token']
control.setSetting("kitsu.token", token)
useridScrobble_resp = requests.get('https://kitsu.io/api/edge/users?filter[self]=true', headers=self.kitsu_headers())
userid = json.loads(useridScrobble_resp.text)['data'][0]['id']
control.setSetting("kitsu.userid", userid)
control.setSetting("kitsu.login_auth", 'Kitsu')
dialog = xbmcgui.Dialog()
dialog.ok('Kitsu', 'Login successful')
except:
dialog = xbmcgui.Dialog()
dialog.ok('Kitsu', 'Login error. Incorrect email or password.')
def run(self, anime_id, ep_id, url, synop, start_date, start_year, gen, epnum, epcount, eplink):
control.sleep(200)
self.anime_id = int(anime_id)
self.episode_id = int(ep_id)
item = control.item(path=url)
try:
c = cache.get(masterani.get_anime_details, 3, self.anime_id)
ctype = c['type']
ctype = 'movie' if int(ctype) is 2 else 'episode'
tvshowtitle = c['title']
poster = c['poster']
coverlink = "http://cdn.masterani.me/poster/" + poster
print coverlink
item.setArt({'icon': coverlink, 'thumb': coverlink, 'poster': coverlink, 'tvshow.poster': coverlink, 'season.poster': coverlink})
e = c['episodes'][self.episode_id]
title = e['info']['title']
season2options = [': Season 2', ' Season 2', ': 2nd Season', ': Second Season', ' 2nd Season', ' Second Season', ': Part 2', ' Part 2', ': Part II', ' Part II']
season3options = [': Season 3', ' Season 3', ': 3rd Season', ': Third Season', ' 3rd Season', ' Third Season', ': Part 3', ' Part 3', ': Part III', ' Part III']
season4options = [': Season 4', ' Season 4', ': 4th Season', ': Fourth Season', ' 4th Season', ' Fourth Season', ': Part 4', ' Part 4', ': Part IV', ' Part IV']
season5options = [': Season 5', ' Season 5', ': 5th Season', ': Fifth Season', ' 5th Season', ' Fifth Season', ': Part 5', ' Part 5', ': Part V', ' Part V']
season = 1
for option in season2options:
if option in tvshowtitle:
tvshowtitle = tvshowtitle.replace(option, "")
season = 2
for option in season3options:
if option in tvshowtitle:
tvshowtitle = tvshowtitle.replace(option, "")
season = 3
for option in season4options:
if option in tvshowtitle:
tvshowtitle = tvshowtitle.replace(option, "")
season = 4
for option in season5options:
if option in tvshowtitle:
tvshowtitle = tvshowtitle.replace(option, "")
season = 5
episode = e['info']['episode']
if ctype is 'video': title = c['title']
if title is None: title = "Episode %s" % episode
item.setInfo(type="video",
infoLabels={'tvshowtitle': title, 'title': tvshowtitle, 'episode': int(episode),
'season': int(season), 'mediatype': ctype})
#year = e['info']['aired'].split("-", 1)[0]
#plot = e['info']['description']
if 'movie' in ctype:
year = start_year
plot = synop
genre = gen
item.setInfo(type="video",
infoLabels={'year': year, 'plot': plot, 'genre': genre})
else:
year = e['info']['aired'].split("-", 1)[0]
plot = e['info']['description']
item.setInfo(type="video",
infoLabels={'year': year, 'plot': plot, 'genre': gen})
except:
pass
item.setProperty('Video', 'true')
item.setProperty('IsPlayable', 'true')
trackyesno = control.getSetting("track.yesno")
tracktype = control.getSetting("track.type")
if trackyesno == "true" and tracktype == 'Kitsu':
kitsu.KitsuScrobbler().kitsu_initScrobble(tvshowtitle, start_date, epnum, epcount)
else:
pass
self.play(url, item)
self.playback_checker(self.anime_id, eplink)
pass
def tvmaze_list(self, url):
try:
result = client.request(url) # not json request
next = ''
if getSetting('tvshows.networks.view') == '0':
result = client.parseDOM(result,
'section',
attrs={'id': 'this-seasons-shows'})
items = client.parseDOM(result,
'span',
attrs={'class': 'title .*'})
list_count = 60
if getSetting('tvshows.networks.view') == '1':
result = client.parseDOM(result, 'div', attrs={'id': 'w1'})
items = client.parseDOM(result,
'span',
attrs={'class': 'title'})
list_count = 25
page = int(str(url.split('&page=', 1)[1]))
next = '%s&page=%s' % (url.split('&page=', 1)[0], page + 1)
last = []
last = client.parseDOM(result,
'li',
attrs={'class': 'last disabled'})
if last != []: next = ''
items = [client.parseDOM(i, 'a', ret='href') for i in items]
items = [i[0] for i in items if len(i) > 0]
items = [
re.findall(r'/(\d+)/', i) for i in items
] #https://www.tvmaze.com/networks/645/tlc pulls tvmaze_id from link
items = [i[0] for i in items if len(i) > 0]
items = items[:list_count]
sortList = items
except:
log_utils.error()
return
def items_list(tvmaze_id):
# if i['metacache']: return # not possible with only a tvmaze_id
try:
values = {}
values['next'] = next
values['tvmaze'] = tvmaze_id
url = self.tvmaze_info_link % tvmaze_id
item = get_request(url)
values['content'] = item.get('type', '').lower()
values['mediatype'] = 'tvshow'
values['title'] = item.get('name')
values['originaltitle'] = values['title']
values['tvshowtitle'] = values['title']
values['premiered'] = str(item.get(
'premiered', '')) if item.get('premiered') else ''
try:
values['year'] = values['premiered'][:4]
except:
values['year'] = ''
ids = item.get('externals')
imdb = str(ids.get('imdb', '')) if ids.get('imdb') else ''
tvdb = str(ids.get('thetvdb',
'')) if ids.get('thetvdb') else ''
tmdb = '' # TVMaze does not have tmdb_id in api
studio = item.get('network', {}) or item.get('webChannel', {})
values['studio'] = studio.get('name', '')
values['genre'] = []
for i in item['genres']:
values['genre'].append(i.title())
if values['genre'] == []: values['genre'] = 'NA'
values['duration'] = int(item.get(
'runtime', '')) * 60 if item.get('runtime') else ''
values['rating'] = str(item.get('rating').get(
'average',
'')) if item.get('rating').get('average') else ''
values['plot'] = client.cleanHTML(item['summary'])
values['status'] = item.get('status', '')
values['castandart'] = []
for person in item['_embedded']['cast']:
try:
values['castandart'].append({
'name':
person['person']['name'],
'role':
person['character']['name'],
'thumbnail':
(person['person']['image']['medium']
if person['person']['image']['medium'] else '')
})
except:
pass
if len(values['castandart']) == 150: break
image = item.get('image', {}) or ''
values['poster'] = image.get('original', '') if image else ''
values['fanart'] = ''
values['banner'] = ''
values['mpaa'] = ''
values['votes'] = ''
try:
values['airday'] = item['schedule']['days'][0]
except:
values['airday'] = ''
values['airtime'] = item['schedule']['time'] or ''
try:
values['airzone'] = item['network']['country']['timezone']
except:
values['airzone'] = ''
values['metacache'] = False
#### -- Missing id's lookup -- ####
if not tmdb and (imdb or tvdb):
try:
result = cache.get(tmdb_indexer.TVshows().IdLookup, 96,
imdb, tvdb)
tmdb = str(result.get('id',
'')) if result.get('id') else ''
except:
tmdb = ''
if not imdb or not tmdb or not tvdb:
try:
trakt_ids = trakt.SearchTVShow(quote_plus(
values['tvshowtitle']),
values['year'],
full=False)
if not trakt_ids: raise Exception
ids = trakt_ids[0].get('show', {}).get('ids', {})
if not imdb:
imdb = str(ids.get('imdb',
'')) if ids.get('imdb') else ''
if not tmdb:
tmdb = str(ids.get('tmdb',
'')) if ids.get('tmdb') else ''
if not tvdb:
tvdb = str(ids.get('tvdb',
'')) if ids.get('tvdb') else ''
except:
log_utils.error()
#################################
if not tmdb:
return log_utils.log(
'tvshowtitle: (%s) missing tmdb_id: ids={imdb: %s, tmdb: %s, tvdb: %s}'
% (values['tvshowtitle'], imdb, tmdb, tvdb), __name__,
log_utils.LOGDEBUG
) # log TMDb shows that they do not have
# self.list = metacache.fetch(self.list, self.lang, self.user)
# if self.list['metacache'] is True: raise Exception()
showSeasons = cache.get(
tmdb_indexer.TVshows().get_showSeasons_meta, 96, tmdb)
if not showSeasons: return
showSeasons = dict(
(k, v) for k, v in iter(showSeasons.items())
if v is not None and v != ''
) # removes empty keys so .update() doesn't over-write good meta
values.update(showSeasons)
if not values.get('imdb'): values['imdb'] = imdb
if not values.get('tmdb'): values['tmdb'] = tmdb
if not values.get('tvdb'): values['tvdb'] = tvdb
for k in ('seasons', ):
values.pop(
k, None
) # pop() keys from showSeasons that are not needed anymore
if self.enable_fanarttv:
extended_art = fanarttv_cache.get(fanarttv.get_tvshow_art,
168, tvdb)
if extended_art: values.update(extended_art)
meta = {
'imdb': imdb,
'tmdb': tmdb,
'tvdb': tvdb,
'lang': self.lang,
'user': self.user,
'item': values
} # DO NOT move this after "values = dict()" below or it becomes the same object and "del meta['item']['next']" removes it from both
values = dict((k, v) for k, v in iter(values.items())
if v is not None and v != '')
self.list.append(values)
if 'next' in meta.get('item'):
del meta['item']['next'] # next can not exist in metacache
self.meta.append(meta)
self.meta = [
i for i in self.meta if i.get('tmdb')
] # without this ui removed missing tmdb but it still writes these cases to metacache?
metacache.insert(self.meta)
except:
log_utils.error()
try:
threads = []
append = threads.append
for tvmaze_id in items:
append(Thread(target=items_list, args=(tvmaze_id, )))
[i.start() for i in threads]
[i.join() for i in threads]
sorted_list = []
self.list = [
i for i in self.list if i.get('tmdb') and i.get('tmdb') != '0'
] # to rid missing tmdb_id's because season list can not load without
for i in sortList:
sorted_list += [
item for item in self.list if str(item['tvmaze']) == str(i)
]
return sorted_list
except:
log_utils.error()
return
# -*- coding: UTF-8 -*-
import os
from pkgutil import walk_packages
from resources.lib.modules.control import setting as getSetting
debug_enabled = getSetting('debug.enabled') == 'true'
def cloudSources():
try:
sourceDict = []
sourceFolderLocation = os.path.dirname(__file__)
for loader, module_name, is_pkg in walk_packages([sourceFolderLocation]):
if is_pkg: continue
if 'cloud_utils' in module_name: continue
if enabledCheck(module_name):
try:
module = loader.find_module(module_name).load_module(module_name)
sourceDict.append((module_name, module.source()))
except Exception as e:
if debug_enabled:
from resources.lib.modules import log_utils
log_utils.log('Error: Loading cloud scraper module: "%s": %s' % (module_name, e), level=log_utils.LOGWARNING)
return sourceDict
except:
from resources.lib.modules import log_utils
log_utils.error()
return []
def enabledCheck(cloud_scraper):
# -*- coding: utf-8 -*-
"""
Venom Add-on
"""
import requests
from requests.adapters import HTTPAdapter
from urllib3.util.retry import Retry
from resources.lib.modules.control import setting as getSetting, apiLanguage, notification
headers = {'api-key': '9f846e7ec1ea94fad5d8a431d1d26b43'}
client_key = getSetting('fanart.tv.api.key')
if not client_key: client_key = 'cf0ebcc2f7b824bd04cf3a318f15c17d'
headers.update({'client-key': client_key})
base_url = "http://webservice.fanart.tv/v3/%s/%s"
lang = apiLanguage()['trakt']
error_codes = [
'500 Internal Server Error', '502 Bad Gateway', '504 Gateway Timeout'
]
session = requests.Session()
retries = Retry(total=5,
backoff_factor=0.1,
status_forcelist=[500, 502, 503, 504])
session.mount('http://', HTTPAdapter(max_retries=retries))
def get_request(url):
try:
try:
result = session.get(url, headers=headers, timeout=5)
except requests.exceptions.SSLError:
def syncMyAccounts(silent=False):
try:
all_acct = myaccounts.getAll()
trakt_acct = all_acct.get('trakt')
if getSetting('trakt.token') != trakt_acct.get('token'):
trakt_username = trakt_acct.get('username')
setSetting('trakt.username', trakt_username)
if trakt_username != '': setSetting('trakt.isauthed', 'true')
else: setSetting('trakt.isauthed', '')
setSetting('trakt.expires', trakt_acct.get('expires'))
setSetting('trakt.token', trakt_acct.get('token'))
setSetting('trakt.refresh', trakt_acct.get('refresh'))
ad_acct = all_acct.get('alldebrid')
if getSetting('alldebrid.username') != ad_acct.get('username'):
setSetting('alldebrid.token', ad_acct.get('token'))
# if getSetting('alldebrid.token') == '': setSetting('alldebrid.enable', 'false')
setSetting('alldebrid.username', ad_acct.get('username'))
pm_acct = all_acct.get('premiumize')
if getSetting('premiumize.username') != pm_acct.get('username'):
setSetting('premiumize.token', pm_acct.get('token'))
# if getSetting('premiumize.token') == '': setSetting('premiumize.enable', 'false')
setSetting('premiumize.username', pm_acct.get('username'))
rd_acct = all_acct.get(
'realdebrid'
) # token refresh 1hr expiry, Venom handles this internally
if getSetting('realdebrid.username') != rd_acct.get('username'):
setSetting('realdebrid.token', rd_acct.get('token'))
# if getSetting('realdebrid.token') == '': setSetting('realdebrid.enable', 'false')
setSetting('realdebrid.username', rd_acct.get('username'))
setSetting('realdebrid.client_id', rd_acct.get('client_id'))
setSetting('realdebrid.refresh', rd_acct.get('refresh'))
setSetting('realdebrid.secret', rd_acct.get('secret'))
fanart_acct = all_acct.get('fanart_tv')
if getSetting('fanart.tv.api.key') != fanart_acct.get('api_key'):
setSetting('fanart.tv.api.key', fanart_acct.get('api_key'))
tmdb_acct = all_acct.get('tmdb')
if getSetting('tmdb.api.key') != tmdb_acct.get('api_key'):
setSetting('tmdb.api.key', tmdb_acct.get('api_key'))
if getSetting('tmdb.username') != tmdb_acct.get('username'):
setSetting('tmdb.username', tmdb_acct.get('username'))
if getSetting('tmdb.password') != tmdb_acct.get('password'):
setSetting('tmdb.password', tmdb_acct.get('password'))
if getSetting('tmdb.session_id') != tmdb_acct.get('session_id'):
setSetting('tmdb.session_id', tmdb_acct.get('session_id'))
tvdb_acct = all_acct.get('tvdb')
if getSetting('tvdb.api.key') != tvdb_acct.get('api_key'):
setSetting('tvdb.api.key', tvdb_acct.get('api_key'))
imdb_acct = all_acct.get('imdb')
if getSetting('imdb.user') != imdb_acct.get('user'):
setSetting('imdb.user', imdb_acct.get('user'))
fu_acct = all_acct.get('furk')
if getSetting('furk.username') != fu_acct.get('username'):
setSetting('furk.username', fu_acct.get('username'))
setSetting('furk.password', fu_acct.get('password'))
if getSetting('furk.api') != fu_acct.get('api_key'):
setSetting('furk.api', fu_acct.get('api_key'))
if not silent: notification(message=32114)
except:
from resources.lib.modules import log_utils
log_utils.error()
def run(self, anime_id, ep_id, url, synop, start_date, start_year, gen,
epnum, epcount, eplink):
control.sleep(200)
self.anime_id = int(anime_id)
self.episode_id = int(ep_id)
item = control.item(path=url)
try:
c = cache.get(masterani.get_anime_details, 3, self.anime_id)
ctype = c['type']
ctype = 'movie' if int(ctype) is 2 else 'episode'
tvshowtitle = c['title']
poster = c['poster']
coverlink = "http://cdn.masterani.me/poster/" + poster
print coverlink
item.setArt({
'icon': coverlink,
'thumb': coverlink,
'poster': coverlink,
'tvshow.poster': coverlink,
'season.poster': coverlink
})
e = c['episodes'][self.episode_id]
title = e['info']['title']
season2options = [
': Season 2', ' Season 2', ': 2nd Season', ': Second Season',
' 2nd Season', ' Second Season', ': Part 2', ' Part 2',
': Part II', ' Part II'
]
season3options = [
': Season 3', ' Season 3', ': 3rd Season', ': Third Season',
' 3rd Season', ' Third Season', ': Part 3', ' Part 3',
': Part III', ' Part III'
]
season4options = [
': Season 4', ' Season 4', ': 4th Season', ': Fourth Season',
' 4th Season', ' Fourth Season', ': Part 4', ' Part 4',
': Part IV', ' Part IV'
]
season5options = [
': Season 5', ' Season 5', ': 5th Season', ': Fifth Season',
' 5th Season', ' Fifth Season', ': Part 5', ' Part 5',
': Part V', ' Part V'
]
season = 1
for option in season2options:
if option in tvshowtitle:
tvshowtitle = tvshowtitle.replace(option, "")
season = 2
for option in season3options:
if option in tvshowtitle:
tvshowtitle = tvshowtitle.replace(option, "")
season = 3
for option in season4options:
if option in tvshowtitle:
tvshowtitle = tvshowtitle.replace(option, "")
season = 4
for option in season5options:
if option in tvshowtitle:
tvshowtitle = tvshowtitle.replace(option, "")
season = 5
episode = e['info']['episode']
if ctype is 'video': title = c['title']
if title is None: title = "Episode %s" % episode
item.setInfo(type="video",
infoLabels={
'tvshowtitle': title,
'title': tvshowtitle,
'episode': int(episode),
'season': int(season),
'mediatype': ctype
})
#year = e['info']['aired'].split("-", 1)[0]
#plot = e['info']['description']
if 'movie' in ctype:
year = start_year
plot = synop
genre = gen
item.setInfo(type="video",
infoLabels={
'year': year,
'plot': plot,
'genre': genre
})
else:
year = e['info']['aired'].split("-", 1)[0]
plot = e['info']['description']
item.setInfo(type="video",
infoLabels={
'year': year,
'plot': plot,
'genre': gen
})
except:
pass
item.setProperty('Video', 'true')
item.setProperty('IsPlayable', 'true')
trackyesno = control.getSetting("track.yesno")
tracktype = control.getSetting("track.type")
if trackyesno == "true" and tracktype == 'Kitsu':
kitsu.KitsuScrobbler().kitsu_initScrobble(tvshowtitle, start_date,
epnum, epcount)
else:
pass
self.play(url, item)
self.playback_checker(self.anime_id, eplink)
pass
