Original conversion suggestions via flynt, edited by hand.
:param identifier: the identifier string of the unsupported locale
"""
- Exception.__init__(self, 'unknown locale %r' % identifier)
+ Exception.__init__(self, f"unknown locale {identifier!r}")
#: The identifier of the locale that could not be found.
self.identifier = identifier
elif isinstance(identifier, Locale):
return identifier
elif not isinstance(identifier, str):
- raise TypeError('Unexpected value for identifier: %r' % (identifier,))
+ raise TypeError(f"Unexpected value for identifier: {identifier!r}")
parts = parse_locale(identifier, sep=sep)
input_id = get_locale_identifier(parts)
for key in ('territory', 'script', 'variant'):
value = getattr(self, key)
if value is not None:
- parameters.append('%s=%r' % (key, value))
- parameter_string = '%r' % self.language + ', '.join(parameters)
- return 'Locale(%s)' % parameter_string
+ parameters.append(f"{key}={value!r}")
+ return f"Locale({self.language!r}{', '.join(parameters)})"
def __str__(self):
return get_locale_identifier((self.language, self.territory,
details.append(locale.variants.get(self.variant))
details = filter(None, details)
if details:
- retval += ' (%s)' % u', '.join(details)
+ retval += f" ({', '.join(details)})"
return retval
display_name = property(get_display_name, doc="""\
parts = identifier.split(sep)
lang = parts.pop(0).lower()
if not lang.isalpha():
- raise ValueError('expected only letters, got %r' % lang)
+ raise ValueError(f"expected only letters, got {lang!r}")
script = territory = variant = None
if parts:
variant = parts.pop().upper()
if parts:
- raise ValueError('%r is not a valid locale identifier' % identifier)
+ raise ValueError(f"{identifier!r} is not a valid locale identifier")
return lang, territory, script, variant
try:
return _pytz.timezone(zone)
except _pytz.UnknownTimeZoneError:
- raise LookupError('Unknown timezone %s' % zone)
+ raise LookupError(f"Unknown timezone {zone}")
def get_next_timezone_transition(zone=None, dt=None):
return int(self.to_tzinfo._utcoffset.total_seconds())
def __repr__(self):
- return '<TimezoneTransition %s -> %s (%s)>' % (
- self.from_tz,
- self.to_tz,
- self.activates,
- )
+ return f"<TimezoneTransition {self.from_tz} -> {self.to_tz} ({self.activates})>"
def get_period_names(width='wide', context='stand-alone', locale=LC_TIME):
yield unit_rel_patterns['future']
else:
yield unit_rel_patterns['past']
- a_unit = 'duration-' + a_unit
+ a_unit = f"duration-{a_unit}"
yield locale._data['unit_patterns'].get(a_unit, {}).get(format)
for unit, secs_per_unit in TIMEDELTA_UNITS:
self.format = format
def __repr__(self):
- return '<%s %r>' % (type(self).__name__, self.pattern)
+ return f"<{type(self).__name__} {self.pattern!r}>"
def __str__(self):
pat = self.pattern
elif char in ('z', 'Z', 'v', 'V', 'x', 'X', 'O'):
return self.format_timezone(char, num)
else:
- raise KeyError('Unsupported date/time field %r' % char)
+ raise KeyError(f"Unsupported date/time field {char!r}")
def extract(self, char):
char = str(char)[0]
elif char == 'a':
return int(self.value.hour >= 12) # 0 for am, 1 for pm
else:
- raise NotImplementedError("Not implemented: extracting %r from %r" % (char, self.value))
+ raise NotImplementedError(f"Not implemented: extracting {char!r} from {self.value!r}")
def format_era(self, char, num):
width = {3: 'abbreviated', 4: 'wide', 5: 'narrow'}[max(3, num)]
if week == 0:
date = self.value - timedelta(days=self.value.day)
week = self.get_week_number(date.day, date.weekday())
- return '%d' % week
+ return str(week)
def format_weekday(self, char='E', num=4):
"""
return self.format(self.get_day_of_year(), num)
def format_day_of_week_in_month(self):
- return '%d' % ((self.value.day - 1) // 7 + 1)
+ return str((self.value.day - 1) // 7 + 1)
def format_period(self, char, num):
"""
period_names = get_period_names(context=context, width=width, locale=self.locale)
if period in period_names:
return period_names[period]
- raise ValueError('Could not format period %s in %s' % (period, self.locale))
+ raise ValueError(f"Could not format period {period} in {self.locale}")
def format_frac_seconds(self, num):
""" Return fractional seconds.
fieldchar, fieldnum = tok_value
limit = PATTERN_CHARS[fieldchar]
if limit and fieldnum not in limit:
- raise ValueError('Invalid length for field: %r'
- % (fieldchar * fieldnum))
+ raise ValueError(f"Invalid length for field: {fieldchar * fieldnum!r}")
result.append('%%(%s)s' % (fieldchar * fieldnum))
else:
- raise NotImplementedError("Unknown token type: %s" % tok_type)
+ raise NotImplementedError(f"Unknown token type: {tok_type}")
_pattern_cache[pattern] = pat = DateTimePattern(pattern, u''.join(result))
return pat
return lst[0]
if style not in locale.list_patterns:
- raise ValueError('Locale %s does not support list formatting style %r (supported are %s)' % (
- locale,
- style,
- list(sorted(locale.list_patterns)),
- ))
+ raise ValueError(
+ f'Locale {locale} does not support list formatting style {style!r} '
+ f'(supported are {sorted(locale.list_patterns)})'
+ )
patterns = locale.list_patterns[style]
if len(lst) == 2:
# Ensure we're not left with one of the Windows reserved names.
if sys.platform == "win32" and _windows_reserved_name_re.match(os.path.splitext(name)[0]):
- raise ValueError("Name %s is invalid on Windows" % name)
+ raise ValueError(f"Name {name} is invalid on Windows")
# Build the path.
- return os.path.join(_dirname, '%s.dat' % name)
+ return os.path.join(_dirname, f"{name}.dat")
def exists(name):
self.keys = tuple(keys)
def __repr__(self):
- return '<%s %r>' % (type(self).__name__, self.keys)
+ return f"<{type(self).__name__} {self.keys!r}>"
def resolve(self, data):
"""Resolve the alias based on the given data.
if timezone is None:
# Nope, that didn't work. Try adding 'Standard Time',
# it seems to work a lot of times:
- timezone = tz_names.get(tzkeyname + ' Standard Time')
+ timezone = tz_names.get(f"{tzkeyname} Standard Time")
# Return what we have.
if timezone is None:
- raise pytz.UnknownTimeZoneError('Can not find timezone ' + tzkeyname)
+ raise pytz.UnknownTimeZoneError(f"Can not find timezone {tzkeyname}")
return timezone
hours_offset_s, mins_offset_s = rest[:2], rest[2:]
# Make them all integers
- plus_minus = int(plus_minus_s + '1')
+ plus_minus = int(f"{plus_minus_s}1")
hours_offset = int(hours_offset_s)
mins_offset = int(mins_offset_s)
self.context = context
def __repr__(self):
- return '<%s %r (flags: %r)>' % (type(self).__name__, self.id,
- list(self.flags))
+ return f"<{type(self).__name__} {self.id!r} (flags: {list(self.flags)!r})>"
def __cmp__(self, other):
"""Compare Messages, taking into account plural ids"""
self._locale = None
return
- raise TypeError('`locale` must be a Locale, a locale identifier string, or None; got %r' % locale)
+ raise TypeError(f"`locale` must be a Locale, a locale identifier string, or None; got {locale!r}")
def _get_locale(self):
return self._locale
.replace('ORGANIZATION', self.copyright_holder)
locale_name = (self.locale.english_name if self.locale else self.locale_identifier)
if locale_name:
- comment = comment.replace('Translations template', '%s translations' % locale_name)
+ comment = comment.replace("Translations template", f"{locale_name} translations")
return comment
def _set_header_comment(self, string):
def _get_mime_headers(self):
headers = []
- headers.append(('Project-Id-Version',
- '%s %s' % (self.project, self.version)))
+ headers.append(("Project-Id-Version", f"{self.project} {self.version}"))
headers.append(('Report-Msgid-Bugs-To', self.msgid_bugs_address))
headers.append(('POT-Creation-Date',
format_datetime(self.creation_date, 'yyyy-MM-dd HH:mmZ',
if self.locale is not None:
headers.append(('Plural-Forms', self.plural_forms))
headers.append(('MIME-Version', '1.0'))
- headers.append(('Content-Type',
- 'text/plain; charset=%s' % self.charset))
+ headers.append(("Content-Type", f"text/plain; charset={self.charset}"))
headers.append(('Content-Transfer-Encoding', '8bit'))
- headers.append(('Generated-By', 'Babel %s\n' % VERSION))
+ headers.append(("Generated-By", f"Babel {VERSION}\n"))
return headers
def _force_text(self, s, encoding='utf-8', errors='strict'):
if 'charset' in params:
self.charset = params['charset'].lower()
elif name == 'plural-forms':
- params = parse_separated_header(' ;' + value)
+ params = parse_separated_header(f" ;{value}")
self._num_plurals = int(params.get('nplurals', 2))
self._plural_expr = params.get('plural', '(n != 1)')
elif name == 'pot-creation-date':
'nplurals=2; plural=(n > 1);'
:type: `str`"""
- return 'nplurals=%s; plural=%s;' % (self.num_plurals, self.plural_expr)
+ return f"nplurals={self.num_plurals}; plural={self.plural_expr};"
def __contains__(self, id):
"""Return whether the catalog has a message with the specified ID."""
:rtype: ``iterator``"""
buf = []
for name, value in self.mime_headers:
- buf.append('%s: %s' % (name, value))
+ buf.append(f"{name}: {value}")
flags = set()
if self.fuzzy:
flags |= {'fuzzy'}
def __repr__(self):
locale = ''
if self.locale:
- locale = ' %s' % self.locale
- return '<%s %r%s>' % (type(self).__name__, self.domain, locale)
+ locale = f" {self.locale}"
+ return f"<{type(self).__name__} {self.domain!r}{locale}>"
def __delitem__(self, id):
"""Delete the message with the specified ID."""
elif id == '':
# special treatment for the header message
self.mime_headers = message_from_string(message.string).items()
- self.header_comment = '\n'.join([('# %s' % c).rstrip() for c
- in message.user_comments])
+ self.header_comment = "\n".join([f"# {c}".rstrip() for c in message.user_comments])
self.fuzzy = message.fuzzy
else:
if isinstance(id, (list, tuple)):
assert isinstance(message.string, (list, tuple)), \
- 'Expected sequence but got %s' % type(message.string)
+ f"Expected sequence but got {type(message.string)}"
self._messages[key] = message
def add(self, id, string=None, locations=(), flags=(), auto_comments=(),
type_map = dict(a)
for name, typechar in b:
if name not in type_map:
- raise TranslationError('unknown named placeholder %r' % name)
+ raise TranslationError(f'unknown named placeholder {name!r}')
elif not _compatible(typechar, type_map[name]):
raise TranslationError('incompatible format for '
'placeholder %r: '
DEFAULT_MAPPING = [('**.py', 'python')]
-empty_msgid_warning = (
- '%s: warning: Empty msgid. It is reserved by GNU gettext: gettext("") '
- 'returns the header entry with meta information, not the empty string.')
def _strip_comment_tags(comments, tags):
func = builtin.get(method)
if func is None:
- raise ValueError('Unknown extraction method %r' % method)
+ raise ValueError(f"Unknown extraction method {method!r}")
results = func(fileobj, keywords.keys(), comment_tags,
options=options or {})
first_msg_index = spec[0] - 1
if not messages[first_msg_index]:
# An empty string msgid isn't valid, emit a warning
- where = '%s:%i' % (hasattr(fileobj, 'name') and
- fileobj.name or '(unknown)', lineno)
- sys.stderr.write((empty_msgid_warning % where) + '\n')
+ filename = (getattr(fileobj, "name", None) or "(unknown)")
+ sys.stderr.write(
+ f"{filename}:{lineno}: warning: Empty msgid. It is reserved by GNU gettext: gettext(\"\") "
+ f"returns the header entry with meta information, not the empty string.\n"
+ )
continue
messages = tuple(msgs)
for catalog, errors in self._run_domain(domain).items():
n_errors += len(errors)
if n_errors:
- self.log.error('%d errors encountered.' % n_errors)
+ self.log.error('%d errors encountered.', n_errors)
return (1 if n_errors else 0)
def _run_domain(self, domain):
po_files.append((self.locale,
os.path.join(self.directory, self.locale,
'LC_MESSAGES',
- domain + '.po')))
+ f"{domain}.po")))
mo_files.append(os.path.join(self.directory, self.locale,
'LC_MESSAGES',
- domain + '.mo'))
+ f"{domain}.mo"))
else:
for locale in os.listdir(self.directory):
po_file = os.path.join(self.directory, locale,
- 'LC_MESSAGES', domain + '.po')
+ 'LC_MESSAGES', f"{domain}.po")
if os.path.exists(po_file):
po_files.append((locale, po_file))
mo_files.append(os.path.join(self.directory, locale,
'LC_MESSAGES',
- domain + '.mo'))
+ f"{domain}.mo"))
else:
po_files.append((self.locale, self.input_file))
if self.output_file:
else:
mo_files.append(os.path.join(self.directory, self.locale,
'LC_MESSAGES',
- domain + '.mo'))
+ f"{domain}.mo"))
if not po_files:
raise OptionError('no message catalogs found')
for path in self.input_paths:
if not os.path.exists(path):
- raise OptionError("Input path: %s does not exist" % path)
+ raise OptionError(f"Input path: {path} does not exist")
self.add_comments = listify_value(self.add_comments or (), ",")
optstr = ''
if options:
- optstr = ' (%s)' % ', '.join(['%s="%s"' % (k, v) for
- k, v in options.items()])
+ opt_values = ", ".join(f'{k}="{v}"' for k, v in options.items())
+ optstr = f" ({opt_values})"
self.log.info('extracting messages from %s%s', filepath, optstr)
if os.path.isfile(path):
raise OptionError('you must specify the output directory')
if not self.output_file:
self.output_file = os.path.join(self.output_dir, self.locale,
- 'LC_MESSAGES', self.domain + '.po')
+ 'LC_MESSAGES', f"{self.domain}.po")
if not os.path.exists(os.path.dirname(self.output_file)):
os.makedirs(os.path.dirname(self.output_file))
po_files.append((self.locale,
os.path.join(self.output_dir, self.locale,
'LC_MESSAGES',
- self.domain + '.po')))
+ f"{self.domain}.po")))
else:
for locale in os.listdir(self.output_dir):
po_file = os.path.join(self.output_dir, locale,
'LC_MESSAGES',
- self.domain + '.po')
+ f"{self.domain}.po")
if os.path.exists(po_file):
po_files.append((locale, po_file))
else:
"""
usage = '%%prog %s [options] %s'
- version = '%%prog %s' % VERSION
+ version = f'%prog {VERSION}'
commands = {
'compile': 'compile message catalogs to MO files',
'extract': 'extract messages from source files and generate a POT file',
cmdname = args[0]
if cmdname not in self.commands:
- self.parser.error('unknown command "%s"' % cmdname)
+ self.parser.error(f'unknown command "{cmdname}"')
cmdinst = self._configure_command(cmdname, args[1:])
return cmdinst.run()
as_args = getattr(cmdclass, "as_args", ())
for long, short, help in cmdclass.user_options:
name = long.strip("=")
- default = getattr(cmdinst, name.replace('-', '_'))
- strs = ["--%s" % name]
+ default = getattr(cmdinst, name.replace("-", "_"))
+ strs = [f"--{name}"]
if short:
- strs.append("-%s" % short)
+ strs.append(f"-{short}")
strs.extend(cmdclass.option_aliases.get(name, ()))
choices = cmdclass.option_choices.get(name, None)
if name == as_args:
- parser.usage += "<%s>" % name
+ parser.usage += f"<{name}>"
elif name in cmdclass.boolean_options:
parser.add_option(*strs, action="store_true", help=help)
elif name in cmdclass.multiple_value_options:
if self.abort_invalid:
raise PoFileError(msg, self.catalog, line, lineno)
print("WARNING:", msg)
- # `line` is guaranteed to be unicode so u"{}"-interpolating would always
- # succeed, but on Python < 2 if not in a TTY, `sys.stdout.encoding`
- # is `None`, unicode may not be printable so we `repr()` to ASCII.
- print(u"WARNING: Problem on line {0}: {1}".format(lineno + 1, repr(line)))
+ print(f"WARNING: Problem on line {lineno + 1}: {line!r}")
def read_po(fileobj, locale=None, domain=None, ignore_obsolete=False, charset=None, abort_invalid=False):
else:
_width = 76
for line in wraptext(comment, _width):
- _write('#%s %s\n' % (prefix, line.strip()))
+ _write(f"#{prefix} {line.strip()}\n")
def _write_message(message, prefix=''):
if isinstance(message.id, (list, tuple)):
if message.context:
- _write('%smsgctxt %s\n' % (prefix,
- _normalize(message.context, prefix)))
- _write('%smsgid %s\n' % (prefix, _normalize(message.id[0], prefix)))
- _write('%smsgid_plural %s\n' % (
- prefix, _normalize(message.id[1], prefix)
- ))
+ _write(f"{prefix}msgctxt {_normalize(message.context, prefix)}\n")
+ _write(f"{prefix}msgid {_normalize(message.id[0], prefix)}\n")
+ _write(f"{prefix}msgid_plural {_normalize(message.id[1], prefix)}\n")
for idx in range(catalog.num_plurals):
try:
string = message.string[idx]
except IndexError:
string = ''
- _write('%smsgstr[%d] %s\n' % (
- prefix, idx, _normalize(string, prefix)
- ))
+ _write(f"{prefix}msgstr[{idx:d}] {_normalize(string, prefix)}\n")
else:
if message.context:
- _write('%smsgctxt %s\n' % (prefix,
- _normalize(message.context, prefix)))
- _write('%smsgid %s\n' % (prefix, _normalize(message.id, prefix)))
- _write('%smsgstr %s\n' % (
- prefix, _normalize(message.string or '', prefix)
- ))
+ _write(f"{prefix}msgctxt {_normalize(message.context, prefix)}\n")
+ _write(f"{prefix}msgid {_normalize(message.id, prefix)}\n")
+ _write(f"{prefix}msgstr {_normalize(message.string or '', prefix)}\n")
sort_by = None
if sort_output:
lines += wraptext(line, width=width,
subsequent_indent='# ')
comment_header = u'\n'.join(lines)
- _write(comment_header + u'\n')
+ _write(f"{comment_header}\n")
for comment in message.user_comments:
_write_comment(comment)
locations = message.locations
for filename, lineno in locations:
+ location = filename.replace(os.sep, '/')
if lineno and include_lineno:
- location = u'%s:%d' % (filename.replace(os.sep, '/'), lineno)
- else:
- location = u'%s' % filename.replace(os.sep, '/')
+ location = f"{location}:{lineno:d}"
if location not in locs:
locs.append(location)
_write_comment(' '.join(locs), prefix=':')
"""Create the exception.
:param identifier: the identifier string of the unsupported currency
"""
- Exception.__init__(self, 'Unknown currency %r.' % identifier)
+ Exception.__init__(self, f"Unknown currency {identifier!r}.")
#: The identifier of the locale that could not be found.
self.identifier = identifier
try:
pattern = locale.currency_formats[format_type]
except KeyError:
- raise UnknownCurrencyFormatError(
- "%r is not a known currency format type" % format_type)
+ raise UnknownCurrencyFormatError(f"{format_type!r} is not a known currency format type")
return pattern.apply(
number, locale, currency=currency, currency_digits=currency_digits,
try:
return int(string.replace(get_group_symbol(locale), ''))
except ValueError:
- raise NumberFormatError('%r is not a valid number' % string)
+ raise NumberFormatError(f"{string!r} is not a valid number")
def parse_decimal(string, locale=LC_NUMERIC, strict=False):
parsed = decimal.Decimal(string.replace(group_symbol, '')
.replace(decimal_symbol, '.'))
except decimal.InvalidOperation:
- raise NumberFormatError('%r is not a valid decimal number' % string)
+ raise NumberFormatError(f"{string!r} is not a valid decimal number")
if strict and group_symbol in string:
proper = format_decimal(parsed, locale=locale, decimal_quantization=False)
if string != proper and string.rstrip('0') != (proper + decimal_symbol):
parsed_alt = decimal.Decimal(string.replace(decimal_symbol, '')
.replace(group_symbol, '.'))
except decimal.InvalidOperation:
- raise NumberFormatError((
- "%r is not a properly formatted decimal number. Did you mean %r?" %
- (string, proper)
- ), suggestions=[proper])
+ raise NumberFormatError(
+ f"{string!r} is not a properly formatted decimal number. "
+ f"Did you mean {proper!r}?",
+ suggestions=[proper],
+ )
else:
proper_alt = format_decimal(parsed_alt, locale=locale, decimal_quantization=False)
if proper_alt == proper:
- raise NumberFormatError((
- "%r is not a properly formatted decimal number. Did you mean %r?" %
- (string, proper)
- ), suggestions=[proper])
+ raise NumberFormatError(
+ f"{string!r} is not a properly formatted decimal number. "
+ f"Did you mean {proper!r}?",
+ suggestions=[proper],
+ )
else:
- raise NumberFormatError((
- "%r is not a properly formatted decimal number. Did you mean %r? Or maybe %r?" %
- (string, proper, proper_alt)
- ), suggestions=[proper, proper_alt])
+ raise NumberFormatError(
+ f"{string!r} is not a properly formatted decimal number. "
+ f"Did you mean {proper!r}? Or maybe {proper_alt!r}?",
+ suggestions=[proper, proper_alt],
+ )
return parsed
NUMBER_PATTERN = r"(?P<number>%s*)" % NUMBER_TOKEN
SUFFIX_PATTERN = r"(?P<suffix>.*)"
-number_re = re.compile(r"%s%s%s" % (PREFIX_PATTERN, NUMBER_PATTERN,
- SUFFIX_PATTERN))
+number_re = re.compile(f"{PREFIX_PATTERN}{NUMBER_PATTERN}{SUFFIX_PATTERN}")
def parse_grouping(p):
def _match_number(pattern):
rv = number_re.search(pattern)
if rv is None:
- raise ValueError('Invalid number pattern %r' % pattern)
+ raise ValueError(f"Invalid number pattern {pattern!r}")
return rv.groups()
pos_pattern = pattern
neg_prefix, _, neg_suffix = _match_number(neg_pattern)
else:
pos_prefix, number, pos_suffix = _match_number(pos_pattern)
- neg_prefix = '-' + pos_prefix
+ neg_prefix = f"-{pos_prefix}"
neg_suffix = pos_suffix
if 'E' in number:
number, exp = number.split('E', 1)
self.scale = self.compute_scale()
def __repr__(self):
- return '<%s %r>' % (type(self).__name__, self.pattern)
+ return f"<{type(self).__name__} {self.pattern!r}>"
def compute_scale(self):
"""Return the scaling factor to apply to the number before rendering.
def _quantize_value(self, value, locale, frac_prec, group_separator):
quantum = get_decimal_quantum(frac_prec[1])
rounded = value.quantize(quantum)
- a, sep, b = "{:f}".format(rounded).partition(".")
+ a, sep, b = f"{rounded:f}".partition(".")
integer_part = a
if group_separator:
integer_part = self._format_int(a, self.int_prec[0], self.int_prec[1], locale)
self.abstract = []
for key, expr in sorted(list(rules)):
if key not in _plural_tags:
- raise ValueError('unknown tag %r' % key)
+ raise ValueError(f"unknown tag {key!r}")
elif key in found:
- raise ValueError('tag %r defined twice' % key)
+ raise ValueError(f"tag {key!r} defined twice")
found.add(key)
ast = _Parser(expr).ast
if ast:
def __repr__(self):
rules = self.rules
- return '<%s %r>' % (
- type(self).__name__,
- ', '.join(['%s: %s' % (tag, rules[tag]) for tag in _plural_tags
- if tag in rules])
- )
+ args = ", ".join([f"{tag}: {rules[tag]}" for tag in _plural_tags if tag in rules])
+ return f"<{type(self).__name__} {args!r}>"
@classmethod
def parse(cls, rules):
to_js = _JavaScriptCompiler().compile
result = ['(function(n) { return ']
for tag, ast in PluralRule.parse(rule).abstract:
- result.append('%s ? %r : ' % (to_js(ast), tag))
+ result.append(f"{to_js(ast)} ? {tag!r} : ")
result.append('%r; })' % _fallback_tag)
return ''.join(result)
for tag, ast in PluralRule.parse(rule).abstract:
# the str() call is to coerce the tag to the native string. It's
# a limited ascii restricted set of tags anyways so that is fine.
- result.append(' if (%s): return %r' % (to_python_func(ast), str(tag)))
- result.append(' return %r' % _fallback_tag)
+ result.append(f" if ({to_python_func(ast)}): return {str(tag)!r}")
+ result.append(f" return {_fallback_tag!r}")
code = compile('\n'.join(result), '<rule>', 'exec')
eval(code, namespace)
return namespace['evaluate']
_compile = _GettextCompiler().compile
_get_index = [tag for tag in _plural_tags if tag in used_tags].index
- result = ['nplurals=%d; plural=(' % len(used_tags)]
+ result = [f"nplurals={len(used_tags)}; plural=("]
for tag, ast in rule.abstract:
- result.append('%s ? %d : ' % (_compile(ast), _get_index(tag)))
- result.append('%d);' % _get_index(_fallback_tag))
+ result.append(f"{_compile(ast)} ? {_get_index(tag)} : ")
+ result.append(f"{_get_index(_fallback_tag)});")
return ''.join(result)
return
self.ast = self.condition()
if self.tokens:
- raise RuleError('Expected end of rule, got %r' %
- self.tokens[-1][1])
+ raise RuleError(f"Expected end of rule, got {self.tokens[-1][1]!r}")
def expect(self, type_, value=None, term=None):
token = skip_token(self.tokens, type_, value)
if term is None:
term = repr(value is None and type_ or value)
if not self.tokens:
- raise RuleError('expected %s but end of rule reached' % term)
- raise RuleError('expected %s but got %r' % (term, self.tokens[-1][1]))
+ raise RuleError(f"expected {term} but end of rule reached")
+ raise RuleError(f"expected {term} but got {self.tokens[-1][1]!r}")
def condition(self):
op = self.and_condition()
def compile(self, arg):
op, args = arg
- return getattr(self, 'compile_' + op)(*args)
+ return getattr(self, f"compile_{op}")(*args)
compile_n = lambda x: 'n'
compile_i = lambda x: 'i'
compile_mod = _binary_compiler('MOD(%s, %s)')
def compile_relation(self, method, expr, range_list):
- compile_range_list = '[%s]' % ','.join(
- ['(%s, %s)' % tuple(map(self.compile, range_))
- for range_ in range_list[1]])
- return '%s(%s, %s)' % (method.upper(), self.compile(expr),
- compile_range_list)
+ ranges = ",".join([f"({self.compile(a)}, {self.compile(b)})" for (a, b) in range_list[1]])
+ return f"{method.upper()}({self.compile(expr)}, [{ranges}])"
class _GettextCompiler(_Compiler):
expr = self.compile(expr)
for item in range_list[1]:
if item[0] == item[1]:
- rv.append('(%s == %s)' % (
- expr,
- self.compile(item[0])
- ))
+ rv.append(f"({expr} == {self.compile(item[0])})")
else:
min, max = map(self.compile, item)
- rv.append('(%s >= %s && %s <= %s)' % (
- expr,
- min,
- expr,
- max
- ))
- return '(%s)' % ' || '.join(rv)
+ rv.append(f"({expr} >= {min} && {expr} <= {max})")
+ return f"({' || '.join(rv)})"
class _JavaScriptCompiler(_GettextCompiler):
self, method, expr, range_list)
if method == 'in':
expr = self.compile(expr)
- code = '(parseInt(%s, 10) == %s && %s)' % (expr, expr, code)
+ code = f"(parseInt({expr}, 10) == {expr} && {code})"
return code
if item[0] == item[1]:
ranges.append(self.compile(item[0]))
else:
- ranges.append('%s..%s' % tuple(map(self.compile, item)))
- return '%s%s %s %s' % (
- self.compile(expr), negated and ' not' or '',
- method, ','.join(ranges)
- )
+ ranges.append(f"{self.compile(item[0])}..{self.compile(item[1])}")
+ return f"{self.compile(expr)}{' not' if negated else ''} {method} {','.join(ranges)}"
return cls(fp=fp, domain=domain)
def __repr__(self):
- return '<%s: "%s">' % (type(self).__name__,
- self._info.get('project-id-version'))
+ version = self._info.get('project-id-version')
+ return f'<{type(self).__name__}: "{version}">'
def add(self, translations, merge=True):
"""Add the given translations to the catalog.
class UnknownUnitError(ValueError):
def __init__(self, unit, locale):
- ValueError.__init__(self, "%s is not a known unit in %s" % (unit, locale))
+ ValueError.__init__(self, f"{unit} is not a known unit in {locale}")
def get_unit_name(measurement_unit, length='long', locale=LC_NUMERIC):
# Fall back to a somewhat bad representation.
# nb: This is marked as no-cover, as the current CLDR seemingly has no way for this to happen.
- return '%s %s' % ( # pragma: no cover
- formatted_value,
- (get_unit_name(measurement_unit, length=length, locale=locale) or measurement_unit)
- )
+ fallback_name = get_unit_name(measurement_unit, length=length, locale=locale) # pragma: no cover
+ return f"{formatted_value} {fallback_name or measurement_unit}" # pragma: no cover
def _find_compound_unit(numerator_unit, denominator_unit, locale=LC_NUMERIC):
# Now we can try and rebuild a compound unit specifier, then qualify it:
- return _find_unit_pattern("%s-per-%s" % (bare_numerator_unit, bare_denominator_unit), locale=locale)
+ return _find_unit_pattern(f"{bare_numerator_unit}-per-{bare_denominator_unit}", locale=locale)
def format_compound_unit(
if m:
magic_comment_encoding = m.group(1).decode('latin-1')
if magic_comment_encoding != 'utf-8':
- raise SyntaxError(
- 'encoding problem: {0} with BOM'.format(
- magic_comment_encoding))
+ raise SyntaxError(f"encoding problem: {magic_comment_encoding} with BOM")
return 'utf-8'
elif m:
return m.group(1).decode('latin-1')
buf.append(symbols[part])
elif part:
buf.append(re.escape(part))
- match = re.match(''.join(buf) + '$', filename.replace(os.sep, '/'))
+ match = re.match(f"{''.join(buf)}$", filename.replace(os.sep, "/"))
return match is not None
return self.zone
def __repr__(self):
- return '<FixedOffset "%s" %s>' % (self.zone, self._offset)
+ return f'<FixedOffset "{self.zone}" {self._offset}>'
def utcoffset(self, dt):
return self._offset
def get_authors_file_content():
- author_list = '\n'.join('- %s' % a for a in get_sorted_authors_list())
+ author_list = "\n".join(f"- {a}" for a in get_sorted_authors_list())
return '''
Babel is written and maintained by the Babel team and various contributors:
pickle.dump(data, outfile, 2)
if dump_json:
import json
- with open(path + '.json', 'w') as outfile:
+
+ with open(f"{path}.json", "w") as outfile:
json.dump(data, outfile, indent=4, default=debug_repr)
if ext != '.xml':
continue
- full_filename = os.path.join(srcdir, 'main', filename)
- data_filename = os.path.join(destdir, 'locale-data', stem + '.dat')
+ full_filename = os.path.join(srcdir, "main", filename)
+ data_filename = os.path.join(destdir, "locale-data", f"{stem}.dat")
data = {}
if not (force or need_conversion(data_filename, data, full_filename)):
unsupported_number_systems_string = ', '.join(sorted(data.pop('unsupported_number_systems')))
if unsupported_number_systems_string:
- log.warning('%s: unsupported number systems were ignored: %s' % (
- locale_id,
- unsupported_number_systems_string,
- ))
+ log.warning(
+ f"{locale_id}: unsupported number systems were ignored: "
+ f"{unsupported_number_systems_string}"
+ )
write_datafile(data_filename, data, dump_json=dump_json)
if item_sub.tag == "greatestDifference":
skel_data[item_sub.attrib["id"]] = split_interval_pattern(item_sub.text)
else:
- raise NotImplementedError("Not implemented: %s(%r)" % (item_sub.tag, item_sub.attrib))
+ raise NotImplementedError(f"Not implemented: {item_sub.tag}({item_sub.attrib!r})")
def parse_currency_formats(data, tree):
try:
from babel import __version__
except SyntaxError as exc:
- sys.stderr.write("Unable to import Babel (%s). Are you running a supported version of Python?\n" % exc)
+ sys.stderr.write(f"Unable to import Babel ({exc}). Are you running a supported version of Python?\n")
sys.exit(1)
('MIME-Version', '1.0'),
('Content-Type', 'text/plain; charset=utf-8'),
('Content-Transfer-Encoding', '8bit'),
- ('Generated-By', 'Babel %s\n' % catalog.VERSION),
+ ('Generated-By', f'Babel {catalog.VERSION}\n'),
]
('MIME-Version', '1.0'),
('Content-Type', 'text/plain; charset=utf-8'),
('Content-Transfer-Encoding', '8bit'),
- ('Generated-By', 'Babel %s\n' % catalog.VERSION),
+ ('Generated-By', f'Babel {catalog.VERSION}\n'),
]
assert ('file1.py' in msg.locations[0][0])
def test_input_paths_handle_spaces_after_comma(self):
- self.cmd.input_paths = '%s, %s' % (this_dir, data_dir)
+ self.cmd.input_paths = f"{this_dir}, {data_dir}"
self.cmd.output_file = pot_file
self.cmd.finalize_options()
assert self.cmd.input_paths == [this_dir, data_dir]
self.cli.run(sys.argv + ['compile',
'--locale', 'de_DE',
'-d', i18n_dir])
- assert not os.path.isfile(mo_file), 'Expected no file at %r' % mo_file
+ assert not os.path.isfile(mo_file), f'Expected no file at {mo_file!r}'
assert sys.stderr.getvalue() == f'catalog {po_file} is marked as fuzzy, skipping\n'
def test_compile_fuzzy_catalog(self):
]
if split: # Generate a command line with multiple -ks
- kwarg_text = " ".join("%s %s" % (arg_name, kwarg_spec) for kwarg_spec in kwarg_specs)
+ kwarg_text = " ".join(f"{arg_name} {kwarg_spec}" for kwarg_spec in kwarg_specs)
else: # Generate a single space-separated -k
- kwarg_text = "%s \"%s\"" % (arg_name, " ".join(kwarg_specs))
+ specs = ' '.join(kwarg_specs)
+ kwarg_text = f'{arg_name} "{specs}"'
# (Both of those invocation styles should be equivalent, so there is no parametrization from here on out)
cmdinst = configure_cli_command(
- "extract -F babel-django.cfg --add-comments Translators: -o django232.pot %s ." % kwarg_text
+ f"extract -F babel-django.cfg --add-comments Translators: -o django232.pot {kwarg_text} ."
)
assert isinstance(cmdinst, extract_messages)
assert set(cmdinst.keywords.keys()) == {'_', 'dgettext', 'dngettext',
def test_extract_ignore_dirs(monkeypatch, capsys, tmp_path, with_underscore_ignore):
pot_file = tmp_path / 'temp.pot'
monkeypatch.chdir(project_dir)
- cmd = "extract . -o '{}' --ignore-dirs '*ignored*' ".format(pot_file)
+ cmd = f"extract . -o '{pot_file}' --ignore-dirs '*ignored*' "
if with_underscore_ignore:
# This also tests that multiple arguments are supported.
cmd += "--ignore-dirs '_*'"
expected_denormalized = u'multi-line\n translation'
assert expected_denormalized == pofile.denormalize(msgstr)
- assert expected_denormalized == pofile.denormalize('""\n' + msgstr)
+ assert expected_denormalized == pofile.denormalize(f'""\n{msgstr}')
def test_unknown_language_roundtrip():
# *.dat files must have compatible classes between Python 2 and 3
if module.split('.')[0] == 'babel':
return pickle.Unpickler.find_class(self, module, name)
- raise pickle.UnpicklingError("global '%s.%s' is forbidden" %
- (module, name))
+ raise pickle.UnpicklingError(f"global '{module}.{name}' is forbidden")
with open(filename, 'rb') as f:
assert Unpickler(f).load()
chars = 'ivwft'
# Test that these rules are valid for this test; i.e. that they contain at least one
# of the gettext-unsupported characters.
- assert any((" " + ch + " ") in rule for ch in chars for rule in ru_rules.values())
+ assert any(f" {ch} " in rule for ch in chars for rule in ru_rules.values())
# Then test that the generated value indeed does not contain these.
ru_rules_gettext = plural.to_gettext(ru_rules)
assert not any(ch in ru_rules_gettext for ch in chars)
def assertEqualTypeToo(self, expected, result):
assert expected == result
- assert type(expected) == type(result), "instance type's do not " + \
- "match: %r!=%r" % (type(expected), type(result))
+ assert type(expected) == type(result), f"instance types do not match: {type(expected)!r}!={type(result)!r}"
def test_pgettext(self):
self.assertEqualTypeToo('Voh', self.translations.gettext('foo'))
def test_same_methods(self):
for name in self.method_names():
if not hasattr(self.null_translations, name):
- self.fail('NullTranslations does not provide method %r' % name)
+ self.fail(f"NullTranslations does not provide method {name!r}")
def test_method_signature_compatibility(self):
for name in self.method_names():
def test_lazy_proxy():
def greeting(name='world'):
- return u'Hello, %s!' % name
+ return f"Hello, {name}!"
+
lazy_greeting = support.LazyProxy(greeting, name='Joe')
assert str(lazy_greeting) == u"Hello, Joe!"
assert u' ' + lazy_greeting == u' Hello, Joe!'
assert u'(%s)' % lazy_greeting == u'(Hello, Joe!)'
+ assert f"[{lazy_greeting}]" == "[Hello, Joe!]"
greetings = [
support.LazyProxy(greeting, 'world'),
projects / thirdparty / babel.git / commitdiff
