def rand(filename, is_header, page, start):
import csv
import time
from jikanpy import Jikan, exceptions
jikan = Jikan()
def write_row(info, fieldnames, writer):
f = (info.title, info.type, info.episodes, info.studio, info.source,
info.genre, info.score, info.synopsis, info.url, info.image_url)
row = {x: y for x, y in zip(fieldnames, f)}
writer.writerow(row)
# time.sleep(15)
with open(filename, 'a', newline='', encoding='UTF-8') as csvfile:
fieldnames = [
'title', 'type', 'episodes', 'studio', 'src', 'genre', 'score',
'synopsis', 'url', 'image_url'
]
writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
if is_header:
writer.writeheader()
top_anime = jikan.top(type='anime')
for index, each in enumerate(top_anime['top'][start:]):
print('Processing anime number [{}].'.format(index + start))
try:
info = AnimePageInfo(each['mal_id'])
except exceptions.APIException:
print('FAIL.')
exit(1)
else:
write_row(info, fieldnames, writer)
def vrv(vrvlink):
jikan = Jikan()
page = requests.get(vrvlink)
soup = bs(page.content, 'html.parser')
title = str(soup.find_all('title'))[8:-9]
mallink = jikan.search('anime', title)['results'][0]['url']
return mallink
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 rating(code):
try:
jikan = Jikan()
data = jikan.anime(code)
return data["score"]
except Exception:
return 0
def get_top_500():
data = set()
jikan = Jikan()
for i in range(1, 11):
time.sleep(2)
print(f"Processing page: {i}")
top_anime = jikan.top(type='anime', page=i, subtype='bypopularity')
for j in range(0, 50):
if top_anime["top"][j]["type"] not in ["OVA", "Music", "Special"]:
data.add(top_anime["top"][j]["title"])
for i in range(11, 16):
time.sleep(2)
print(f"Processing page: {i}")
top_anime = jikan.top(type='anime', page=i, subtype='bypopularity')
for j in range(0, 50):
if (top_anime["top"][j]["type"] not in [
"OVA", "Music", "Special"
]) and top_anime["top"][j]["score"] >= 7.4:
data.add(top_anime["top"][j]["title"])
for i in range(16, 21):
time.sleep(2)
print(f"Processing page: {i}")
top_anime = jikan.top(type='anime', page=i, subtype='bypopularity')
for j in range(0, 50):
if (top_anime["top"][j]["type"] not in [
"OVA", "Music", "Special"
]) and top_anime["top"][j]["score"] >= 7.8:
data.add(top_anime["top"][j]["title"])
return data
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
class MyAnimeListAPI(object):
def __init__(self, username):
self._instance = Jikan()
self._user = username
def search(self, title):
search_results = self._instance.search('anime', title)['results']
entries = []
for result in search_results:
entries.append(AnimeEntry(result))
return entries
def currently_watching(self):
response = self._instance.user(username=self._user,
request="animelist",
argument="watching")
anime_list = []
for anime in response['anime']:
anime_list.append(AnimeEntry(anime))
return anime_list
def plan_to_watch(self):
response = self._instance.user(username=self._user,
request="animelist",
argument="plantowatch")
anime_list = []
for anime in response['anime']:
anime_list.append(AnimeEntry(anime))
return anime_list
def handle(self, *args, **options):
links = []
jikan = Jikan()
driver = webdriver.Chrome(
"C:/Users/AFIF/Downloads/chromedriver_win32/chromedriver.exe")
# driver = webdriver.Chrome()
url = "https://www.justwatch.com/in/provider/netflix/tv-shows?genres=ani&sort_by=release_year"
driver.maximize_window()
driver.get(url)
time.sleep(5)
count = 0
#Scrolling _____________________________________________________________________
from selenium.webdriver.common.action_chains import ActionChains
i = 1
for i in range(15):
ActionChains(driver).move_to_element(
driver.find_element_by_class_name(
'jw-app-footer__link')).perform()
time.sleep(1.5)
content = driver.page_source.encode('utf-8').strip()
soup1 = BeautifulSoup(content, "html.parser")
anime1 = soup1.find_all(class_="title-list-grid__item")
for div in anime1:
links.append(div.a['href'])
l = []
l = div.a['href'].split('/')
l2 = []
l2 = l[3].split('-')
s = ""
for i in l2:
s += i
s += " "
# try:
# save in db
if Anime.objects.filter(anime_name=s).exists():
print("{} contained in queryset".format(s))
else:
try:
search_result = jikan.search('anime', s)
p = Anime(
anime_name=s,
score=search_result['results'][0]['score'],
synopsis=search_result['results'][0]['synopsis'],
url=search_result['results'][0]['url'],
image_url=search_result['results'][0]['image_url'])
p.save()
print('%s added' % (s))
count += 1
except:
print("{} COULD NOT BE ADDED".format(s))
time.sleep(4)
print(count)
# print(AnimeNames.objects.get(anime_name='ergo proxy'))
driver.quit()
self.stdout.write('job complete')
def malSearch(name):
print()
print('Initial title: ' + name)
#Initiate Jikan
jikan = Jikan()
if len(name) < 3:
log(1, name)
return False
rname = name.replace('&', 'and')
try:
jfile = jikan.search('anime', rname)
except:
log(2, name)
return False
jdata = json.loads(json.dumps(jfile))
jver = jverify(name, jdata)
if jver == False:
log(2, name)
return False
return [str(jdata['results'][jver[1]]['mal_id']), jver[0]]
def netflix(netflixlink):
url = re.findall('https:.*$', netflixlink)
jikan = Jikan()
page = requests.get(url[0])
soup = bs(page.content, 'html.parser')
title = str(soup.find_all('title'))[8:-19]
mallink = jikan.search('anime', title)['results'][0]['url']
return mallink
def searchMAL(title, imgList, sleep):
jikan = Jikan()
result = jikan.search('anime', title)
firstResult = result["results"][0]
imgList.append(firstResult["image_url"])
print(firstResult["title"])
time.sleep(sleep)
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 getSeasonAnime(animePos=1):
searchResult = Jikan().top(type='anime', page=1, subtype='upcoming')
animeID = searchResult['top'][animePos - 1]['mal_id']
searchResult = Jikan().anime(animeID)
embedVar = showAnime(searchResult)
embedVar.set_footer(text=f"{animePos}/50")
return embedVar
def series_memo_identifier(id=None, *, name=None):
jikan = Jikan()
if id:
mal_id = id
elif name:
mal_id = jikan.search('anime', name)['results'][0]['mal_id']
else:
raise ValueError('You must specify an ID or name.')
return mal_id
def top_animes(self, message, name_sender):
jikan = Jikan()
anime_name = []
top_anime = jikan.top(type='anime')
for episode in top_anime['top']:
anime_name.append([episode['title']])
self.post(message="Top_5 animes \n 1°%s\n2°%s\n3°%s\n4°%s\n5°%s." %
(anime_name[0], anime_name[1], anime_name[2], anime_name[3],
anime_name[4]))
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 __init__(self, bot):
"""
Constructor: initialize the cog.
:param bot: The Discord bot.
"""
self.bot = bot
self.discordUser = None
self.malUser = None
self.channel = None
self.jikan = Jikan()
def handle(self, *args, **options):
jikan = Jikan()
resp = jikan.top('anime')
for data in resp['top']:
print(data)
form = AnimeForm(data=data)
if form.is_valid():
form.save()
else:
print(form.errors)
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
class MTJikan(API):
calls_minute = None
calls_second = None
last_api_call = None
def __init__(
self,
selected_base: Optional[str] = None,
session: Optional[requests.Session] = None,
) -> None:
self.jikan = Jikan()
@classmethod
def initialize(cls):
super().__init__(2, 30)
def search(
self,
search_type: str,
query: str,
page: Optional[int] = None,
parameters: Optional[Mapping[str, Optional[Union[int, str,
float]]]] = None,
) -> Dict[str, Any]:
super()._check_rate_seconds()
super()._check_rate_minutes()
MTJikan.calls_second += 1
MTJikan.calls_minute += 1
MTJikan.last_api_call = datetime.now()
search_results = self.jikan.search(search_type, query, page,
parameters)
return search_results["results"]
def manga(self,
id: int,
extension: Optional[str] = None,
page: Optional[int] = None) -> Dict[str, Any]:
super()._check_rate_seconds()
super()._check_rate_minutes()
MTJikan.calls_second += 1
MTJikan.calls_minute += 1
MTJikan.last_api_call = datetime.now()
search_results = self.jikan.manga(id, extension, page)
search_results["source"] = "MAL"
search_results["id"] = str(id)
search_results["url"] = r"https://myanimelist.net/manga/" + str(id)
return search_results
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 repeat_all_messages(message):
request = message.text
jikan = Jikan()
apiResult = jikan.search('anime', request)
listResult = apiResult['results'][:5]
keyboard: InlineKeyboardMarkup = types.InlineKeyboardMarkup()
for item in listResult:
btn = types.InlineKeyboardButton(text=item['title'], url=item['url'])
keyboard.add(btn)
if not listResult:
bot.send_message(message.chat.id, "Ошибка, введите название аниме:")
else:
bot.send_message(message.chat.id,
'Нажми на кнопку и перейди по ссылки.',
reply_markup=keyboard)
async def seasonal(ctx,rank=9999):
jk = Jikan()
anime = jk.season(year=2020,season='summer')['anime']
if rank != 9999:
rank = rank -1
if rank > len(anime):
await ctx.send('baka, Only {} new anime this summer'.format(len(anime)))
else:
data = "{} \n\nName: {}\nScore: {}\nEpisodes: TBA\n".format(anime[rank]['image_url'],anime[rank]['title'],anime[rank]['score'])
await ctx.send(data)
else:
for i in range(10):
if anime[i]['episodes'] == None:
data = "{} \n\nName: {}\nScore: {}\nEpisodes: TBA\n".format(anime[i]['image_url'],anime[i]['title'],anime[i]['score'])
else:
data = "{} \n\nName: {}\nScore: {}\nEpisodes: {}\n".format(anime[i]['image_url'],anime[i]['title'],anime[i]['score'],anime[i]['episodes'])
await ctx.send(data)
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 __init__(self, id=None, *, name=None):
self._jikan = Jikan()
self.series = self._get_franchise_list(id)
self.title = self._discern_title()
self.release_run = (self.series[0].premiered, self.series[-1].ended)
self._absolute = [
ep for series in self.series for ep in series.episodes
]
def get_default_jikan():
global jikan
if jikan is None:
print('[I] Created new Jikan instance')
jikan = Jikan()
return jikan
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
