def test_create_and_retrieve_anime_by_name_and_alias(session):
season = Season.get_or_create(SeasonOfYear.SPRING, 2006, session)
anime = Anime.create(1234, "The Melancholy of Haruhi Suzumiya", season,
session)
assert anime == Anime.get_by_name("The Melancholy of Haruhi Suzumiya",
session)
anime.add_alias("Suzumiya Haruhi no Yuutsu")
assert anime == Anime.get_by_name("Suzumiya Haruhi no Yuutsu", session)
def test_bench_swap(
# patches
season_config_mock,
# fixtures
session,
config_functor,
):
config_function = config_functor(
sections=["weekly info", "season info"],
kv={"current-week": 0, "min-weeks-between-bench-swaps": 3},
)
season_config_mock.getint.side_effect = config_function
season = Season.get_or_create(SeasonOfYear.SPRING, 2006, session)
haruhi = Anime.create(1234, "The Melancholy of Haruhi Suzumiya", season, session)
bebop = Anime.create(4321, "Cowboy Bebop", season, session)
team = Team.create(name=fake.user_name(), season=season, session=session)
team.add_anime_to_team(haruhi)
team.add_anime_to_team(bebop, True)
with pytest.raises(AssertionError):
# this should fail since bench and active are swapped
team.bench_swap(active_anime=bebop, bench_anime=haruhi, week=0)
team.bench_swap(active_anime=haruhi, bench_anime=bebop, week=0)
week_snapshot = team.get_anime(week=0)
assert week_snapshot == WeekSnapshotOfTeamAnime(
week=0, active=[bebop], bench=[haruhi]
)
with pytest.raises(AssertionError):
# this should fail since we just swapped this week
team.bench_swap(active_anime=bebop, bench_anime=haruhi, week=0)
for week in range(1, 5):
season.init_new_week(week)
config_function = config_functor(
sections=["weekly info", "season info"],
kv={"current-week": 4, "min-weeks-between-bench-swaps": 3},
)
season_config_mock.getint.side_effect = config_function
team.bench_swap(active_anime=bebop, bench_anime=haruhi, week=4)
week_snapshot = team.get_anime(week=4)
assert week_snapshot == WeekSnapshotOfTeamAnime(
week=4, active=[haruhi], bench=[bebop]
)
def calculate_anime_weekly_points(
self,
anime: Anime,
stat_data: JikanResults,
num_teams_owned_active: int,
double_score_max_num_teams: int,
num_regions: int,
is_licensed: bool,
) -> int:
"""
Calculate the points for the week for the anime based on the stats
"""
lower_ownership_multiplier = (
2 if num_teams_owned_active <= double_score_max_num_teams else 1)
# fmt: off
points = (lower_ownership_multiplier *
(stat_data.watching + stat_data.completed) +
self.dropped_multiplier * stat_data.dropped +
self.favorite_multiplier * stat_data.favorites +
self.simulcast_multiplier * num_regions +
self.license_score * int(is_licensed))
if self.current_week % self.forum_post_week_interval == 0:
previous_forum_posts = anime.get_forum_posts_for_week(
self.current_week - self.forum_post_week_interval)
points += self.forum_post_multipler * (
stat_data.total_forum_posts - previous_forum_posts)
# multiplying by None type produces weird results
# so we do these calculations only if stat_data.score exists
if stat_data.score:
points += int(self.anime_score_multipler * stat_data.score)
return points
def _execute(self, session: Session, season: Season) -> None:
post_content_regex = re.compile(r"(.+)\<br /\>.*\\n(.+)")
for username, post_content in self.get_swaps(session):
match = post_content_regex.fullmatch(post_content)
try:
assert match
except AssertionError:
print(f"Unexpected post contents: {post_content}")
raise
active, bench = match.group(1, 2)
team = Team.get_by_name(name=username,
season=season,
session=session)
team.bench_swap(
active_anime=Anime.get_by_name(active, session),
bench_anime=Anime.get_by_name(bench, session),
week=self.current_week,
)
def get_licensed_anime(self, session: Session) -> Set[int]:
print("Getting licensed anime from licenses file")
licensed_anime = set()
if self.licenses_lines is not None:
for title in self.licenses_lines:
title = title.strip()
try:
anime = Anime.get_by_name(title, session)
except sqlalchemy.orm.exc.NoResultFound:
print(f"{title} is not found in database")
continue
licensed_anime.add(anime.mal_id)
return licensed_anime
def get_anime_simulcast_region_counts(self,
session: Session) -> Dict[int, int]:
print("Getting region counts of each anime in simulcast file")
anime_simulcast_region_counts = {}
if self.simulcast_lines is not None:
for line in self.simulcast_lines:
title, subs = line.split("=")
title = title.strip()
try:
anime = Anime.get_by_name(title, session)
except sqlalchemy.orm.exc.NoResultFound:
print(f"{title} is not found in database")
continue
num_regions = len(
[entry for entry in subs.split() if entry == "simul"])
anime_simulcast_region_counts[anime.mal_id] = num_regions
return anime_simulcast_region_counts
def test_add_same_anime_to_team_raises_exception(
# patches
config_mock,
# factories
season_factory,
# fixtures
session,
config_functor,
):
config_function = config_functor(sections=["weekly info"], kv={"current-week": 0})
config_mock.getint.side_effect = config_function
season = season_factory()
anime = Anime.create(1234, "The Melancholy of Haruhi Suzumiya", season, session)
team = Team.create(name=fake.user_name(), season=season, session=session)
team.add_anime_to_team(anime)
with pytest.raises(IntegrityError):
team.add_anime_to_team(anime, True)
def get_anime(self, week: int) -> WeekSnapshotOfTeamAnime:
"""
Returns all anime on team during week specified
"""
this_week_anime = (self._session.query(orm.TeamWeeklyAnime).filter(
orm.TeamWeeklyAnime.team_id == self._entity.id,
orm.TeamWeeklyAnime.week == week,
).all())
snapshot = WeekSnapshotOfTeamAnime(week=week)
for team_weekly_anime in this_week_anime:
anime = Anime.from_orm_anime(team_weekly_anime.anime,
self._session)
if team_weekly_anime.bench:
snapshot.bench.append(anime)
else:
snapshot.active.append(anime)
return snapshot
def test_create_anime_twice_throws_exception(session):
season = Season.get_or_create(SeasonOfYear.SPRING, 2006, session)
Anime.create(1234, "The Melancholy of Haruhi Suzumiya", season, session)
with pytest.raises(IntegrityError):
Anime.create(1234, "Suzumiya Haruhi no Yuutsu", season, session)
def test_retrieve_anime_does_not_exist(session):
season = Season.get_or_create(SeasonOfYear.SPRING, 2006, session)
Anime.create(1234, "The Melancholy of Haruhi Suzumiya", season, session)
with pytest.raises(NoResultFound):
Anime.get_by_name("Suzumiya Haruhi no Yuutsu", session)