[dict-value-with-operator]
x = {
    'key': (
        first_function_name(argument_one)
        + second_function_name(argument_two)
    )
}

[f-string-fields]
x = (
    f'{{literal}} {name} and }} a text that is'
    f' long enough {data["key"]} to be split at'
    ' spaces'
)

[format-trailer]
x = (
    'a text with {} that goes on and on until it'
    ' is split'.format(value)
)
y = (
    'a text with {} that goes on and on until it'
    ' is split'.format(f(value), (b))
)
z = Field(
    None,
    title=(
        'a text with {} that goes on and on until'
        ' it is split'.upper()
    ),
)
w = (
    'a text with {} that goes on and on until it'
    ' is split'.format(
        a_long_argument_name, another_argument
    )
)

[format-trailer-own-line]
x = (
    'word word word word word word word'
    ' word word wor with {} goes'
    .format(value)
)

[percent-trailer]
x = call(
    argument,
    'a text with %s that goes on and on until it'
    ' is split' % (value, other),
)
y = (
    'a text with %s that goes on and on until it'
    ' is split again here' % value
)

[unmerged-groups]
x = f(
    argument,
    r'a raw string that is long'
    r' and another raw part',
)
y = f(
    argument,
    u'a string with a prefix'
    'and one without',
)
z = f(
    argument,
    f'an f-string {a["k"]} that'
    'is joined',
)

[parenthesized-strings]
x = f(
    argument,
    (
        r'a raw string that is long'
        r' and another raw part'
    ),
)
y = f(
    argument,
    'a string in parentheses that is'
    ' long',
)
z = f(
    argument,
    b
    * (
        'a text %s with percent' % value
    ),
)
w = f(
    argument,
    (
        'a string that has a method'
    ).upper(),
)

[string-operators]
x = (
    first_value
    + 'a string after a plus that'
    ' goes on'
)
y = (
    first_value
    not in 'a string after not in that'
    ' goes on'
)
z = (
    first_value
    in 'a string after in that goes on'
    ' and on'
)

[dict-entries]
x = {
    'first': (
        'a string value of the first'
        ' entry'
    ),
    'second': (
        some_long_variable_name_here
    ),
    'third': [1, 2],
}

[not-responsible]
x = Field(
    a_very_long_keyword_argument_name=(
        'short'
    )
)

[wide-string]
x = Field(
    None,
    description='数据的时间戳使用格式时间',
)

[positional-argument]
x = f(
    'a long positional string argument'
    ' that goes on',
    other_argument,
)

[high-depth]
class A:
    x = f(
        g(
            'a string at a depth that leaves no room'
        )
    )

[name-escapes]
x = Field(
    None,
    description=(
        'a text with \N{BULLET} escapes'
        ' \N{EM DASH} that goes on'
        ' and on'
    ),
)

[lambda-value]
x = {
    'key': lambda: (
        'a long string value returned by the lambda that'
        ' goes on and on'
    ),
    'b': 1,
}

[list-elements]
x = [
    'a string element of a list',
    name,
    'first second joined part',
    'last element of the list',
]
y = [
    'a string in a comprehension that'
    ' goes on'
    for item in items
]
z = (
    (
        'a string element of a tuple'
        ' that goes on'
    ),
    'b',
)
w = {
    (
        'a string element of a set that'
        ' goes on'
    ),
    'b',
}

[augmented-assignment]
x += (
    'a string that is added to x and'
    ' goes on'
)

[short-joined]
x = 'a joined short string'

[long-annotated-head]
class A:
    nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn: (
        ClassVar[str]
    ) = 'datauserdata'

[return-yield-assert]
def f(x):
    return (
        'a returned text that is long enough to be split at'
        ' its spaces'
    )
    yield (
        'a yielded text that is long enough to be split at'
        ' its spaces'
    )
    assert x, (
        'an assert message that is long enough to be split'
        ' at its spaces'
    )
    assert check(
        x, y
    ), 'a message with {} that is split as well'.format(x)
    assert check(
        first_argument, second_argument
    ), message_name_here

[octal-escape-boundary]
x = '\1' '23'
y = b'\12' b'3'
z = '\1' '' '2'
w = '\1234'

[f-string-other-quotes]
x = f(
    argument,
    'a plain start'
    f"an f-string {a['k']} end",
)

[f-string-field-with-own-quote]
x = f"{data['a"b']} " 'suffix'

[tuple-after-string]
def f(c, d, rest):
    yield 'a yielded text that is long enough to be split at its spaces', 7,
    yield 'a yielded text that is long enough to be split at its spaces', *rest,
    yield (
        'a yielded text that is long enough to be split'
        if c
        else d
    ), 7,
    yield (
        (
            'a yielded text that is long enough to be split'
            ' at its spaces'
        ),
        7,
    )
    yield (
        'a yielded text that is long enough to be split at'
        ' its spaces'
    ),
    return (
        (
            'a returned text that is long enough to be'
            ' split at its spaces'
        ),
        7,
    )


'a statement text that is long enough to be split at its spaces',
