"_keywords",

"_parser",

"args",

"argsbuf",

"fastargs",

"kwargs",

"kwnames",

"nargs",

"noptargs",

"return_value",

unspecified = "unspecified"

unknown = "unknown"

def __repr__(self) -> str:

text: list[str] = []

def output() -> str:

s = ''.join(text)

text.clear()

return s

"""

text, append, output = _text_accumulator()

message: str

_: dc.KW_ONLY

lineno: int | None = None

filename: str | None = None

def __post_init__(self) -> None:

super().__init__(self.message)

def report(self, *, warn_only: bool = False) -> str:

msg = "Warning" if warn_only else "Error"

if self.filename is not None:

msg += f" in file {self.filename!r}"

if self.lineno is not None:

msg += f" on line {self.lineno}"

msg += ":\n"

msg += f"{self.message}\n"

*args: object,

fail: Literal[True],

filename: str | None = None,

line_number: int | None = None,

*args: object,

fail: Literal[False] = False,

filename: str | None = None,

line_number: int | None = None,

*args: object,

fail: bool = False,

filename: str | None = None,

line_number: int | None = None,

) -> None:

joined = " ".join([str(a) for a in args])

if clinic:

if filename is None:

filename = clinic.filename

if getattr(clinic, 'block_parser', None) and (line_number is None):

line_number = clinic.block_parser.line_number

error = ClinicError(joined, filename=filename, lineno=line_number)

if fail:

raise error

else:

*args: object,

filename: str | None = None,

line_number: int | None = None,

) -> None:

*args: object,

filename: str | None = None,

line_number: int | None = None,

) -> NoReturn:

for old, new in (

('\\', '\\\\'), # must be first!

('"', '\\"'),

("'", "\\'"),

):

s = s.replace(old, new)

text: str,

*,

width: int = 72,

suffix: str = '',

initial_indent: int = 0,

subsequent_indent: int = 4

) -> str:

wrapped = textwrap.wrap(text, width=width, replace_whitespace=False,

drop_whitespace=False, break_on_hyphens=False)

separator = '"' + suffix + '\n' + subsequent_indent * ' ' + '"'

# for now, just complain if what we're given isn't legal

if not is_legal_c_identifier(s):

fail("Illegal C identifier:", s)

# but if we picked a C keyword, pick something else

if s in c_keywords:

return s + "_value"

text, add, output = _text_accumulator()

for line in s.split('\n'):

add(line.rstrip())

add('\n')

text.pop()

# double up curly-braces, this string will be used

# as part of a format_map() template later

s = s.replace('{', '{{')

s = s.replace('}', '}}')

"""

add, output = text_accumulator()

for line in s.split('\n'):

indent, curly, trailing = line.partition('{')

if not curly:

add(line)

add('\n')

continue

name, curly, trailing = trailing.partition('}')

if not curly or name not in kwargs:

add(line)

add('\n')

continue

if trailing:

fail(f"Text found after {{{name}}} block marker! "

"It must be on a line by itself.")

if indent.strip():

fail(f"Non-whitespace characters found before {{{name}}} block marker! "

"It must be on a line by itself.")

value = kwargs[name]

if not value:

continue

value = textwrap.indent(rstrip_lines(value), indent)

add(value)

add('\n')

"""

split = s.split('\n')

last = split.pop()

final = []

for line in split:

final.append(prefix)

final.append(line)

final.append('\n')

if last:

final.append(prefix)

final.append(last)

"""

split = s.split('\n')

last = split.pop()

final = []

for line in split:

final.append(line)

final.append(suffix)

final.append('\n')

if last:

final.append(last)

final.append(suffix)

if len(items) <= 2:

return " and ".join(items)

else:

"""Splits a version string into a tuple of integers.

version: list[int] = []

accumulator: list[str] = []

def flush() -> None:

if not accumulator:

fail(f'Unsupported version string: {s!r}')

version.append(int(''.join(accumulator)))

accumulator.clear()

for c in s:

if c.isdigit():

accumulator.append(c)

elif c == '.':

flush()

elif c in 'abc':

flush()

version.append('abc'.index(c) - 3)

else:

fail(f'Illegal character {c!r} in version string {s!r}')

flush()

iterator = itertools.zip_longest(

version_splitter(version1), version_splitter(version2), fillvalue=0

)

for a, b in iterator:

if a < b:

return -1

if a > b:

return 1

def __init__(self) -> None:

# The C statements to declare variables.

# Should be full lines with \n eol characters.

self.declarations: list[str] = []

# The C statements required to initialize the variables before the parse call.

# Should be full lines with \n eol characters.

self.initializers: list[str] = []

# The C statements needed to dynamically modify the values

# parsed by the parse call, before calling the impl.

self.modifications: list[str] = []

# The entries for the "keywords" array for PyArg_ParseTuple.

# Should be individual strings representing the names.

self.keywords: list[str] = []

# The "format units" for PyArg_ParseTuple.

# Should be individual strings that will get

self.format_units: list[str] = []

# The varargs arguments for PyArg_ParseTuple.

self.parse_arguments: list[str] = []

# The parameter declarations for the impl function.

self.impl_parameters: list[str] = []

# The arguments to the impl function at the time it's called.

self.impl_arguments: list[str] = []

# For return converters: the name of the variable that

# should receive the value returned by the impl.

self.return_value = "return_value"

# For return converters: the code to convert the return

# value from the parse function. This is also where

# you should check the _return_value for errors, and

# "goto exit" if there are any.

self.return_conversion: list[str] = []

self.converter_retval = "_return_value"

# The C statements required to do some operations

# after the end of parsing but before cleaning up.

# These operations may be, for example, memory deallocations which

# can only be done without any error happening during argument parsing.

self.post_parsing: list[str] = []

# The C statements required to clean up after the impl call.

self.cleanup: list[str] = []

# The C statements to generate critical sections (per-object locking).

self.lock: list[str] = []

"""

def __init__(self) -> None:

self.counts = collections.Counter[str]()

def get_value(

self, key: str, args: object, kwargs: object # type: ignore[override]

) -> Literal['']:

self.counts[key] += 1

start_line = ""

body_prefix = ""

stop_line = ""

checksum_line = ""

def __init__(self, filename: str) -> None:

...

@abc.abstractmethod

def render(

self,

clinic: Clinic | None,

signatures: Iterable[Module | Class | Function]

) -> str:

...

def parse_line(self, line: str) -> None:

...

def validate(self) -> None:

def assert_only_one(

attr: str,

*additional_fields: str

) -> None:

"""

fields = ['dsl_name']

fields.extend(additional_fields)

line: str = getattr(self, attr)

fcf = FormatCounterFormatter()

fcf.format(line)

def local_fail(should_be_there_but_isnt: bool) -> None:

if should_be_there_but_isnt:

fail("{} {} must contain {{{}}} exactly once!".format(

self.__class__.__name__, attr, name))

else:

fail("{} {} must not contain {{{}}}!".format(

self.__class__.__name__, attr, name))

for name, count in fcf.counts.items():

if name in fields:

if count > 1:

local_fail(True)

else:

local_fail(False)

for name in fields:

if fcf.counts.get(name) != 1:

local_fail(True)

assert_only_one('start_line')

assert_only_one('stop_line')

field = "arguments" if "{arguments}" in self.checksum_line else "checksum"

language = 'Python'

start_line = "#/*[{dsl_name} input]"

body_prefix = "#"

stop_line = "#[{dsl_name} start generated code]*/"

l: Sequence[Iterable[Parameter]]

) -> Iterator[ParamTuple]:

"""

yield tuple()

accumulator: list[Parameter] = []

for group in reversed(l):

accumulator = list(group) + accumulator

l: Sequence[Iterable[Parameter]]

) -> Iterator[ParamTuple]:

"""

yield tuple()

accumulator: list[Parameter] = []

for group in l:

accumulator.extend(group)

left: Sequence[Iterable[Parameter]],

required: Iterable[Parameter],

right: Sequence[Iterable[Parameter]]

) -> tuple[ParamTuple, ...]:

"""

required = tuple(required)

if not required:

if left:

raise ValueError("required is empty but left is not")

accumulator: list[ParamTuple] = []

counts = set()

for r in permute_right_option_groups(right):

for l in permute_left_option_groups(left):

t = l + required + r

if len(t) in counts:

continue

counts.add(len(t))

accumulator.append(t)

accumulator.sort(key=len)

lines = s.rstrip().split('\n')

while lines:

line = lines[0]

if line.strip():

break

del lines[0]

s: str,

*,

indent: int = 0

) -> str:

"""

s = strip_leading_and_trailing_blank_lines(s)

s = textwrap.dedent(s)

if indent:

s = textwrap.indent(s, ' ' * indent)

f: Function,

*,

hasformat: bool = False,

clinic: Clinic,

limited_capi: bool,

) -> str:

"""

if hasformat:

fname = ''

format_ = '.format = "{format_units}:{name}",'

else:

fname = '.fname = "{name}",'

format_ = ''

num_keywords = len([

p for p in f.parameters.values()

if not p.is_positional_only() and not p.is_vararg()

])

if limited_capi:

declarations = """

elif num_keywords == 0:

declarations = """

else:

declarations = """

""" % num_keywords

condition = '#if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)'

clinic.add_include('pycore_gc.h', 'PyGC_Head', condition=condition)

clinic.add_include('pycore_runtime.h', '_Py_ID()', condition=condition)

declarations += """

""" % (format_ or fname)

text: str,

length: int = 78

) -> str:

"""

lines = []

for line in text.split('\n'):

prefix, _, after_l_paren = line.partition('(')

if not after_l_paren:

lines.append(line)

continue

in_paren, _, after_r_paren = after_l_paren.partition(')')

if not _:

lines.append(line)

continue

if ',' not in in_paren:

lines.append(line)

continue

parameters = [x.strip() + ", " for x in in_paren.split(',')]

prefix += "("

if len(prefix) < length:

spaces = " " * len(prefix)

else:

spaces = " " * 4

while parameters:

line = prefix

first = True

while parameters:

if (not first and

(len(line) + len(parameters[0]) > length)):

break

line += parameters.pop(0)

first = False

if not parameters:

line = line.rstrip(", ") + ")" + after_r_paren

lines.append(line.rstrip())

prefix = spaces

body_prefix = "#"

language = 'C'

start_line = "/*[{dsl_name} input]"

body_prefix = ""

stop_line = "[{dsl_name} start generated code]*/"

checksum_line = "/*[{dsl_name} end generated code: {arguments}]*/"

PARSER_PROTOTYPE_KEYWORD: Final[str] = normalize_snippet("""

""")

PARSER_PROTOTYPE_KEYWORD___INIT__: Final[str] = normalize_snippet("""

""")

PARSER_PROTOTYPE_VARARGS: Final[str] = normalize_snippet("""

""")

PARSER_PROTOTYPE_FASTCALL: Final[str] = normalize_snippet("""

""")

PARSER_PROTOTYPE_FASTCALL_KEYWORDS: Final[str] = normalize_snippet("""

""")

PARSER_PROTOTYPE_DEF_CLASS: Final[str] = normalize_snippet("""

""")

PARSER_PROTOTYPE_NOARGS: Final[str] = normalize_snippet("""

""")

METH_O_PROTOTYPE: Final[str] = normalize_snippet("""

""")

DOCSTRING_PROTOTYPE_VAR: Final[str] = normalize_snippet("""

""")

DOCSTRING_PROTOTYPE_STRVAR: Final[str] = normalize_snippet("""

""")

IMPL_DEFINITION_PROTOTYPE: Final[str] = normalize_snippet("""

""")

METHODDEF_PROTOTYPE_DEFINE: Final[str] = normalize_snippet(r"""

""")

METHODDEF_PROTOTYPE_IFNDEF: Final[str] = normalize_snippet("""

""")

COMPILER_DEPRECATION_WARNING_PROTOTYPE: Final[str] = r"""

DEPRECATION_WARNING_PROTOTYPE: Final[str] = r"""

def __init__(self, filename: str) -> None:

super().__init__(filename)

self.cpp = cpp.Monitor(filename)

self.cpp.fail = fail # type: ignore[method-assign]

def parse_line(self, line: str) -> None:

self.cpp.writeline(line)

def render(

self,

clinic: Clinic | None,

signatures: Iterable[Module | Class | Function]

) -> str:

function = None

for o in signatures:

if isinstance(o, Function):

if function:

fail("You may specify at most one function per block.\nFound a block containing at least two:\n\t" + repr(function) + " and " + repr(o))

function = o

return self.render_function(clinic, function)

def compiler_deprecated_warning(

self,

func: Function,

parameters: list[Parameter],

) -> str | None:

minversion: VersionTuple | None = None

for p in parameters:

for version in p.deprecated_positional, p.deprecated_keyword:

if version and (not minversion or minversion > version):

minversion = version

if not minversion:

return None

# Format the preprocessor warning and error messages.

assert isinstance(self.cpp.filename, str)

message = f"Update the clinic input of {func.full_name!r}."

code = self.COMPILER_DEPRECATION_WARNING_PROTOTYPE.format(

major=minversion[0],

minor=minversion[1],

message=c_repr(message),

)

return normalize_snippet(code)

def deprecate_positional_use(

self,

func: Function,

params: dict[int, Parameter],

) -> str:

assert len(params) > 0

first_pos = next(iter(params))

last_pos = next(reversed(params))

# Format the deprecation message.

if len(params) == 1:

condition = f"nargs == {first_pos+1}"

amount = f"{first_pos+1} " if first_pos else ""

pl = "s"

else:

condition = f"nargs > {first_pos} && nargs <= {last_pos+1}"

amount = f"more than {first_pos} " if first_pos else ""

pl = "s" if first_pos != 1 else ""

message = (

f"Passing {amount}positional argument{pl} to "

f"{func.fulldisplayname}() is deprecated."

)

for (major, minor), group in itertools.groupby(

params.values(), key=attrgetter("deprecated_positional")

):

names = [repr(p.name) for p in group]

pstr = pprint_words(names)

if len(names) == 1:

message += (

f" Parameter {pstr} will become a keyword-only parameter "

f"in Python {major}.{minor}."

)

else:

message += (

f" Parameters {pstr} will become keyword-only parameters "

f"in Python {major}.{minor}."

)

# Append deprecation warning to docstring.

docstring = textwrap.fill(f"Note: {message}")

func.docstring += f"\n\n{docstring}\n"

# Format and return the code block.

code = self.DEPRECATION_WARNING_PROTOTYPE.format(

condition=condition,

errcheck="",

message=wrapped_c_string_literal(message, width=64,

subsequent_indent=20),

)

return normalize_snippet(code, indent=4)

def deprecate_keyword_use(

self,

func: Function,

params: dict[int, Parameter],

argname_fmt: str | None,

*,

fastcall: bool,

limited_capi: bool,

clinic: Clinic,

) -> str:

assert len(params) > 0