tests/data/long_strings__regression.py

   1 class A:
   2     def foo():
   3         result = type(message)("")
   4
   5
   6 # Don't merge multiline (e.g. triple-quoted) strings.
   7 def foo():
   8     query = (
   9         """SELECT xxxxxxxxxxxxxxxxxxxx(xxx)"""
  10         """ FROM xxxxxxxxxxxxxxxx WHERE xxxxxxxxxx AND xxx <> xxxxxxxxxxxxxx()""")
  11
  12 # There was a bug where tuples were being identified as long strings.
  13 long_tuple = ('Apple', 'Berry', 'Cherry', 'Dill', 'Evergreen', 'Fig',
  14            'Grape', 'Harry', 'Iglu', 'Jaguar')
  15
  16 stupid_format_method_bug = "Some really long string that just so happens to be the {} {} to force the 'format' method to hang over the line length boundary. This is pretty annoying.".format("perfect", "length")
  17
  18 class A:
  19     def foo():
  20         os.system("This is a regression test. xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxxx.".format("xxxxxxxxxx", "xxxxxx", "xxxxxxxxxx"))
  21
  22
  23 class A:
  24     def foo():
  25         XXXXXXXXXXXX.append(
  26             (
  27                 "xxx_xxxxxxxxxx(xxxxx={}, xxxx={}, xxxxx, xxxx_xxxx_xxxxxxxxxx={})".format(
  28                     xxxxx, xxxx, xxxx_xxxx_xxxxxxxxxx
  29                 ),
  30                 my_var,
  31                 my_other_var,
  32             )
  33         )
  34
  35 class A:
  36     class B:
  37         def foo():
  38             bar(
  39                 (
  40                     "[{}]: xxx_xxxxxxxxxx(xxxxx={}, xxxx={}, xxxxx={}"
  41                     " xxxx_xxxx_xxxxxxxxxx={}, xxxx={})"
  42                     .format(xxxx._xxxxxxxxxxxxxx, xxxxx, xxxx, xxxx_xxxx_xxxxxxxxxx, xxxxxxx)
  43                 ),
  44                 varX,
  45                 varY,
  46                 varZ,
  47             )
  48
  49 def foo(xxxx):
  50     for (xxx_xxxx, _xxx_xxx, _xxx_xxxxx, xxx_xxxx) in xxxx:
  51         for xxx in xxx_xxxx:
  52             assert ("x" in xxx) or (
  53                 xxx in xxx_xxx_xxxxx
  54             ), "{0} xxxxxxx xx {1}, xxx {1} xx xxx xx xxxx xx xxx xxxx: xxx xxxx {2}".format(
  55                 xxx_xxxx, xxx, xxxxxx.xxxxxxx(xxx_xxx_xxxxx)
  56             )
  57
  58 class A:
  59     def disappearing_comment():
  60         return (
  61             (  # xx -x xxxxxxx xx xxx xxxxxxx.
  62                 '{{xxx_xxxxxxxxxx_xxxxxxxx}} xxx xxxx'
  63                 ' {} {{xxxx}} >&2'
  64                 .format(
  65                     "{xxxx} {xxxxxx}"
  66                     if xxxxx.xx_xxxxxxxxxx
  67                     else ( # Disappearing Comment
  68                         "--xxxxxxx --xxxxxx=x --xxxxxx-xxxxx=xxxxxx"
  69                         " --xxxxxx-xxxx=xxxxxxxxxxx.xxx"
  70                     )
  71                 )
  72             ),
  73             (x, y, z),
  74         )
  75
  76 class A:
  77     class B:
  78         def foo():
  79             xxxxx_xxxx(
  80                 xx, "\t"
  81                 "@xxxxxx '{xxxx_xxx}\t' > {xxxxxx_xxxx}.xxxxxxx;"
  82                 "{xxxx_xxx} >> {xxxxxx_xxxx}.xxxxxxx 2>&1; xx=$$?;"
  83                 "xxxx $$xx"
  84                 .format(xxxx_xxx=xxxx_xxxxxxx, xxxxxx_xxxx=xxxxxxx + "/" + xxxx_xxx_xxxx, x=xxx_xxxxx_xxxxx_xxx),
  85                 x,
  86                 y,
  87                 z,
  88             )
  89
  90 func_call_where_string_arg_has_method_call_and_bad_parens(
  91     (
  92         "A long string with {}. This string is so long that it is ridiculous. It can't fit on one line at alllll.".format("formatting")
  93     ),
  94 )
  95
  96 func_call_where_string_arg_has_old_fmt_and_bad_parens(
  97     (
  98         "A long string with {}. This string is so long that it is ridiculous. It can't fit on one line at alllll." % "formatting"
  99     ),
 100 )
 101
 102 func_call_where_string_arg_has_old_fmt_and_bad_parens(
 103     (
 104         "A long string with {}. This {} is so long that it is ridiculous. It can't fit on one line at alllll." % ("formatting", "string")
 105     ),
 106 )
 107
 108 class A:
 109     def append(self):
 110         if True:
 111             xxxx.xxxxxxx.xxxxx( ('xxxxxxxxxx xxxx xx xxxxxx(%x) xx %x xxxx xx xxx %x.xx'
 112                                  % (len(self) + 1,
 113                                     xxxx.xxxxxxxxxx,
 114                                     xxxx.xxxxxxxxxx))
 115                                 + (' %.3f (%s) to %.3f (%s).\n'
 116                                    % (xxxx.xxxxxxxxx,
 117                                       xxxx.xxxxxxxxxxxxxx(xxxx.xxxxxxxxx),
 118                                       x,
 119                                       xxxx.xxxxxxxxxxxxxx( xx)
 120                                       )))
 121
 122 class A:
 123     def foo():
 124         some_func_call(
 125             'xxxxxxxxxx',
 126             (
 127                 "xx {xxxxxxxxxxx}/xxxxxxxxxxx.xxx xxxx.xxx && xxxxxx -x "
 128                 "\"xxxx xxxxxxx xxxxxx xxxx; xxxx xxxxxx_xxxxx xxxxxx xxxx; "
 129                 "xxxx.xxxx_xxxxxx(['xxxx.xxx'], xxxx.xxxxxxx().xxxxxxxxxx)\" "
 130             ),
 131             None,
 132             ('xxxxxxxxxxx',),
 133         ),
 134
 135 class A:
 136     def foo():
 137         some_func_call(
 138             (
 139                 "xx {xxxxxxxxxxx}/xxxxxxxxxxx.xxx xxxx.xxx && xxxxxx -x "
 140                 "xxxx, ('xxxxxxx xxxxxx xxxx, xxxx') xxxxxx_xxxxx xxxxxx xxxx; "
 141                 "xxxx.xxxx_xxxxxx(['xxxx.xxx'], xxxx.xxxxxxx().xxxxxxxxxx)\" "
 142             ),
 143             None,
 144             ('xxxxxxxxxxx',),
 145         ),
 146
 147 xxxxxxx = { 'xx' : 'xxxx xxxxxxx xxxxxxxxx -x xxx -x /xxx/{0} -x xxx,xxx -xx {1} \
 148 -xx {1} -xx xxx=xxx_xxxx,xxx_xx,xxx_xxx,xxx_xxxx,xxx_xx,xxx_xxx |\
 149  xxxxxx -x xxxxxxxx -x xxxxxxxx -x',
 150          'xx' : 'xxxx xxxxxxx xxxxxxxxx -x xxx -x /xxx/{0} -x xxx,xxx -xx {1} \
 151 -xx {1} -xx xxx=xxx_xxxx_xxx_xxxx,xxx_xx_xxx_xxxx,xxx_xxxx_xxx_xxxx,\
 152 xxx_xx_xxxx_xxxx,xxx_xxx_xxxx,xxx_xxx_xxxx xxxx=xxx | xxxxxx -x xxxxxxxx -x xxxxxxxx -x'
 153 }
 154
 155 class A:
 156     def foo(self):
 157         if True:
 158             xxxxx_xxxxxxxxxxxx('xxx xxxxxx xxx xxxxxxxxx.xx xx xxxxxxxx.  xxx xxxxxxxxxxxxx.xx xxxxxxx '
 159                                + 'xx xxxxxx xxxxxx xxxxxx xx xxxxxxx xxx xxx ${0} xx x xxxxxxxx xxxxx'.xxxxxx(xxxxxx_xxxxxx_xxx))
 160
 161 class A:
 162     class B:
 163         def foo():
 164             row = {
 165                 'xxxxxxxxxxxxxxx' : xxxxxx_xxxxx_xxxx,
 166                 # 'xxxxxxxxxxxxxxxxxxxxxxx'
 167                 # 'xxxxxxxxxxxxxxxxxxxxxx'
 168                 # 'xxxxxxxxxxxxxxxxxx'
 169                 # 'xxxxxxxxxxxxxxxxx'
 170                 'xxxxxxxxxx' : xxxxx_xxxxx,
 171                 }
 172
 173 class A:
 174     def xxxx_xxx_xx_xxxxxxxxxx_xxxx_xxxxxxxxx(xxxx):
 175         xxxxxxxx = [
 176             xxxxxxxxxxxxxxxx(
 177                 'xxxx',
 178                 xxxxxxxxxxx={
 179                     'xxxx' : 1.0,
 180                 },
 181                 xxxxxx={'xxxxxx 1' : xxxxxx(xxxx='xxxxxx 1', xxxxxx=600.0)},
 182                 xxxxxxxx_xxxxxxx=0.0,
 183             ),
 184             xxxxxxxxxxxxxxxx(
 185                 'xxxxxxx',
 186                 xxxxxxxxxxx={
 187                     'xxxx' : 1.0,
 188                 },
 189                 xxxxxx={'xxxxxx 1' : xxxxxx(xxxx='xxxxxx 1', xxxxxx=200.0)},
 190                 xxxxxxxx_xxxxxxx=0.0,
 191             ),
 192             xxxxxxxxxxxxxxxx(
 193                 'xxxx',
 194             ),
 195         ]
 196
 197 some_dictionary = {
 198     'xxxxx006': ['xxx-xxx xxxxx3xxxx1xx2xxxxxxxxxxxxxx0xx6xxxxxxxxxx2xxxxxx9xxxxxxxxxx0xxxxx1xxx2x/xx9xx6+x+xxxxxxxxxxxxxx4xxxxxxxxxxxxxxxxxxxxx43xxx2xx2x4x++xxx6xxxxxxxxx+xxxxx/xx9x+xxxxxxxxxxxxxx8x15xxxxxxxxxxxxxxxxx82xx/xxxxxxxxxxxxxx/x5xxxxxxxxxxxxxx6xxxxxx74x4/xxx4x+xxxxxxxxx2xxxxxxxx87xxxxx4xxxxxxxx3xx0xxxxx4xxx1xx9xx5xxxxxxx/xxxxx5xx6xx4xxxx1x/x2xxxxxxxxxxxx64xxxxxxx1x0xx5xxxxxxxxxxxxxx== xxxxx000 xxxxxxxxxx\n',
 199                  'xxx-xxx xxxxx3xxxx1xx2xxxxxxxxxxxxxx6xxxxxxxxxxxxxx9xxxxxxxxxxxxx3xxx9xxxxxxxxxxxxxxxx0xxxxxxxxxxxxxxxxx2xxxx2xxx6xxxxx/xx54xxxxxxxxx4xxx3xxxxxx9xx3xxxxx39xxxxxxxxx5xx91xxxx7xxxxxx8xxxxxxxxxxxxxxxx9xxx93xxxxxxxxxxxxxxxxx7xxx8xx8xx4/x1xxxxx1x3xxxxxxxxxxxxx3xxxxxx9xx4xx4x7xxxxxxxxxxxxx1xxxxxxxxx7xxxxxxxxxxxxxx4xx6xxxxxxxxx9xxx7xxxx2xxxxxxxxxxxxxxxxxxxxxx8xxxxxxxxxxxxxxxxxxxx6xx== xxxxx010 xxxxxxxxxx\n'],
 200     'xxxxx016': ['xxx-xxx xxxxx3xxxx1xx2xxxxxxxxxxxxxx0xx6xxxxxxxxxx2xxxxxx9xxxxxxxxxx0xxxxx1xxx2x/xx9xx6+x+xxxxxxxxxxxxxx4xxxxxxxxxxxxxxxxxxxxx43xxx2xx2x4x++xxx6xxxxxxxxx+xxxxx/xx9x+xxxxxxxxxxxxxx8x15xxxxxxxxxxxxxxxxx82xx/xxxxxxxxxxxxxx/x5xxxxxxxxxxxxxx6xxxxxx74x4/xxx4x+xxxxxxxxx2xxxxxxxx87xxxxx4xxxxxxxx3xx0xxxxx4xxx1xx9xx5xxxxxxx/xxxxx5xx6xx4xxxx1x/x2xxxxxxxxxxxx64xxxxxxx1x0xx5xxxxxxxxxxxxxx== xxxxx000 xxxxxxxxxx\n',
 201                  'xxx-xxx xxxxx3xxxx1xx2xxxxxxxxxxxxxx6xxxxxxxxxxxxxx9xxxxxxxxxxxxx3xxx9xxxxxxxxxxxxxxxx0xxxxxxxxxxxxxxxxx2xxxx2xxx6xxxxx/xx54xxxxxxxxx4xxx3xxxxxx9xx3xxxxx39xxxxxxxxx5xx91xxxx7xxxxxx8xxxxxxxxxxxxxxxx9xxx93xxxxxxxxxxxxxxxxx7xxx8xx8xx4/x1xxxxx1x3xxxxxxxxxxxxx3xxxxxx9xx4xx4x7xxxxxxxxxxxxx1xxxxxxxxx7xxxxxxxxxxxxxx4xx6xxxxxxxxx9xxx7xxxx2xxxxxxxxxxxxxxxxxxxxxx8xxxxxxxxxxxxxxxxxxxx6xx== xxxxx010 xxxxxxxxxx\n']
 202 }
 203
 204 def foo():
 205     xxx_xxx = (
 206         'xxxx xxx xxxxxxxx_xxxx xx "xxxxxxxxxx".'
 207         '\n xxx: xxxxxx xxxxxxxx_xxxx=xxxxxxxxxx'
 208     ) # xxxx xxxxxxxxxx xxxx xx xxxx xx xxx xxxxxxxx xxxxxx xxxxx.
 209
 210 some_tuple = ("some string", "some string" " which should be joined")
 211
 212 some_commented_string = (
 213     "This string is long but not so long that it needs hahahah toooooo be so greatttt"  # This comment gets thrown to the top.
 214     " {} that I just can't think of any more good words to say about it at"
 215     " allllllllllll".format("ha")  # comments here are fine
 216 )
 217
 218 some_commented_string = (
 219     "This string is long but not so long that it needs hahahah toooooo be so greatttt"  # But these
 220     " {} that I just can't think of any more good words to say about it at"  # comments will stay
 221     " allllllllllll".format("ha")  # comments here are fine
 222 )
 223
 224 lpar_and_rpar_have_comments = func_call(  # LPAR Comment
 225     "Long really ridiculous type of string that shouldn't really even exist at all. I mean commmme onnn!!!",  # Comma Comment
 226 )  # RPAR Comment
 227
 228 cmd_fstring = (
 229     f"sudo -E deluge-console info --detailed --sort-reverse=time_added "
 230     f"{'' if ID is None else ID} | perl -nE 'print if /^{field}:/'"
 231 )
 232
 233 cmd_fstring = f"sudo -E deluge-console info --detailed --sort-reverse=time_added {'' if ID is None else ID} | perl -nE 'print if /^{field}:/'"
 234
 235 cmd_fstring = f"sudo -E deluge-console info --detailed --sort-reverse=time_added {'{{}}' if ID is None else ID} | perl -nE 'print if /^{field}:/'"
 236
 237 cmd_fstring = f"sudo -E deluge-console info --detailed --sort-reverse=time_added {{'' if ID is None else ID}} | perl -nE 'print if /^{field}:/'"
 238
 239 fstring = f"This string really doesn't need to be an {{{{fstring}}}}, but this one most certainly, absolutely {does}."
 240
 241 fstring = (
 242     f"We have to remember to escape {braces}."
 243     " Like {these}."
 244     f" But not {this}."
 245 )
 246
 247 class A:
 248     class B:
 249         def foo():
 250             st_error = STError(
 251                 f"This string ({string_leaf.value}) appears to be pointless (i.e. has"
 252                 " no parent)."
 253             )
 254
 255 def foo():
 256     user_regex = _lazy_re_compile(
 257         r"(^[-!#$%&'*+/=?^_`{}|~0-9A-Z]+(\.[-!#$%&'*+/=?^_`{}|~0-9A-Z]+)*\Z"  # dot-atom
 258         r'|^"([\001-\010\013\014\016-\037!#-\[\]-\177]|\\[\001-\011\013\014\016-\177])*"\Z)',  # quoted-string
 259         re.IGNORECASE)
 260
 261 def foo():
 262     user_regex = _lazy_re_compile(
 263         "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"  # dot-atom
 264         'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx',  # quoted-string
 265         xyz
 266     )
 267
 268 def foo():
 269     user_regex = _lazy_re_compile(
 270         "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"  # dot-atom
 271         'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx',  # quoted-string
 272         xyz
 273     )
 274
 275 class A:
 276     class B:
 277         def foo():
 278             if not hasattr(module, name):
 279                 raise ValueError(
 280                     "Could not find object %s in %s.\n"
 281                     "Please note that you cannot serialize things like inner "
 282                     "classes. Please move the object into the main module "
 283                     "body to use migrations.\n"
 284                     "For more information, see "
 285                     "https://docs.djangoproject.com/en/%s/topics/migrations/#serializing-values"
 286                     % (name, module_name, get_docs_version()))
 287
 288 class A:
 289     class B:
 290         def foo():
 291             if not hasattr(module, name):
 292                 raise ValueError(
 293                     "Could not find object %s in %s.\nPlease note that you cannot serialize things like inner classes. Please move the object into the main module body to use migrations.\nFor more information, see https://docs.djangoproject.com/en/%s/topics/migrations/#serializing-values"
 294                     % (name, module_name, get_docs_version()))
 295
 296 x = (
 297     "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
 298     "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
 299     "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
 300     "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
 301 )
 302
 303 class Step(StepBase):
 304     def who(self):
 305         self.cmd = 'SR AAAA-CORRECT NAME IS {last_name} {first_name}{middle_name} {title}/P{passenger_association}'.format(
 306             last_name=last_name,
 307             first_name=first_name,
 308             middle_name=middle_name,
 309             title=title,
 310             passenger_association=passenger_association,
 311         )
 312
 313 xxxxxxx_xxxxxx_xxxxxxx = xxx(
 314     [
 315         xxxxxxxxxxxx(
 316             xxxxxx_xxxxxxx=(
 317                 '((x.aaaaaaaaa = "xxxxxx.xxxxxxxxxxxxxxxxxxxxx") || (x.xxxxxxxxx = "xxxxxxxxxxxx")) && '
 318                 # xxxxx xxxxxxxxxxxx xxxx xxx (xxxxxxxxxxxxxxxx) xx x xxxxxxxxx xx xxxxxx.
 319                 "(x.bbbbbbbbbbbb.xxx != "
 320                 '"xxx:xxx:xxx::cccccccccccc:xxxxxxx-xxxx/xxxxxxxxxxx/xxxxxxxxxxxxxxxxx") && '
 321             )
 322         )
 323     ]
 324 )
 325
 326 if __name__ == "__main__":
 327     for i in range(4, 8):
 328         cmd = (
 329             r"for pid in $(ps aux | grep paster | grep -v grep | grep '\-%d' | awk '{print $2}'); do kill $pid; done"
 330             % (i)
 331         )
 332
 333 def A():
 334     def B():
 335         def C():
 336             def D():
 337                 def E():
 338                     def F():
 339                         def G():
 340                             assert (
 341                                 c_float(val[0][0] / val[0][1]).value
 342                                 == c_float(value[0][0] / value[0][1]).value
 343                             ), "%s didn't roundtrip" % tag
 344
 345 class xxxxxxxxxxxxxxxxxxxxx(xxxx.xxxxxxxxxxxxx):
 346     def xxxxxxx_xxxxxx(xxxx):
 347         assert xxxxxxx_xxxx in [
 348             x.xxxxx.xxxxxx.xxxxx.xxxxxx,
 349             x.xxxxx.xxxxxx.xxxxx.xxxx,
 350         ], ("xxxxxxxxxxx xxxxxxx xxxx (xxxxxx xxxx) %x xxx xxxxx" % xxxxxxx_xxxx)
 351
 352 value.__dict__[
 353     key
 354 ] = "test"  # set some Thrift field to non-None in the struct aa bb cc dd ee
 355
 356 RE_ONE_BACKSLASH = {
 357     "asdf_hjkl_jkl": re.compile(
 358         r"(?<!([0-9]\ ))(?<=(^|\ ))([A-Z]+(\ )?|[0-9](\ )|[a-z](\ )){4,7}([A-Z]|[0-9]|[a-z])($|\b)(?!(\ ?([0-9]\ )|(\.)))"
 359     ),
 360 }
 361
 362 RE_TWO_BACKSLASHES = {
 363     "asdf_hjkl_jkl": re.compile(
 364         r"(?<!([0-9]\ ))(?<=(^|\ ))([A-Z]+(\ )?|[0-9](\ )|[a-z](\\ )){4,7}([A-Z]|[0-9]|[a-z])($|\b)(?!(\ ?([0-9]\ )|(\.)))"
 365     ),
 366 }
 367
 368 RE_THREE_BACKSLASHES = {
 369     "asdf_hjkl_jkl": re.compile(
 370         r"(?<!([0-9]\ ))(?<=(^|\ ))([A-Z]+(\ )?|[0-9](\ )|[a-z](\\\ )){4,7}([A-Z]|[0-9]|[a-z])($|\b)(?!(\ ?([0-9]\ )|(\.)))"
 371     ),
 372 }
 373
 374 # We do NOT split on f-string expressions.
 375 print(f"Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam. {[f'{i}' for i in range(10)]}")
 376 x = f"This is a long string which contains an f-expr that should not split {{{[i for i in range(5)]}}}."
 377
 378 # The parens should NOT be removed in this case.
 379 (
 380     "my very long string that should get formatted if I'm careful to make sure it goes"
 381     " over 88 characters which it has now"
 382 )
 383
 384 # The parens should NOT be removed in this case.
 385 (
 386     "my very long string that should get formatted if I'm careful to make sure it goes over 88 characters which"
 387     " it has now"
 388 )
 389
 390 # The parens should NOT be removed in this case.
 391 (
 392     "my very long string"
 393     " that should get formatted"
 394     " if I'm careful to make sure"
 395     " it goes over 88 characters which"
 396     " it has now"
 397 )
 398
 399
 400 def _legacy_listen_examples():
 401     text += (
 402         "    \"listen for the '%(event_name)s' event\"\n"
 403         "\n    # ... (event logic logic logic) ...\n"
 404         % {
 405             "since": since,
 406         }
 407     )
 408
 409
 410 class X:
 411     async def foo(self):
 412         msg = ""
 413         for candidate in CANDIDATES:
 414             msg += (
 415                 "**{candidate.object_type} {candidate.rev}**"
 416                 " - {candidate.description}\n"
 417             )
 418
 419
 420 temp_msg = (
 421     f"{f'{humanize_number(pos)}.': <{pound_len+2}} "
 422     f"{balance: <{bal_len + 5}} "
 423     f"<<{author.display_name}>>\n"
 424 )
 425
 426 assert str(suffix_arr) == (
 427     "['$', 'angaroo$', 'angrykangaroo$', 'aroo$', 'garoo$', "
 428     "'grykangaroo$', 'kangaroo$', 'ngaroo$', 'ngrykangaroo$', "
 429     "'o$', 'oo$', 'roo$', 'rykangaroo$', 'ykangaroo$']"
 430 )
 431 assert str(suffix_arr) != (
 432     "['$', 'angaroo$', 'angrykangaroo$', 'aroo$', 'garoo$', "
 433     "'grykangaroo$', 'kangaroo$', 'ngaroo$', 'ngrykangaroo$', "
 434     "'o$', 'oo$', 'roo$', 'rykangaroo$', 'ykangaroo$']"
 435 )
 436 assert str(suffix_arr) <= (
 437     "['$', 'angaroo$', 'angrykangaroo$', 'aroo$', 'garoo$', "
 438     "'grykangaroo$', 'kangaroo$', 'ngaroo$', 'ngrykangaroo$', "
 439     "'o$', 'oo$', 'roo$', 'rykangaroo$', 'ykangaroo$']"
 440 )
 441 assert str(suffix_arr) >= (
 442     "['$', 'angaroo$', 'angrykangaroo$', 'aroo$', 'garoo$', "
 443     "'grykangaroo$', 'kangaroo$', 'ngaroo$', 'ngrykangaroo$', "
 444     "'o$', 'oo$', 'roo$', 'rykangaroo$', 'ykangaroo$']"
 445 )
 446 assert str(suffix_arr) < (
 447     "['$', 'angaroo$', 'angrykangaroo$', 'aroo$', 'garoo$', "
 448     "'grykangaroo$', 'kangaroo$', 'ngaroo$', 'ngrykangaroo$', "
 449     "'o$', 'oo$', 'roo$', 'rykangaroo$', 'ykangaroo$']"
 450 )
 451 assert str(suffix_arr) > (
 452     "['$', 'angaroo$', 'angrykangaroo$', 'aroo$', 'garoo$', "
 453     "'grykangaroo$', 'kangaroo$', 'ngaroo$', 'ngrykangaroo$', "
 454     "'o$', 'oo$', 'roo$', 'rykangaroo$', 'ykangaroo$']"
 455 )
 456 assert str(suffix_arr) in "['$', 'angaroo$', 'angrykangaroo$', 'aroo$', 'garoo$', 'grykangaroo$', 'kangaroo$', 'ngaroo$', 'ngrykangaroo$', 'o$', 'oo$', 'roo$', 'rykangaroo$', 'ykangaroo$']"
 457 assert str(suffix_arr) not in "['$', 'angaroo$', 'angrykangaroo$', 'aroo$', 'garoo$', 'grykangaroo$', 'kangaroo$', 'ngaroo$', 'ngrykangaroo$', 'o$', 'oo$', 'roo$', 'rykangaroo$', 'ykangaroo$']"
 458
 459 # output
 460
 461
 462 class A:
 463     def foo():
 464         result = type(message)("")
 465
 466
 467 # Don't merge multiline (e.g. triple-quoted) strings.
 468 def foo():
 469     query = (
 470         """SELECT xxxxxxxxxxxxxxxxxxxx(xxx)"""
 471         """ FROM xxxxxxxxxxxxxxxx WHERE xxxxxxxxxx AND xxx <> xxxxxxxxxxxxxx()"""
 472     )
 473
 474
 475 # There was a bug where tuples were being identified as long strings.
 476 long_tuple = (
 477     "Apple",
 478     "Berry",
 479     "Cherry",
 480     "Dill",
 481     "Evergreen",
 482     "Fig",
 483     "Grape",
 484     "Harry",
 485     "Iglu",
 486     "Jaguar",
 487 )
 488
 489 stupid_format_method_bug = (
 490     "Some really long string that just so happens to be the {} {} to force the 'format'"
 491     " method to hang over the line length boundary. This is pretty annoying.".format(
 492         "perfect", "length"
 493     )
 494 )
 495
 496
 497 class A:
 498     def foo():
 499         os.system(
 500             "This is a regression test. xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx"
 501             " xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx"
 502             " xxxx.".format("xxxxxxxxxx", "xxxxxx", "xxxxxxxxxx")
 503         )
 504
 505
 506 class A:
 507     def foo():
 508         XXXXXXXXXXXX.append(
 509             (
 510                 "xxx_xxxxxxxxxx(xxxxx={}, xxxx={}, xxxxx, xxxx_xxxx_xxxxxxxxxx={})"
 511                 .format(xxxxx, xxxx, xxxx_xxxx_xxxxxxxxxx),
 512                 my_var,
 513                 my_other_var,
 514             )
 515         )
 516
 517
 518 class A:
 519     class B:
 520         def foo():
 521             bar(
 522                 "[{}]: xxx_xxxxxxxxxx(xxxxx={}, xxxx={}, xxxxx={}"
 523                 " xxxx_xxxx_xxxxxxxxxx={}, xxxx={})".format(
 524                     xxxx._xxxxxxxxxxxxxx, xxxxx, xxxx, xxxx_xxxx_xxxxxxxxxx, xxxxxxx
 525                 ),
 526                 varX,
 527                 varY,
 528                 varZ,
 529             )
 530
 531
 532 def foo(xxxx):
 533     for (xxx_xxxx, _xxx_xxx, _xxx_xxxxx, xxx_xxxx) in xxxx:
 534         for xxx in xxx_xxxx:
 535             assert ("x" in xxx) or (xxx in xxx_xxx_xxxxx), (
 536                 "{0} xxxxxxx xx {1}, xxx {1} xx xxx xx xxxx xx xxx xxxx: xxx xxxx {2}"
 537                 .format(xxx_xxxx, xxx, xxxxxx.xxxxxxx(xxx_xxx_xxxxx))
 538             )
 539
 540
 541 class A:
 542     def disappearing_comment():
 543         return (
 544             (  # xx -x xxxxxxx xx xxx xxxxxxx.
 545                 "{{xxx_xxxxxxxxxx_xxxxxxxx}} xxx xxxx {} {{xxxx}} >&2".format(
 546                     "{xxxx} {xxxxxx}"
 547                     if xxxxx.xx_xxxxxxxxxx
 548                     else (  # Disappearing Comment
 549                         "--xxxxxxx --xxxxxx=x --xxxxxx-xxxxx=xxxxxx"
 550                         " --xxxxxx-xxxx=xxxxxxxxxxx.xxx"
 551                     )
 552                 )
 553             ),
 554             (x, y, z),
 555         )
 556
 557
 558 class A:
 559     class B:
 560         def foo():
 561             xxxxx_xxxx(
 562                 xx,
 563                 "\t"
 564                 "@xxxxxx '{xxxx_xxx}\t' > {xxxxxx_xxxx}.xxxxxxx;"
 565                 "{xxxx_xxx} >> {xxxxxx_xxxx}.xxxxxxx 2>&1; xx=$$?;"
 566                 "xxxx $$xx".format(
 567                     xxxx_xxx=xxxx_xxxxxxx,
 568                     xxxxxx_xxxx=xxxxxxx + "/" + xxxx_xxx_xxxx,
 569                     x=xxx_xxxxx_xxxxx_xxx,
 570                 ),
 571                 x,
 572                 y,
 573                 z,
 574             )
 575
 576
 577 func_call_where_string_arg_has_method_call_and_bad_parens(
 578     "A long string with {}. This string is so long that it is ridiculous. It can't fit"
 579     " on one line at alllll.".format("formatting"),
 580 )
 581
 582 func_call_where_string_arg_has_old_fmt_and_bad_parens(
 583     "A long string with {}. This string is so long that it is ridiculous. It can't fit"
 584     " on one line at alllll." % "formatting",
 585 )
 586
 587 func_call_where_string_arg_has_old_fmt_and_bad_parens(
 588     "A long string with {}. This {} is so long that it is ridiculous. It can't fit on"
 589     " one line at alllll." % ("formatting", "string"),
 590 )
 591
 592
 593 class A:
 594     def append(self):
 595         if True:
 596             xxxx.xxxxxxx.xxxxx(
 597                 "xxxxxxxxxx xxxx xx xxxxxx(%x) xx %x xxxx xx xxx %x.xx"
 598                 % (len(self) + 1, xxxx.xxxxxxxxxx, xxxx.xxxxxxxxxx)
 599                 + " %.3f (%s) to %.3f (%s).\n"
 600                 % (
 601                     xxxx.xxxxxxxxx,
 602                     xxxx.xxxxxxxxxxxxxx(xxxx.xxxxxxxxx),
 603                     x,
 604                     xxxx.xxxxxxxxxxxxxx(xx),
 605                 )
 606             )
 607
 608
 609 class A:
 610     def foo():
 611         some_func_call(
 612             "xxxxxxxxxx",
 613             "xx {xxxxxxxxxxx}/xxxxxxxxxxx.xxx xxxx.xxx && xxxxxx -x "
 614             '"xxxx xxxxxxx xxxxxx xxxx; xxxx xxxxxx_xxxxx xxxxxx xxxx; '
 615             "xxxx.xxxx_xxxxxx(['xxxx.xxx'], xxxx.xxxxxxx().xxxxxxxxxx)\" ",
 616             None,
 617             ("xxxxxxxxxxx",),
 618         ),
 619
 620
 621 class A:
 622     def foo():
 623         some_func_call(
 624             "xx {xxxxxxxxxxx}/xxxxxxxxxxx.xxx xxxx.xxx && xxxxxx -x "
 625             "xxxx, ('xxxxxxx xxxxxx xxxx, xxxx') xxxxxx_xxxxx xxxxxx xxxx; "
 626             "xxxx.xxxx_xxxxxx(['xxxx.xxx'], xxxx.xxxxxxx().xxxxxxxxxx)\" ",
 627             None,
 628             ("xxxxxxxxxxx",),
 629         ),
 630
 631
 632 xxxxxxx = {
 633     "xx": (
 634         "xxxx xxxxxxx xxxxxxxxx -x xxx -x /xxx/{0} -x xxx,xxx -xx {1} -xx {1} -xx"
 635         " xxx=xxx_xxxx,xxx_xx,xxx_xxx,xxx_xxxx,xxx_xx,xxx_xxx | xxxxxx -x xxxxxxxx -x"
 636         " xxxxxxxx -x"
 637     ),
 638     "xx": (
 639         "xxxx xxxxxxx xxxxxxxxx -x xxx -x /xxx/{0} -x xxx,xxx -xx {1} -xx {1} -xx"
 640         " xxx=xxx_xxxx_xxx_xxxx,xxx_xx_xxx_xxxx,xxx_xxxx_xxx_xxxx,xxx_xx_xxxx_xxxx,xxx_xxx_xxxx,xxx_xxx_xxxx"
 641         " xxxx=xxx | xxxxxx -x xxxxxxxx -x xxxxxxxx -x"
 642     ),
 643 }
 644
 645
 646 class A:
 647     def foo(self):
 648         if True:
 649             xxxxx_xxxxxxxxxxxx(
 650                 "xxx xxxxxx xxx xxxxxxxxx.xx xx xxxxxxxx.  xxx xxxxxxxxxxxxx.xx"
 651                 " xxxxxxx "
 652                 + "xx xxxxxx xxxxxx xxxxxx xx xxxxxxx xxx xxx ${0} xx x xxxxxxxx xxxxx"
 653                 .xxxxxx(xxxxxx_xxxxxx_xxx)
 654             )
 655
 656
 657 class A:
 658     class B:
 659         def foo():
 660             row = {
 661                 "xxxxxxxxxxxxxxx": xxxxxx_xxxxx_xxxx,
 662                 # 'xxxxxxxxxxxxxxxxxxxxxxx'
 663                 # 'xxxxxxxxxxxxxxxxxxxxxx'
 664                 # 'xxxxxxxxxxxxxxxxxx'
 665                 # 'xxxxxxxxxxxxxxxxx'
 666                 "xxxxxxxxxx": xxxxx_xxxxx,
 667             }
 668
 669
 670 class A:
 671     def xxxx_xxx_xx_xxxxxxxxxx_xxxx_xxxxxxxxx(xxxx):
 672         xxxxxxxx = [
 673             xxxxxxxxxxxxxxxx(
 674                 "xxxx",
 675                 xxxxxxxxxxx={
 676                     "xxxx": 1.0,
 677                 },
 678                 xxxxxx={"xxxxxx 1": xxxxxx(xxxx="xxxxxx 1", xxxxxx=600.0)},
 679                 xxxxxxxx_xxxxxxx=0.0,
 680             ),
 681             xxxxxxxxxxxxxxxx(
 682                 "xxxxxxx",
 683                 xxxxxxxxxxx={
 684                     "xxxx": 1.0,
 685                 },
 686                 xxxxxx={"xxxxxx 1": xxxxxx(xxxx="xxxxxx 1", xxxxxx=200.0)},
 687                 xxxxxxxx_xxxxxxx=0.0,
 688             ),
 689             xxxxxxxxxxxxxxxx(
 690                 "xxxx",
 691             ),
 692         ]
 693
 694
 695 some_dictionary = {
 696     "xxxxx006": [
 697         "xxx-xxx"
 698         " xxxxx3xxxx1xx2xxxxxxxxxxxxxx0xx6xxxxxxxxxx2xxxxxx9xxxxxxxxxx0xxxxx1xxx2x/xx9xx6+x+xxxxxxxxxxxxxx4xxxxxxxxxxxxxxxxxxxxx43xxx2xx2x4x++xxx6xxxxxxxxx+xxxxx/xx9x+xxxxxxxxxxxxxx8x15xxxxxxxxxxxxxxxxx82xx/xxxxxxxxxxxxxx/x5xxxxxxxxxxxxxx6xxxxxx74x4/xxx4x+xxxxxxxxx2xxxxxxxx87xxxxx4xxxxxxxx3xx0xxxxx4xxx1xx9xx5xxxxxxx/xxxxx5xx6xx4xxxx1x/x2xxxxxxxxxxxx64xxxxxxx1x0xx5xxxxxxxxxxxxxx=="
 699         " xxxxx000 xxxxxxxxxx\n",
 700         "xxx-xxx"
 701         " xxxxx3xxxx1xx2xxxxxxxxxxxxxx6xxxxxxxxxxxxxx9xxxxxxxxxxxxx3xxx9xxxxxxxxxxxxxxxx0xxxxxxxxxxxxxxxxx2xxxx2xxx6xxxxx/xx54xxxxxxxxx4xxx3xxxxxx9xx3xxxxx39xxxxxxxxx5xx91xxxx7xxxxxx8xxxxxxxxxxxxxxxx9xxx93xxxxxxxxxxxxxxxxx7xxx8xx8xx4/x1xxxxx1x3xxxxxxxxxxxxx3xxxxxx9xx4xx4x7xxxxxxxxxxxxx1xxxxxxxxx7xxxxxxxxxxxxxx4xx6xxxxxxxxx9xxx7xxxx2xxxxxxxxxxxxxxxxxxxxxx8xxxxxxxxxxxxxxxxxxxx6xx=="
 702         " xxxxx010 xxxxxxxxxx\n",
 703     ],
 704     "xxxxx016": [
 705         "xxx-xxx"
 706         " xxxxx3xxxx1xx2xxxxxxxxxxxxxx0xx6xxxxxxxxxx2xxxxxx9xxxxxxxxxx0xxxxx1xxx2x/xx9xx6+x+xxxxxxxxxxxxxx4xxxxxxxxxxxxxxxxxxxxx43xxx2xx2x4x++xxx6xxxxxxxxx+xxxxx/xx9x+xxxxxxxxxxxxxx8x15xxxxxxxxxxxxxxxxx82xx/xxxxxxxxxxxxxx/x5xxxxxxxxxxxxxx6xxxxxx74x4/xxx4x+xxxxxxxxx2xxxxxxxx87xxxxx4xxxxxxxx3xx0xxxxx4xxx1xx9xx5xxxxxxx/xxxxx5xx6xx4xxxx1x/x2xxxxxxxxxxxx64xxxxxxx1x0xx5xxxxxxxxxxxxxx=="
 707         " xxxxx000 xxxxxxxxxx\n",
 708         "xxx-xxx"
 709         " xxxxx3xxxx1xx2xxxxxxxxxxxxxx6xxxxxxxxxxxxxx9xxxxxxxxxxxxx3xxx9xxxxxxxxxxxxxxxx0xxxxxxxxxxxxxxxxx2xxxx2xxx6xxxxx/xx54xxxxxxxxx4xxx3xxxxxx9xx3xxxxx39xxxxxxxxx5xx91xxxx7xxxxxx8xxxxxxxxxxxxxxxx9xxx93xxxxxxxxxxxxxxxxx7xxx8xx8xx4/x1xxxxx1x3xxxxxxxxxxxxx3xxxxxx9xx4xx4x7xxxxxxxxxxxxx1xxxxxxxxx7xxxxxxxxxxxxxx4xx6xxxxxxxxx9xxx7xxxx2xxxxxxxxxxxxxxxxxxxxxx8xxxxxxxxxxxxxxxxxxxx6xx=="
 710         " xxxxx010 xxxxxxxxxx\n",
 711     ],
 712 }
 713
 714
 715 def foo():
 716     xxx_xxx = (  # xxxx xxxxxxxxxx xxxx xx xxxx xx xxx xxxxxxxx xxxxxx xxxxx.
 717         'xxxx xxx xxxxxxxx_xxxx xx "xxxxxxxxxx".\n xxx: xxxxxx xxxxxxxx_xxxx=xxxxxxxxxx'
 718     )
 719
 720
 721 some_tuple = ("some string", "some string which should be joined")
 722
 723 some_commented_string = (  # This comment gets thrown to the top.
 724     "This string is long but not so long that it needs hahahah toooooo be so greatttt"
 725     " {} that I just can't think of any more good words to say about it at"
 726     " allllllllllll".format("ha")  # comments here are fine
 727 )
 728
 729 some_commented_string = (
 730     "This string is long but not so long that it needs hahahah toooooo be so greatttt"  # But these
 731     " {} that I just can't think of any more good words to say about it at"  # comments will stay
 732     " allllllllllll".format("ha")  # comments here are fine
 733 )
 734
 735 lpar_and_rpar_have_comments = func_call(  # LPAR Comment
 736     "Long really ridiculous type of string that shouldn't really even exist at all. I"
 737     " mean commmme onnn!!!",  # Comma Comment
 738 )  # RPAR Comment
 739
 740 cmd_fstring = (
 741     "sudo -E deluge-console info --detailed --sort-reverse=time_added "
 742     f"{'' if ID is None else ID} | perl -nE 'print if /^{field}:/'"
 743 )
 744
 745 cmd_fstring = (
 746     "sudo -E deluge-console info --detailed --sort-reverse=time_added"
 747     f" {'' if ID is None else ID} | perl -nE 'print if /^{field}:/'"
 748 )
 749
 750 cmd_fstring = (
 751     "sudo -E deluge-console info --detailed --sort-reverse=time_added"
 752     f" {'{{}}' if ID is None else ID} | perl -nE 'print if /^{field}:/'"
 753 )
 754
 755 cmd_fstring = (
 756     "sudo -E deluge-console info --detailed --sort-reverse=time_added {'' if ID is"
 757     f" None else ID}} | perl -nE 'print if /^{field}:/'"
 758 )
 759
 760 fstring = (
 761     "This string really doesn't need to be an {{fstring}}, but this one most"
 762     f" certainly, absolutely {does}."
 763 )
 764
 765 fstring = f"We have to remember to escape {braces}. Like {{these}}. But not {this}."
 766
 767
 768 class A:
 769     class B:
 770         def foo():
 771             st_error = STError(
 772                 f"This string ({string_leaf.value}) appears to be pointless (i.e. has"
 773                 " no parent)."
 774             )
 775
 776
 777 def foo():
 778     user_regex = _lazy_re_compile(
 779         r"(^[-!#$%&'*+/=?^_`{}|~0-9A-Z]+(\.[-!#$%&'*+/=?^_`{}|~0-9A-Z]+)*\Z"  # dot-atom
 780         r'|^"([\001-\010\013\014\016-\037!#-\[\]-\177]|\\[\001-\011\013\014\016-\177])*"\Z)',  # quoted-string
 781         re.IGNORECASE,
 782     )
 783
 784
 785 def foo():
 786     user_regex = _lazy_re_compile(
 787         "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"  # dot-atom
 788         "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",  # quoted-string
 789         xyz,
 790     )
 791
 792
 793 def foo():
 794     user_regex = _lazy_re_compile(
 795         "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"  # dot-atom
 796         "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",  # quoted-string
 797         xyz,
 798     )
 799
 800
 801 class A:
 802     class B:
 803         def foo():
 804             if not hasattr(module, name):
 805                 raise ValueError(
 806                     "Could not find object %s in %s.\n"
 807                     "Please note that you cannot serialize things like inner "
 808                     "classes. Please move the object into the main module "
 809                     "body to use migrations.\n"
 810                     "For more information, see "
 811                     "https://docs.djangoproject.com/en/%s/topics/migrations/#serializing-values"
 812                     % (name, module_name, get_docs_version())
 813                 )
 814
 815
 816 class A:
 817     class B:
 818         def foo():
 819             if not hasattr(module, name):
 820                 raise ValueError(
 821                     "Could not find object %s in %s.\nPlease note that you cannot"
 822                     " serialize things like inner classes. Please move the object into"
 823                     " the main module body to use migrations.\nFor more information,"
 824                     " see https://docs.djangoproject.com/en/%s/topics/migrations/#serializing-values"
 825                     % (name, module_name, get_docs_version())
 826                 )
 827
 828
 829 x = (
 830     "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
 831     "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
 832     "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
 833     "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
 834 )
 835
 836
 837 class Step(StepBase):
 838     def who(self):
 839         self.cmd = (
 840             "SR AAAA-CORRECT NAME IS {last_name} {first_name}{middle_name}"
 841             " {title}/P{passenger_association}".format(
 842                 last_name=last_name,
 843                 first_name=first_name,
 844                 middle_name=middle_name,
 845                 title=title,
 846                 passenger_association=passenger_association,
 847             )
 848         )
 849
 850
 851 xxxxxxx_xxxxxx_xxxxxxx = xxx(
 852     [
 853         xxxxxxxxxxxx(
 854             xxxxxx_xxxxxxx=(
 855                 '((x.aaaaaaaaa = "xxxxxx.xxxxxxxxxxxxxxxxxxxxx") || (x.xxxxxxxxx ='
 856                 ' "xxxxxxxxxxxx")) && '
 857                 # xxxxx xxxxxxxxxxxx xxxx xxx (xxxxxxxxxxxxxxxx) xx x xxxxxxxxx xx xxxxxx.
 858                 "(x.bbbbbbbbbbbb.xxx != "
 859                 '"xxx:xxx:xxx::cccccccccccc:xxxxxxx-xxxx/xxxxxxxxxxx/xxxxxxxxxxxxxxxxx") && '
 860             )
 861         )
 862     ]
 863 )
 864
 865 if __name__ == "__main__":
 866     for i in range(4, 8):
 867         cmd = (
 868             r"for pid in $(ps aux | grep paster | grep -v grep | grep '\-%d' | awk"
 869             r" '{print $2}'); do kill $pid; done" % (i)
 870         )
 871
 872
 873 def A():
 874     def B():
 875         def C():
 876             def D():
 877                 def E():
 878                     def F():
 879                         def G():
 880                             assert (
 881                                 c_float(val[0][0] / val[0][1]).value
 882                                 == c_float(value[0][0] / value[0][1]).value
 883                             ), "%s didn't roundtrip" % tag
 884
 885
 886 class xxxxxxxxxxxxxxxxxxxxx(xxxx.xxxxxxxxxxxxx):
 887     def xxxxxxx_xxxxxx(xxxx):
 888         assert xxxxxxx_xxxx in [
 889             x.xxxxx.xxxxxx.xxxxx.xxxxxx,
 890             x.xxxxx.xxxxxx.xxxxx.xxxx,
 891         ], (
 892             "xxxxxxxxxxx xxxxxxx xxxx (xxxxxx xxxx) %x xxx xxxxx" % xxxxxxx_xxxx
 893         )
 894
 895
 896 value.__dict__[
 897     key
 898 ] = "test"  # set some Thrift field to non-None in the struct aa bb cc dd ee
 899
 900 RE_ONE_BACKSLASH = {
 901     "asdf_hjkl_jkl": re.compile(
 902         r"(?<!([0-9]\ ))(?<=(^|\ ))([A-Z]+(\ )?|[0-9](\ )|[a-z](\ )){4,7}([A-Z]|[0-9]|[a-z])($|\b)(?!(\ ?([0-9]\ )|(\.)))"
 903     ),
 904 }
 905
 906 RE_TWO_BACKSLASHES = {
 907     "asdf_hjkl_jkl": re.compile(
 908         r"(?<!([0-9]\ ))(?<=(^|\ ))([A-Z]+(\ )?|[0-9](\ )|[a-z](\\"
 909         r" )){4,7}([A-Z]|[0-9]|[a-z])($|\b)(?!(\ ?([0-9]\ )|(\.)))"
 910     ),
 911 }
 912
 913 RE_THREE_BACKSLASHES = {
 914     "asdf_hjkl_jkl": re.compile(
 915         r"(?<!([0-9]\ ))(?<=(^|\ ))([A-Z]+(\ )?|[0-9](\ )|[a-z](\\\ )){4,7}([A-Z]|[0-9]|[a-z])($|\b)(?!(\ ?([0-9]\ )|(\.)))"
 916     ),
 917 }
 918
 919 # We do NOT split on f-string expressions.
 920 print(
 921     "Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam."
 922     f" {[f'{i}' for i in range(10)]}"
 923 )
 924 x = (
 925     "This is a long string which contains an f-expr that should not split"
 926     f" {{{[i for i in range(5)]}}}."
 927 )
 928
 929 # The parens should NOT be removed in this case.
 930 (
 931     "my very long string that should get formatted if I'm careful to make sure it goes"
 932     " over 88 characters which it has now"
 933 )
 934
 935 # The parens should NOT be removed in this case.
 936 (
 937     "my very long string that should get formatted if I'm careful to make sure it goes"
 938     " over 88 characters which it has now"
 939 )
 940
 941 # The parens should NOT be removed in this case.
 942 (
 943     "my very long string"
 944     " that should get formatted"
 945     " if I'm careful to make sure"
 946     " it goes over 88 characters which"
 947     " it has now"
 948 )
 949
 950
 951 def _legacy_listen_examples():
 952     text += (
 953         "    \"listen for the '%(event_name)s' event\"\n"
 954         "\n    # ... (event logic logic logic) ...\n"
 955         % {
 956             "since": since,
 957         }
 958     )
 959
 960
 961 class X:
 962     async def foo(self):
 963         msg = ""
 964         for candidate in CANDIDATES:
 965             msg += (
 966                 "**{candidate.object_type} {candidate.rev}**"
 967                 " - {candidate.description}\n"
 968             )
 969
 970
 971 temp_msg = (
 972     f"{f'{humanize_number(pos)}.': <{pound_len+2}} "
 973     f"{balance: <{bal_len + 5}} "
 974     f"<<{author.display_name}>>\n"
 975 )
 976
 977 assert (
 978     str(suffix_arr)
 979     == "['$', 'angaroo$', 'angrykangaroo$', 'aroo$', 'garoo$', "
 980     "'grykangaroo$', 'kangaroo$', 'ngaroo$', 'ngrykangaroo$', "
 981     "'o$', 'oo$', 'roo$', 'rykangaroo$', 'ykangaroo$']"
 982 )
 983 assert (
 984     str(suffix_arr)
 985     != "['$', 'angaroo$', 'angrykangaroo$', 'aroo$', 'garoo$', "
 986     "'grykangaroo$', 'kangaroo$', 'ngaroo$', 'ngrykangaroo$', "
 987     "'o$', 'oo$', 'roo$', 'rykangaroo$', 'ykangaroo$']"
 988 )
 989 assert (
 990     str(suffix_arr)
 991     <= "['$', 'angaroo$', 'angrykangaroo$', 'aroo$', 'garoo$', "
 992     "'grykangaroo$', 'kangaroo$', 'ngaroo$', 'ngrykangaroo$', "
 993     "'o$', 'oo$', 'roo$', 'rykangaroo$', 'ykangaroo$']"
 994 )
 995 assert (
 996     str(suffix_arr)
 997     >= "['$', 'angaroo$', 'angrykangaroo$', 'aroo$', 'garoo$', "
 998     "'grykangaroo$', 'kangaroo$', 'ngaroo$', 'ngrykangaroo$', "
 999     "'o$', 'oo$', 'roo$', 'rykangaroo$', 'ykangaroo$']"
1000 )
1001 assert (
1002     str(suffix_arr)
1003     < "['$', 'angaroo$', 'angrykangaroo$', 'aroo$', 'garoo$', "
1004     "'grykangaroo$', 'kangaroo$', 'ngaroo$', 'ngrykangaroo$', "
1005     "'o$', 'oo$', 'roo$', 'rykangaroo$', 'ykangaroo$']"
1006 )
1007 assert (
1008     str(suffix_arr)
1009     > "['$', 'angaroo$', 'angrykangaroo$', 'aroo$', 'garoo$', "
1010     "'grykangaroo$', 'kangaroo$', 'ngaroo$', 'ngrykangaroo$', "
1011     "'o$', 'oo$', 'roo$', 'rykangaroo$', 'ykangaroo$']"
1012 )
1013 assert (
1014     str(suffix_arr)
1015     in "['$', 'angaroo$', 'angrykangaroo$', 'aroo$', 'garoo$', 'grykangaroo$',"
1016     " 'kangaroo$', 'ngaroo$', 'ngrykangaroo$', 'o$', 'oo$', 'roo$', 'rykangaroo$',"
1017     " 'ykangaroo$']"
1018 )
1019 assert (
1020     str(suffix_arr)
1021     not in "['$', 'angaroo$', 'angrykangaroo$', 'aroo$', 'garoo$', 'grykangaroo$',"
1022     " 'kangaroo$', 'ngaroo$', 'ngrykangaroo$', 'o$', 'oo$', 'roo$',"
1023     " 'rykangaroo$', 'ykangaroo$']"
1024 )