def __init__(self):
self.base_url = 'http://webservice.fanart.tv/v3/%s/%s'
self.api_key = 'dfe6380e34f49f9b2b9518184922b49c'
self.client_key = tools.getSetting('key.fanart')
self.lang = tools.getSetting('fanart.lang')
self.languages = ['en', 'ja', '00', '']
self.headers = {'client-key': self.client_key, 'api-key': self.api_key}
self.art = {}
self.season = ''
def scrape(self, data):
tools.progressDialog.create(heading=self.heading,
line1=self.startingLineOne)
self.data = data
if 'episode' in self.data:
tools.progressDialog.update(
0,
line1=self.episodeLineOne %
(self.data['titles']['canon'], self.data['episode']))
else:
tools.progressDialog.update(0,
line1=self.movieLineOne %
self.data['titles']['canon'])
for provider in self.torrents:
if tools.getSetting(provider) == 'true':
self.remaining_providers.append(provider)
self.task_queue.put(self._scrape_torrent_provider, provider)
for provider in self.hosters:
if tools.getSetting(provider) == 'true':
self.remaining_providers.append(provider)
self.task_queue.put(self._scrape_hoster_provider, provider)
run_time = 0
max_time = int(tools.getSetting('scraping.timeout'))
start_time = time.time()
while len(self.remaining_providers
) > 0 and not tools.progressDialog.iscanceled(
) and run_time < max_time:
tools.progressDialog.update(
self._get_progress_percentage(start_time),
line2=self.LineTwo % self._get_provider_display_string(),
line3=self.LineThree % len(self.sources))
run_time += int(time.time() - start_time)
time.sleep(1)
# Check to see if we should break early if preemptive is on
if tools.getSetting('preemptive.enable') == 'true':
if self._check_preemptive():
break
tools.progressDialog.close()
if tools.getSetting('general.enablememes') == 'true':
self._run_memes()
self.sources = [value for key, value in self.sources.items()]
return self.sources
def __init__(self):
self.site = "https://graphql.anilist.co"
self.username = tools.getSetting('ani.user')
self.password = tools.getSetting('ani.pass')
self.user_id = tools.getSetting('ani.userid')
self.headers = {
'Authorization': 'Bearer ' + self.password,
'Content-Type': 'application/json',
'Accept': 'application/json',
}
def __init__(self):
self.site = 'https://myanimelist.net'
self.username = tools.getSetting('mal.user')
self.password = tools.getSetting('mal.pass')
self.logsessid = tools.getSetting('mal.logsess')
self.sessionid = tools.getSetting('mal.sessionid')
self.headers = {
'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8',
'Accept': '*/*',
'Cookie': 'MALHLOGSESSID=%s; MALSESSIONID=%s; is_logged_in=1; anime_update_advanced=1' % (self.logsessid, self.sessionid),
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) Gecko/20100101 \Firefox/56.0',
}
def getPlanned(self):
data_items = []
mal_anime = []
kitsu_ids = []
sort_status = tools.getSetting('planned.sort')
sort = tools.account_sort['mal'][sort_status] % '6'
resp = requests.get(self.site + '/animelist/%s?%s' %
(self.username, sort))
soup = BeautifulSoup(resp.content, 'html.parser')
items = soup.find_all('table', attrs={'class': 'list-table'})
for a in items:
data_items = str(a.get('data-items'))
data_items = data_items.replace('"', '"')
data_items = json.loads(data_items)
for a in data_items:
mal_anime.append(a['anime_id'])
kitsu_ids = Mappings().get_list('mal', mal_anime, 'kitsu')
anime_list = kitsu_api.KitsuBrowser().getListById(kitsu_ids)
anime_list = tools.sort_anime_by_id(anime_list, kitsu_ids)
tools.log(anime_list, 'error') #Should print list of anime
if '-' in sort_status:
anime_list = sorted(anime_list, reverse=True)
return anime_list
def getPlanned(self):
status = 'planned'
sort_status = tools.getSetting('planned.sort')
sort = tools.account_sort['kitsu'][sort_status]
params = {
"fields[anime]":
"slug,posterImage,coverImage,canonicalTitle,titles,synopsis,subtype,startDate,status,averageRating,popularityRank,ratingRank,episodeCount,episodeLength",
"fields[users]": "id",
"filter[user_id]": self.userid,
"filter[kind]": "anime",
"filter[status]": status,
"include": "anime,user,mediaReaction",
"page[limit]": "500",
"page[offset]": "0",
"sort": sort
}
anime = requests.get('https://kitsu.io/api/edge/library-entries',
headers=self.headers,
params=params)
data = json.loads(anime.content)
try:
info = data['included'][1:]
except:
info = []
extracted_items = kitsu_api.KitsuBrowser().extract_items(info)
sortedItems = tools.sort_anime_by_json(extracted_items, info)
return sortedItems
def __init__(self):
self.api_path = 'https://kitsu.io/api/edge'
self.oauth_path = 'https://kitsu.io/api/oauth'
self.client_id = 'dd031b32d2f56c990b1425efe6c42ad847e7fe3ab46bf1299f05ecd856bdb7dd'
self.client_secret = '54d7307928f63414defd96399fc31ba847961ceaecef3a5fd93144e960c0e151'
self.headers = {
'Accept': 'application/vnd.api+json',
'Content-Type': 'application/vnd.api+json'
}
if tools.getSetting('kitsu.access') is not '' and tools.getSetting(
'kitsu.18plus') is not 'false':
self.headers['Authorization'] = 'Bearer %s' % tools.getSetting(
'kitsu.access')
def getHold(self):
data_items = []
mal_anime = []
kitsu_ids = []
sort_status = tools.getSetting('hold.sort')
sort = account_info.account_sort['mal'][sort_status] % '3'
resp = requests.get(self.site + '/animelist/%s?%s' %
(self.username, sort))
items = re.findall(r'<table class="list-table" data-items="(.*?)">',
str(resp.content))[0]
data_items = items.replace('"', '"')
data_items = json.loads(data_items)
for a in data_items:
mal_anime.append({
'id': a['anime_id'],
'status': 'onhold',
'progress': a['num_watched_episodes']
})
mal_data = MyAnimeList().get_data(mal_anime)
if '-' in sort_status:
mal_data = sorted(mal_data, reverse=True)
return mal_data
def _try_set_token(self):
token = tools.getSetting('ws.token')
if token == '':
token = self._do_login()
self._session.set_token(token)
tools.setSetting('ws.token', token)
self._is_authorized = True
def __init__(self):
self.api_search = '/api/v2/media/search?options=summary&q=%s'
self.api_series = '/api/v2/media/series?series={}'
self.api_source = '/api/v2/media/stream?code%s%s'
self._login_url = '/api/v2/users/login'
self.source_dict = {
'ka': 'KissAnime',
'cr': 'Crunchyroll',
'fa': 'Funimation'
}
self._user_name = tools.getSetting('ws.username')
self._password = tools.getSetting('ws.password')
self._session = WonderfulSession()
if not self._user_name == '' or not self._password == '':
self._try_set_token()
self._is_authorized = False
def __init__(self):
self.kitsu_access = tools.getSetting('kitsu.access')
self.kitsu_user = tools.getSetting('kitsu.user')
self.mal_access = tools.getSetting('mal.sessionid')
self.mal_user = tools.getSetting('mal.user')
self.ani_access = tools.getSetting('ani.userid')
self.ani_user = tools.getSetting('ani.user')
self.last_watched = tools.getSetting('anime.lastwatched')
def select(self, source_select, audio_type, sources):
if sources is None:
tools.showDialog.notification(tools.addonName, 'No sources found.')
return None
sortedSources = sorting.SortSources().sort(sources, audio_type)
if len(sortedSources) == 0:
tools.showDialog.notification(
tools.addonName, 'No sources available on current settings.')
return None
streamLink = ''
settingPlayback = tools.getSetting('play.type')
sourceSelect = False
if settingPlayback == 'Source Select':
sourceSelect = True
if source_select == True:
sourceSelect = True
if sourceSelect == True:
list = []
for a in sortedSources:
list.append(
'%s | %s | %s | %s' %
(a['quality'], a['site'], a['source'], a['audio_type']))
while self.working_link is False:
selection = tools.showDialog.select(
tools.addonName + ': Source Select', list)
if selection == -1:
return
streamLink = sortedSources[selection]
self.resolve_link(streamLink)
else:
index = 0
while self.working_link is False:
streamLink = sortedSources[index]
self.resolve_link(streamLink)
if self.working_link is False:
index += 1
return {
'url': self.stream_link,
'adaptive': streamLink['adaptive'],
'subtitles': self.subtitles_link
}
def __init__(self):
# Base Variables
self.hosters = providers.get_hosters()
self.torrents = providers.get_torrents()
self.remaining_providers = []
self.sources = {}
self.data = {}
self.task_queue = ThreadPool()
# Scraping Strings
self.heading = tools.addonName + ': Scraping'
self.startingLineOne = 'Starting Scraping...'
self.hosterLineOne = 'Hosters Scraping...'
self.torrentLineOne = 'Torrents Scraping...'
self.episodeLineOne = 'Scraping %s - Episode %s'
self.movieLineOne = 'Scraping %s'
self.LineTwo = 'Remaining Providers: %s'
self.LineThree = 'Sources Found: %s'
# Pre-emptive Settings
self.preemp_minimum_sources = int(tools.getSetting('preemptive.limit'))
self.preemp_resolution = int(tools.getSetting('preemptive.resolution'))
self.preemptive_source_type = tools.getSetting('preemptive.sourcetype')
self.preemptive_audiotype = tools.getSetting('preemptive.audiotype')
def list_builder_alt(self, anime, site):
for a in anime:
name_choice = tools.getSetting('show.titles')
name = a['titles']['base']
if name_choice == 'English':
name = a['titles']['english']
elif name_choice == 'Kanji':
name = a['titles']['japanese']
if name is None:
name = a['titles']['canon']
if a['titles']['japanese'] is not None:
originaltitle = a['titles']['japanese'].encode('utf-8')
else:
originaltitle = ''
duration = 1
item = {'plot': a['plot'],
'genre': a['genres'],
'year': a['year'],
'originaltitle': originaltitle,
'duration': str(duration*60),
'country': 'Japan'}
if a['subtype'] == 'Movie':
action = 'play_anime&get_anime_info=true&site=%s' % site
folder = False
playable = True
cm = [('Source Select', 'PlayMedia(%s?action=play_anime&source_select=true&actionArgs=%s)' % (sysaddon, tools.quote(json.dumps(a, sort_keys=True))))]
item['mediatype'] = 'movie'
item['title'] = name
else:
action = 'episode_list&get_anime_info=true&site=%s' % site
folder = True
playable = False
cm = []
item['mediatype'] = 'tvshow'
item['tvshowtitle'] = name
item['status'] = a['status']
args = tools.quote(json.dumps(a, sort_keys=True))
art = {'poster': a['picture']}
tools.addDirectoryItem(name, action, item, art, cm=cm, isFolder=folder, isPlayable=playable, actionArgs=args)
def __init__(self):
#Audio
self.audio_exclusion = tools.getSetting('sort.exclusion')
self.audio_preference = tools.getSetting('sort.audio')
#Quality
self.minimum_quality = tools.getSetting('sort.minq')
self.maximum_quality = tools.getSetting('sort.maxq')
#Scrapers
self.legitimate_preference = tools.getSetting('legit.prefer')
self.site_preference = tools.getSetting('site.prefer')
self.sources = []
def __init__(self):
self.client_id = 'dd031b32d2f56c990b1425efe6c42ad847e7fe3ab46bf1299f05ecd856bdb7dd'
self.client_secret = '54d7307928f63414defd96399fc31ba847961ceaecef3a5fd93144e960c0e151'
self.oauth = 'https://kitsu.io/api/oauth'
self.headers = {'Accept': 'application/vnd.api+json',
'Content-Type': 'application/vnd.api+json'}
self.username = tools.getSetting('kitsu.user')
self.email = tools.getSetting('kitsu.email')
self.password = tools.getSetting('kitsu.pass')
self.access = tools.getSetting('kitsu.access')
self.refresh = tools.getSetting('kitsu.refresh')
self.userid = tools.getSetting('kitsu.userid')
def top_upcoming(self, page):
anime = []
sort_status = tools.getSetting('upcoming.sort')
sort = tools.menu_sort[sort_status]
resp = cache.hummingCache().cacheCheck(
Backend().request,
24,
'/anime?filter[status]=upcoming&sort=%s' % sort,
page=page)
load = json.loads(resp)
data = load['data']
for a in data:
self.remaining_threads.append(a['attributes']['canonicalTitle'])
self.thread_list.put(self.extract, a)
while len(self.remaining_threads) > 0:
time.sleep(1)
sortedItems = tools.sort_anime_by_json(self.extractedItems, data)
return sortedItems
def episode_list_builder(self, show, episode_list, progress=False, smartPlay=False, sourceSelect=False, audioType=False):
reverse = tools.getSetting('ep.reverse')
shownum = tools.getSetting('ep.number')
ep_list = episode_list
if reverse == 'true':
ep_list = sorted(episode_list, key=lambda x: int(x['episodeNumber']), reverse=True)
else:
ep_list = sorted(episode_list, key=lambda x: int(x['episodeNumber']), reverse=False)
index = 0
smartplay_list = []
try: progress = show['account_info']['progress']
except: progress = 0
for a in ep_list:
name_choice = tools.getSetting('ep.titles')
name = a['episode_title']
if name_choice == 'English':
name = a['alt_titles']['english']
elif name_choice == 'Romaji':
name = a['alt_titles']['romaji']
elif name_choice == 'Kanji':
name = a['alt_titles']['kanji'].encode('utf-8')
if name is None:
name = 'Episode %s' % str(a['episodeNumber'])
if shownum == 'true':
name = str(a['episodeNumber']) + ' - ' + name
action = 'play_anime'
folder = False
playable = True
if sourceSelect != False:
action += '&source_select=true'
if audioType != False:
action += '&audio_type=%s' % audioType
try: duration = str(show['episode_length']*60)
except: duration = '22'
item = {'plot': a['episodePlot'],
'premiered': a['airdate'],
'year': a['year'],
'mediatype': 'episode',
'duration': duration,
'episode': int(a['episodeNumber'])}
if int(a['episodeNumber']) <= progress:
item['playcount'] = 1
else:
item['playcount'] = 0
poster = a['thumbnail']
if poster is None:
poster = show['art']['poster']
art = {'poster': poster,
'fanart': show['art']['fanart']}
args = dict(show)
args.update(a)
if tools.getSetting('smartplay.enable') == 'true' and smartPlay == False:
cm = []
else:
source_select_cm = ('Source Select', 'PlayMedia(%s?action=play_anime&source_select=true&actionArgs=%s)' % (sysaddon, tools.quote(json.dumps(args, sort_keys=True))))
play_sub_cm = ('Play Subbed', 'PlayMedia(%s?action=play_anime&audio_type=bub&actionArgs=%s)' % (sysaddon, tools.quote(json.dumps(args, sort_keys=True))))
play_dub_cm = ('Play Dubbed', 'PlayMedia(%s?action=play_anime&audio_type=sub&actionArgs=%s)' % (sysaddon, tools.quote(json.dumps(args, sort_keys=True))))
cm = [source_select_cm, play_sub_cm, play_dub_cm]
args = tools.quote(json.dumps(args, sort_keys=True))
smartplay_list.append(tools.addDirectoryItem(name, action, item, art, cm=cm, isFolder=folder, isPlayable=playable, actionArgs=args, bulk_add=True))
if smartPlay == True:
return smartplay_list
else:
tools.addMenuItems(syshandle, smartplay_list, len(smartplay_list))
def add_last_watched(self):
a = kitsu_api.KitsuBrowser().getShow(self.last_watched)
name_choice = tools.getSetting('show.titles')
name = a['titles']['canon']
if name_choice == 'English':
name = a['titles']['english']
elif name_choice == 'Romaji':
name = a['titles']['romaji']
elif name_choice == 'Kanji':
name = a['titles']['kanji'].encode('utf-8')
if name is None:
name = a['titles']['canon']
name = 'Last Watched: %s' % name
duration = 1
status = 'ended'
try:
duration = int(a['episode_count'])*int(a['episode_length'])
except:
try:
duration = int(a['episode_length'])
except:
duration = 0
try:
if a['status'] == 'current':
status = 'returning series'
elif a['status'] == 'finished':
status = 'ended'
else:
status = 'in production'
except:
status = 'in production'
originaltitle = ''
if a['titles']['kanji'] is not None:
originaltitle = a['titles']['kanji'].encode('utf-8')
else:
originaltitle = ''
item = {'plot': a['plot'],
'genre': ', '.join(a['genres']),
'year': a['year'],
'premiered': a['start_date'],
'originaltitle': originaltitle,
'userrating': a['average_rating'],
'mpaa': a['age_rating'],
'duration': str(duration*60),
'country': 'Japan'}
if a['subtype'] == 'movie':
action = 'play_anime'
folder = False
playable = True
cm = []
item['mediatype'] = 'movie'
item['title'] = name
else:
action = 'episode_list'
folder = True
playable = False
cm = []
item['mediatype'] = 'tvshow'
item['tvshowtitle'] = name
item['status'] = status
if 'youtube_trailer' in a:
item['trailer'] = tools.youtube_url % a['youtube_trailer']
args = tools.quote(json.dumps(a, sort_keys=True))
tools.addDirectoryItem(name, action, item, a['art'], cm=cm, isFolder=folder, isPlayable=playable, actionArgs=args)
def getPlanned(self):
anilist_items = []
kitsu_ids = []
status = 'PLANNING'
sort_status = tools.getSetting('planned.sort')
sort = account_info.account_sort['anilist'][sort_status]
query = '''
query ($userId: Int, $userName: String, $status: MediaListStatus, $type: MediaType, $sort: [MediaListSort]) {
MediaListCollection(userId: $userId, userName: $userName, status: $status, type: $type, sort: $sort) {
lists {
entries {
...mediaListEntry
}
}
}
}
fragment mediaListEntry on MediaList {
id
mediaId
status
progress
customLists
media {
id
title {
romaji
english
native
}
format
episodes
status
description
seasonYear
genres
coverImage {
extraLarge
}
}
}
'''
variables = {
'userId': int(self.user_id),
'username': self.username,
'status': status,
'type': 'ANIME',
'sort': [sort]
}
resp = requests.post(self.site,
json={
'query': query,
'variables': variables
})
results = json.loads(resp.content)
if 'errors' in results:
return
try:
entries = results['data']['MediaListCollection']['lists'][0][
'entries']
except:
entries = []
for a in entries:
anilist_items.append({
'id': a['media']['id'],
'status': 'current',
'progress': a['progress'],
'media': a['media']
})
anilist_data = Anilist().get_data(anilist_items)
if '-' in sort_status:
anilist_data = sorted(anilist_data, reverse=True)
return anilist_data
def __init__(self):
self.site = 'https://myanimelist.net'
self.username = tools.getSetting('mal.user')
def extract(self, item):
dict = {}
attributes = item['attributes']
dict['id'] = item['id']
dict['titles'] = {}
try:
dict['titles']['canon'] = attributes['canonicalTitle']
except:
dict['titles']['canon'] = None
try:
dict['titles']['english'] = attributes['titles']['en']
except:
try:
dict['titles']['english'] = attributes['titles']['en_us']
except:
dict['titles']['english'] = None
try:
dict['titles']['romaji'] = attributes['titles']['en_jp']
except:
dict['titles']['romaji'] = None
try:
dict['titles']['kanji'] = attributes['titles']['ja_jp']
except:
dict['titles']['kanji'] = None
try:
dict['abbreviated_titles'] = attributes['abbreviatedTitles']
except:
dict['abbreviated_titles'] = None
year = ''
try:
year = attributes['startDate'][:4]
except:
year = attributes['tba']
dict['mappings'] = cache.hummingCache().cacheCheck(
mappings.Mappings().get, 24, dict['id'], attributes['subtype'],
year)
try:
dict['mal_titles'] = cache.hummingCache().cacheCheck(
Other().getMALTitles, 24, dict['mappings'])
except:
dict['mal_titles'] = {}
try:
dict['plot'] = attributes['synopsis']
except:
sict['plot'] = None
try:
dict['year'] = attributes['startDate'][:4]
except:
dict['year'] = None
try:
dict['start_date'] = attributes['startDate']
except:
dict['start_date'] = None
try:
dict['end_date'] = attributes['endDate']
except:
dict['end_date'] = None
try:
dict['popularity_rank'] = attributes['popularityRank']
except:
dict['popularity_rank'] = None
try:
dict['rating_rank'] = attributes['ratingRank']
except:
dict['rating_rank'] = None
try:
dict['average_rating'] = attributes['averageRating']
except:
dict['average_rating'] = None
try:
dict['age_rating'] = attributes['ageRating']
except:
dict['age_rating'] = None
try:
dict['age_guide'] = attributes['ageRatingGuide']
except:
dict['age_guide'] = None
try:
dict['subtype'] = attributes['subtype']
except:
dict['subtype'] = None
try:
dict['status'] = attributes['status']
except:
dict['status'] = None
try:
dict['episode_count'] = attributes['episodeCount']
except:
dict['episode_count'] = None
try:
dict['episode_length'] = attributes['episodeLength']
except:
dict['episode_length'] = None
try:
dict['youtube_trailer'] = attributes['youtubeVideoId']
except:
dict['youtube_trailer'] = None
try:
dict['nsfw'] = attributes['nsfw']
except:
dict['nsfw'] = None
try:
dict['genres'] = Other().get_genres(item['id'])
except:
dict['genres'] = []
try:
dict['franchise_name'] = tools.get_franchise_name(dict['titles'])
except:
dict['franchise_name'] = None
try:
dict['season'] = tools.get_season_number(dict['titles'])
except:
dict['season'] = 1
qualities = ['original', 'large', 'medium', 'small', 'tiny']
posterCheck = attributes['posterImage']
fanartCheck = attributes['coverImage']
poster = ''
fanart = ''
if posterCheck is not None:
for a in qualities:
if poster == '':
try:
poster = posterCheck[a]
except:
poster = ''
if fanartCheck is not None:
for a in qualities:
if fanart == '':
try:
fanart = fanartCheck[a]
except:
fanart = ''
dict['art'] = {}
if not tools.getSetting('key.fanart') == '' and tools.getSetting(
'art.fanart') == 'true':
from resources.lib.modules import fanarttv
if dict['subtype'] == 'movie':
try:
dict['art'] = cache.hummingCache().cacheCheck(
fanarttv.FanartTV().get, 24, dict['mappings'],
dict['subtype'], tools.getSetting('fanart.lang'))
except:
pass
else:
try:
dict['art'] = cache.hummingCache().cacheCheck(
fanarttv.FanartTV().get,
24,
dict['mappings'],
dict['subtype'],
tools.getSetting('fanart.lang'),
season=dict['season'])
except:
pass
dict['art']['poster'] = dict['art'].get('poster', poster)
dict['art']['fanart'] = dict['art'].get('fanart', fanart)
else:
try:
dict['art']['poster'] = poster
except:
dict['art']['poster'] = None
try:
dict['art']['fanart'] = fanart
except:
dict['art']['fanart'] = None
self.remaining_threads.remove(item['attributes']['canonicalTitle'])
self.extractedItems.append(dict)
def search(self,
title=None,
year=None,
rating=None,
season=None,
subtype=None,
genre=None,
page=1):
filters = []
if title != None and title != '':
filters.append('filter[text]=%s' % title)
if season == None or season == '':
if year != None and year != '':
filters.append(
'filter[season]=winter,spring,summer,fall&filter[seasonYear]=%s'
% year)
if season != None and season != '':
if year == None or year == '':
filters.append('filter[season]=%s' % season)
if year != None and year != '':
filters.append('filter[season]=%s&filter[seasonYear]=%s' %
(season, year))
if rating != None and rating != '':
filters.append('filter[ageRating]=%s' % rating)
if subtype != None and subtype != '':
filters.append('filter[subtype]=%s' % subtype)
if genre != None and genre != '':
filters.append('filter[categories]=%s' % genre)
#for a in filters:
#if a == 'filter[text]=None':
#filters.remove(a)
filter_string = '&'.join(filters)
sort_status = tools.getSetting('search.sort')
sort_string = tools.menu_sort[sort_status]
if title == None or title == '':
request = '/anime?' + filter_string + '&sort=%s' % sort_string
else:
request = '/anime?' + filter_string
anime = []
resp = cache.hummingCache().cacheCheck(Backend().request,
24,
request,
page=page)
load = json.loads(resp)
data = load['data']
for a in data:
self.remaining_threads.append(a['attributes']['canonicalTitle'])
self.thread_list.put(self.extract, a)
while len(self.remaining_threads) > 0:
time.sleep(1)
sortedItems = tools.sort_anime_by_json(self.extractedItems, data)
return sortedItems
def play(self, data, args):
#Set Up Metadata
info = json.loads(tools.unquote(args))
try:
ep_num = info['episodeNumber']
genre_string = ', '.join(info['genres'])
metadata = {
'title': info['episode_title'],
'tvshowtitle': info['titles']['canon'],
'season': info['seasonNumber'],
'episode': info['episodeNumber'],
'genre': genre_string,
'year': info['airdate'][:4],
'plot': info['episodePlot']
}
except:
genre_string = ', '.join(info['genres'])
metadata = {
'title': info['titles']['canon'],
'genre': genre_string,
'year': info['year'],
'plot': info['plot']
}
item = tools.menuItem(path=data['url'])
item.setInfo(type='video', infoLabels=metadata)
item.setArt(info['art'])
item.setProperty('Video', 'true')
item.setProperty('isPlayable', 'true')
if data['adaptive'] != False and 'auengine' not in data['url']:
item.setProperty('inputstreamaddon', 'inputstream.adaptive')
item.setProperty('inputstream.adaptive.manifest_type',
data['adaptive'])
tools.setSetting('anime.lastwatched', str(info['id']))
try:
if int(info['episodeNumber']) == int(info['episode_count']):
kitsu_status = 'completed'
mal_status = 2
anilist_status = 'COMPLETED'
else:
kitsu_status = 'current'
mal_status = 1
anilist_status = 'CURRENT'
except:
kitsu_status = 'current'
mal_status = 1
anilist_status = 'CURRENT'
try:
if tools.getSetting('kitsu.access') != '' and tools.getSetting(
'kitsu.track') == 'true':
accounts.Kitsu().track(info['id'], info['episodeNumber'],
kitsu_status)
if tools.getSetting('mal.sessionid') != '' and tools.getSetting(
'mal.track') == 'true':
accounts.Mal().track(info['id'], info['episodeNumber'],
mal_status)
if tools.getSetting('ani.userid') != '' and tools.getSetting(
'ani.track') == 'true':
accounts.Anilist().track(info['id'], info['episodeNumber'],
anilist_status)
except:
if tools.getSetting('kitsu.access') != '' and tools.getSetting(
'kitsu.track') == 'true':
accounts.Kitsu().track(info['id'], '1', 'current')
if tools.getSetting('mal.sessionid') != '' and tools.getSetting(
'mal.track') == 'true':
accounts.Mal().track(info['id'], '1', 2)
if tools.getSetting('ani.userid') != '' and tools.getSetting(
'ani.track') == 'true':
accounts.Anilist().track(info['id'], '1', 'COMPLETED')
tools.resolvedUrl(syshandle, True, item)
if data['subtitles'] != None:
subtitle_link = data['subtitles']
sub_file_ex = subtitle_link.split('.')
sub_file_ex = sub_file_ex[int(len(sub_file_ex) - 1)]
#subtitle_location = os.path.join(tools.subtitle_file, 'temp.%s' % sub_file_ex)
subtitle_location = tools.subtitle_file
if os.path.exists(subtitle_location):
os.remove(subtitle_location)
file = requests.get(subtitle_link)
sub_data = file.text
sub_data = sub_data.encode('utf-8')
with open(subtitle_location, 'wb') as code:
code.write(sub_data)
tools.sleep(3000)
tools.player().setSubtitles(subtitle_location)
def getHold(self):
anilist_items = []
kitsu_ids = []
status = 'PAUSED'
sort_status = tools.getSetting('hold.sort')
sort = tools.account_sort['anilist'][sort_status]
query = '''
query ($userId: Int, $userName: String, $status: MediaListStatus, $type: MediaType, $sort: [MediaListSort]) {
MediaListCollection(userId: $userId, userName: $userName, status: $status, type: $type, sort: $sort) {
lists {
entries {
...mediaListEntry
}
}
}
}
fragment mediaListEntry on MediaList {
id
mediaId
status
progress
customLists
media {
id
title {
userPreferred
}
coverImage {
extraLarge
}
status
episodes
}
}
'''
variables = {
'userId': int(self.user_id),
'username': self.username,
'status': status,
'type': 'ANIME',
'sort': [sort]
}
resp = requests.post(self.site,
json={
'query': query,
'variables': variables
})
results = json.loads(resp.content)
if results.has_key('errors'):
return
try:
entries = results['data']['MediaListCollection']['lists'][0][
'entries']
except:
entries = []
for a in entries:
anilist_items.append(a['media']['id'])
kitsu_ids = Mappings.get_list('anilist', anilist_items, 'kitsu')
anime_list = kitsu_api.KitsuBrowser().getListById(kitsu_ids)
tools.log(anime_list, 'error') #Should print list of anime
anime_list = tools.sort_anime_by_id(anime_list, kitsu_ids)
tools.log(anime_list, 'error') #Should print list of anime
if '-' in sort_status:
anime_list = sorted(anime_list, reverse=True)
return anime_list
from resources.lib.menus import anime
anime.List().episode_list(actionArgs, page, progress_info)
##PLAY
if action == 'play_anime':
#Convert MAL/AniList to Kitsu item.
if get_kitsu_item == True:
from resources.lib.modules import accounts
from resources.lib.modules import kitsu_api
args = json.loads(tools.unquote(actionArgs))
kitsu_id = accounts.Mappings().get(site, args['id'], 'kitsu')
extracted_info = kitsu_api.KitsuBrowser().getListById([kitsu_id])[0]
actionArgs = tools.quote(json.dumps(extracted_info))
#Smartplay
if tools.getSetting('smartplay.enable') == 'true' and smart_play == False:
from resources.lib.modules import smartplay
smartplay.SmartPlay().smartPlay(actionArgs, source_select, audio_type)
else:
tools.closeBusyDialog()
#Scrape
from resources.lib.modules import sources
animeSources = sources.GetSources().scrape(actionArgs)
#Source Selection
from resources.lib.modules import sourceselect
episode_link = sourceselect.Selection().select(source_select,
audio_type,
animeSources)
if not episode_link is None:
#Play
from resources.lib.modules import player
