def test_date(self):
fd = fluent_date(self.a_date)
self.assertTrue(isinstance(fd, date))
self.assertTrue(isinstance(fd, FluentDateType))
self.assertEqual(fd.year, self.a_date.year)
self.assertEqual(fd.month, self.a_date.month)
self.assertEqual(fd.day, self.a_date.day)
def test_copy_attributes(self):
f1 = fluent_date(self.a_date, dateStyle='long', hour12=False)
self.assertEqual(f1.options.dateStyle, 'long')
f2 = fluent_date(f1, hour12=False)
# Check we copied other attributes:
self.assertEqual(f2.options.dateStyle, "long")
self.assertEqual(f2.options.hour12, False)
# Check we can override
f3 = fluent_date(f2, dateStyle="full")
self.assertEqual(f3.options.dateStyle, "full")
# and didn't mutate anything
self.assertEqual(f1.options.dateStyle, "long")
self.assertEqual(f2.options.dateStyle, "long")
def test_allow_unsupported_options(self):
# We are just checking that these don't raise exceptions
with warnings.catch_warnings():
warnings.simplefilter("ignore")
fluent_date(
self.a_date,
hour12=True,
weekday="narrow",
era="narrow",
year="numeric",
month="numeric",
day="numeric",
hour="numeric",
minute="numeric",
second="numeric",
timeZoneName="short",
)
def get_song_embed(self, ctx, song: MusicMaster):
l10n = self.l10n[ctx]
color_code = song.unit.main_color_code
color = discord.Colour.from_rgb(*ImageColor.getcolor(
color_code, 'RGB')) if color_code else discord.Embed.Empty
embed = discord.Embed(title=song.name, color=color)
embed.set_thumbnail(url=self.bot.asset_url +
get_asset_filename(song.jacket_path))
embed.add_field(
name=l10n.format_value('artist'),
value=l10n.format_value(
'artist-desc', {
'lyricist': song.lyricist,
'composer': song.composer,
'arranger': song.arranger,
'unit-name': song.unit.name,
'special-unit-name': song.special_unit_name or 'None',
}),
inline=False)
embed.add_field(
name=l10n.format_value('info'),
value=l10n.format_value(
'song-info-desc', {
'song-category':
song.category.name,
'duration':
self.format_duration(song.duration),
'bpm':
song.bpm,
'section-trend':
song.section_trend.name,
'sort-order':
song.default_order,
'levels':
', '.join(c.display_level for c in song.charts.values()),
'chart-designers':
', '.join({
f'{c.designer.name} ({c.designer.id})': None
for c in song.charts.values()
}.keys()),
'release-date':
fluent_date(ctx.convert_tz(song.start_datetime),
dateStyle='medium',
timeStyle='medium'),
'hidden':
song.is_hidden,
'fair-use':
song.can_fair_use,
}),
inline=False)
embed.set_footer(
text=l10n.format_value('song-id', {'song-id': f'{song.id:>07}'}))
return embed
def get_card_embed(self, ctx, card: CardMaster, limit_break):
l10n = self.l10n[ctx]
if card.rarity_id <= 2:
limit_break = 0
color_code = card.character.color_code
color = discord.Colour.from_rgb(*ImageColor.getcolor(color_code, 'RGB')) if color_code else discord.Embed.Empty
embed = discord.Embed(title=self.format_card_name(card), color=color)
thumb_url = ctx.bot.asset_url + get_asset_filename(card.icon_path(limit_break))
art_url = ctx.bot.asset_url + get_asset_filename(card.art_path(limit_break))
embed.set_thumbnail(url=thumb_url)
embed.set_image(url=art_url)
embed.add_field(name=l10n.format_value('info'),
value=l10n.format_value('info-desc', {
'rarity': f'{card.rarity_id}★',
'character': f'{card.character.full_name_english}',
'attribute': f'{ctx.bot.get_emoji(attribute_emoji_ids_by_attribute_id[card.attribute_id])} {card.attribute.en_name.capitalize()}',
'unit': f'{ctx.bot.get_emoji(unit_emoji_ids_by_unit_id[card.character.unit_id])} {card.character.unit.name}',
'release-date': fluent_date(ctx.convert_tz(card.start_datetime),
dateStyle='medium', timeStyle='medium'),
'event': f'{card.event.name if card.event else "None"}',
'gacha': f'{card.gacha.name if card.gacha else "None"}',
'availability': card.availability.name,
}),
inline=False)
embed.add_field(name=l10n.format_value('parameters'),
value=l10n.format_value('parameters-desc', {
'total': card.max_power_with_limit_break,
'heart': card.max_parameters_with_limit_break[0],
'technique': card.max_parameters_with_limit_break[1],
'physical': card.max_parameters_with_limit_break[2],
'heart-emoji': str(ctx.bot.get_emoji(parameter_bonus_emoji_ids_by_parameter_id[1])),
'technique-emoji': str(ctx.bot.get_emoji(parameter_bonus_emoji_ids_by_parameter_id[2])),
'physical-emoji': str(ctx.bot.get_emoji(parameter_bonus_emoji_ids_by_parameter_id[3])),
}),
inline=True)
skill: SkillMaster = card.skill
embed.add_field(name=l10n.format_value('skill'),
value=l10n.format_value('skill-desc', {
'name': card.skill_name,
'duration': f'{skill.min_seconds}-{skill.max_seconds}s',
'score-up': f'{skill.score_up_rate}%' if not skill.perfect_score_up_rate else f'{skill.score_up_rate}% + {skill.perfect_score_up_rate}% perfect',
'heal': (f'{skill.min_recovery_value}-{skill.max_recovery_value}'
if skill.min_recovery_value != skill.max_recovery_value
else str(skill.min_recovery_value))
}),
inline=True)
embed.set_footer(text=l10n.format_value('card-id', {'card-id': f'{card.id:0>8}'}))
return embed
def test_datetime(self):
fd = fluent_date(self.a_datetime)
self.assertTrue(isinstance(fd, datetime))
self.assertTrue(isinstance(fd, FluentDateType))
self.assertEqual(fd.year, self.a_datetime.year)
self.assertEqual(fd.month, self.a_datetime.month)
self.assertEqual(fd.day, self.a_datetime.day)
self.assertEqual(fd.hour, self.a_datetime.hour)
self.assertEqual(fd.minute, self.a_datetime.minute)
self.assertEqual(fd.second, self.a_datetime.second)
self.assertEqual(fd.microsecond, self.a_datetime.microsecond)
self.assertEqual(fd.tzinfo, self.a_datetime.tzinfo)
def test_timeZone(self):
en_GB = Locale.parse('en_GB')
LondonTZ = pytz.timezone('Europe/London')
# 1st July is a date in British Summer Time
# datetime object with tzinfo set to BST
dt1 = datetime(2018, 7, 1, 23, 30, 0,
tzinfo=pytz.UTC).astimezone(LondonTZ)
fd1 = fluent_date(dt1, dateStyle='short', timeStyle='short')
self.assertEqual(fd1.format(en_GB), '02/07/2018, 00:30')
fd1b = fluent_date(dt1, dateStyle='full', timeStyle='full')
self.assertEqual(
fd1b.format(en_GB),
'Monday, 2 July 2018 at 00:30:00 British Summer Time')
fd1c = fluent_date(dt1, dateStyle='short')
self.assertEqual(fd1c.format(en_GB), '02/07/2018')
fd1d = fluent_date(dt1, timeStyle='short')
self.assertEqual(fd1d.format(en_GB), '00:30')
# datetime object with no TZ, TZ passed in to fluent_date
dt2 = datetime(2018, 7, 1, 23, 30, 0) # Assumed UTC
fd2 = fluent_date(dt2,
dateStyle='short',
timeStyle='short',
timeZone='Europe/London')
self.assertEqual(fd2.format(en_GB), '02/07/2018, 00:30')
fd2b = fluent_date(dt2,
dateStyle='full',
timeStyle='full',
timeZone='Europe/London')
self.assertEqual(
fd2b.format(en_GB),
'Monday, 2 July 2018 at 00:30:00 British Summer Time')
fd2c = fluent_date(dt2, dateStyle='short', timeZone='Europe/London')
self.assertEqual(fd2c.format(en_GB), '02/07/2018')
fd2d = fluent_date(dt1, timeStyle='short', timeZone='Europe/London')
self.assertEqual(fd2d.format(en_GB), '00:30')
def fmt_date(date):
return fluent_date(date, dateStyle='medium', timeStyle='medium')
def test_arg_overrides_fluent_date(self):
val, errs = self.ctx.format(
'call-with-arg',
{'date': fluent_date(date(2018, 2, 1), dateStyle='short')})
self.assertEqual(val, "February 1, 2018")
self.assertEqual(len(errs), 0)
def test_explicit_call_date_fluent_date(self):
val, errs = self.ctx.format(
'explicit-call',
{'date': fluent_date(date(2018, 2, 1), dateStyle='short')})
self.assertEqual(val, "2/1/18")
self.assertEqual(len(errs), 0)
def test_dateStyle_and_timeStyle_datetime(self):
fd = fluent_date(self.a_datetime, timeStyle='short', dateStyle='short')
en_US = Locale.parse('en_US')
en_GB = Locale.parse('en_GB')
self.assertEqual(fd.format(en_US), '2/1/18, 2:15 PM')
self.assertEqual(fd.format(en_GB), '01/02/2018, 14:15')
def test_timeStyle_datetime(self):
fd = fluent_date(self.a_datetime, timeStyle='short')
en_US = Locale.parse('en_US')
en_GB = Locale.parse('en_GB')
self.assertEqual(fd.format(en_US), '2:15 PM')
self.assertEqual(fd.format(en_GB), '14:15')
def test_dateStyle_datetime(self):
fd = fluent_date(self.a_datetime, dateStyle='long')
en_US = Locale.parse('en_US')
en_GB = Locale.parse('en_GB')
self.assertEqual(fd.format(en_GB), '1 February 2018')
self.assertEqual(fd.format(en_US), 'February 1, 2018')
def test_format_defaults(self):
fd = fluent_date(self.a_date)
en_US = Locale.parse('en_US')
en_GB = Locale.parse('en_GB')
self.assertEqual(fd.format(en_GB), '1 Feb 2018')
self.assertEqual(fd.format(en_US), 'Feb 1, 2018')
def test_explicit_call_date_fluent_date(self):
val, errs = self.bundle.format_pattern(
self.bundle.get_message('explicit-call').value,
{'date': fluent_date(date(2018, 2, 1), dateStyle='short')})
self.assertEqual(val, "2/1/18")
self.assertEqual(len(errs), 0)
def test_arg_overrides_fluent_date(self):
val, errs = self.bundle.format_pattern(
self.bundle.get_message('call-with-arg').value,
{'date': fluent_date(date(2018, 2, 1), dateStyle='short')})
self.assertEqual(val, "February 1, 2018")
self.assertEqual(len(errs), 0)
def test_dont_wrap_unnecessarily(self):
f1 = fluent_date(self.a_date)
f2 = fluent_date(f1)
self.assertIs(f1, f2)
