def get_all_eps(name: str, select: int = 0) -> Dict[int, Tuple[str, bool]]:
"""
`str` `name`: Name of the anime.
`bool` `select_first`: Instead of showing the prompt, select the `select` result.
RETURNS `Dict<int, Tuple<str, bool>>`: A dictionary containing an
episode's name and filler info.
Get all the episodes of an anime.
"""
client = Jikan()
results = client.search("anime", name)["results"][:10]
anime = {i: j for i, j in enumerate(results, 1)}
if select == 0:
prompt = "\n".join(f"{n:0>2} => {t['title']}"
for n, t in anime.items())
select = input(prompt + "\nSelect Anime: ")
anime_id = anime[int(select)]["mal_id"]
selected_anime = client.anime(anime_id, extension="episodes")
eps = selected_anime["episodes"]
eps_len = selected_anime["episodes_last_page"]
if eps_len != 1:
for i in range(2, eps_len + 1):
eps.extend(
client.anime(anime_id, extension="episodes",
page=i)["episodes"])
ep_dict = {i["episode_id"]: [i["title"], i["filler"]] for i in eps}
return ep_dict
def rating(code):
try:
jikan = Jikan()
data = jikan.anime(code)
return data["score"]
except Exception:
return 0
class MyAnimeList(AnimeInformationProvider):
def __init__(self):
self.jikan = Jikan()
self.logger = logging.getLogger(self.__class__.__name__)
def anime_to_characters_names(self, anime_name: str):
animes = self.jikan.search('anime', anime_name)['results']
if not animes:
raise Exception('Could not find anime: {}'.format(anime_name))
anime = animes[0]
anime_title = anime['title']
self.logger.debug('Found anime: %s.', anime_title)
characters = self.jikan.anime(
anime['mal_id'], extension='characters_staff')['characters']
self.logger.debug('Found %s characters for the anime: %s.',
len(characters), anime_title)
names = []
for character in characters:
full_name = character['name']
name_parts = full_name.split(',')
if len(name_parts) == 2:
last_name = name_parts[0]
first_name = name_parts[1]
names.append(Name(last_name=last_name, first_name=first_name))
return names
def get_characters_for_anime_id(mal_id: int) -> Optional[list[AnimeCharacter]]:
jikan = Jikan()
try:
res = jikan.anime(mal_id, extension="characters_staff")
except jikanpy.APIException:
print(f"Character api error for {mal_id=}")
return None
chars_list = res["characters"]
result_chars_list = [AnimeCharacter.from_api(char) for char in chars_list]
return result_chars_list
def search_anime(s):
jikan = Jikan()
results = jikan.search('anime', s)
result = {}
print(CGREEN + "[Mai] These are the top results I found." + CEND)
for idx, resultitems in enumerate(results['results'], start=1):
print("\t" + CRED + str(idx) + ". " +
wrapper.fill(resultitems['title']) + CEND)
# storing mal_id for later use
result[idx] = resultitems['mal_id']
# to check if everything is working as expected
# print(result)
print(
CGREEN +
"[Mai] Type the index of the anime you want information on or type 0 to exit: "
+ CEND,
end=' ')
idx = int(input())
if (idx == 0):
return
results = jikan.anime(result[idx])
print(
CGREEN +
"[Mai] This is the information I found on the requested anime (press q to exit imageviewer)"
+ CEND)
# sanity check
# print(results)
# downloading image and storing in cache
f = open('cachepic.jpg', 'wb')
f.write(urllib.request.urlopen(results['image_url']).read())
f.close()
# ugh i don't like this hack. depends too much on system and imageviewer installed. try to fix this later.
subprocess.call(["feh", "-x", "cachepic.jpg"])
title = results['title']
episodes = results['episodes']
status = results['status']
# returns as list
title_syns = results['title_synonyms']
date = results['aired']['string']
syn = results['synopsis']
score = results['score']
printnicely(title, title_syns, score, status, syn, episodes, date)
def parse_no_user_info(list_to_parse):
fields = [
'ID', 'Image Url', 'Title', 'Episodes', 'Rating', 'Score', 'Rank',
'Popularity', 'Members', 'Favorites', 'Adaption_Size', 'Producers',
'Studios', 'Genres', 'Type', 'Status'
]
jikan = Jikan()
with open(csv_file_name, 'a') as csv_file:
writer = csv.DictWriter(csv_file, fieldnames=fields)
if csv_file.tell() == 0:
writer.writeheader()
for anime_id in list_to_parse:
try:
# 2 seconds per request
time.sleep(2)
# write anime info to csv file
anime = jikan.anime(anime_id)
content = {}
content['ID'] = anime_id
content['Image Url'] = anime['image_url']
content['Title'] = anime['title_english']
content['Episodes'] = anime['episodes']
content['Rating'] = anime['rating']
content['Score'] = anime['score']
content['Rank'] = anime['rank']
content['Popularity'] = anime['popularity']
content['Members'] = anime['members']
content['Favorites'] = anime['favorites']
if 'Adaptation' in anime['related']:
content['Adaption_Size'] = len(
anime['related']['Adaptation'])
else:
content['Adaption_Size'] = 0
content['Producers'] = extract_list_info(
anime['producers'], 'name')
content['Studios'] = extract_list_info(anime['studios'],
'name')
content['Genres'] = extract_list_info(anime['genres'], 'name')
content['Type'] = anime['type']
content['Status'] = anime['status']
print(content)
writer.writerow(content)
except exceptions.APIException:
print("anime id " + str(anime_id) + " does not exist")
except:
print("failure at " + str(anime_id))
raise
class CachedJikan():
def __init__(self, username):
self._jikan = Jikan()
self._last_request_time = time.time()
self._REQUEST_DELAY = 2
self._mal_username = username
self._animelist_watching = None
self._animelist_watching_time = None
self._animes = dict()
def _request_wait_time(self):
return max(0, (self._last_request_time + self._REQUEST_DELAY) -
time.time())
def _delay_request(self, request_func):
time.sleep(self._request_wait_time())
result = request_func()
self._last_request_time = time.time()
return result
def animelist_watching(self):
if self._animelist_watching is None or time.time(
) - self._animelist_watching_time > 5 * 60:
try:
def do_request():
return self._jikan.user(username=self._mal_username,
request='animelist',
argument='watching')
self._animelist_watching = self._delay_request(do_request)
self._animelist_watching_time = time.time()
except APIException as e:
LOG.error('exception getting watchlist')
LOG.error(e)
return self._animelist_watching
def anime(self, anime_id):
if anime_id not in self._animes:
try:
def do_request():
return self._jikan.anime(anime_id)
anime = self._delay_request(do_request)
self._animes[anime_id] = anime
except APIException as e:
LOG.error(str.format('exception getting anime id:{}',
anime_id))
LOG.error(e)
return None
return self._animes[anime_id]
def get_ptw_info(anime_list: Iterable[Anime]) -> List[PTWEntry]:
"""Store PTW of each anime in a list of tuples"""
jikan = Jikan()
ptw = list()
print("Requesting ptw via Jikan")
for anime in anime_list:
print(f"Looking up stats for {anime.name}")
anime_stats = jikan.anime(anime.id, extension="stats")
anime_ptw_num = localize_number(anime_stats["plan_to_watch"])
ptw.append(PTWEntry(anime.name, anime.id, anime_ptw_num))
time.sleep(config.getint("jikanpy", "request-interval"))
return ptw
def getInfoFromDatabase(allShows):
jikan = Jikan()
Database = mysql.connector.connect(host="127.0.0.1",
user="******",
passwd="python",
database="streaming")
cursor = Database.cursor(buffered=True)
c = 0
for CShows in allShows:
print("current: " + CShows)
cursor.execute("SELECT * FROM series WHERE SeriesName=%s", (CShows, ))
fetch = cursor.fetchone()
if getIFCheck(fetch):
search_result = jikan.search('anime', CShows)
try:
if len(search_result) >= 1:
Mal_id = str(search_result['results'][0]['mal_id'])
anime = jikan.anime(Mal_id)
sql = ""
execute = True
val = None
if fetch != None:
if anime['status'] == "Currently Airing":
execute = False
sql = "UPDATE customers SET seriesStatus = %s WHERE id = %s"
val = (anime['status'], fetch[0])
print("Show Updated !")
else:
sql = "INSERT INTO series (seriesName, JapaneseName, genres, seriesStatus, Description, episodeCount, ImageURL, LargeImageURL, malID, trailer, aired, duration, type ) VALUES (%s, %s, %s, %s,%s,%s,%s,%s,%s,%s,%s,%s,%s)"
val = (CShows, anime['title_japanese'],
GetGenres(anime), anime['status'],
anime['synopsis'], anime['episodes'],
anime['image_url'], anime['image_url'].replace(
".jpg", "l.jpg"), Mal_id,
anime['trailer_url'], anime['premiered'],
anime['duration'], anime['type'])
if execute:
cursor.execute(sql, val)
Database.commit()
except:
print("error at: " + CShows)
getSchedule(cursor, Database)
def get_json(self, req_anime_list, season, year):
jikan = Jikan()
animes_this_season = jikan.season(year=year, season=season)
animes = []
for anime in animes_this_season['anime']:
for req_anime in req_anime_list:
if anime['title'] == req_anime['name']:
anime_details = jikan.anime(anime['mal_id'])
ani = copy.deepcopy(anime)
ani['torrentname'] = req_anime['torrentname']
ani['quality'] = req_anime['quality']
ani['search_queries'] = self.create_search_queries(
req_anime, anime_details)
ani['have_prequel'] = self.check_new_anime(anime_details)
ani['folder_name'] = req_anime['folder_name']
animes.append(ani)
return animes
def main():
"Use Jikan API to update the database with new anime entries"
"New anime ids from MAL are gathered from mal-id-cache repo"
conn = connect_to_db()
db_ids = get_all_ids_from_db(conn)
cache_ids = get_ids_from_mal_id_cache()
left_over_ids = [
cached_id for cached_id in cache_ids if cached_id not in db_ids
]
print(len(left_over_ids))
jikan = Jikan()
for anime_id in left_over_ids:
try:
anime = jikan.anime(anime_id)
except jikanpy.exceptions.APIException:
continue
add_jikan_response_to_db(conn, anime)
time.sleep(2)
conn.close()
class MyAnimeListService():
def __init__(self):
self.jk = Jikan()
def get_anime(self,anime_name):
# BUSCAMOS EL ANIME
result = self.jk.search("anime",anime_name,parameters={"limit": 1})
anime_data = self.jk.anime(result["results"][0]["mal_id"])
anime = {}
## OBTENEMOS NADA MAS LA INOFMRACIÓN QUE NECESITAMOS
anime["title"] = anime_data["title"] # TITULO
anime["episodes"] = anime_data["episodes"] # EPISODIOS
anime["airing"] = "🔴 Finished Airing" if not anime_data["airing"] else "✅ Currently Airing" # Al aire
## SCORE con emoji
if anime_data["score"]>7.5:
score = "%s 😍"%anime_data["score"]
elif 5<anime_data["score"]<=7.5:
score = "%s 🙂"%anime_data["score"]
elif 2.5<anime_data["score"]<=5:
score = "%s 😞"%anime_data["score"]
elif anime_data["score"]<=2.5:
score = "%s 😠"%anime_data["score"]
anime["score"] = score # Score
anime["date"] = "%s"%anime_data["aired"]["from"][:10] #Fecha en que se publico
anime["rated"] = anime_data["rating"] # Rating
anime["synopsis"] = anime_data["synopsis"] # Sinpopsis
anime["background"] = anime_data["background"] # Contexto
anime["genres"] = ", ".join([x["name"] for x in anime_data["genres"] ]) # Generos
anime["ranked"] = str(anime_data["rank"]) # Rank en MAL
anime["trailer"] = anime_data["trailer_url"] # URL del trailer
# Tratamos de obtener su imagen
try:
regex = re.search(r"\.jpg",anime_data["image_url"])
anime["image"] = anime_data["image_url"][:regex.end()]
except:
anime["image"] = None
return anime
class MyAnimeListService():
def __init__(self):
self.jk = Jikan()
def search(self, m):
m.m_type = "text"
print("searching %s" % m.text)
result = self.jk.search("anime", m.text, parameters={"limit": 5})
print("finish")
names = ["- %s\n" % x["title"] for x in result["results"]]
m.text = "Resultados:\n" + "".join(names)
return m
def getAnime(self, m):
result = self.jk.search("anime", m.text, parameters={"limit": 1})
anime = result["results"][0]
title = "*%s*" % anime["title"]
episodes = "Episodes: %s" % anime["episodes"]
airing = "🔴 Finished Airing" if not anime[
"airing"] else "✅ Currently Airing"
if anime["score"] > 7.5:
score = "Score: %s 😍" % anime["score"]
elif 5 < anime["score"] <= 7.5:
score = "Score: %s 🙂" % anime["score"]
elif 2.5 < anime["score"] <= 5:
score = "Score: %s 😞" % anime["score"]
elif anime["score"] <= 2.5:
score = "Score: %s 😠" % anime["score"]
date = "Date: %s" % anime["start_date"][:10]
rated = "Rated: %s" % anime["rated"]
synopsis = "Synopsis: %s" % anime["synopsis"]
m.text = "%s\n%s\n%s\n%s\n%s\n%s\n%s\n" % (
title, episodes, airing, score, date, rated, synopsis)
try:
regex = re.search(r"\.jpg", anime["image_url"])
m.img = anime["image_url"][:regex.end()]
m.m_type = "img"
except:
m.m_type = "text"
return m
def getAllInfo(self, m):
result = self.jk.search("anime", m.text, parameters={"limit": 1})
anime = self.jk.anime(result["results"][0]["mal_id"])
title = "*%s*" % anime["title"]
episodes = "Episodes: %s" % anime["episodes"]
airing = "🔴 Finished Airing" if not anime[
"airing"] else "✅ Currently Airing"
if anime["score"] > 7.5:
score = "Score: %s 😍" % anime["score"]
elif 5 < anime["score"] <= 7.5:
score = "Score: %s 🙂" % anime["score"]
elif 2.5 < anime["score"] <= 5:
score = "Score: %s 😞" % anime["score"]
elif anime["score"] <= 2.5:
score = "Score: %s 😠" % anime["score"]
date = "Date: %s" % anime["aired"]["from"][:10]
rated = "Rated: %s" % anime["rating"]
synopsis = "Synopsis: %s" % anime["synopsis"]
background = "Background: %s" % anime["background"]
genres = "Genres:" + ", ".join([x["name"] for x in anime["genres"]])
ranked = "Ranked: " + str(anime["rank"])
trailer = "Trailer: " + anime["trailer_url"]
data = (title, genres, episodes, airing, score, ranked, date, rated,
synopsis, background, trailer)
m.text = "%s\n" * len(data)
m.text = m.text % data
try:
regex = re.search(r"\.jpg", anime["image_url"])
m.img = anime["image_url"][:regex.end()]
m.m_type = "img"
except:
m.m_type = "text"
return m
def main(num_id_visited):
fields = [
'ID', 'Image Url', 'Title', 'Episodes', 'Rating', 'Score', 'Rank',
'Popularity', 'Members', 'Favorites', 'Adaption_Size', 'Producers',
'Studios', 'Genres', 'Type', 'Status'
]
review_fields = [
'Anime ID', 'Username', 'Scores_overall', 'Scores_story',
'Scores_animation', 'Scores_sound', 'Scores_character',
'Scores_enjoyment'
]
jikan = Jikan()
user_name_set = set()
with open(csv_file_name, 'a') as csv_file:
with open(csv_reviews_file_name, 'a') as csv_reviews_file:
writer = csv.DictWriter(csv_file, fieldnames=fields)
reviews_writer = csv.DictWriter(csv_reviews_file,
fieldnames=review_fields)
if csv_file.tell() == 0:
writer.writeheader()
if csv_reviews_file.tell() == 0:
reviews_writer.writeheader()
i = 0
while i < num_id_visited:
anime_id = start_id + i
try:
#2 seconds per request
time.sleep(3)
#write anime info to csv file
anime = jikan.anime(anime_id)
content = {}
content['ID'] = anime_id
content['Image Url'] = anime['image_url']
content['Title'] = anime['title_english']
content['Episodes'] = anime['episodes']
content['Rating'] = anime['rating']
content['Score'] = anime['score']
content['Rank'] = anime['rank']
content['Popularity'] = anime['popularity']
content['Members'] = anime['members']
content['Favorites'] = anime['favorites']
if 'Adaptation' in anime['related']:
content['Adaption_Size'] = len(
anime['related']['Adaptation'])
else:
content['Adaption_Size'] = 0
content['Producers'] = extract_list_info(
anime['producers'], 'name')
content['Studios'] = extract_list_info(
anime['studios'], 'name')
content['Genres'] = extract_list_info(
anime['genres'], 'name')
content['Type'] = anime['type']
content['Status'] = anime['status']
print(content)
writer.writerow(content)
#parse user info
for j in range(25):
time.sleep(2)
anime_reviews = jikan.anime(anime_id,
extension='reviews',
page=j + 1)
print("get " + str(len(anime_reviews['reviews'])) +
" results")
for review in anime_reviews['reviews']:
review_info = {}
reviewer = review['reviewer']
user_name_set.add(reviewer['username'])
review_info['Anime ID'] = str(start_id + i)
review_info['Username'] = reviewer['username']
review_info['Scores_overall'] = reviewer['scores'][
'overall']
review_info['Scores_story'] = reviewer['scores'][
'story']
review_info['Scores_animation'] = reviewer[
'scores']['animation']
review_info['Scores_sound'] = reviewer['scores'][
'sound']
review_info['Scores_character'] = reviewer[
'scores']['character']
review_info['Scores_enjoyment'] = reviewer[
'scores']['enjoyment']
reviews_writer.writerow(review_info)
if len(anime_reviews['reviews']) < 20:
break
i += 1
except exceptions.APIException:
print("anime id " + str(anime_id) + " does not exist")
i += 1
except:
print("failure at " + str(anime_id))
print("Have collected " + str(len(user_name_set)) +
" usernames")
pickle.dump(user_name_set, open(pickle_file_name, "wb"))
raise
pickle.dump(user_name_set, open(pickle_file_name, "wb"))
print("Have collected " + str(len(user_name_set)) + " usernames")
class Recomender:
def __init__(self, user_name):
self.user_name: str = user_name # MAL username
self.jikan = Jikan() # API object
self.anime_dic = {} # dic of anime id and it's score
self.genre_dic = defaultdict(
list) # dic of genres and a list of user scores for them
self.studio_dic = defaultdict(
list) # dic of studios and a list of user scores for them
self.source_material_dic = defaultdict(
list) # dic of source materials and a list of user scores for them
self.type_dic = defaultdict(
list) # dic of types and a list of user scores for them
self.episodes_amount_dic = defaultdict(
list
) # dic of episode amount enums and a list of user scores for them
self.staff_dic = defaultdict(
list) # dic of staff people and a list of user scores for them
self.analyzed_anime_dic = {
} # dic of analyzed seasonal anime and their scores
self.anime_name_dic = {} # dic of MAL anime ids and names
self.staff_name_dic = {} # dic of MAL staff ids and names
"""
Fills the anime_dic with the users rated anime
"""
def fill_anime_dic(self):
print("Started filling anime dic.")
last_page: bool = False
page_num: int = 1
while not last_page: # the API only returns 300 anime so we may need to request multiple pages
animelist = self.jikan.user(username=self.user_name,
request='animelist',
argument="all",
page=page_num)
if animelist["request_cached"] is False:
time.sleep(
SLEEP_TIME
) # if the request was uncached we need to add a delay or we get a 429
for anime in animelist["anime"]:
if anime["score"] > 0: # only add the anime if the user set a score
self.anime_dic[anime["mal_id"]] = anime["score"]
if len(animelist["anime"]
) < 300: # each page contains max 300 anime
last_page = True
page_num += 1
"""
Gathers data like genre or studio scores based upon the anime in the anime dic
"""
def gather_anime_data_from_anime_dic(self):
print("Started gathering anime data from anime dic.")
progress_counter = 1
for animeID in self.anime_dic.keys(): # go though every anime
if progress_counter % 10 == 1:
print("Gathered " + str(progress_counter) + " anime.")
progress_counter += 1
anime = self.jikan.anime(animeID)
if anime["request_cached"] is False:
time.sleep(SLEEP_TIME) # sleep to prevent 429
anime_staff_full = self.jikan.anime(
animeID, extension='characters_staff') # get staff data
anime_staff = anime_staff_full["staff"]
if anime_staff_full["request_cached"] is False:
time.sleep(SLEEP_TIME)
score = self.anime_dic[animeID]
for genre in anime["genres"]: # add score for every genre
self.genre_dic[genre["mal_id"]].append(score)
for studio in anime["studios"]: # add score for every studio
self.studio_dic[studio["mal_id"]].append(score)
self.source_material_dic[anime["source"]].append(
score) # add score for source material
self.type_dic[anime["type"]].append(score) # add score for type
episodes = anime["episodes"]
if episodes is None: # if episodes are unset set the to zero
episodes = 0
if episodes > 0: # only add score if episodes are set
episodes_enum = self.get_episode_amount_enum(episodes)
self.episodes_amount_dic[episodes_enum].append(score)
for staff_member in anime_staff:
for position in staff_member["positions"]:
# only add the staff member if their position is relevant according to my own decision
if position in POSITION_SET:
self.staff_dic[staff_member["mal_id"]].append(score)
self.staff_name_dic[
staff_member["mal_id"]] = staff_member["name"]
"""
analyzes the anime of a specific season with the data gathered from the user
year = int, year of the season
season = string, season of the year (either winter, spring, summer or fall)
kids = boolean, if you want to analyze kids shows
r18 = if you want to analyze r18 (hentai) shows
"""
def analyze_seasonal_anime(self, year, season, kids, r18):
seasonal_anime_full = self.jikan.season(year=year, season=season)
if seasonal_anime_full["request_cached"] is False:
time.sleep(SLEEP_TIME)
seasonal_anime = seasonal_anime_full["anime"]
print("Started analyzing seasonal anime.")
progress_counter = 1
for anime in seasonal_anime:
if progress_counter % 10 == 1:
print("Analyzed " + str(progress_counter) + " anime.")
progress_counter += 1
if anime[
"continuing"]: # if the anime is actually from a previous season, don't analyze it
continue
if not r18 and anime["r18"]:
continue
if not kids and anime["kids"]:
continue
self.analyze_anime(anime)
"""
analyzes an anime and puts it and the score to the analyzed anime dic
anime = either an anime object or the MAL ID as an int
"""
def analyze_anime(self, anime):
if isinstance(anime,
int): # if anime is an int get the anime object of it
anime = self.jikan.anime(anime)
score_divisor = 0 # variable through which the score in the end will be divided so that we get one that goes from 1 to 10 by adding the FACTOR of a value
anime_staff_full = self.jikan.anime(anime["mal_id"],
extension='characters_staff')
if anime_staff_full["request_cached"] is False:
time.sleep(SLEEP_TIME)
anime_staff = anime_staff_full["staff"]
score = 0.0
score_addition_counter = 0 # count how many scores were actually added to the score
genre_amount = 0
genre_score = 0.0
for genre in anime["genres"]:
if genre["mal_id"] in self.genre_dic.keys():
genre_amount += 1
# get the average of the scores in the list
genre_score += sum(self.genre_dic[genre["mal_id"]]) / len(
self.genre_dic[genre["mal_id"]])
if genre_amount > 0: # only add if there was atleast one genre
score += genre_score / genre_amount * GENRE_FACTOR
score_addition_counter += 1
score_divisor += GENRE_FACTOR
studio_amount = 0
studio_score = 0.0
for studio in anime["producers"]:
if studio["mal_id"] in self.studio_dic.keys():
studio_amount += 1
studio_score += sum(self.studio_dic[studio["mal_id"]]) / len(
self.studio_dic[studio["mal_id"]])
if studio_amount > 0:
score += studio_score / studio_amount * STUDIO_FACTOR
score_addition_counter += 1
score_divisor += STUDIO_FACTOR
if anime["source"] in self.source_material_dic:
source_score = sum(
self.source_material_dic[anime["source"]]) / len(
self.source_material_dic[anime["source"]])
if source_score > 0:
score += source_score * SOURCE_MATERIAL_FACTOR
score_addition_counter += 1
score_divisor += SOURCE_MATERIAL_FACTOR
if anime["type"] in self.type_dic:
type_score = sum(self.type_dic[anime["type"]]) / len(
self.type_dic[anime["type"]])
if type_score > 0:
score += type_score * TYPE_FACTOR
score_addition_counter += 1
score_divisor += TYPE_FACTOR
episode_amount = anime["episodes"]
if episode_amount is None: # check if episodes are set and if they are not set them to 0
episode_amount = 0
if episode_amount > 0:
episode_enum = self.get_episode_amount_enum(episode_amount)
if episode_enum in self.episodes_amount_dic:
episode_amount_score = sum(
self.episodes_amount_dic[episode_enum]) / len(
self.episodes_amount_dic[episode_enum])
if episode_amount_score > 0:
score += episode_amount_score * EPISODE_AMOUNT_FACTOR
score_addition_counter += 1
score_divisor += EPISODE_AMOUNT_FACTOR
staff_score = 0.0
staff_amount = 0
for staff_member in anime_staff:
if staff_member["mal_id"] in self.staff_dic:
staff_amount += 1
staff_score += sum(
self.staff_dic[staff_member["mal_id"]]) / len(
self.staff_dic[staff_member["mal_id"]])
if staff_amount > 0:
staff_score /= staff_amount
score += staff_score * STAFF_FACTOR
score_addition_counter += 1
score_divisor += STAFF_FACTOR
if score_addition_counter > 0:
self.anime_name_dic[anime["mal_id"]] = anime["title"]
self.analyzed_anime_dic[anime["mal_id"]] = (
(score / score_addition_counter) *
(0.4 + 0.1 * score_addition_counter)) / (
score_divisor / score_addition_counter
) # calculate the score and add the anime to the dic
"""
writes a comma seperated value file with the result of the analyzed seasonal anime
"""
def write_analyzed_anime_to_file(self):
with open("analyzed_anime.txt", mode="w",
encoding="utf8") as text_file:
text_file.write("Name^MAL ID^Score\n")
for anime in self.analyzed_anime_dic.keys():
text_file.write(
str(self.anime_name_dic[anime]) + "^" + str(anime) + "^" +
str(self.analyzed_anime_dic[anime]) + "\n")
print("Done writing anime file!")
"""
writes a comma seperated value file with staff members and their score
"""
def write_analyzed_staff_to_file(self):
with open("analyzed_staff.txt", mode="w",
encoding="utf8") as text_file:
text_file.write("Name^MAL ID^Average^Amount^Score\n")
max_len = -1
for staff in self.staff_dic.keys():
if len(self.staff_dic[staff]) > max_len:
max_len = len(self.staff_dic[staff])
for staff in self.staff_dic.keys():
FACTOR = 0.866
length = len(self.staff_dic[staff])
scores_list = self.staff_dic[staff]
average = sum(scores_list) / length
text_file.write(
str(self.staff_name_dic[staff]) + "^" + str(staff) + "^" +
str(average) + "^" + str(length) + "^" +
str(average * FACTOR + ((length / max_len) *
(1.0 - FACTOR) * 10.0)) + "\n")
print("Done writing staff file!")
"""
A Function that returns an Enum for summarizing episode amounts
"""
@staticmethod
def get_episode_amount_enum(amount) -> EpisodesAmount:
if amount < 1:
return None
elif amount == 1:
return EpisodesAmount.One
elif 2 <= amount <= 8:
return EpisodesAmount.TwoEight
elif 9 <= amount <= 19:
return EpisodesAmount.NineNineteen
elif 20 <= amount <= 30:
return EpisodesAmount.TwentyThirty
elif 31 <= amount <= 50:
return EpisodesAmount.ThirtyoneFifty
elif 51 <= amount <= 100:
return EpisodesAmount.FiftyoneOnehundred
else:
return EpisodesAmount.OnehundredonePlus
from jikanpy import Jikan
import logging
import re
import requests
import shutil
import time
logging.basicConfig(filename='logs/scrape.log', level=logging.DEBUG)
anime_id = 21
jikan = Jikan()
characters_staff = jikan.anime(anime_id, extension='characters_staff')
chars = characters_staff['characters']
person_ids = set()
for c in chars:
va = c['voice_actors']
for v in va:
if v['language'] == 'Japanese':
person_ids.add(v['mal_id'])
for pid in person_ids:
time.sleep(3)
person = jikan.person(pid)
name = re.sub('\s', '', person['name'])
path = "tmp/raw_images/%s" % name
url = person['image_url']
r = requests.get(url, stream=True)
def fetchAllAnimes():
#jikan.season_later()
#jikan.schedule()
#top_anime = jikan.top(type='anime')
#winter_2018 = jikan.season(year=2018, season='winter')
animes = []
jikan = Jikan()
archive = jikan.season_archive()
year = int(archive['archive'][0]['year'])
d = enchant.Dict("en_US")
while year >= 1975:
for seasonname in archive['archive'][0]['seasons']:
while True:
try:
season = jikan.season(year=year, season=seasonname)
break
except Exception as error:
if '429' in str(error):
print('[DetectAnime] Rate limited. Sleeping for 30secs...')
time.sleep(30)
else:
print(error)
pass
for animesmall in season['anime']:
id = animesmall['mal_id']
while True:
try:
anime = jikan.anime(int(id))
break
except Exception as error:
if '429' in str(error):
print('[DetectAnime] Rate limited. Sleeping for 30secs...')
time.sleep(30)
else:
logging.error(error)
pass
title = anime['title']
engtitle = anime['title_english']
japtitle = anime['title_japanese']
synonym = anime['title_synonyms']
try:
isValidTitle = len(title) > 4 and not d.check(title) and not d.check(re.sub('[^A-Za-z ]+', '', title))
except Exception as e:
print('[DetectAnime] Error determining validity of title: ' + str(e) + '. Defaulting to False.')
isValidTitle = False
if isValidTitle:
print(f'[DetectAnime] Appending "{title}" with id {id}. List size is now {len(animes)}.')
animes.append(title)
spacedreg = re.sub(r'[^\w]|[ ]', ' ', title)
if len(spacedreg) > 4:
animes.append(spacedreg)
blankedreg = re.sub(r'[^\w]|[ ]', '', title)
if len(blankedreg) > 4:
animes.append(spacedreg)
try:
isValidTitle = len(engtitle) > 4 and not d.check(engtitle) and not d.check(re.sub('[^A-Za-z ]+', '', engtitle))
except Exception as e:
print('[DetectAnime] Error determining validity of title: ' + str(e) + '. Defaulting to False.')
isValidTitle = False
if isValidTitle:
print(f'[DetectAnime] Appending "{engtitle}" with id {id}. List size is now {len(animes)}.')
animes.append(engtitle)
spacedreg = re.sub(r'[^\w]|[ ]', ' ', engtitle)
if len(spacedreg) > 4:
animes.append(spacedreg)
blankedreg = re.sub(r'[^\w]|[ ]', '', engtitle)
if len(blankedreg) > 4:
animes.append(spacedreg)
if not japtitle == None and len(japtitle) > 5:
print(f'[DetectAnime] Appending "{japtitle}" with id {id}. List size is now {len(animes)}.')
animes.append(japtitle)
for syn in synonym:
if len(syn) > 4:
print(f'[DetectAnime] Appending synonym "{syn}" for "{title}". List size is now {len(animes)}.')
animes.append(syn)
spacedreg = re.sub(r'[^\w]|[ ]', ' ', syn)
if len(spacedreg) > 4:
animes.append(spacedreg)
blankedreg = re.sub(r'[^\w]|[ ]', '', syn)
if len(blankedreg) > 4:
animes.append(spacedreg)
year -= 1
animes = list(dict.fromkeys(animes))
animes = removeDupStrings(animes)
return animes
class Container:
def __init__(self, id: str, shared_info):
self.shared_info = shared_info
self.shared_info.pending_updates_main = True
self.names_list = []
self.graphs_list = []
self.jikan = Jikan()
self.div = html.Div(id="graphcontainer")
self.status_children = "Status: No issues. Feel free to add graphs"
self.max_graphs = False
self.app = DjangoDash(id, external_stylesheets=external_stylesheets)
self.genre_options = [
{'label': 'Any', 'value': '1'},
{'label': 'Action', 'value': '2'},
{'label': 'Adventure', 'value': '3'},
{'label': 'Cars', 'value': '4'},
{'label': 'Comedy', 'value': '5'},
{'label': 'Dementia', 'value': '6'},
{'label': 'Demons', 'value': '7'},
{'label': 'Mystery', 'value': '8'},
{'label': 'Drama', 'value': '9'},
{'label': 'Ecchi', 'value': '10'},
{'label': 'Fantasy', 'value': '11'},
{'label': 'Game', 'value': '12'},
{'label': 'Hentai', 'value': '13'},
{'label': 'Historical', 'value': '14'},
{'label': 'Horror', 'value': '15'},
{'label': 'Kids', 'value': '16'},
{'label': 'Magic', 'value': '17'},
{'label': 'Martial Arts', 'value': '18'},
{'label': 'Mecha', 'value': '19'},
{'label': 'Music', 'value': '20'},
{'label': 'Parody', 'value': '21'},
{'label': 'Samurai', 'value': '22'},
{'label': 'Romance', 'value': '23'},
{'label': 'School', 'value': '24'},
{'label': 'Sci Fi', 'value': '25'},
{'label': 'Shoujo', 'value': '26'},
{'label': 'Shoujo Ai', 'value': '27'},
{'label': 'Shounen', 'value': '28'},
{'label': 'Shounen Ai', 'value': '29'},
{'label': 'Space', 'value': '30'},
{'label': 'Sports', 'value': '31'},
{'label': 'Super Power', 'value': '32'},
{'label': 'Vampire', 'value': '33'},
{'label': 'Yaoi', 'value': '34'},
{'label': 'Yuri', 'value': '35'},
{'label': 'Harem', 'value': '36'},
{'label': 'Slice Of Life', 'value': '37'},
{'label': 'Supernatural', 'value': '38'},
{'label': 'Military', 'value': '39'},
{'label': 'Police', 'value': '40'},
{'label': 'Psychological', 'value': '41'},
{'label': 'Thriller', 'value': '42'},
{'label': 'Seinen', 'value': '43'},
{'label': 'Josei', 'value': '44'},
]
self.category_options = [
{'label': 'Any', 'value': '1'},
{'label': 'TV', 'value': '2'},
{'label': 'OVA', 'value': '3'},
{'label': 'Movie', 'value': '4'},
{'label': 'Special', 'value': '5'},
{'label': 'ONA', 'value': '6'},
{'label': 'Music', 'value': '7'},
]
self.app.layout = self.serve_layout
# @self.app.callback(
# Output('graphcontainer', 'children'),
# [Input('search_button', 'n_clicks'),
# State('searchname', 'value')]
# )
@self.app.callback(
[Output('table', 'data'),
Output('table', 'dropdown')],
[Input('search_button', 'n_clicks'),
Input("searchname", 'n_submit'),
State("searchname", "value"),
State('genre_dropdown', 'value'),
State('category_dropdown', 'value'),
State('date_picker_range', 'start_date'),
State('date_picker_range', 'end_date')]
)
def update_table(n_clicks, n_submit, searchname, genre_dropdown, category_dropdown, start_date, end_date):
data = [{'Name': "", 'Add Graph(s)': ""},
{'Name': "", 'Add Graph(s)': ""},
{'Name': "", 'Add Graph(s)': ""},
{'Name': "", 'Add Graph(s)': ""},
{'Name': "", 'Add Graph(s)': ""}]
dropdown = {}
if searchname is not None:
data = []
selected_genre = int(genre_dropdown) - 1
selected_category = (self.category_options[int(category_dropdown) - 1]['label'])
results = self.search_anime(searchname, selected_genre, selected_category, start_date, end_date)
for x in range(0, len(results) - 1):
data.append({'Name': results[x]["title"], 'Add Graph(s)': "Don't add Graph"})
dropdown = {
'Add Graph(s)': {
'options': [
{'label': "No", 'value': "Don't add Graph"},
{'label': "Yes", 'value': "Add Graph"}
],
'searchable': False,
'clearable': False
}
}
return data, dropdown
@self.app.callback(
[Output('graphcontainer', 'children'),
Output('status_message', 'children'),
Output('add_graphs', 'disabled')],
[Input('add_graphs', 'n_clicks'),
State('table', 'data')]
)
def add_graph(n_clicks, data):
id = 'graph-{}'.format(n_clicks)
disable_add_button = self.max_graphs
children = self.status_children
names_added = []
names_no_data = []
names_duplicate = []
names_above_max = []
num_graphs = Anime.objects.count()
if n_clicks > 0:
for i in data:
if i['Add Graph(s)'] == 'Add Graph':
if num_graphs < 5:
if i['Name'] not in self.names_list:
try:
test = graphs.Graphs(i['Name'] + 'app', i['Name'], i['Name'], i['Name'] + 'slider',
False,
[Input(i['Name'] + 'slider', 'value')],
self.shared_info.color_graphs,
self.shared_info.time_scale, i['Name'])
self.graphs_list.append(test.return_layout()) # Potentially causes exception
self.names_list.append(i['Name'])
names_added.append(i['Name'])
num_graphs = num_graphs + 1
a = Anime(anime_name=i['Name'], anime_order=num_graphs)
a.save()
except exceptions.ResponseError:
names_no_data.append(i['Name'])
else:
names_duplicate.append(i['Name'])
else:
names_above_max.append(i['Name'])
str_names = ""
str_no_data = ""
str_duplicates = ""
str_above = ""
if num_graphs == 5:
disable_add_button = True
self.max_graphs = True
if len(names_added) > 0:
self.shared_info.pending_updates_edit = True
self.shared_info.pending_updates_export = True
str_names = "Added (" + str(num_graphs) + "/5 total limit): "
for i in names_added:
str_names = str_names + i + "; "
if len(names_no_data) > 0:
str_no_data = "Not added (no search data or rate limit exceeded): "
for i in names_no_data:
str_no_data = str_no_data + i + "; "
if len(names_duplicate) > 0:
str_duplicates = "Not added (duplicate graph): "
for i in names_duplicate:
str_duplicates = str_duplicates + i + "; "
if len(names_above_max) > 0:
str_above = "Not added (exceeded 5-graph limit): "
for i in names_above_max:
str_above = str_above + i + "; "
if len(str_names) > 0 or len(str_no_data) > 0 or len(str_duplicates) > 0 or len(str_above) > 0:
children = "Status - "
if len(str_names) > 0:
children = children + str_names
if len(str_no_data) > 0:
children = children + str_no_data
if len(str_duplicates) > 0:
children = children + str_duplicates
if len(str_above) > 0:
children = children + str_above
return html.Div(self.graphs_list), children, disable_add_button
def serve_layout(self):
if self.shared_info.pending_updates_main:
self.shared_info.pending_updates_main = False
self.div = html.Div(children=self.init_graph(), id="graphcontainer")
num_graphs = Anime.objects.count()
if num_graphs == 5:
self.status_children = "Status: Max graphs (5) limit reached. Graphs may be removed via 'Settings' page."
self.max_graphs = True
else:
self.status_children = "Status: No changes made yet. Feel free to add graphs (" + str(
num_graphs) + "/5 total limit)"
self.max_graphs = False
graph_area = self.div
return html.Div([
html.Div(
id='searchtablearea',
children=[
html.Div(
id='searcharea',
children=[
dcc.Input(
id='searchname',
type='text',
placeholder='Enter Show Name',
debounce=True,
n_submit=0
),
html.Button(id="search_button", n_clicks=0, children="Search"),
html.P('Genre:'),
dcc.Dropdown(id='genre_dropdown',
options=self.genre_options,
value='1',
clearable=False
),
html.P('Category:'),
dcc.Dropdown(id='category_dropdown',
options=self.category_options,
value='1',
clearable=False
),
html.P('Select search range:'),
dcc.DatePickerRange(
id='date_picker_range',
start_date_placeholder_text='Select start date',
end_date_placeholder_text='Select end date',
clearable=True,
),
]),
html.Div(
id='tablearea',
children=
[self.init_table(),
html.P(id='status_message', children=self.status_children, style={'font-style': 'italic'}),
html.Button(id="add_graphs", n_clicks=0, children="Add selected graphs",
disabled=self.max_graphs),
])
]),
graph_area,
])
def init_graph(self):
initial_graphs = []
self.graphs_list = []
self.names_list = []
for a in Anime.objects.raw('SELECT anime_name FROM home_anime ORDER BY anime_order ASC'):
p = str(a)
self.names_list.append(p)
initial_graphs.append(
graphs.Graphs(p.replace(" ", ""), p, p.replace(" ", ""), p.replace(" ", "") + 'slider', False,
[Input(p.replace(" ", "") + 'slider', 'value')], self.shared_info.color_graphs,
self.shared_info.time_scale, p))
if len(initial_graphs) != 0:
for i in initial_graphs:
self.graphs_list.append(i.return_layout())
return html.Div(self.graphs_list)
def search_anime_gender_birthday(self, anime_id):
data = [sub['username'] for sub in self.jikan.anime(anime_id, extension='userupdates', page=1)["users"]]
user = [self.jikan.user(username=name) for name in data]
print(name['birthday'] for name in user)
print(name['gender'] for name in user)
def search_anime(self, anime_name, genre_number, category_name, start_date, end_date):
search_params = {}
if genre_number > 0:
search_params['genre'] = genre_number
if category_name != "Any":
search_params['type'] = category_name
if start_date is not None:
search_params['start_date'] = start_date
if end_date is not None:
search_params['end_date'] = end_date
search = self.jikan.search('anime', anime_name, parameters=search_params)
# user = self.jikan.user_list(38000)
# print(user)
# print(user['birthday'])
# print(user['gender'])
return search["results"]
def init_table(self, type: str = 'Add', pg_size: int = 5):
layout = dash_table.DataTable(
id='table',
style_cell={'textAlign': 'left'},
style_data_conditional=[
{
"if": {"state": "active"}, # 'active' | 'selected'
"backgroundColor": "#FFFFFF",
"border": "1px solid #3CCFCF",
},
{
"if": {"state": "selected"},
"backgroundColor": "##FFFFFF",
"border": "1px solid #3CCFCF",
},
],
style_header={
'backgroundColor': 'rgb(230, 230, 230)',
'fontWeight': 'bold'
},
columns=[{"name": "Name",
"id": "Name",
"editable": False
},
{"name": type + ' Graph(s)',
"id": type + ' Graph(s)',
"presentation": "dropdown",
"editable": True,
}
],
dropdown={},
data=[{'Name': "", 'Add Graph(s)': ""},
{'Name': "", 'Add Graph(s)': ""},
{'Name': "", 'Add Graph(s)': ""},
{'Name': "", 'Add Graph(s)': ""},
{'Name': "", 'Add Graph(s)': ""}],
page_size=pg_size,
)
return layout
from anime.models import Anime
from jikanpy import Jikan, exceptions
jikan = Jikan()
idx = 1
for _ in range(1, 41000):
try:
json = jikan.anime(idx)
Anime.objects.create(title=json['title'],
title_jap=json['title_japanese'],
img_url=json['image_url'],
type=json['type'],
season=json['premiered'],
status=json['status'],
air_date=json['aired']['string'],
synopsis=json['synopsis'])
except exceptions.APIException as e:
pass
idx += 1
class MALHandler(object):
def __init__(self):
self.jikan = Jikan()
self.fileHandler = FileHandler()
self.dataPath = './data/meta'
self.labelPath = './label/meta'
self.allSeoson = ['spring', 'summer', 'fall', 'winter']
def getDetailSynopsisAndScore(self, id):
detail_anime = self.jikan.anime(id)
return detail_anime['score']
def getAnimeData(self, year, season):
print('Getting all anime in {} {}'.format(year, season))
animeData = self.jikan.season(year=year, season=season)
input = []
label = []
for anime in animeData['anime']:
print('total:{}, processed:{}'.format(len(animeData['anime']),
len(input)))
synopsis = anime['synopsis']
synopsis = ' '.join(synopsis.splitlines())
synopsis = synopsis.replace(' ', ' ')
if anime['score'] is None:
while True:
try:
score = self.getDetailSynopsisAndScore(anime['mal_id'])
except:
time.sleep(10)
else:
break
else:
score = anime['score']
label.append(str(score))
input.append(synopsis)
return input, label
def saveAnimeData(self, year, season):
input, label = self.getAnimeData(year, season)
self.fileHandler.saveFileHandler(
'{}/{}_{}_data.txt'.format(self.dataPath, year, season), input)
self.fileHandler.saveFileHandler(
'{}/{}_{}_label.txt'.format(self.labelPath, year, season), label)
def loadData(self, year, season):
data = self.fileHandler.loadFileHandler('{}/{}_{}_data.txt'.format(
self.dataPath, year, season))
label = self.fileHandler.loadFileHandler('{}/{}_{}_label.txt'.format(
self.labelPath, year, season))
if len(data) != len(label):
raise RuntimeError('Input and label numbers not match!')
return data, label
def savaAllSeasonAnimeData(self, year):
for season in self.allSeason:
self.saveAnimeData(year, season)
def run(self, formYear, toYear):
for year in range(formYear, toYear):
for season in self.allSeoson:
self.saveAnimeData(year, season)
with open('submissions/AnimeSoc Termly Anime Nomination Form (Responses) - Form responses 1.csv',newline='') as csvfile:
readCSV = csv.reader(csvfile,delimiter=',')
for row in readCSV:
currentitem = 4
while currentitem <= 16:
id = ''
for i in row[currentitem+1]:
if str.isdigit(i):
id=id+i
if i == '/' and len(id) > 1:
break
if row[currentitem+2] == 'Slot A':
slotA.append([row[currentitem],row[currentitem+1],str(row[currentitem+3]).replace("'","\'"),jikan.anime(id).get("image_url"),jikan.anime(id).get("synopsis").replace("'","\'")])
elif row[currentitem+2] == 'Slot B':
slotB.append([row[currentitem],row[currentitem+1],str(row[currentitem+3]).replace("'","\'"),jikan.anime(id).get("image_url"),jikan.anime(id).get("synopsis").replace("'","\'")])
elif row[currentitem+2] == 'Slot C':
slotC.append([row[currentitem],row[currentitem+1],str(row[currentitem+3]).replace("'","\'"),jikan.anime(id).get("image_url"),jikan.anime(id).get("synopsis").replace("'","\'")])
time.sleep(4)
currentitem+=4
with open('Slot A.csv', 'w') as csvfile:
filewriter = csv.writer(csvfile,delimiter=',')
filewriter.writerow(['Title','MAL Link','Nomination Description','Image URL','Synopsis'])
for row in slotA:
filewriter.writerow([row[0],row[1],row[2],row[3],row[4]])
with open('Slot B.csv', 'w') as csvfile:
filewriter = csv.writer(csvfile,delimiter=',')
from jikanpy import Jikan
jikan = Jikan()
mushishi = jikan.anime(39617)
mushishi_with_eps = jikan.anime(21, extension='episodes', page=10)
search_result = jikan.search('anime', 'One Piece', page=1)
winter_2018_anime = jikan.season(year=2021, season='winter')
archive = jikan.season_archive()
for anime in winter_2018_anime['anime']:
if anime['title'] == 'One Piece':
print(anime)
print(archive)
print(winter_2018_anime)
print(search_result)
from jikanpy import Jikan
jikan = Jikan()
# json of all anime info specified by Jikan docs
mushishi = jikan.anime(id=457, page=2)
# mushishi = jikan._get(endpoint="anime",id=457, page=2, extension=None)
print(mushishi)
# # same as above, but with extra info
# # see Jikan docs for information about which endpoints have which extensions
# mushishi_with_eps = jikan.anime(457, extension='episodes')
# mushishi_with_eps_2 = jikan.anime(457, extension='episodes', page=2)
# mushishi_with_characters_and_staff = jikan.anime(457, extension='characters_staff')
# # you can also query characters
# ginko = jikan.character(425)
# # and manga
# mushishi_manga = jikan.manga(418)
# # search up people too
# kana_hanazawa = jikan.person(185)
# # search
# search_result = jikan.search('anime', 'Mushishi')
# # add a page number to the search request
# search_result = jikan.search('anime', 'Mushishi', page=2)
# # add a filter to the search (see Jikan docs about what filters are legal)
# search_result = jikan.search('anime', 'Mushishi', parameters={'type': 'tv'})
# search_result = jikan.search('anime', 'Mushishi', parameters={'genre': 37})
animeFallback = 'https://animepahe.com'
MALRegex = re.compile(r'''
myanimelist.net/anime/
''', re.VERBOSE)
anilistRegex = re.compile(r'''
anilist.co/anime/
''', re.VERBOSE)
try:
address = pyperclip.paste()
if bool(MALRegex.search(address)): # check if the link is MAL
MALid = address.split('/')[4]
search_result = jikan.anime(MALid)
title = search_result['title']
webbrowser.open(animepaheLink.getAnimePahe(title))
elif bool(anilistRegex.search(address)): # check if the link is Anilist
ALid = address.split('/')[4]
title = anilistLink.anilistTitle(ALid)
webbrowser.open(animepaheLink.getAnimePahe(title))
else:
webbrowser.open(
animeFallback
) # will launch animepahe's homepage if the selected link is invalid
except IndexError as error:
print('Link is invalid. Please try again.')
from hikka.services.anime import AnimeService
from hikka.services.files import FileService
from hikka.tools import helpers
from jikanpy import Jikan
from hikka import utils
import time
jikan = Jikan()
top = jikan.top(type="anime")
for index, item in enumerate(top["top"]):
data = jikan.anime(item["mal_id"])
myanimelist = data["mal_id"]
if data["synopsis"] is None:
data["synopsis"] = "Lorem ipsum dolor sit amet."
title = AnimeService.get_title(data["title"])
anime = AnimeService.create(title, data["synopsis"],
helpers.category(data["type"].lower()),
helpers.state("released"),
utils.create_slug(data["title"]))
anime.search = utils.create_search(anime.title.ua, data["title_synonyms"])
anime.external = AnimeService.get_external(myanimelist)
anime.year = data["aired"]["prop"]["from"]["year"]
anime.teams = [helpers.team("fanvox")]
anime.aliases = data["title_synonyms"]
anime.total = data["episodes"]
anime.rating = data["score"]
class MAL_Series(object, metaclass=MAL_SeriesMemoizer):
def __init__(self, id=None, *, name=None):
self._jikan = Jikan()
self.id = id
self._raw = self._jikan.anime(self.id)
self._cached = self._raw['request_cached']
# MAL meta info
self.url = self._raw['url']
self.image_url = self._raw['image_url']
# titles
self.title = self._raw['title']
self.title_en = self._raw['title_english']
self.title_jp = self._raw['title_japanese']
self.synonyms = self._raw['title_synonyms']
# series meta info
self.type = AnimeType(self._raw['type'])
self.source = AnimeSource(self._raw['source'])
self.status = AiringStatus(self._raw['status'])
self.score = self._raw['score']
self.rank = self._raw['rank']
# release date info
self.airing = self._raw['airing'] # bool
if not self._raw['aired']['from']:
self.premiered = None
else:
self.premiered = isoparse(self._raw['aired']['from'])
if not self._raw['aired']['to']:
self.ended = None
else:
self.ended = isoparse(self._raw['aired']['to'])
self.release_run = self._raw['aired']['string']
self.release_season = self._raw['premiered']
# series info
self.synopsis = self._raw['synopsis']
self.background = self._raw['background']
self.studio = self._raw['studios']
self.rating = self._raw['rating']
self.episodes = self.fetch_episodes()
try:
self._sequel_id = self._raw['related'].get('Sequel')[0]['mal_id']
except TypeError:
self._sequel_id = None
try:
self._prequel_id = self._raw['related'].get('Prequel')[0]['mal_id']
except TypeError:
self._prequel_id = None
@property
def sequel(self):
return MAL_Series(self._sequel_id) if self._sequel_id else None
@property
def prequel(self):
return MAL_Series(self._prequel_id) if self._prequel_id else None
def fetch_episodes(self):
"""
Fetch all episodes of a series (automatically de-paginates, so we
*actually* get them all, not just the first page)
"""
resp = self._jikan.anime(self.id, extension='episodes')
episodes = resp['episodes']
last_page = resp['episodes_last_page']
if last_page > 1:
for i in range(2, last_page + 1):
episodes += self._jikan.anime(self.id,
extension='episodes',
page=i)['episodes']
# return as episode object
return [MAL_Episode(self, ep) for ep in episodes]
def __repr__(self):
return f"<MAL_Series: {self.title} [{self.id}]>"
# get page data
page_num = 1
print('[I] Doing page number ' + str(page_num))
page = jikan.user(username, 'animelist', list_type, page_num)
anime_list = page['anime']
while len(anime_list) > 0:
anime_in_page_done = 0
for idx_anime, anime in enumerate(anime_list):
if page_lim_enable and anime_in_page_done >= page_lim:
print('[I] Debug limit (' + str(page_lim) + ') reached')
break # break if page limit exceeded
mal_id = anime['mal_id']
anime_page = jikan.anime(mal_id)
title = anime_page['title']
to_search = [
title + ' op ' + str(i + 1)
for i in range(len(anime_page['opening_themes']))
]
to_search.extend([
title + ' ed ' + str(i + 1)
for i in range(len(anime_page['ending_themes']))
])
print('[I] Got page for "' + title + '" (' + str(mal_id) + ')')
already_downloaded = []
for idx_video, request in enumerate(to_search):
base_dir = "../data/reviews_small"
source = "../data/anime_data.csv"
codes_df = pd.read_csv(source)
num_reviews = 5
time_between_requests = 3 # in seconds
if not os.path.isdir(base_dir): # If the base_dir does not exist create it
os.mkdir(base_dir)
jikan = Jikan()
#scrap the reviews starting from the lower_bound
for index, row in codes_df.iterrows():
# Put an upper bound on the amoun of reviews to reduce the inbalance problem
try:
reviews = jikan.anime(row["code"],
extension='reviews')['reviews'][:num_reviews]
time.sleep(
time_between_requests
) # wait before making too many requests as per API guidelines
except APIException as e:
#If myanimelist refuses the connection stop the scrapping and resume some time later
logging.error(f"The server did not respond when scrapping {index}: " +
str(e))
try:
print("Retrying after 15 seconds...")
time.sleep(15)
reviews = jikan.anime(row["code"],
extension='reviews')['reviews'][:num_reviews]
logging.basicConfig(level=logging.ERROR)
base_dir = "../data/recommendations"
source = "../data/anime_data.csv"
codes_df = pd.read_csv(source)
time_between_requests = 4 # in seconds
if not os.path.isdir(base_dir): # If the base_dir does not exist create it
os.mkdir(base_dir)
jikan = Jikan()
#scrap the recommendations starting from the lower_bound
for index, row in codes_df.iterrows():
try:
recommendations = jikan.anime(row["code"], extension='recommendations')['recommendations']
time.sleep(time_between_requests) # wait before making too many requests as per API guidelines
except APIException as e:
#If myanimelist refuses the connection stop the scrapping and resume some time later
logging.error(f"The server did not respond when scrapping {index}: " + str(e))
try:
print("Retrying after 15 seconds...")
time.sleep(15)
recommendations = jikan.anime(row["code"], extension='recommendations')['recommendations']
except APIException as e:
#If myanimelist refuses the connection stop the scrapping and resume some time later
logging.error(f"The server did not respond again when scrapping {index}: " + str(e))
continue
from jikanpy import Jikan from pprint import pprint jikan = Jikan() mushishi = jikan.anime(457) pprint(mushishi) fma = jikan.manga(25) pprint(fma) ginko = jikan.character(425) pprint(ginko) kana_hanazawa = jikan.person(189) pprint(kana_hanazawa) naruto = jikan.search(search_type='anime', query='naruto') pprint(naruto) winter_2018 = jikan.season(year=2018, season='winter') pprint(winter_2018) archive = jikan.season_archive() pprint(archive) later = jikan.season_later() pprint(later) monday = jikan.schedule(day='monday') pprint(monday)
