def test_dict_filter():
def filter_(key, val):
return key == val
dict_ = {'foo': 'foo', 'bar': 'baz', (): ()}
assert dict_filter(dict_, filter_) == {'foo': 'foo', (): ()}
def test_dict_filter_too_many_args():
def filter_(arg, argg, arggg):
return True
with pytest.raises(TypeError):
dict_filter({'': ''}, filter_)
def update_media_list_entry( # pylint: disable=R0913
self,
id_: int,
status: Optional[MediaListStatus] = None,
score: Optional[float] = None,
progress: Optional[int] = None,
custom_lists: Optional[Dict[str, bool]] = None,
private: Optional[bool] = None,
started_at: Optional[date] = None,
completed_at: Optional[date] = None,
repeat: Optional[int] = None) -> Optional[dict]:
"""
Update a media list entry for the user.
Args:
id_: The media ID
status: The watching status
score: The score of the entry
progress: The amount of episodes consumed by the user
custom_lists: Map of booleans for which lists the entry are in
private: If the entry should only be visible to authenticated user
started_at: When the entry was started by the user
completed_at: When the entry was completed by the user
repeat: The amount of times the user has re-watched the media
Returns:
The updated media entry values.
"""
query = """\
mutation (
$mediaId: Int,
$status: MediaListStatus,
$score: Float,
$progress: Int,
$customLists: Json,
$private: Boolean,
$startedAt: FuzzyDate,
$completedAt: FuzzyDate,
$repeat: Int
) {
SaveMediaListEntry (
mediaId: $mediaId,
status: $status,
score: $score,
progress: $progress,
customLists: $customLists,
private: $private,
startedAt: $startedAt,
completedAt: $completedAt,
repeat: $repeat
) {
id
status
score
progress
customLists
private
startedAt
completedAt
repeat
}
}"""
variables = dict_filter({
"mediaId": id_,
"status": status.name if status else None,
"score": score,
"progress": progress,
"customLists": custom_lists,
"private": private,
"startedAt": {
"year": started_at.year,
"month": started_at.month,
"day": started_at.day
} if started_at else None,
"completedAt": {
"year": completed_at.year,
"month": completed_at.month,
"day": completed_at.day
} if completed_at else None,
"repeat": repeat,
})
return self.query(query, variables)
def test_dict_filter_none():
dict_ = {'foo': None, None: 'bar', '': [], (): {}}
assert dict_filter(dict_) == {'': [], (): {}}
def browse_anime( # pylint: disable=R0914
self,
page=1,
*,
is_adult: bool = None,
search: str = None,
format_: MediaFormat = None,
status: MediaStatus = None,
season: MediaSeason = None,
year_range: Tuple[int, int] = None,
on_list: bool = None,
licensed_by: List[str] = None,
included_genres: List[str] = None,
excluded_genres: List[str] = None,
included_tags: List[str] = None,
excluded_tags: List[str] = None,
sort: List[MediaSort] = None) -> Tuple[List[dict], bool]:
"""
Browse anime by the given filters.
Args:
page: which page of the anime to return
is_adult: Filter by if the media's intended for 18+ adult audiences
search: Filter by search query
format_: Filter by the media's format
status: Filter by the media's current release status
season: The season the media was initially released in
year_range: The year range the media is ranked within
on_list: Filter by the media on the authenticated user's lists
licensed_by: Filter media by sites with a online streaming license
included_genres: Filter by the media's genres
excluded_genres: Filter by the media's genres
included_tags: Filter by the media's tags
excluded_tags: Filter by the media's tags
sort: The order the results will be returned in
Returns:
The page anime returned and if there's a next page
"""
query = """\
query (
$page: Int = 1,
$isAdult: Boolean = false,
$search: String,
$format: MediaFormat
$status: MediaStatus,
$season: MediaSeason,
$year: String,
$onList: Boolean,
$yearLesser: FuzzyDateInt,
$yearGreater: FuzzyDateInt,
$licensedBy: [String],
$includedGenres: [String],
$excludedGenres: [String],
$includedTags: [String],
$excludedTags: [String],
$sort: [MediaSort] = [SCORE_DESC, POPULARITY_DESC],
$perPage: Int,
) {
Page (page: $page, perPage: $perPage) {
pageInfo {
total
perPage
currentPage
lastPage
hasNextPage
}
media (
type: ANIME,
season: $season,
format: $format,
status: $status,
search: $search,
onList: $onList,
startDate_like: $year,
startDate_lesser: $yearLesser,
startDate_greater: $yearGreater,
licensedBy_in: $licensedBy,
genre_in: $includedGenres,
genre_not_in: $excludedGenres,
tag_in: $includedTags,
tag_not_in: $excludedTags,
sort: $sort,
isAdult: $isAdult
) {
id
title {
userPreferred
}
coverImage {
large
}
bannerImage
startDate {
year
month
day
}
endDate {
year
month
day
}
season
description
type
format
status
genres
isAdult
averageScore
popularity
mediaListEntry {
status
}
nextAiringEpisode {
airingAt
timeUntilAiring
episode
}
studios (isMain: true) {
edges {
isMain
node {
id
name
}
}
}
}
}
}"""
variables = dict_filter({
'page': page,
'isAdult': is_adult,
'search': search,
'format': format_.name if format_ else None,
'status': status.name if status else None,
'season': season.name if season else None,
'onList': on_list,
'licensedBy': licensed_by,
'includedGenres': included_genres,
'excludedGenres': excluded_genres,
'includedTags': included_tags,
'excludedTags': excluded_tags,
})
if sort:
variables['sort'] = [s.name for s in sort]
if year_range and year_range[0] and year_range[1]:
start, fin = year_range
if start == fin:
variables['year'] = f'{start}%'
else:
variables['yearGreater'] = start * 10000
variables['yearLesser'] = fin * 10000
res = self.query(query, variables).get('data', {}).get('Page', {})
has_next = res.get('pageInfo', {}).get('hasNextPage', False)
return res.get('media', []), has_next