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