def search(self, search_type, query, page=None, key=None, value=None):
"""
Searches for a query on MyAnimeList
Keyword Arguments:
search_type -- where to search (anime, manga, person, character)
query -- query to search for
page -- page number of the results (default None)
key -- key for ?key=value URL query (default None)
value -- value for ?key=value URL query (default None)
"""
url = self.search_base.format(search_type=search_type, query=query)
# Check if page and query are valid
if page is not None:
if not isinstance(page, int):
raise ClientException('The parameter \'page\' must be an integer')
url += '/' + page
if key is not None:
if value is None:
raise ClientException('You need to pass a value with the key')
values = SEARCH_PARAMS.get(key, d=None)
if values is None:
raise ClientException('The key is not valid')
elif isinstance(values, list) and value not in values:
raise ClientException('The value is not valid')
url += '?' + key + '=' + value
# Get information from the API
response = session.get(url)
# Check if there's an error with the response
kwargs = {'search type': search_type, 'query': query}
self._check_response(response, **kwargs)
return response.json()
def top(self, type, page=None, subtype=None):
"""
Gets top items on MyAnimeList
Keyword Arguments:
type -- type to get top items from (anime, manga)
page -- page number of the results (default None)
subtype -- subtype to get filtered top items, possible values in docs
"""
url = self.top_base.format(type=type.lower())
# Check if type is valid
if type.lower() not in SUBTYPES:
raise ClientException('Type must be anime or manga')
# Check if page is valid
if page is not None:
if not isinstance(page, int):
raise ClientException('The parameter \'page\' must be an integer')
url += '/' + page
# Check if subtype is valid
if subtype is not None:
if subtype.lower() not in SUBTYPES[type.lower()]:
raise ClientException('Subtype is not valid for ' + type)
url += '/' + subtype.lower()
# Get information from the API
response = session.get(url)
# Check if there's an error with the response
self._check_response(response, type=type)
return response.json()
def genre(self,
type: str,
genre_id: int,
page: Optional[int] = None) -> Dict:
url: str = self._get_genre_url(type, genre_id, page)
response: Any = session.get(url)
self._check_response(response, id=genre_id, type=type)
return response.json()
def top(self,
type: str,
page: Optional[int] = None,
subtype: Optional[str] = None) -> Dict:
url: str = self._get_top_url(type, page, subtype)
response: Any = session.get(url)
self._check_response(response, type=type)
return response.json()
def _get_creator(self,
creator_type: str,
creator_id: int,
page: Optional[int] = None) -> Dict:
url: str = self._get_creator_url(creator_type, creator_id, page)
response: Any = session.get(url)
self._check_response(response, id=creator_id, endpoint=creator_type)
return response.json()
def meta(self, request, type, period):
url = self._get_meta_url(request, type, period)
response = session.get(url)
self._check_response(response,
request=request,
type=type,
period=period)
return response.json()
def _get(
self,
endpoint: str,
id: int,
extension: Optional[str],
page: Optional[int] = None,
) -> Dict:
url: str = self._get_url(endpoint, id, extension, page)
response: Any = session.get(url)
self._check_response(response, id=id, endpoint=endpoint)
return response.json()
def user(
self,
username: str,
request: Optional[str] = None,
argument: Optional[Union[int, str]] = None,
page: Optional[int] = None,
parameters: Optional[Mapping] = None,
) -> Dict:
url: str = self._get_user_url(username, request, argument, page,
parameters)
response: Any = session.get(url)
self._check_response(response, username=username, request=request)
return response.json()
def search(
self,
search_type: str,
query: str,
page: Optional[int] = None,
parameters: Optional[Mapping[str, Optional[Union[int, str,
float]]]] = None,
) -> Dict:
url: str = self._get_search_url(search_type, query, page, parameters)
response: Any = session.get(url)
kwargs: Dict[str, str] = {"search type": search_type, "query": query}
self._check_response(response, **kwargs)
return response.json()
def meta(
self,
request: str,
type: Optional[str] = None,
period: Optional[str] = None,
offset: Optional[int] = None,
) -> Dict:
url: str = self._get_meta_url(request, type, period, offset)
response: Any = session.get(url)
self._check_response(response,
request=request,
type=type,
period=period)
return response.json()
def _get(self, endpoint, id, extension):
url = self.base.format(endpoint=endpoint, id=id)
if extension is not None:
if extension not in EXTENSIONS[endpoint]:
raise ClientException
url += '/' + extension
response = session.get(url)
if response.status_code >= 400:
err_str = '{}: error for id {} on endpoint {}'.format(
response.status_code, id, endpoint)
raise APIException(err_str)
return response.json()
def season(self, year, season):
"""
Gets information on anime of the specific season
Keyword Arguments:
year -- year to get anime of
season -- season to get anime of (winter, spring, summer, fall)
"""
url = self.season_base.format(year=year, season=season.lower())
# Check if year and season are valid
if not (isinstance(year, int) and season.lower() in SEASONS):
raise ClientException('Season or year is not valid')
# Get information from the API
response = session.get(url)
# Check if there's an error with the response
self._check_response(response, year=year, season=season)
return response.json()
def schedule(self, day=None):
"""
Gets anime scheduled for the specific day
Keyword Arguments:
day -- day to get anime of (default None)
"""
url = self.schedule_base
# Check if day is valid
if day is not None:
if day.lower() not in DAYS:
raise ClientException('Day is not valid')
else:
url += '/' + day.lower()
# Get information from the API
response = session.get(url)
# Check if there's an error with the response
self._check_response(response, day=day)
return response.json()
def meta(self, request, type, period):
"""
Gets meta information regarding the Jikan REST API
Keyword Arguments:
request -- requests (requests, status)
type -- type to get info on, possible values in docs
period -- time period (today, weekly, monthly)
"""
url = self.meta_base.format(request=request, type=type, period=period)
# Check if request is valid
if request not in META['request']:
raise ClientException('Request must be \'requests\' or \'status\'')
if type not in META['type']:
raise ClientException('Type is not valid')
if period not in META['period']:
raise ClientException('Period must be \'today\', \'weekly\', or \'monthly\'')
# Get information from the API
response = session.get(url)
# Check if there's an error with the response
self._check_response(response, request=request, type=type, period=period)
return response.json()
def _get(self, endpoint, id, extension, page=None):
"""
Gets the response from Jikan API given the endpoint
Keyword Arguments:
endpoint -- endpoint of API (anime, manga, character, person)
id -- id of what to get the information of
extension -- special information to get, possible values in the docs
page -- page number of the results (default None)
"""
url = self.base.format(endpoint=endpoint, id=id)
# Check if extension is valid
if extension is not None:
if extension not in EXTENSIONS[endpoint]:
raise ClientException('The extension is not valid')
url += '/' + extension
if extension == 'episodes' and isinstance(page, int):
url += '/' + page
# Get information from the API
response = session.get(url)
# Check if there's an error with the response
self._check_response(response, id=id, endpoint=endpoint)
return response.json()
def _get(self, endpoint, id, extension, page=None):
url = self._get_url(endpoint, id, extension, page)
response = session.get(url)
self._check_response(response, id=id, endpoint=endpoint)
return response.json()
def user(self, username, request=None, argument=None, page=None):
url = self._get_user_url(username, request, argument, page)
response = session.get(url)
self._check_response(response, username=username, request=request)
return response.json()
def genre(self, type, genre_id, page=None):
url = self._get_genre_url(type, genre_id, page)
response = session.get(url)
self._check_response(response, id=genre_id, type=type)
return response.json()
def top(self, type, page=None, subtype=None):
url = self._get_top_url(type, page, subtype)
response = session.get(url)
self._check_response(response, type=type)
return response.json()
def schedule(self, day=None):
url = self._get_schedule_url(day)
response = session.get(url)
self._check_response(response, day=day)
return response.json()
def season_later(self):
response = session.get(self.season_later_url)
self._check_response(response)
return response.json()
def season_archive(self):
response = session.get(self.season_archive_url)
self._check_response(response)
return response.json()
def season(self, year, season):
url = self._get_season_url(year, season)
response = session.get(url)
self._check_response(response, year=year, season=season)
return response.json()
def search(self, search_type, query, page=None, parameters=None):
url = self._get_search_url(search_type, query, page, parameters)
response = session.get(url)
kwargs = {'search type': search_type, 'query': query}
self._check_response(response, **kwargs)
return response.json()
def _get_creator(self, creator_type, creator_id, page=None):
url = self._get_creator_url(creator_type, creator_id, page)
response = session.get(url)
self._check_response(response, id=creator_id, endpoint=creator_type)
return response.json()
def season(self, year: int, season: str) -> Dict:
url: str = self._get_season_url(year, season)
response: Any = session.get(url)
self._check_response(response, year=year, season=season)
return response.json()
def schedule(self, day: Optional[str] = None) -> Dict:
url: str = self._get_schedule_url(day)
response: Any = session.get(url)
self._check_response(response, day=day)
return response.json()
