def genre_get(self, genre, page):
from resources.lib.modules import kitsu_api
if genre is None:
genres = kitsu_api.KitsuBrowser().all_categories()
genres = sorted(genres, key=lambda a: (a['name']))
genre_display_list = []
for a in genres:
genre_display_list.append(a['name'])
genre_multiselect = tools.showDialog.multiselect(
tools.addonName + ": Genre Selection", genre_display_list)
if genre_multiselect is None: return
genre_selection = []
for selection in genre_multiselect:
genre_selection.append(genres[selection]['slug'])
genre_string = ','.join(genre_selection)
else:
genre_string = genre
anime = kitsu_api.KitsuBrowser().search(genre=genre_string, page=page)
self.list_builder(anime)
if len(anime) == 20:
tools.addDirectoryItem(
'Next Page...',
'genre_get&genre=%s&page=%s' % (genre_string, str(page + 1)),
None, None)
tools.closeDirectory('tvshows')
def season_get(self, season, page):
if season is None:
seasons = [
{'name': 'Winter', 'slug': 'winter'},
{'name': 'Spring', 'slug': 'spring'},
{'name': 'Summer', 'slug': 'summer'},
{'name': 'Fall', 'slug': 'fall'}
]
season_display_list = []
for a in seasons:
season_display_list.append(a['name'])
season_multiselect = tools.showDialog.multiselect(tools.addonName + ": Season Selection", season_display_list)
if season_multiselect is None: return
season_selection = []
for selection in season_multiselect:
season_selection.append(seasons[selection]['slug'])
season_string = ','.join(season_selection)
else:
season_string = season
anime = kitsu_api.KitsuBrowser().search(season=season_string, page=page)
self.list_builder(anime)
if len(anime) == 20:
tools.addDirectoryItem('Next Page...', 'season_get&season=%s&page=%s' % (season_string, str(page+1)), None, None)
tools.closeDirectory('tvshows')
def rating_get(self, rating, page):
if rating is None:
ratings = [{
'name': 'General Audiences',
'slug': 'G'
}, {
'name': 'Parental Guidence',
'slug': 'PG'
}, {
'name': 'Restricted',
'slug': 'R'
}]
rating_display_list = []
for a in ratings:
rating_display_list.append(a['name'])
rating_multiselect = tools.showDialog.multiselect(
tools.addonName + ": Rating Selection", rating_display_list)
if rating_multiselect is None: return
rating_selection = []
for selection in rating_multiselect:
rating_selection.append(ratings[selection]['slug'])
rating_string = ','.join(rating_selection)
else:
rating_string = rating
anime = kitsu_api.KitsuBrowser().search(rating=rating_string,
page=page)
self.list_builder(anime)
if len(anime) == 20:
tools.addDirectoryItem(
'Next Page...', 'rating_get&rating=%s&page=%s' %
(rating_string, str(page + 1)), None, None)
tools.closeDirectory('tvshows')
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 year_get(self, year, page):
if year is None:
from datetime import datetime
current_year = int(datetime.today().year)
years = []
for a in range(1907, current_year + 1):
years.append(a)
years = sorted(years, reverse=True)
year_display_list = []
for a in years:
year_display_list.append(str(a))
year_multiselect = tools.showDialog.multiselect(tools.addonName + ": Year Selection", year_display_list)
if year_multiselect is None: return
year_selection = []
for selection in year_multiselect:
year_selection.append(year_display_list[selection])
year_string = ','.join(year_selection)
else:
year_string = year
anime = kitsu_api.KitsuBrowser().search(year=year_string, page=page)
self.list_builder(anime)
if len(anime) == 20:
tools.addDirectoryItem('Next Page...', 'year_get&year=%s&page=%s' % (year_string, str(page+1)), None, None)
tools.closeDirectory('tvshows')
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 franchise(self, args, page):
show_info = json.loads(tools.unquote(args))
anime = kitsu_api.KitsuBrowser().franchise(id=show_info['id'])
self.list_builder(anime)
if len(anime) == 20:
tools.addDirectoryItem('Next Page...', 'franchise&page=%s' % str(page+1), None, None, actionArgs=tools.quote(tools.unquote(args)))
tools.closeDirectory('episodes')
def subtype_get(self, subtype, page):
if subtype is None:
subtypes = [
{'name': 'TV Shows', 'slug': 'tv'},
{'name': 'Movies', 'slug': 'movie'},
{'name': 'OVA', 'slug': 'ova'},
{'name': 'ONA', 'slug': 'ona'},
{'name': 'Specials', 'slug': 'special'}
]
subtype_display_list = []
for a in subtypes:
subtype_display_list.append(a['name'])
subtype_multiselect = tools.showDialog.multiselect(tools.addonName + ": Subtype Selection", subtype_display_list)
if subtype_multiselect is None: return
subtype_selection = []
for selection in subtype_multiselect:
subtype_selection.append(subtypes[selection]['slug'])
subtype_string = ','.join(subtype_selection)
else:
subtype_string = subtype
anime = kitsu_api.KitsuBrowser().search(subtype=subtype_string, page=page)
self.list_builder(anime)
if len(anime) == 20:
tools.addDirectoryItem('Next Page...', 'subtype_get&subtype=%s&page=%s' % (subtype_string, str(page+1)), None, None)
tools.closeDirectory('tvshows')
def top_upcoming(self, page):
anime = kitsu_api.KitsuBrowser().top_upcoming(page)
self.list_builder(anime)
if len(anime) == 20:
tools.addDirectoryItem('Next Page...',
'upcoming&page=%s' % str(page + 1), None,
None)
tools.closeDirectory('tvshows')
def buildPlaylist(self):
show = kitsu_api.KitsuBrowser().getShow(
self.actionArgs['mappings']['kitsu'])
episodes = kitsu_api.KitsuBrowser().all_episodes(
self.actionArgs['mappings']['kitsu'])
for a in episodes:
if int(a['episodeNumber']) >= int(
self.actionArgs['episodeNumber']):
self.episodes.append(a)
list_items = anime.List().episode_list_builder(show, self.episodes,
True, self.sourceSelect,
self.audioType)
for a in list_items:
tools.playList.add(url=a[0] + '&smartplay=true', listitem=a[1])
def highest_rated(self, page):
anime = kitsu_api.KitsuBrowser().highest_rated(page)
self.list_builder(anime)
if len(anime) == 20:
tools.addDirectoryItem('Next Page...',
'highest_rated&page=%s' % str(page + 1),
None, None)
tools.closeDirectory('tvshows')
def most_popular(self, page):
anime = kitsu_api.KitsuBrowser().most_popular(page)
self.list_builder(anime)
if len(anime) == 20:
tools.addDirectoryItem('Next Page...',
'most_popular&page=%s' % (page + 1), None,
None)
tools.closeDirectory('tvshows')
def genre_list(self):
from resources.lib.modules import kitsu_api
genres = kitsu_api.KitsuBrowser().all_categories()
genres = sorted(genres, key= lambda a: (a['name']))
tools.addDirectoryItem('Multi Select...', 'genre_get', None, None)
for a in genres:
tools.addDirectoryItem(a['name'], 'genre_get&genre=%s' % a['slug'], None, None)
tools.closeDirectory('addons')
def top_by_season(self, season, year, page):
anime = kitsu_api.KitsuBrowser().search(season=season,
year=year,
page=page)
self.list_builder(anime)
if len(anime) == 20:
tools.addDirectoryItem(
'Next Page...', 'top_by_season&season=%s&year=%s&page=%s' %
(season, year, str(page + 1)), None, None)
tools.closeDirectory('tvshows')
def title_search(self, query, page):
if query is None:
k = tools.showKeyboard('', 'Search Anime')
k.doModal()
search_query = (k.getText() if k.isConfirmed() else None)
if search_query == None or query == '':
return
else:
search_query = query
anime = kitsu_api.KitsuBrowser().search(title=search_query, subtype='TV,movie,ova,ona,special', page=page)
self.list_builder(anime)
if len(anime) == 20:
tools.addDirectoryItem('Next Page...', 'title_search&title=%s&page=%s' % (search_query, str(page+1)), None, None)
tools.closeDirectory('tvshows')
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)
from resources.lib.menus import anime
anime.List().franchise(actionArgs, page)
##EPISODES STUFF
if action == 'episode_list':
progress_info = ''
#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))
progress_info = args['account_info']
tools.log(progress_info, 'error')
kitsu_id = accounts.Mappings().get(site, args['id'], 'kitsu')
extracted_info = kitsu_api.KitsuBrowser().getListById(
[kitsu_id], progress=progress_info)[0]
tools.log(extracted_info, 'error')
actionArgs = tools.quote(json.dumps(extracted_info))
else:
args = json.loads(tools.unquote(actionArgs))
progress_info = args['account_info']
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
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
def trending(self):
anime = kitsu_api.KitsuBrowser().trending()
self.list_builder(anime)
tools.closeDirectory('tvshows')
def episode_list(self, args, page, progress):
show_info = json.loads(tools.unquote(args))
episodes = kitsu_api.KitsuBrowser().all_episodes(id=show_info['id'])
self.episode_list_builder(show_info, episodes, progress)
tools.closeDirectory('episodes')
def advanced_search(self, year, rating, season, subtype, genre, page):
items_preselect = ['Years', 'Ratings', 'Seasons', 'Subtypes', 'Genres']
items_selected = ['Years', 'Ratings', 'Seasons', 'Subtypes', 'Genres', 'Search']
years = []
ratings = []
seasons = []
subtypes = []
genres = []
select = ''
year_string = year
rating_string = rating
season_string = season
subtype_string = subtype
genre_string = genre
if year is None and rating is None and season is None and subtype is None and genre is None:
while select != 'Search':
if years == [] and ratings == [] and seasons == [] and subtypes == [] and genres == []:
select_area = tools.showDialog.select(tools.addonName + ': Advanced Search', items_preselect)
else:
select_area = tools.showDialog.select(tools.addonName + ': Advanced Search', items_selected)
if select_area == -1:
return
select = items_selected[select_area]
if select == 'Years':
if years != []:
years = []
from datetime import datetime
adv_year = int(datetime.today().year)
adv_years = []
for a in range(1907, adv_year + 1):
adv_years.append(str(a))
adv_years = sorted(adv_years, reverse=True)
adv_select = tools.showDialog.select(tools.addonName + ': Year Selection', adv_years)
if adv_select is None or adv_select == -1: continue
years.append(adv_years[adv_select])
if select == 'Ratings':
if ratings != []:
ratings = []
adv_ratings = [
{'name': 'General Audiences', 'slug': 'G'},
{'name': 'Parental Guidence', 'slug': 'PG'},
{'name': 'Restricted', 'slug': 'R'}
]
rating_display_list = []
for a in adv_ratings:
rating_display_list.append(a['name'])
rating_multiselect = tools.showDialog.multiselect(tools.addonName + ": Rating Selection", rating_display_list)
if rating_multiselect is None: continue
rating_selection = []
for selection in rating_multiselect:
rating_selection.append(adv_ratings[selection]['slug'])
ratings=rating_selection
if select == 'Seasons':
if seasons != []:
seasons = []
adv_seasons = [
{'name': 'Winter', 'slug': 'winter'},
{'name': 'Spring', 'slug': 'spring'},
{'name': 'Summer', 'slug': 'summer'},
{'name': 'Fall', 'slug': 'fall'}
]
season_display_list = []
for a in adv_seasons:
season_display_list.append(a['name'])
season_multiselect = tools.showDialog.multiselect(tools.addonName + ": Season Selection", season_display_list)
if season_multiselect is None: continue
season_selection = []
for selection in season_multiselect:
season_selection.append(adv_seasons[selection]['slug'])
seasons = season_selection
if select == 'Subtypes':
if subtypes != []:
subtypes = []
adv_subtypes = [
{'name': 'TV Shows', 'slug': 'tv'},
{'name': 'Movies', 'slug': 'movie'},
{'name': 'OVA', 'slug': 'ova'},
{'name': 'ONA', 'slug': 'ona'},
{'name': 'Specials', 'slug': 'special'}
]
subtype_display_list = []
for a in adv_subtypes:
subtype_display_list.append(a['name'])
subtype_multiselect = tools.showDialog.multiselect(tools.addonName + ": Subtype Selection", subtype_display_list)
if subtype_multiselect is None: continue
subtype_selection = []
for selection in subtype_multiselect:
subtype_selection.append(adv_subtypes[selection]['slug'])
subtypes = subtype_selection
if select == 'Genres':
if genres != []:
genres = []
from resources.lib.modules import kitsu_api
adv_genres = kitsu_api.KitsuBrowser().all_categories()
adv_genres = sorted(adv_genres, key= lambda a: (a['name']))
genre_display_list = []
for a in adv_genres:
genre_display_list.append(a['name'])
genre_multiselect = tools.showDialog.multiselect(tools.addonName + ": Genre Selection", genre_display_list)
if genre_multiselect is None: continue
genre_selection = []
for selection in genre_multiselect:
genre_selection.append(adv_genres[selection]['slug'])
genres = genre_selection
year_string = ','.join(years)
rating_string = ','.join(ratings)
season_string = ','.join(seasons)
subtype_string = ','.join(subtypes)
genre_string = ','.join(genres)
from resources.lib.modules import kitsu_api
anime = kitsu_api.KitsuBrowser().search(title='', year=year_string, rating=rating_string, season=season_string, subtype=subtype_string, genre=genre_string, page=page)
self.list_builder(anime)
if len(anime) == 20:
tools.addDirectoryItem('Next Page...', 'advanced_search&year=%s&rating=%s&season=%s&subtype=%s&genre=%s&page=%s' % (year_string, rating_string, season_string, subtype_string, genre_string, str(page+1)), None, None)
tools.closeDirectory('tvshows')
