def ensure_legal_c_identifier(s: str) -> str:
# for now, just complain if what we're given isn't legal
if not is_legal_c_identifier(s):
- fail("Illegal C identifier: {}".format(s))
+ fail("Illegal C identifier:", s)
# but if we picked a C keyword, pick something else
if s in c_keywords:
return s + "_value"
argname_fmt = 'PyTuple_GET_ITEM(args, %d)'
- left_args = "{} - {}".format(nargs, max_pos)
+ left_args = f"{nargs} - {max_pos}"
max_args = NO_VARARG if (vararg != NO_VARARG) else max_pos
parser_code = [normalize_snippet("""
if (!_PyArg_CheckPositional("{name}", %s, %d, %s)) {{
first_optional = min(first_optional, i)
if p.is_vararg():
- data.cleanup.append("Py_XDECREF({});".format(c.parser_name))
+ data.cleanup.append(f"Py_XDECREF({c.parser_name});")
# insert group variable
group = p.group
template_dict['c_basename'] = c_basename
- methoddef_name = "{}_METHODDEF".format(c_basename.upper())
- template_dict['methoddef_name'] = methoddef_name
+ template_dict['methoddef_name'] = c_basename.upper() + "_METHODDEF"
template_dict['docstring'] = self.docstring_for_c_string(f)
for field in shlex.split(arguments):
name, equals, value = field.partition('=')
if not equals:
- fail("Mangled Argument Clinic marker line: {!r}".format(line))
+ fail("Mangled Argument Clinic marker line:", repr(line))
d[name.strip()] = value.strip()
if self.verify:
output += '\n'
write(output)
- arguments="output={} input={}".format(compute_checksum(output, 16), compute_checksum(input, 16))
+ arguments = "output={output} input={input}".format(
+ output=compute_checksum(output, 16),
+ input=compute_checksum(input, 16)
+ )
write(self.language.checksum_line.format(dsl_name=dsl_name, arguments=arguments))
write("\n")
def file_changed(filename: str, new_contents: str) -> bool:
"""Return true if file contents changed (meaning we must update it)"""
try:
- with open(filename, 'r', encoding="utf-8") as fp:
+ with open(filename, encoding="utf-8") as fp:
old_contents = fp.read()
return old_contents != new_contents
except FileNotFoundError:
dsl_name = block.dsl_name
if dsl_name:
if dsl_name not in self.parsers:
- assert dsl_name in parsers, "No parser to handle {!r} block.".format(dsl_name)
+ assert dsl_name in parsers, f"No parser to handle {dsl_name!r} block."
self.parsers[dsl_name] = parsers[dsl_name](self)
parser = self.parsers[dsl_name]
try:
"can't make directory {}!".format(
destination.filename, dirname))
if self.verify:
- with open(destination.filename, "rt") as f:
+ with open(destination.filename) as f:
parser_2 = BlockParser(f.read(), language=self.language)
blocks = list(parser_2)
if (len(blocks) != 1) or (blocks[0].input != 'preserve\n'):
except KeyError:
fail("Can't identify file type for file " + repr(filename))
- with open(filename, 'r', encoding="utf-8") as f:
+ with open(filename, encoding="utf-8") as f:
raw = f.read()
# exit quickly if there are no clinic markers in the file
if i == 0:
return '"argument"'
if not self.is_positional_only():
- return '''"argument '{}'"'''.format(self.name)
+ return f'"argument {self.name!r}"'
else:
- return '"argument {}"'.format(i)
+ return f'"argument {i}"'
class LandMine:
if isinstance(self.default_type, type):
types_str = self.default_type.__name__
else:
- types_str = ', '.join((cls.__name__ for cls in self.default_type))
+ names = [cls.__name__ for cls in self.default_type]
+ types_str = ', '.join(names)
fail("{}: default value {!r} for field {} is not of type {}".format(
self.__class__.__name__, default, name, types_str))
self.default = default
' Py_TYPE({0})->tp_new == base_tp->tp_new)'
).format(self.name)
- line = '{} &&\n '.format(type_check)
+ line = f'{type_check} &&\n '
template_dict['self_type_check'] = line
type_object = self.function.cls.type_object
data.return_value = data.converter_retval
def err_occurred_if(self, expr, data):
- data.return_conversion.append('if (({}) && PyErr_Occurred()) {{\n goto exit;\n}}\n'.format(expr))
+ line = f'if (({expr}) && PyErr_Occurred()) {{\n goto exit;\n}}\n'
+ data.return_conversion.append(line)
def err_occurred_if_null_pointer(self, variable, data):
- data.return_conversion.append('if ({} == NULL) {{\n goto exit;\n}}\n'.format(variable))
+ line = f'if ({variable} == NULL) {{\n goto exit;\n}}\n'
+ data.return_conversion.append(line)
def render(self, function, data):
"""
c_basename = c_basename.strip() or None
if not is_legal_py_identifier(full_name):
- fail("Illegal function name: {}".format(full_name))
+ fail("Illegal function name:", full_name)
if c_basename and not is_legal_c_identifier(c_basename):
- fail("Illegal C basename: {}".format(c_basename))
+ fail("Illegal C basename:", c_basename)
return_converter = None
if returns:
- ast_input = "def x() -> {}: pass".format(returns)
+ ast_input = f"def x() -> {returns}: pass"
module = None
try:
module = ast.parse(ast_input)
module = None
try:
- ast_input = "def x({}): pass".format(base)
+ ast_input = f"def x({base}): pass"
module = ast.parse(ast_input)
except SyntaxError:
try:
# c: int(accept={str})
# so assume there was no actual default value.
default = None
- ast_input = "def x({}): pass".format(line)
+ ast_input = f"def x({line}): pass"
module = ast.parse(ast_input)
except SyntaxError:
pass
self.parameter_state = self.ps_optional
default = default.strip()
bad = False
- ast_input = "x = {}".format(default)
- bad = False
+ ast_input = f"x = {default}"
try:
module = ast.parse(ast_input)
dict = legacy_converters if legacy else converters
legacy_str = "legacy " if legacy else ""
if name not in dict:
- fail('{} is not a valid {}converter'.format(name, legacy_str))
+ fail(f'{name} is not a valid {legacy_str}converter')
# if you use a c_name for the parameter, we just give that name to the converter
# but the parameter object gets the python name
converter = dict[name](c_name or parameter_name, parameter_name, self.function, value, **kwargs)
for parameter_name, parameter in signature.parameters.items():
if parameter.kind == inspect.Parameter.KEYWORD_ONLY:
if parameter.default != inspect.Parameter.empty:
- s = '{}={!r}'.format(parameter_name, parameter.default)
+ s = f'{parameter_name}={parameter.default!r}'
else:
s = parameter_name
parameters.append(s)
projects / thirdparty / Python / cpython.git / commitdiff
